1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package backup
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/backup/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpCreateBackupPlan struct {
14}
15
16func (*validateOpCreateBackupPlan) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpCreateBackupPlan) 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.(*CreateBackupPlanInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpCreateBackupPlanInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpCreateBackupSelection struct {
34}
35
36func (*validateOpCreateBackupSelection) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpCreateBackupSelection) 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.(*CreateBackupSelectionInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpCreateBackupSelectionInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpCreateBackupVault struct {
54}
55
56func (*validateOpCreateBackupVault) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpCreateBackupVault) 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.(*CreateBackupVaultInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpCreateBackupVaultInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpCreateFramework struct {
74}
75
76func (*validateOpCreateFramework) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpCreateFramework) 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.(*CreateFrameworkInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpCreateFrameworkInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpCreateReportPlan struct {
94}
95
96func (*validateOpCreateReportPlan) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpCreateReportPlan) 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.(*CreateReportPlanInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpCreateReportPlanInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpDeleteBackupPlan struct {
114}
115
116func (*validateOpDeleteBackupPlan) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpDeleteBackupPlan) 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.(*DeleteBackupPlanInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpDeleteBackupPlanInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpDeleteBackupSelection struct {
134}
135
136func (*validateOpDeleteBackupSelection) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpDeleteBackupSelection) 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.(*DeleteBackupSelectionInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpDeleteBackupSelectionInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpDeleteBackupVaultAccessPolicy struct {
154}
155
156func (*validateOpDeleteBackupVaultAccessPolicy) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpDeleteBackupVaultAccessPolicy) 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.(*DeleteBackupVaultAccessPolicyInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpDeleteBackupVaultAccessPolicyInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpDeleteBackupVault struct {
174}
175
176func (*validateOpDeleteBackupVault) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpDeleteBackupVault) 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.(*DeleteBackupVaultInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpDeleteBackupVaultInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpDeleteBackupVaultNotifications struct {
194}
195
196func (*validateOpDeleteBackupVaultNotifications) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpDeleteBackupVaultNotifications) 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.(*DeleteBackupVaultNotificationsInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpDeleteBackupVaultNotificationsInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpDeleteFramework struct {
214}
215
216func (*validateOpDeleteFramework) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpDeleteFramework) 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.(*DeleteFrameworkInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpDeleteFrameworkInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpDeleteRecoveryPoint struct {
234}
235
236func (*validateOpDeleteRecoveryPoint) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpDeleteRecoveryPoint) 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.(*DeleteRecoveryPointInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpDeleteRecoveryPointInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpDeleteReportPlan struct {
254}
255
256func (*validateOpDeleteReportPlan) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpDeleteReportPlan) 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.(*DeleteReportPlanInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpDeleteReportPlanInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpDescribeBackupJob struct {
274}
275
276func (*validateOpDescribeBackupJob) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpDescribeBackupJob) 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.(*DescribeBackupJobInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpDescribeBackupJobInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpDescribeBackupVault struct {
294}
295
296func (*validateOpDescribeBackupVault) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpDescribeBackupVault) 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.(*DescribeBackupVaultInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpDescribeBackupVaultInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpDescribeCopyJob struct {
314}
315
316func (*validateOpDescribeCopyJob) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpDescribeCopyJob) 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.(*DescribeCopyJobInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpDescribeCopyJobInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpDescribeFramework struct {
334}
335
336func (*validateOpDescribeFramework) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpDescribeFramework) 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.(*DescribeFrameworkInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpDescribeFrameworkInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpDescribeProtectedResource struct {
354}
355
356func (*validateOpDescribeProtectedResource) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpDescribeProtectedResource) 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.(*DescribeProtectedResourceInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpDescribeProtectedResourceInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpDescribeRecoveryPoint struct {
374}
375
376func (*validateOpDescribeRecoveryPoint) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpDescribeRecoveryPoint) 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.(*DescribeRecoveryPointInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpDescribeRecoveryPointInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpDescribeReportJob struct {
394}
395
396func (*validateOpDescribeReportJob) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpDescribeReportJob) 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.(*DescribeReportJobInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpDescribeReportJobInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpDescribeReportPlan struct {
414}
415
416func (*validateOpDescribeReportPlan) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpDescribeReportPlan) 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.(*DescribeReportPlanInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpDescribeReportPlanInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpDescribeRestoreJob struct {
434}
435
436func (*validateOpDescribeRestoreJob) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpDescribeRestoreJob) 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.(*DescribeRestoreJobInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpDescribeRestoreJobInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpDisassociateRecoveryPoint struct {
454}
455
456func (*validateOpDisassociateRecoveryPoint) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpDisassociateRecoveryPoint) 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.(*DisassociateRecoveryPointInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpDisassociateRecoveryPointInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpExportBackupPlanTemplate struct {
474}
475
476func (*validateOpExportBackupPlanTemplate) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpExportBackupPlanTemplate) 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.(*ExportBackupPlanTemplateInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpExportBackupPlanTemplateInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpGetBackupPlanFromJSON struct {
494}
495
496func (*validateOpGetBackupPlanFromJSON) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpGetBackupPlanFromJSON) 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.(*GetBackupPlanFromJSONInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpGetBackupPlanFromJSONInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpGetBackupPlanFromTemplate struct {
514}
515
516func (*validateOpGetBackupPlanFromTemplate) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpGetBackupPlanFromTemplate) 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.(*GetBackupPlanFromTemplateInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpGetBackupPlanFromTemplateInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpGetBackupPlan struct {
534}
535
536func (*validateOpGetBackupPlan) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpGetBackupPlan) 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.(*GetBackupPlanInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpGetBackupPlanInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpGetBackupSelection struct {
554}
555
556func (*validateOpGetBackupSelection) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpGetBackupSelection) 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.(*GetBackupSelectionInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpGetBackupSelectionInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpGetBackupVaultAccessPolicy struct {
574}
575
576func (*validateOpGetBackupVaultAccessPolicy) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpGetBackupVaultAccessPolicy) 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.(*GetBackupVaultAccessPolicyInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpGetBackupVaultAccessPolicyInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpGetBackupVaultNotifications struct {
594}
595
596func (*validateOpGetBackupVaultNotifications) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpGetBackupVaultNotifications) 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.(*GetBackupVaultNotificationsInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpGetBackupVaultNotificationsInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpGetRecoveryPointRestoreMetadata struct {
614}
615
616func (*validateOpGetRecoveryPointRestoreMetadata) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpGetRecoveryPointRestoreMetadata) 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.(*GetRecoveryPointRestoreMetadataInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpGetRecoveryPointRestoreMetadataInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpListBackupPlanVersions struct {
634}
635
636func (*validateOpListBackupPlanVersions) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpListBackupPlanVersions) 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.(*ListBackupPlanVersionsInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpListBackupPlanVersionsInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653type validateOpListBackupSelections struct {
654}
655
656func (*validateOpListBackupSelections) ID() string {
657	return "OperationInputValidation"
658}
659
660func (m *validateOpListBackupSelections) 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.(*ListBackupSelectionsInput)
664	if !ok {
665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666	}
667	if err := validateOpListBackupSelectionsInput(input); err != nil {
668		return out, metadata, err
669	}
670	return next.HandleInitialize(ctx, in)
671}
672
673type validateOpListRecoveryPointsByBackupVault struct {
674}
675
676func (*validateOpListRecoveryPointsByBackupVault) ID() string {
677	return "OperationInputValidation"
678}
679
680func (m *validateOpListRecoveryPointsByBackupVault) 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.(*ListRecoveryPointsByBackupVaultInput)
684	if !ok {
685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
686	}
687	if err := validateOpListRecoveryPointsByBackupVaultInput(input); err != nil {
688		return out, metadata, err
689	}
690	return next.HandleInitialize(ctx, in)
691}
692
693type validateOpListRecoveryPointsByResource struct {
694}
695
696func (*validateOpListRecoveryPointsByResource) ID() string {
697	return "OperationInputValidation"
698}
699
700func (m *validateOpListRecoveryPointsByResource) 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.(*ListRecoveryPointsByResourceInput)
704	if !ok {
705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
706	}
707	if err := validateOpListRecoveryPointsByResourceInput(input); err != nil {
708		return out, metadata, err
709	}
710	return next.HandleInitialize(ctx, in)
711}
712
713type validateOpListTags struct {
714}
715
716func (*validateOpListTags) ID() string {
717	return "OperationInputValidation"
718}
719
720func (m *validateOpListTags) 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.(*ListTagsInput)
724	if !ok {
725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
726	}
727	if err := validateOpListTagsInput(input); err != nil {
728		return out, metadata, err
729	}
730	return next.HandleInitialize(ctx, in)
731}
732
733type validateOpPutBackupVaultAccessPolicy struct {
734}
735
736func (*validateOpPutBackupVaultAccessPolicy) ID() string {
737	return "OperationInputValidation"
738}
739
740func (m *validateOpPutBackupVaultAccessPolicy) 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.(*PutBackupVaultAccessPolicyInput)
744	if !ok {
745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
746	}
747	if err := validateOpPutBackupVaultAccessPolicyInput(input); err != nil {
748		return out, metadata, err
749	}
750	return next.HandleInitialize(ctx, in)
751}
752
753type validateOpPutBackupVaultNotifications struct {
754}
755
756func (*validateOpPutBackupVaultNotifications) ID() string {
757	return "OperationInputValidation"
758}
759
760func (m *validateOpPutBackupVaultNotifications) 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.(*PutBackupVaultNotificationsInput)
764	if !ok {
765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
766	}
767	if err := validateOpPutBackupVaultNotificationsInput(input); err != nil {
768		return out, metadata, err
769	}
770	return next.HandleInitialize(ctx, in)
771}
772
773type validateOpStartBackupJob struct {
774}
775
776func (*validateOpStartBackupJob) ID() string {
777	return "OperationInputValidation"
778}
779
780func (m *validateOpStartBackupJob) 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.(*StartBackupJobInput)
784	if !ok {
785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
786	}
787	if err := validateOpStartBackupJobInput(input); err != nil {
788		return out, metadata, err
789	}
790	return next.HandleInitialize(ctx, in)
791}
792
793type validateOpStartCopyJob struct {
794}
795
796func (*validateOpStartCopyJob) ID() string {
797	return "OperationInputValidation"
798}
799
800func (m *validateOpStartCopyJob) 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.(*StartCopyJobInput)
804	if !ok {
805		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
806	}
807	if err := validateOpStartCopyJobInput(input); err != nil {
808		return out, metadata, err
809	}
810	return next.HandleInitialize(ctx, in)
811}
812
813type validateOpStartReportJob struct {
814}
815
816func (*validateOpStartReportJob) ID() string {
817	return "OperationInputValidation"
818}
819
820func (m *validateOpStartReportJob) 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.(*StartReportJobInput)
824	if !ok {
825		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
826	}
827	if err := validateOpStartReportJobInput(input); err != nil {
828		return out, metadata, err
829	}
830	return next.HandleInitialize(ctx, in)
831}
832
833type validateOpStartRestoreJob struct {
834}
835
836func (*validateOpStartRestoreJob) ID() string {
837	return "OperationInputValidation"
838}
839
840func (m *validateOpStartRestoreJob) 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.(*StartRestoreJobInput)
844	if !ok {
845		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
846	}
847	if err := validateOpStartRestoreJobInput(input); err != nil {
848		return out, metadata, err
849	}
850	return next.HandleInitialize(ctx, in)
851}
852
853type validateOpStopBackupJob struct {
854}
855
856func (*validateOpStopBackupJob) ID() string {
857	return "OperationInputValidation"
858}
859
860func (m *validateOpStopBackupJob) 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.(*StopBackupJobInput)
864	if !ok {
865		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
866	}
867	if err := validateOpStopBackupJobInput(input); err != nil {
868		return out, metadata, err
869	}
870	return next.HandleInitialize(ctx, in)
871}
872
873type validateOpTagResource struct {
874}
875
876func (*validateOpTagResource) ID() string {
877	return "OperationInputValidation"
878}
879
880func (m *validateOpTagResource) 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.(*TagResourceInput)
884	if !ok {
885		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
886	}
887	if err := validateOpTagResourceInput(input); err != nil {
888		return out, metadata, err
889	}
890	return next.HandleInitialize(ctx, in)
891}
892
893type validateOpUntagResource struct {
894}
895
896func (*validateOpUntagResource) ID() string {
897	return "OperationInputValidation"
898}
899
900func (m *validateOpUntagResource) 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.(*UntagResourceInput)
904	if !ok {
905		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
906	}
907	if err := validateOpUntagResourceInput(input); err != nil {
908		return out, metadata, err
909	}
910	return next.HandleInitialize(ctx, in)
911}
912
913type validateOpUpdateBackupPlan struct {
914}
915
916func (*validateOpUpdateBackupPlan) ID() string {
917	return "OperationInputValidation"
918}
919
920func (m *validateOpUpdateBackupPlan) 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.(*UpdateBackupPlanInput)
924	if !ok {
925		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
926	}
927	if err := validateOpUpdateBackupPlanInput(input); err != nil {
928		return out, metadata, err
929	}
930	return next.HandleInitialize(ctx, in)
931}
932
933type validateOpUpdateFramework struct {
934}
935
936func (*validateOpUpdateFramework) ID() string {
937	return "OperationInputValidation"
938}
939
940func (m *validateOpUpdateFramework) 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.(*UpdateFrameworkInput)
944	if !ok {
945		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
946	}
947	if err := validateOpUpdateFrameworkInput(input); err != nil {
948		return out, metadata, err
949	}
950	return next.HandleInitialize(ctx, in)
951}
952
953type validateOpUpdateRecoveryPointLifecycle struct {
954}
955
956func (*validateOpUpdateRecoveryPointLifecycle) ID() string {
957	return "OperationInputValidation"
958}
959
960func (m *validateOpUpdateRecoveryPointLifecycle) 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.(*UpdateRecoveryPointLifecycleInput)
964	if !ok {
965		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
966	}
967	if err := validateOpUpdateRecoveryPointLifecycleInput(input); err != nil {
968		return out, metadata, err
969	}
970	return next.HandleInitialize(ctx, in)
971}
972
973type validateOpUpdateReportPlan struct {
974}
975
976func (*validateOpUpdateReportPlan) ID() string {
977	return "OperationInputValidation"
978}
979
980func (m *validateOpUpdateReportPlan) 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.(*UpdateReportPlanInput)
984	if !ok {
985		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
986	}
987	if err := validateOpUpdateReportPlanInput(input); err != nil {
988		return out, metadata, err
989	}
990	return next.HandleInitialize(ctx, in)
991}
992
993func addOpCreateBackupPlanValidationMiddleware(stack *middleware.Stack) error {
994	return stack.Initialize.Add(&validateOpCreateBackupPlan{}, middleware.After)
995}
996
997func addOpCreateBackupSelectionValidationMiddleware(stack *middleware.Stack) error {
998	return stack.Initialize.Add(&validateOpCreateBackupSelection{}, middleware.After)
999}
1000
1001func addOpCreateBackupVaultValidationMiddleware(stack *middleware.Stack) error {
1002	return stack.Initialize.Add(&validateOpCreateBackupVault{}, middleware.After)
1003}
1004
1005func addOpCreateFrameworkValidationMiddleware(stack *middleware.Stack) error {
1006	return stack.Initialize.Add(&validateOpCreateFramework{}, middleware.After)
1007}
1008
1009func addOpCreateReportPlanValidationMiddleware(stack *middleware.Stack) error {
1010	return stack.Initialize.Add(&validateOpCreateReportPlan{}, middleware.After)
1011}
1012
1013func addOpDeleteBackupPlanValidationMiddleware(stack *middleware.Stack) error {
1014	return stack.Initialize.Add(&validateOpDeleteBackupPlan{}, middleware.After)
1015}
1016
1017func addOpDeleteBackupSelectionValidationMiddleware(stack *middleware.Stack) error {
1018	return stack.Initialize.Add(&validateOpDeleteBackupSelection{}, middleware.After)
1019}
1020
1021func addOpDeleteBackupVaultAccessPolicyValidationMiddleware(stack *middleware.Stack) error {
1022	return stack.Initialize.Add(&validateOpDeleteBackupVaultAccessPolicy{}, middleware.After)
1023}
1024
1025func addOpDeleteBackupVaultValidationMiddleware(stack *middleware.Stack) error {
1026	return stack.Initialize.Add(&validateOpDeleteBackupVault{}, middleware.After)
1027}
1028
1029func addOpDeleteBackupVaultNotificationsValidationMiddleware(stack *middleware.Stack) error {
1030	return stack.Initialize.Add(&validateOpDeleteBackupVaultNotifications{}, middleware.After)
1031}
1032
1033func addOpDeleteFrameworkValidationMiddleware(stack *middleware.Stack) error {
1034	return stack.Initialize.Add(&validateOpDeleteFramework{}, middleware.After)
1035}
1036
1037func addOpDeleteRecoveryPointValidationMiddleware(stack *middleware.Stack) error {
1038	return stack.Initialize.Add(&validateOpDeleteRecoveryPoint{}, middleware.After)
1039}
1040
1041func addOpDeleteReportPlanValidationMiddleware(stack *middleware.Stack) error {
1042	return stack.Initialize.Add(&validateOpDeleteReportPlan{}, middleware.After)
1043}
1044
1045func addOpDescribeBackupJobValidationMiddleware(stack *middleware.Stack) error {
1046	return stack.Initialize.Add(&validateOpDescribeBackupJob{}, middleware.After)
1047}
1048
1049func addOpDescribeBackupVaultValidationMiddleware(stack *middleware.Stack) error {
1050	return stack.Initialize.Add(&validateOpDescribeBackupVault{}, middleware.After)
1051}
1052
1053func addOpDescribeCopyJobValidationMiddleware(stack *middleware.Stack) error {
1054	return stack.Initialize.Add(&validateOpDescribeCopyJob{}, middleware.After)
1055}
1056
1057func addOpDescribeFrameworkValidationMiddleware(stack *middleware.Stack) error {
1058	return stack.Initialize.Add(&validateOpDescribeFramework{}, middleware.After)
1059}
1060
1061func addOpDescribeProtectedResourceValidationMiddleware(stack *middleware.Stack) error {
1062	return stack.Initialize.Add(&validateOpDescribeProtectedResource{}, middleware.After)
1063}
1064
1065func addOpDescribeRecoveryPointValidationMiddleware(stack *middleware.Stack) error {
1066	return stack.Initialize.Add(&validateOpDescribeRecoveryPoint{}, middleware.After)
1067}
1068
1069func addOpDescribeReportJobValidationMiddleware(stack *middleware.Stack) error {
1070	return stack.Initialize.Add(&validateOpDescribeReportJob{}, middleware.After)
1071}
1072
1073func addOpDescribeReportPlanValidationMiddleware(stack *middleware.Stack) error {
1074	return stack.Initialize.Add(&validateOpDescribeReportPlan{}, middleware.After)
1075}
1076
1077func addOpDescribeRestoreJobValidationMiddleware(stack *middleware.Stack) error {
1078	return stack.Initialize.Add(&validateOpDescribeRestoreJob{}, middleware.After)
1079}
1080
1081func addOpDisassociateRecoveryPointValidationMiddleware(stack *middleware.Stack) error {
1082	return stack.Initialize.Add(&validateOpDisassociateRecoveryPoint{}, middleware.After)
1083}
1084
1085func addOpExportBackupPlanTemplateValidationMiddleware(stack *middleware.Stack) error {
1086	return stack.Initialize.Add(&validateOpExportBackupPlanTemplate{}, middleware.After)
1087}
1088
1089func addOpGetBackupPlanFromJSONValidationMiddleware(stack *middleware.Stack) error {
1090	return stack.Initialize.Add(&validateOpGetBackupPlanFromJSON{}, middleware.After)
1091}
1092
1093func addOpGetBackupPlanFromTemplateValidationMiddleware(stack *middleware.Stack) error {
1094	return stack.Initialize.Add(&validateOpGetBackupPlanFromTemplate{}, middleware.After)
1095}
1096
1097func addOpGetBackupPlanValidationMiddleware(stack *middleware.Stack) error {
1098	return stack.Initialize.Add(&validateOpGetBackupPlan{}, middleware.After)
1099}
1100
1101func addOpGetBackupSelectionValidationMiddleware(stack *middleware.Stack) error {
1102	return stack.Initialize.Add(&validateOpGetBackupSelection{}, middleware.After)
1103}
1104
1105func addOpGetBackupVaultAccessPolicyValidationMiddleware(stack *middleware.Stack) error {
1106	return stack.Initialize.Add(&validateOpGetBackupVaultAccessPolicy{}, middleware.After)
1107}
1108
1109func addOpGetBackupVaultNotificationsValidationMiddleware(stack *middleware.Stack) error {
1110	return stack.Initialize.Add(&validateOpGetBackupVaultNotifications{}, middleware.After)
1111}
1112
1113func addOpGetRecoveryPointRestoreMetadataValidationMiddleware(stack *middleware.Stack) error {
1114	return stack.Initialize.Add(&validateOpGetRecoveryPointRestoreMetadata{}, middleware.After)
1115}
1116
1117func addOpListBackupPlanVersionsValidationMiddleware(stack *middleware.Stack) error {
1118	return stack.Initialize.Add(&validateOpListBackupPlanVersions{}, middleware.After)
1119}
1120
1121func addOpListBackupSelectionsValidationMiddleware(stack *middleware.Stack) error {
1122	return stack.Initialize.Add(&validateOpListBackupSelections{}, middleware.After)
1123}
1124
1125func addOpListRecoveryPointsByBackupVaultValidationMiddleware(stack *middleware.Stack) error {
1126	return stack.Initialize.Add(&validateOpListRecoveryPointsByBackupVault{}, middleware.After)
1127}
1128
1129func addOpListRecoveryPointsByResourceValidationMiddleware(stack *middleware.Stack) error {
1130	return stack.Initialize.Add(&validateOpListRecoveryPointsByResource{}, middleware.After)
1131}
1132
1133func addOpListTagsValidationMiddleware(stack *middleware.Stack) error {
1134	return stack.Initialize.Add(&validateOpListTags{}, middleware.After)
1135}
1136
1137func addOpPutBackupVaultAccessPolicyValidationMiddleware(stack *middleware.Stack) error {
1138	return stack.Initialize.Add(&validateOpPutBackupVaultAccessPolicy{}, middleware.After)
1139}
1140
1141func addOpPutBackupVaultNotificationsValidationMiddleware(stack *middleware.Stack) error {
1142	return stack.Initialize.Add(&validateOpPutBackupVaultNotifications{}, middleware.After)
1143}
1144
1145func addOpStartBackupJobValidationMiddleware(stack *middleware.Stack) error {
1146	return stack.Initialize.Add(&validateOpStartBackupJob{}, middleware.After)
1147}
1148
1149func addOpStartCopyJobValidationMiddleware(stack *middleware.Stack) error {
1150	return stack.Initialize.Add(&validateOpStartCopyJob{}, middleware.After)
1151}
1152
1153func addOpStartReportJobValidationMiddleware(stack *middleware.Stack) error {
1154	return stack.Initialize.Add(&validateOpStartReportJob{}, middleware.After)
1155}
1156
1157func addOpStartRestoreJobValidationMiddleware(stack *middleware.Stack) error {
1158	return stack.Initialize.Add(&validateOpStartRestoreJob{}, middleware.After)
1159}
1160
1161func addOpStopBackupJobValidationMiddleware(stack *middleware.Stack) error {
1162	return stack.Initialize.Add(&validateOpStopBackupJob{}, middleware.After)
1163}
1164
1165func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
1166	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
1167}
1168
1169func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
1170	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
1171}
1172
1173func addOpUpdateBackupPlanValidationMiddleware(stack *middleware.Stack) error {
1174	return stack.Initialize.Add(&validateOpUpdateBackupPlan{}, middleware.After)
1175}
1176
1177func addOpUpdateFrameworkValidationMiddleware(stack *middleware.Stack) error {
1178	return stack.Initialize.Add(&validateOpUpdateFramework{}, middleware.After)
1179}
1180
1181func addOpUpdateRecoveryPointLifecycleValidationMiddleware(stack *middleware.Stack) error {
1182	return stack.Initialize.Add(&validateOpUpdateRecoveryPointLifecycle{}, middleware.After)
1183}
1184
1185func addOpUpdateReportPlanValidationMiddleware(stack *middleware.Stack) error {
1186	return stack.Initialize.Add(&validateOpUpdateReportPlan{}, middleware.After)
1187}
1188
1189func validateBackupPlanInput(v *types.BackupPlanInput) error {
1190	if v == nil {
1191		return nil
1192	}
1193	invalidParams := smithy.InvalidParamsError{Context: "BackupPlanInput"}
1194	if v.BackupPlanName == nil {
1195		invalidParams.Add(smithy.NewErrParamRequired("BackupPlanName"))
1196	}
1197	if v.Rules == nil {
1198		invalidParams.Add(smithy.NewErrParamRequired("Rules"))
1199	} else if v.Rules != nil {
1200		if err := validateBackupRulesInput(v.Rules); err != nil {
1201			invalidParams.AddNested("Rules", err.(smithy.InvalidParamsError))
1202		}
1203	}
1204	if invalidParams.Len() > 0 {
1205		return invalidParams
1206	} else {
1207		return nil
1208	}
1209}
1210
1211func validateBackupRuleInput(v *types.BackupRuleInput) error {
1212	if v == nil {
1213		return nil
1214	}
1215	invalidParams := smithy.InvalidParamsError{Context: "BackupRuleInput"}
1216	if v.RuleName == nil {
1217		invalidParams.Add(smithy.NewErrParamRequired("RuleName"))
1218	}
1219	if v.TargetBackupVaultName == nil {
1220		invalidParams.Add(smithy.NewErrParamRequired("TargetBackupVaultName"))
1221	}
1222	if v.CopyActions != nil {
1223		if err := validateCopyActions(v.CopyActions); err != nil {
1224			invalidParams.AddNested("CopyActions", err.(smithy.InvalidParamsError))
1225		}
1226	}
1227	if invalidParams.Len() > 0 {
1228		return invalidParams
1229	} else {
1230		return nil
1231	}
1232}
1233
1234func validateBackupRulesInput(v []types.BackupRuleInput) error {
1235	if v == nil {
1236		return nil
1237	}
1238	invalidParams := smithy.InvalidParamsError{Context: "BackupRulesInput"}
1239	for i := range v {
1240		if err := validateBackupRuleInput(&v[i]); err != nil {
1241			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1242		}
1243	}
1244	if invalidParams.Len() > 0 {
1245		return invalidParams
1246	} else {
1247		return nil
1248	}
1249}
1250
1251func validateBackupSelection(v *types.BackupSelection) error {
1252	if v == nil {
1253		return nil
1254	}
1255	invalidParams := smithy.InvalidParamsError{Context: "BackupSelection"}
1256	if v.SelectionName == nil {
1257		invalidParams.Add(smithy.NewErrParamRequired("SelectionName"))
1258	}
1259	if v.IamRoleArn == nil {
1260		invalidParams.Add(smithy.NewErrParamRequired("IamRoleArn"))
1261	}
1262	if v.ListOfTags != nil {
1263		if err := validateListOfTags(v.ListOfTags); err != nil {
1264			invalidParams.AddNested("ListOfTags", err.(smithy.InvalidParamsError))
1265		}
1266	}
1267	if invalidParams.Len() > 0 {
1268		return invalidParams
1269	} else {
1270		return nil
1271	}
1272}
1273
1274func validateCondition(v *types.Condition) error {
1275	if v == nil {
1276		return nil
1277	}
1278	invalidParams := smithy.InvalidParamsError{Context: "Condition"}
1279	if len(v.ConditionType) == 0 {
1280		invalidParams.Add(smithy.NewErrParamRequired("ConditionType"))
1281	}
1282	if v.ConditionKey == nil {
1283		invalidParams.Add(smithy.NewErrParamRequired("ConditionKey"))
1284	}
1285	if v.ConditionValue == nil {
1286		invalidParams.Add(smithy.NewErrParamRequired("ConditionValue"))
1287	}
1288	if invalidParams.Len() > 0 {
1289		return invalidParams
1290	} else {
1291		return nil
1292	}
1293}
1294
1295func validateCopyAction(v *types.CopyAction) error {
1296	if v == nil {
1297		return nil
1298	}
1299	invalidParams := smithy.InvalidParamsError{Context: "CopyAction"}
1300	if v.DestinationBackupVaultArn == nil {
1301		invalidParams.Add(smithy.NewErrParamRequired("DestinationBackupVaultArn"))
1302	}
1303	if invalidParams.Len() > 0 {
1304		return invalidParams
1305	} else {
1306		return nil
1307	}
1308}
1309
1310func validateCopyActions(v []types.CopyAction) error {
1311	if v == nil {
1312		return nil
1313	}
1314	invalidParams := smithy.InvalidParamsError{Context: "CopyActions"}
1315	for i := range v {
1316		if err := validateCopyAction(&v[i]); err != nil {
1317			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1318		}
1319	}
1320	if invalidParams.Len() > 0 {
1321		return invalidParams
1322	} else {
1323		return nil
1324	}
1325}
1326
1327func validateFrameworkControl(v *types.FrameworkControl) error {
1328	if v == nil {
1329		return nil
1330	}
1331	invalidParams := smithy.InvalidParamsError{Context: "FrameworkControl"}
1332	if v.ControlName == nil {
1333		invalidParams.Add(smithy.NewErrParamRequired("ControlName"))
1334	}
1335	if invalidParams.Len() > 0 {
1336		return invalidParams
1337	} else {
1338		return nil
1339	}
1340}
1341
1342func validateFrameworkControls(v []types.FrameworkControl) error {
1343	if v == nil {
1344		return nil
1345	}
1346	invalidParams := smithy.InvalidParamsError{Context: "FrameworkControls"}
1347	for i := range v {
1348		if err := validateFrameworkControl(&v[i]); err != nil {
1349			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1350		}
1351	}
1352	if invalidParams.Len() > 0 {
1353		return invalidParams
1354	} else {
1355		return nil
1356	}
1357}
1358
1359func validateListOfTags(v []types.Condition) error {
1360	if v == nil {
1361		return nil
1362	}
1363	invalidParams := smithy.InvalidParamsError{Context: "ListOfTags"}
1364	for i := range v {
1365		if err := validateCondition(&v[i]); err != nil {
1366			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1367		}
1368	}
1369	if invalidParams.Len() > 0 {
1370		return invalidParams
1371	} else {
1372		return nil
1373	}
1374}
1375
1376func validateReportDeliveryChannel(v *types.ReportDeliveryChannel) error {
1377	if v == nil {
1378		return nil
1379	}
1380	invalidParams := smithy.InvalidParamsError{Context: "ReportDeliveryChannel"}
1381	if v.S3BucketName == nil {
1382		invalidParams.Add(smithy.NewErrParamRequired("S3BucketName"))
1383	}
1384	if invalidParams.Len() > 0 {
1385		return invalidParams
1386	} else {
1387		return nil
1388	}
1389}
1390
1391func validateReportSetting(v *types.ReportSetting) error {
1392	if v == nil {
1393		return nil
1394	}
1395	invalidParams := smithy.InvalidParamsError{Context: "ReportSetting"}
1396	if v.ReportTemplate == nil {
1397		invalidParams.Add(smithy.NewErrParamRequired("ReportTemplate"))
1398	}
1399	if invalidParams.Len() > 0 {
1400		return invalidParams
1401	} else {
1402		return nil
1403	}
1404}
1405
1406func validateOpCreateBackupPlanInput(v *CreateBackupPlanInput) error {
1407	if v == nil {
1408		return nil
1409	}
1410	invalidParams := smithy.InvalidParamsError{Context: "CreateBackupPlanInput"}
1411	if v.BackupPlan == nil {
1412		invalidParams.Add(smithy.NewErrParamRequired("BackupPlan"))
1413	} else if v.BackupPlan != nil {
1414		if err := validateBackupPlanInput(v.BackupPlan); err != nil {
1415			invalidParams.AddNested("BackupPlan", err.(smithy.InvalidParamsError))
1416		}
1417	}
1418	if invalidParams.Len() > 0 {
1419		return invalidParams
1420	} else {
1421		return nil
1422	}
1423}
1424
1425func validateOpCreateBackupSelectionInput(v *CreateBackupSelectionInput) error {
1426	if v == nil {
1427		return nil
1428	}
1429	invalidParams := smithy.InvalidParamsError{Context: "CreateBackupSelectionInput"}
1430	if v.BackupPlanId == nil {
1431		invalidParams.Add(smithy.NewErrParamRequired("BackupPlanId"))
1432	}
1433	if v.BackupSelection == nil {
1434		invalidParams.Add(smithy.NewErrParamRequired("BackupSelection"))
1435	} else if v.BackupSelection != nil {
1436		if err := validateBackupSelection(v.BackupSelection); err != nil {
1437			invalidParams.AddNested("BackupSelection", err.(smithy.InvalidParamsError))
1438		}
1439	}
1440	if invalidParams.Len() > 0 {
1441		return invalidParams
1442	} else {
1443		return nil
1444	}
1445}
1446
1447func validateOpCreateBackupVaultInput(v *CreateBackupVaultInput) error {
1448	if v == nil {
1449		return nil
1450	}
1451	invalidParams := smithy.InvalidParamsError{Context: "CreateBackupVaultInput"}
1452	if v.BackupVaultName == nil {
1453		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
1454	}
1455	if invalidParams.Len() > 0 {
1456		return invalidParams
1457	} else {
1458		return nil
1459	}
1460}
1461
1462func validateOpCreateFrameworkInput(v *CreateFrameworkInput) error {
1463	if v == nil {
1464		return nil
1465	}
1466	invalidParams := smithy.InvalidParamsError{Context: "CreateFrameworkInput"}
1467	if v.FrameworkName == nil {
1468		invalidParams.Add(smithy.NewErrParamRequired("FrameworkName"))
1469	}
1470	if v.FrameworkControls == nil {
1471		invalidParams.Add(smithy.NewErrParamRequired("FrameworkControls"))
1472	} else if v.FrameworkControls != nil {
1473		if err := validateFrameworkControls(v.FrameworkControls); err != nil {
1474			invalidParams.AddNested("FrameworkControls", err.(smithy.InvalidParamsError))
1475		}
1476	}
1477	if invalidParams.Len() > 0 {
1478		return invalidParams
1479	} else {
1480		return nil
1481	}
1482}
1483
1484func validateOpCreateReportPlanInput(v *CreateReportPlanInput) error {
1485	if v == nil {
1486		return nil
1487	}
1488	invalidParams := smithy.InvalidParamsError{Context: "CreateReportPlanInput"}
1489	if v.ReportPlanName == nil {
1490		invalidParams.Add(smithy.NewErrParamRequired("ReportPlanName"))
1491	}
1492	if v.ReportDeliveryChannel == nil {
1493		invalidParams.Add(smithy.NewErrParamRequired("ReportDeliveryChannel"))
1494	} else if v.ReportDeliveryChannel != nil {
1495		if err := validateReportDeliveryChannel(v.ReportDeliveryChannel); err != nil {
1496			invalidParams.AddNested("ReportDeliveryChannel", err.(smithy.InvalidParamsError))
1497		}
1498	}
1499	if v.ReportSetting == nil {
1500		invalidParams.Add(smithy.NewErrParamRequired("ReportSetting"))
1501	} else if v.ReportSetting != nil {
1502		if err := validateReportSetting(v.ReportSetting); err != nil {
1503			invalidParams.AddNested("ReportSetting", err.(smithy.InvalidParamsError))
1504		}
1505	}
1506	if invalidParams.Len() > 0 {
1507		return invalidParams
1508	} else {
1509		return nil
1510	}
1511}
1512
1513func validateOpDeleteBackupPlanInput(v *DeleteBackupPlanInput) error {
1514	if v == nil {
1515		return nil
1516	}
1517	invalidParams := smithy.InvalidParamsError{Context: "DeleteBackupPlanInput"}
1518	if v.BackupPlanId == nil {
1519		invalidParams.Add(smithy.NewErrParamRequired("BackupPlanId"))
1520	}
1521	if invalidParams.Len() > 0 {
1522		return invalidParams
1523	} else {
1524		return nil
1525	}
1526}
1527
1528func validateOpDeleteBackupSelectionInput(v *DeleteBackupSelectionInput) error {
1529	if v == nil {
1530		return nil
1531	}
1532	invalidParams := smithy.InvalidParamsError{Context: "DeleteBackupSelectionInput"}
1533	if v.BackupPlanId == nil {
1534		invalidParams.Add(smithy.NewErrParamRequired("BackupPlanId"))
1535	}
1536	if v.SelectionId == nil {
1537		invalidParams.Add(smithy.NewErrParamRequired("SelectionId"))
1538	}
1539	if invalidParams.Len() > 0 {
1540		return invalidParams
1541	} else {
1542		return nil
1543	}
1544}
1545
1546func validateOpDeleteBackupVaultAccessPolicyInput(v *DeleteBackupVaultAccessPolicyInput) error {
1547	if v == nil {
1548		return nil
1549	}
1550	invalidParams := smithy.InvalidParamsError{Context: "DeleteBackupVaultAccessPolicyInput"}
1551	if v.BackupVaultName == nil {
1552		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
1553	}
1554	if invalidParams.Len() > 0 {
1555		return invalidParams
1556	} else {
1557		return nil
1558	}
1559}
1560
1561func validateOpDeleteBackupVaultInput(v *DeleteBackupVaultInput) error {
1562	if v == nil {
1563		return nil
1564	}
1565	invalidParams := smithy.InvalidParamsError{Context: "DeleteBackupVaultInput"}
1566	if v.BackupVaultName == nil {
1567		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
1568	}
1569	if invalidParams.Len() > 0 {
1570		return invalidParams
1571	} else {
1572		return nil
1573	}
1574}
1575
1576func validateOpDeleteBackupVaultNotificationsInput(v *DeleteBackupVaultNotificationsInput) error {
1577	if v == nil {
1578		return nil
1579	}
1580	invalidParams := smithy.InvalidParamsError{Context: "DeleteBackupVaultNotificationsInput"}
1581	if v.BackupVaultName == nil {
1582		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
1583	}
1584	if invalidParams.Len() > 0 {
1585		return invalidParams
1586	} else {
1587		return nil
1588	}
1589}
1590
1591func validateOpDeleteFrameworkInput(v *DeleteFrameworkInput) error {
1592	if v == nil {
1593		return nil
1594	}
1595	invalidParams := smithy.InvalidParamsError{Context: "DeleteFrameworkInput"}
1596	if v.FrameworkName == nil {
1597		invalidParams.Add(smithy.NewErrParamRequired("FrameworkName"))
1598	}
1599	if invalidParams.Len() > 0 {
1600		return invalidParams
1601	} else {
1602		return nil
1603	}
1604}
1605
1606func validateOpDeleteRecoveryPointInput(v *DeleteRecoveryPointInput) error {
1607	if v == nil {
1608		return nil
1609	}
1610	invalidParams := smithy.InvalidParamsError{Context: "DeleteRecoveryPointInput"}
1611	if v.BackupVaultName == nil {
1612		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
1613	}
1614	if v.RecoveryPointArn == nil {
1615		invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointArn"))
1616	}
1617	if invalidParams.Len() > 0 {
1618		return invalidParams
1619	} else {
1620		return nil
1621	}
1622}
1623
1624func validateOpDeleteReportPlanInput(v *DeleteReportPlanInput) error {
1625	if v == nil {
1626		return nil
1627	}
1628	invalidParams := smithy.InvalidParamsError{Context: "DeleteReportPlanInput"}
1629	if v.ReportPlanName == nil {
1630		invalidParams.Add(smithy.NewErrParamRequired("ReportPlanName"))
1631	}
1632	if invalidParams.Len() > 0 {
1633		return invalidParams
1634	} else {
1635		return nil
1636	}
1637}
1638
1639func validateOpDescribeBackupJobInput(v *DescribeBackupJobInput) error {
1640	if v == nil {
1641		return nil
1642	}
1643	invalidParams := smithy.InvalidParamsError{Context: "DescribeBackupJobInput"}
1644	if v.BackupJobId == nil {
1645		invalidParams.Add(smithy.NewErrParamRequired("BackupJobId"))
1646	}
1647	if invalidParams.Len() > 0 {
1648		return invalidParams
1649	} else {
1650		return nil
1651	}
1652}
1653
1654func validateOpDescribeBackupVaultInput(v *DescribeBackupVaultInput) error {
1655	if v == nil {
1656		return nil
1657	}
1658	invalidParams := smithy.InvalidParamsError{Context: "DescribeBackupVaultInput"}
1659	if v.BackupVaultName == nil {
1660		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
1661	}
1662	if invalidParams.Len() > 0 {
1663		return invalidParams
1664	} else {
1665		return nil
1666	}
1667}
1668
1669func validateOpDescribeCopyJobInput(v *DescribeCopyJobInput) error {
1670	if v == nil {
1671		return nil
1672	}
1673	invalidParams := smithy.InvalidParamsError{Context: "DescribeCopyJobInput"}
1674	if v.CopyJobId == nil {
1675		invalidParams.Add(smithy.NewErrParamRequired("CopyJobId"))
1676	}
1677	if invalidParams.Len() > 0 {
1678		return invalidParams
1679	} else {
1680		return nil
1681	}
1682}
1683
1684func validateOpDescribeFrameworkInput(v *DescribeFrameworkInput) error {
1685	if v == nil {
1686		return nil
1687	}
1688	invalidParams := smithy.InvalidParamsError{Context: "DescribeFrameworkInput"}
1689	if v.FrameworkName == nil {
1690		invalidParams.Add(smithy.NewErrParamRequired("FrameworkName"))
1691	}
1692	if invalidParams.Len() > 0 {
1693		return invalidParams
1694	} else {
1695		return nil
1696	}
1697}
1698
1699func validateOpDescribeProtectedResourceInput(v *DescribeProtectedResourceInput) error {
1700	if v == nil {
1701		return nil
1702	}
1703	invalidParams := smithy.InvalidParamsError{Context: "DescribeProtectedResourceInput"}
1704	if v.ResourceArn == nil {
1705		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1706	}
1707	if invalidParams.Len() > 0 {
1708		return invalidParams
1709	} else {
1710		return nil
1711	}
1712}
1713
1714func validateOpDescribeRecoveryPointInput(v *DescribeRecoveryPointInput) error {
1715	if v == nil {
1716		return nil
1717	}
1718	invalidParams := smithy.InvalidParamsError{Context: "DescribeRecoveryPointInput"}
1719	if v.BackupVaultName == nil {
1720		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
1721	}
1722	if v.RecoveryPointArn == nil {
1723		invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointArn"))
1724	}
1725	if invalidParams.Len() > 0 {
1726		return invalidParams
1727	} else {
1728		return nil
1729	}
1730}
1731
1732func validateOpDescribeReportJobInput(v *DescribeReportJobInput) error {
1733	if v == nil {
1734		return nil
1735	}
1736	invalidParams := smithy.InvalidParamsError{Context: "DescribeReportJobInput"}
1737	if v.ReportJobId == nil {
1738		invalidParams.Add(smithy.NewErrParamRequired("ReportJobId"))
1739	}
1740	if invalidParams.Len() > 0 {
1741		return invalidParams
1742	} else {
1743		return nil
1744	}
1745}
1746
1747func validateOpDescribeReportPlanInput(v *DescribeReportPlanInput) error {
1748	if v == nil {
1749		return nil
1750	}
1751	invalidParams := smithy.InvalidParamsError{Context: "DescribeReportPlanInput"}
1752	if v.ReportPlanName == nil {
1753		invalidParams.Add(smithy.NewErrParamRequired("ReportPlanName"))
1754	}
1755	if invalidParams.Len() > 0 {
1756		return invalidParams
1757	} else {
1758		return nil
1759	}
1760}
1761
1762func validateOpDescribeRestoreJobInput(v *DescribeRestoreJobInput) error {
1763	if v == nil {
1764		return nil
1765	}
1766	invalidParams := smithy.InvalidParamsError{Context: "DescribeRestoreJobInput"}
1767	if v.RestoreJobId == nil {
1768		invalidParams.Add(smithy.NewErrParamRequired("RestoreJobId"))
1769	}
1770	if invalidParams.Len() > 0 {
1771		return invalidParams
1772	} else {
1773		return nil
1774	}
1775}
1776
1777func validateOpDisassociateRecoveryPointInput(v *DisassociateRecoveryPointInput) error {
1778	if v == nil {
1779		return nil
1780	}
1781	invalidParams := smithy.InvalidParamsError{Context: "DisassociateRecoveryPointInput"}
1782	if v.BackupVaultName == nil {
1783		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
1784	}
1785	if v.RecoveryPointArn == nil {
1786		invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointArn"))
1787	}
1788	if invalidParams.Len() > 0 {
1789		return invalidParams
1790	} else {
1791		return nil
1792	}
1793}
1794
1795func validateOpExportBackupPlanTemplateInput(v *ExportBackupPlanTemplateInput) error {
1796	if v == nil {
1797		return nil
1798	}
1799	invalidParams := smithy.InvalidParamsError{Context: "ExportBackupPlanTemplateInput"}
1800	if v.BackupPlanId == nil {
1801		invalidParams.Add(smithy.NewErrParamRequired("BackupPlanId"))
1802	}
1803	if invalidParams.Len() > 0 {
1804		return invalidParams
1805	} else {
1806		return nil
1807	}
1808}
1809
1810func validateOpGetBackupPlanFromJSONInput(v *GetBackupPlanFromJSONInput) error {
1811	if v == nil {
1812		return nil
1813	}
1814	invalidParams := smithy.InvalidParamsError{Context: "GetBackupPlanFromJSONInput"}
1815	if v.BackupPlanTemplateJson == nil {
1816		invalidParams.Add(smithy.NewErrParamRequired("BackupPlanTemplateJson"))
1817	}
1818	if invalidParams.Len() > 0 {
1819		return invalidParams
1820	} else {
1821		return nil
1822	}
1823}
1824
1825func validateOpGetBackupPlanFromTemplateInput(v *GetBackupPlanFromTemplateInput) error {
1826	if v == nil {
1827		return nil
1828	}
1829	invalidParams := smithy.InvalidParamsError{Context: "GetBackupPlanFromTemplateInput"}
1830	if v.BackupPlanTemplateId == nil {
1831		invalidParams.Add(smithy.NewErrParamRequired("BackupPlanTemplateId"))
1832	}
1833	if invalidParams.Len() > 0 {
1834		return invalidParams
1835	} else {
1836		return nil
1837	}
1838}
1839
1840func validateOpGetBackupPlanInput(v *GetBackupPlanInput) error {
1841	if v == nil {
1842		return nil
1843	}
1844	invalidParams := smithy.InvalidParamsError{Context: "GetBackupPlanInput"}
1845	if v.BackupPlanId == nil {
1846		invalidParams.Add(smithy.NewErrParamRequired("BackupPlanId"))
1847	}
1848	if invalidParams.Len() > 0 {
1849		return invalidParams
1850	} else {
1851		return nil
1852	}
1853}
1854
1855func validateOpGetBackupSelectionInput(v *GetBackupSelectionInput) error {
1856	if v == nil {
1857		return nil
1858	}
1859	invalidParams := smithy.InvalidParamsError{Context: "GetBackupSelectionInput"}
1860	if v.BackupPlanId == nil {
1861		invalidParams.Add(smithy.NewErrParamRequired("BackupPlanId"))
1862	}
1863	if v.SelectionId == nil {
1864		invalidParams.Add(smithy.NewErrParamRequired("SelectionId"))
1865	}
1866	if invalidParams.Len() > 0 {
1867		return invalidParams
1868	} else {
1869		return nil
1870	}
1871}
1872
1873func validateOpGetBackupVaultAccessPolicyInput(v *GetBackupVaultAccessPolicyInput) error {
1874	if v == nil {
1875		return nil
1876	}
1877	invalidParams := smithy.InvalidParamsError{Context: "GetBackupVaultAccessPolicyInput"}
1878	if v.BackupVaultName == nil {
1879		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
1880	}
1881	if invalidParams.Len() > 0 {
1882		return invalidParams
1883	} else {
1884		return nil
1885	}
1886}
1887
1888func validateOpGetBackupVaultNotificationsInput(v *GetBackupVaultNotificationsInput) error {
1889	if v == nil {
1890		return nil
1891	}
1892	invalidParams := smithy.InvalidParamsError{Context: "GetBackupVaultNotificationsInput"}
1893	if v.BackupVaultName == nil {
1894		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
1895	}
1896	if invalidParams.Len() > 0 {
1897		return invalidParams
1898	} else {
1899		return nil
1900	}
1901}
1902
1903func validateOpGetRecoveryPointRestoreMetadataInput(v *GetRecoveryPointRestoreMetadataInput) error {
1904	if v == nil {
1905		return nil
1906	}
1907	invalidParams := smithy.InvalidParamsError{Context: "GetRecoveryPointRestoreMetadataInput"}
1908	if v.BackupVaultName == nil {
1909		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
1910	}
1911	if v.RecoveryPointArn == nil {
1912		invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointArn"))
1913	}
1914	if invalidParams.Len() > 0 {
1915		return invalidParams
1916	} else {
1917		return nil
1918	}
1919}
1920
1921func validateOpListBackupPlanVersionsInput(v *ListBackupPlanVersionsInput) error {
1922	if v == nil {
1923		return nil
1924	}
1925	invalidParams := smithy.InvalidParamsError{Context: "ListBackupPlanVersionsInput"}
1926	if v.BackupPlanId == nil {
1927		invalidParams.Add(smithy.NewErrParamRequired("BackupPlanId"))
1928	}
1929	if invalidParams.Len() > 0 {
1930		return invalidParams
1931	} else {
1932		return nil
1933	}
1934}
1935
1936func validateOpListBackupSelectionsInput(v *ListBackupSelectionsInput) error {
1937	if v == nil {
1938		return nil
1939	}
1940	invalidParams := smithy.InvalidParamsError{Context: "ListBackupSelectionsInput"}
1941	if v.BackupPlanId == nil {
1942		invalidParams.Add(smithy.NewErrParamRequired("BackupPlanId"))
1943	}
1944	if invalidParams.Len() > 0 {
1945		return invalidParams
1946	} else {
1947		return nil
1948	}
1949}
1950
1951func validateOpListRecoveryPointsByBackupVaultInput(v *ListRecoveryPointsByBackupVaultInput) error {
1952	if v == nil {
1953		return nil
1954	}
1955	invalidParams := smithy.InvalidParamsError{Context: "ListRecoveryPointsByBackupVaultInput"}
1956	if v.BackupVaultName == nil {
1957		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
1958	}
1959	if invalidParams.Len() > 0 {
1960		return invalidParams
1961	} else {
1962		return nil
1963	}
1964}
1965
1966func validateOpListRecoveryPointsByResourceInput(v *ListRecoveryPointsByResourceInput) error {
1967	if v == nil {
1968		return nil
1969	}
1970	invalidParams := smithy.InvalidParamsError{Context: "ListRecoveryPointsByResourceInput"}
1971	if v.ResourceArn == nil {
1972		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1973	}
1974	if invalidParams.Len() > 0 {
1975		return invalidParams
1976	} else {
1977		return nil
1978	}
1979}
1980
1981func validateOpListTagsInput(v *ListTagsInput) error {
1982	if v == nil {
1983		return nil
1984	}
1985	invalidParams := smithy.InvalidParamsError{Context: "ListTagsInput"}
1986	if v.ResourceArn == nil {
1987		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1988	}
1989	if invalidParams.Len() > 0 {
1990		return invalidParams
1991	} else {
1992		return nil
1993	}
1994}
1995
1996func validateOpPutBackupVaultAccessPolicyInput(v *PutBackupVaultAccessPolicyInput) error {
1997	if v == nil {
1998		return nil
1999	}
2000	invalidParams := smithy.InvalidParamsError{Context: "PutBackupVaultAccessPolicyInput"}
2001	if v.BackupVaultName == nil {
2002		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
2003	}
2004	if invalidParams.Len() > 0 {
2005		return invalidParams
2006	} else {
2007		return nil
2008	}
2009}
2010
2011func validateOpPutBackupVaultNotificationsInput(v *PutBackupVaultNotificationsInput) error {
2012	if v == nil {
2013		return nil
2014	}
2015	invalidParams := smithy.InvalidParamsError{Context: "PutBackupVaultNotificationsInput"}
2016	if v.BackupVaultName == nil {
2017		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
2018	}
2019	if v.SNSTopicArn == nil {
2020		invalidParams.Add(smithy.NewErrParamRequired("SNSTopicArn"))
2021	}
2022	if v.BackupVaultEvents == nil {
2023		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultEvents"))
2024	}
2025	if invalidParams.Len() > 0 {
2026		return invalidParams
2027	} else {
2028		return nil
2029	}
2030}
2031
2032func validateOpStartBackupJobInput(v *StartBackupJobInput) error {
2033	if v == nil {
2034		return nil
2035	}
2036	invalidParams := smithy.InvalidParamsError{Context: "StartBackupJobInput"}
2037	if v.BackupVaultName == nil {
2038		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
2039	}
2040	if v.ResourceArn == nil {
2041		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
2042	}
2043	if v.IamRoleArn == nil {
2044		invalidParams.Add(smithy.NewErrParamRequired("IamRoleArn"))
2045	}
2046	if invalidParams.Len() > 0 {
2047		return invalidParams
2048	} else {
2049		return nil
2050	}
2051}
2052
2053func validateOpStartCopyJobInput(v *StartCopyJobInput) error {
2054	if v == nil {
2055		return nil
2056	}
2057	invalidParams := smithy.InvalidParamsError{Context: "StartCopyJobInput"}
2058	if v.RecoveryPointArn == nil {
2059		invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointArn"))
2060	}
2061	if v.SourceBackupVaultName == nil {
2062		invalidParams.Add(smithy.NewErrParamRequired("SourceBackupVaultName"))
2063	}
2064	if v.DestinationBackupVaultArn == nil {
2065		invalidParams.Add(smithy.NewErrParamRequired("DestinationBackupVaultArn"))
2066	}
2067	if v.IamRoleArn == nil {
2068		invalidParams.Add(smithy.NewErrParamRequired("IamRoleArn"))
2069	}
2070	if invalidParams.Len() > 0 {
2071		return invalidParams
2072	} else {
2073		return nil
2074	}
2075}
2076
2077func validateOpStartReportJobInput(v *StartReportJobInput) error {
2078	if v == nil {
2079		return nil
2080	}
2081	invalidParams := smithy.InvalidParamsError{Context: "StartReportJobInput"}
2082	if v.ReportPlanName == nil {
2083		invalidParams.Add(smithy.NewErrParamRequired("ReportPlanName"))
2084	}
2085	if invalidParams.Len() > 0 {
2086		return invalidParams
2087	} else {
2088		return nil
2089	}
2090}
2091
2092func validateOpStartRestoreJobInput(v *StartRestoreJobInput) error {
2093	if v == nil {
2094		return nil
2095	}
2096	invalidParams := smithy.InvalidParamsError{Context: "StartRestoreJobInput"}
2097	if v.RecoveryPointArn == nil {
2098		invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointArn"))
2099	}
2100	if v.Metadata == nil {
2101		invalidParams.Add(smithy.NewErrParamRequired("Metadata"))
2102	}
2103	if v.IamRoleArn == nil {
2104		invalidParams.Add(smithy.NewErrParamRequired("IamRoleArn"))
2105	}
2106	if invalidParams.Len() > 0 {
2107		return invalidParams
2108	} else {
2109		return nil
2110	}
2111}
2112
2113func validateOpStopBackupJobInput(v *StopBackupJobInput) error {
2114	if v == nil {
2115		return nil
2116	}
2117	invalidParams := smithy.InvalidParamsError{Context: "StopBackupJobInput"}
2118	if v.BackupJobId == nil {
2119		invalidParams.Add(smithy.NewErrParamRequired("BackupJobId"))
2120	}
2121	if invalidParams.Len() > 0 {
2122		return invalidParams
2123	} else {
2124		return nil
2125	}
2126}
2127
2128func validateOpTagResourceInput(v *TagResourceInput) error {
2129	if v == nil {
2130		return nil
2131	}
2132	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
2133	if v.ResourceArn == nil {
2134		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
2135	}
2136	if v.Tags == nil {
2137		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
2138	}
2139	if invalidParams.Len() > 0 {
2140		return invalidParams
2141	} else {
2142		return nil
2143	}
2144}
2145
2146func validateOpUntagResourceInput(v *UntagResourceInput) error {
2147	if v == nil {
2148		return nil
2149	}
2150	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
2151	if v.ResourceArn == nil {
2152		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
2153	}
2154	if v.TagKeyList == nil {
2155		invalidParams.Add(smithy.NewErrParamRequired("TagKeyList"))
2156	}
2157	if invalidParams.Len() > 0 {
2158		return invalidParams
2159	} else {
2160		return nil
2161	}
2162}
2163
2164func validateOpUpdateBackupPlanInput(v *UpdateBackupPlanInput) error {
2165	if v == nil {
2166		return nil
2167	}
2168	invalidParams := smithy.InvalidParamsError{Context: "UpdateBackupPlanInput"}
2169	if v.BackupPlanId == nil {
2170		invalidParams.Add(smithy.NewErrParamRequired("BackupPlanId"))
2171	}
2172	if v.BackupPlan == nil {
2173		invalidParams.Add(smithy.NewErrParamRequired("BackupPlan"))
2174	} else if v.BackupPlan != nil {
2175		if err := validateBackupPlanInput(v.BackupPlan); err != nil {
2176			invalidParams.AddNested("BackupPlan", err.(smithy.InvalidParamsError))
2177		}
2178	}
2179	if invalidParams.Len() > 0 {
2180		return invalidParams
2181	} else {
2182		return nil
2183	}
2184}
2185
2186func validateOpUpdateFrameworkInput(v *UpdateFrameworkInput) error {
2187	if v == nil {
2188		return nil
2189	}
2190	invalidParams := smithy.InvalidParamsError{Context: "UpdateFrameworkInput"}
2191	if v.FrameworkName == nil {
2192		invalidParams.Add(smithy.NewErrParamRequired("FrameworkName"))
2193	}
2194	if v.FrameworkControls != nil {
2195		if err := validateFrameworkControls(v.FrameworkControls); err != nil {
2196			invalidParams.AddNested("FrameworkControls", err.(smithy.InvalidParamsError))
2197		}
2198	}
2199	if invalidParams.Len() > 0 {
2200		return invalidParams
2201	} else {
2202		return nil
2203	}
2204}
2205
2206func validateOpUpdateRecoveryPointLifecycleInput(v *UpdateRecoveryPointLifecycleInput) error {
2207	if v == nil {
2208		return nil
2209	}
2210	invalidParams := smithy.InvalidParamsError{Context: "UpdateRecoveryPointLifecycleInput"}
2211	if v.BackupVaultName == nil {
2212		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
2213	}
2214	if v.RecoveryPointArn == nil {
2215		invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointArn"))
2216	}
2217	if invalidParams.Len() > 0 {
2218		return invalidParams
2219	} else {
2220		return nil
2221	}
2222}
2223
2224func validateOpUpdateReportPlanInput(v *UpdateReportPlanInput) error {
2225	if v == nil {
2226		return nil
2227	}
2228	invalidParams := smithy.InvalidParamsError{Context: "UpdateReportPlanInput"}
2229	if v.ReportPlanName == nil {
2230		invalidParams.Add(smithy.NewErrParamRequired("ReportPlanName"))
2231	}
2232	if v.ReportDeliveryChannel != nil {
2233		if err := validateReportDeliveryChannel(v.ReportDeliveryChannel); err != nil {
2234			invalidParams.AddNested("ReportDeliveryChannel", err.(smithy.InvalidParamsError))
2235		}
2236	}
2237	if v.ReportSetting != nil {
2238		if err := validateReportSetting(v.ReportSetting); err != nil {
2239			invalidParams.AddNested("ReportSetting", err.(smithy.InvalidParamsError))
2240		}
2241	}
2242	if invalidParams.Len() > 0 {
2243		return invalidParams
2244	} else {
2245		return nil
2246	}
2247}
2248