1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package glacier
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/glacier/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpAbortMultipartUpload struct {
14}
15
16func (*validateOpAbortMultipartUpload) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpAbortMultipartUpload) 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.(*AbortMultipartUploadInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpAbortMultipartUploadInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpAbortVaultLock struct {
34}
35
36func (*validateOpAbortVaultLock) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpAbortVaultLock) 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.(*AbortVaultLockInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpAbortVaultLockInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpAddTagsToVault struct {
54}
55
56func (*validateOpAddTagsToVault) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpAddTagsToVault) 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.(*AddTagsToVaultInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpAddTagsToVaultInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpCompleteMultipartUpload struct {
74}
75
76func (*validateOpCompleteMultipartUpload) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpCompleteMultipartUpload) 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.(*CompleteMultipartUploadInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpCompleteMultipartUploadInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpCompleteVaultLock struct {
94}
95
96func (*validateOpCompleteVaultLock) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpCompleteVaultLock) 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.(*CompleteVaultLockInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpCompleteVaultLockInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpCreateVault struct {
114}
115
116func (*validateOpCreateVault) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpCreateVault) 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.(*CreateVaultInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpCreateVaultInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpDeleteArchive struct {
134}
135
136func (*validateOpDeleteArchive) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpDeleteArchive) 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.(*DeleteArchiveInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpDeleteArchiveInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpDeleteVaultAccessPolicy struct {
154}
155
156func (*validateOpDeleteVaultAccessPolicy) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpDeleteVaultAccessPolicy) 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.(*DeleteVaultAccessPolicyInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpDeleteVaultAccessPolicyInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpDeleteVault struct {
174}
175
176func (*validateOpDeleteVault) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpDeleteVault) 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.(*DeleteVaultInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpDeleteVaultInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpDeleteVaultNotifications struct {
194}
195
196func (*validateOpDeleteVaultNotifications) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpDeleteVaultNotifications) 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.(*DeleteVaultNotificationsInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpDeleteVaultNotificationsInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpDescribeJob struct {
214}
215
216func (*validateOpDescribeJob) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpDescribeJob) 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.(*DescribeJobInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpDescribeJobInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpDescribeVault struct {
234}
235
236func (*validateOpDescribeVault) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpDescribeVault) 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.(*DescribeVaultInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpDescribeVaultInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpGetDataRetrievalPolicy struct {
254}
255
256func (*validateOpGetDataRetrievalPolicy) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpGetDataRetrievalPolicy) 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.(*GetDataRetrievalPolicyInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpGetDataRetrievalPolicyInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpGetJobOutput struct {
274}
275
276func (*validateOpGetJobOutput) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpGetJobOutput) 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.(*GetJobOutputInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpGetJobOutputInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpGetVaultAccessPolicy struct {
294}
295
296func (*validateOpGetVaultAccessPolicy) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpGetVaultAccessPolicy) 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.(*GetVaultAccessPolicyInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpGetVaultAccessPolicyInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpGetVaultLock struct {
314}
315
316func (*validateOpGetVaultLock) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpGetVaultLock) 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.(*GetVaultLockInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpGetVaultLockInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpGetVaultNotifications struct {
334}
335
336func (*validateOpGetVaultNotifications) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpGetVaultNotifications) 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.(*GetVaultNotificationsInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpGetVaultNotificationsInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpInitiateJob struct {
354}
355
356func (*validateOpInitiateJob) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpInitiateJob) 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.(*InitiateJobInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpInitiateJobInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpInitiateMultipartUpload struct {
374}
375
376func (*validateOpInitiateMultipartUpload) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpInitiateMultipartUpload) 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.(*InitiateMultipartUploadInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpInitiateMultipartUploadInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpInitiateVaultLock struct {
394}
395
396func (*validateOpInitiateVaultLock) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpInitiateVaultLock) 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.(*InitiateVaultLockInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpInitiateVaultLockInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpListJobs struct {
414}
415
416func (*validateOpListJobs) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpListJobs) 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.(*ListJobsInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpListJobsInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpListMultipartUploads struct {
434}
435
436func (*validateOpListMultipartUploads) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpListMultipartUploads) 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.(*ListMultipartUploadsInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpListMultipartUploadsInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpListParts struct {
454}
455
456func (*validateOpListParts) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpListParts) 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.(*ListPartsInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpListPartsInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpListProvisionedCapacity struct {
474}
475
476func (*validateOpListProvisionedCapacity) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpListProvisionedCapacity) 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.(*ListProvisionedCapacityInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpListProvisionedCapacityInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpListTagsForVault struct {
494}
495
496func (*validateOpListTagsForVault) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpListTagsForVault) 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.(*ListTagsForVaultInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpListTagsForVaultInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpListVaults struct {
514}
515
516func (*validateOpListVaults) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpListVaults) 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.(*ListVaultsInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpListVaultsInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpPurchaseProvisionedCapacity struct {
534}
535
536func (*validateOpPurchaseProvisionedCapacity) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpPurchaseProvisionedCapacity) 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.(*PurchaseProvisionedCapacityInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpPurchaseProvisionedCapacityInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpRemoveTagsFromVault struct {
554}
555
556func (*validateOpRemoveTagsFromVault) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpRemoveTagsFromVault) 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.(*RemoveTagsFromVaultInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpRemoveTagsFromVaultInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpSetDataRetrievalPolicy struct {
574}
575
576func (*validateOpSetDataRetrievalPolicy) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpSetDataRetrievalPolicy) 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.(*SetDataRetrievalPolicyInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpSetDataRetrievalPolicyInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpSetVaultAccessPolicy struct {
594}
595
596func (*validateOpSetVaultAccessPolicy) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpSetVaultAccessPolicy) 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.(*SetVaultAccessPolicyInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpSetVaultAccessPolicyInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpSetVaultNotifications struct {
614}
615
616func (*validateOpSetVaultNotifications) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpSetVaultNotifications) 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.(*SetVaultNotificationsInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpSetVaultNotificationsInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpUploadArchive struct {
634}
635
636func (*validateOpUploadArchive) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpUploadArchive) 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.(*UploadArchiveInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpUploadArchiveInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653type validateOpUploadMultipartPart struct {
654}
655
656func (*validateOpUploadMultipartPart) ID() string {
657	return "OperationInputValidation"
658}
659
660func (m *validateOpUploadMultipartPart) 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.(*UploadMultipartPartInput)
664	if !ok {
665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666	}
667	if err := validateOpUploadMultipartPartInput(input); err != nil {
668		return out, metadata, err
669	}
670	return next.HandleInitialize(ctx, in)
671}
672
673func addOpAbortMultipartUploadValidationMiddleware(stack *middleware.Stack) error {
674	return stack.Initialize.Add(&validateOpAbortMultipartUpload{}, middleware.After)
675}
676
677func addOpAbortVaultLockValidationMiddleware(stack *middleware.Stack) error {
678	return stack.Initialize.Add(&validateOpAbortVaultLock{}, middleware.After)
679}
680
681func addOpAddTagsToVaultValidationMiddleware(stack *middleware.Stack) error {
682	return stack.Initialize.Add(&validateOpAddTagsToVault{}, middleware.After)
683}
684
685func addOpCompleteMultipartUploadValidationMiddleware(stack *middleware.Stack) error {
686	return stack.Initialize.Add(&validateOpCompleteMultipartUpload{}, middleware.After)
687}
688
689func addOpCompleteVaultLockValidationMiddleware(stack *middleware.Stack) error {
690	return stack.Initialize.Add(&validateOpCompleteVaultLock{}, middleware.After)
691}
692
693func addOpCreateVaultValidationMiddleware(stack *middleware.Stack) error {
694	return stack.Initialize.Add(&validateOpCreateVault{}, middleware.After)
695}
696
697func addOpDeleteArchiveValidationMiddleware(stack *middleware.Stack) error {
698	return stack.Initialize.Add(&validateOpDeleteArchive{}, middleware.After)
699}
700
701func addOpDeleteVaultAccessPolicyValidationMiddleware(stack *middleware.Stack) error {
702	return stack.Initialize.Add(&validateOpDeleteVaultAccessPolicy{}, middleware.After)
703}
704
705func addOpDeleteVaultValidationMiddleware(stack *middleware.Stack) error {
706	return stack.Initialize.Add(&validateOpDeleteVault{}, middleware.After)
707}
708
709func addOpDeleteVaultNotificationsValidationMiddleware(stack *middleware.Stack) error {
710	return stack.Initialize.Add(&validateOpDeleteVaultNotifications{}, middleware.After)
711}
712
713func addOpDescribeJobValidationMiddleware(stack *middleware.Stack) error {
714	return stack.Initialize.Add(&validateOpDescribeJob{}, middleware.After)
715}
716
717func addOpDescribeVaultValidationMiddleware(stack *middleware.Stack) error {
718	return stack.Initialize.Add(&validateOpDescribeVault{}, middleware.After)
719}
720
721func addOpGetDataRetrievalPolicyValidationMiddleware(stack *middleware.Stack) error {
722	return stack.Initialize.Add(&validateOpGetDataRetrievalPolicy{}, middleware.After)
723}
724
725func addOpGetJobOutputValidationMiddleware(stack *middleware.Stack) error {
726	return stack.Initialize.Add(&validateOpGetJobOutput{}, middleware.After)
727}
728
729func addOpGetVaultAccessPolicyValidationMiddleware(stack *middleware.Stack) error {
730	return stack.Initialize.Add(&validateOpGetVaultAccessPolicy{}, middleware.After)
731}
732
733func addOpGetVaultLockValidationMiddleware(stack *middleware.Stack) error {
734	return stack.Initialize.Add(&validateOpGetVaultLock{}, middleware.After)
735}
736
737func addOpGetVaultNotificationsValidationMiddleware(stack *middleware.Stack) error {
738	return stack.Initialize.Add(&validateOpGetVaultNotifications{}, middleware.After)
739}
740
741func addOpInitiateJobValidationMiddleware(stack *middleware.Stack) error {
742	return stack.Initialize.Add(&validateOpInitiateJob{}, middleware.After)
743}
744
745func addOpInitiateMultipartUploadValidationMiddleware(stack *middleware.Stack) error {
746	return stack.Initialize.Add(&validateOpInitiateMultipartUpload{}, middleware.After)
747}
748
749func addOpInitiateVaultLockValidationMiddleware(stack *middleware.Stack) error {
750	return stack.Initialize.Add(&validateOpInitiateVaultLock{}, middleware.After)
751}
752
753func addOpListJobsValidationMiddleware(stack *middleware.Stack) error {
754	return stack.Initialize.Add(&validateOpListJobs{}, middleware.After)
755}
756
757func addOpListMultipartUploadsValidationMiddleware(stack *middleware.Stack) error {
758	return stack.Initialize.Add(&validateOpListMultipartUploads{}, middleware.After)
759}
760
761func addOpListPartsValidationMiddleware(stack *middleware.Stack) error {
762	return stack.Initialize.Add(&validateOpListParts{}, middleware.After)
763}
764
765func addOpListProvisionedCapacityValidationMiddleware(stack *middleware.Stack) error {
766	return stack.Initialize.Add(&validateOpListProvisionedCapacity{}, middleware.After)
767}
768
769func addOpListTagsForVaultValidationMiddleware(stack *middleware.Stack) error {
770	return stack.Initialize.Add(&validateOpListTagsForVault{}, middleware.After)
771}
772
773func addOpListVaultsValidationMiddleware(stack *middleware.Stack) error {
774	return stack.Initialize.Add(&validateOpListVaults{}, middleware.After)
775}
776
777func addOpPurchaseProvisionedCapacityValidationMiddleware(stack *middleware.Stack) error {
778	return stack.Initialize.Add(&validateOpPurchaseProvisionedCapacity{}, middleware.After)
779}
780
781func addOpRemoveTagsFromVaultValidationMiddleware(stack *middleware.Stack) error {
782	return stack.Initialize.Add(&validateOpRemoveTagsFromVault{}, middleware.After)
783}
784
785func addOpSetDataRetrievalPolicyValidationMiddleware(stack *middleware.Stack) error {
786	return stack.Initialize.Add(&validateOpSetDataRetrievalPolicy{}, middleware.After)
787}
788
789func addOpSetVaultAccessPolicyValidationMiddleware(stack *middleware.Stack) error {
790	return stack.Initialize.Add(&validateOpSetVaultAccessPolicy{}, middleware.After)
791}
792
793func addOpSetVaultNotificationsValidationMiddleware(stack *middleware.Stack) error {
794	return stack.Initialize.Add(&validateOpSetVaultNotifications{}, middleware.After)
795}
796
797func addOpUploadArchiveValidationMiddleware(stack *middleware.Stack) error {
798	return stack.Initialize.Add(&validateOpUploadArchive{}, middleware.After)
799}
800
801func addOpUploadMultipartPartValidationMiddleware(stack *middleware.Stack) error {
802	return stack.Initialize.Add(&validateOpUploadMultipartPart{}, middleware.After)
803}
804
805func validateAccessControlPolicyList(v []types.Grant) error {
806	if v == nil {
807		return nil
808	}
809	invalidParams := smithy.InvalidParamsError{Context: "AccessControlPolicyList"}
810	for i := range v {
811		if err := validateGrant(&v[i]); err != nil {
812			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
813		}
814	}
815	if invalidParams.Len() > 0 {
816		return invalidParams
817	} else {
818		return nil
819	}
820}
821
822func validateGrant(v *types.Grant) error {
823	if v == nil {
824		return nil
825	}
826	invalidParams := smithy.InvalidParamsError{Context: "Grant"}
827	if v.Grantee != nil {
828		if err := validateGrantee(v.Grantee); err != nil {
829			invalidParams.AddNested("Grantee", err.(smithy.InvalidParamsError))
830		}
831	}
832	if invalidParams.Len() > 0 {
833		return invalidParams
834	} else {
835		return nil
836	}
837}
838
839func validateGrantee(v *types.Grantee) error {
840	if v == nil {
841		return nil
842	}
843	invalidParams := smithy.InvalidParamsError{Context: "Grantee"}
844	if len(v.Type) == 0 {
845		invalidParams.Add(smithy.NewErrParamRequired("Type"))
846	}
847	if invalidParams.Len() > 0 {
848		return invalidParams
849	} else {
850		return nil
851	}
852}
853
854func validateJobParameters(v *types.JobParameters) error {
855	if v == nil {
856		return nil
857	}
858	invalidParams := smithy.InvalidParamsError{Context: "JobParameters"}
859	if v.OutputLocation != nil {
860		if err := validateOutputLocation(v.OutputLocation); err != nil {
861			invalidParams.AddNested("OutputLocation", err.(smithy.InvalidParamsError))
862		}
863	}
864	if invalidParams.Len() > 0 {
865		return invalidParams
866	} else {
867		return nil
868	}
869}
870
871func validateOutputLocation(v *types.OutputLocation) error {
872	if v == nil {
873		return nil
874	}
875	invalidParams := smithy.InvalidParamsError{Context: "OutputLocation"}
876	if v.S3 != nil {
877		if err := validateS3Location(v.S3); err != nil {
878			invalidParams.AddNested("S3", err.(smithy.InvalidParamsError))
879		}
880	}
881	if invalidParams.Len() > 0 {
882		return invalidParams
883	} else {
884		return nil
885	}
886}
887
888func validateS3Location(v *types.S3Location) error {
889	if v == nil {
890		return nil
891	}
892	invalidParams := smithy.InvalidParamsError{Context: "S3Location"}
893	if v.AccessControlList != nil {
894		if err := validateAccessControlPolicyList(v.AccessControlList); err != nil {
895			invalidParams.AddNested("AccessControlList", err.(smithy.InvalidParamsError))
896		}
897	}
898	if invalidParams.Len() > 0 {
899		return invalidParams
900	} else {
901		return nil
902	}
903}
904
905func validateOpAbortMultipartUploadInput(v *AbortMultipartUploadInput) error {
906	if v == nil {
907		return nil
908	}
909	invalidParams := smithy.InvalidParamsError{Context: "AbortMultipartUploadInput"}
910	if v.AccountId == nil {
911		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
912	}
913	if v.VaultName == nil {
914		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
915	}
916	if v.UploadId == nil {
917		invalidParams.Add(smithy.NewErrParamRequired("UploadId"))
918	}
919	if invalidParams.Len() > 0 {
920		return invalidParams
921	} else {
922		return nil
923	}
924}
925
926func validateOpAbortVaultLockInput(v *AbortVaultLockInput) error {
927	if v == nil {
928		return nil
929	}
930	invalidParams := smithy.InvalidParamsError{Context: "AbortVaultLockInput"}
931	if v.AccountId == nil {
932		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
933	}
934	if v.VaultName == nil {
935		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
936	}
937	if invalidParams.Len() > 0 {
938		return invalidParams
939	} else {
940		return nil
941	}
942}
943
944func validateOpAddTagsToVaultInput(v *AddTagsToVaultInput) error {
945	if v == nil {
946		return nil
947	}
948	invalidParams := smithy.InvalidParamsError{Context: "AddTagsToVaultInput"}
949	if v.AccountId == nil {
950		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
951	}
952	if v.VaultName == nil {
953		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
954	}
955	if invalidParams.Len() > 0 {
956		return invalidParams
957	} else {
958		return nil
959	}
960}
961
962func validateOpCompleteMultipartUploadInput(v *CompleteMultipartUploadInput) error {
963	if v == nil {
964		return nil
965	}
966	invalidParams := smithy.InvalidParamsError{Context: "CompleteMultipartUploadInput"}
967	if v.AccountId == nil {
968		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
969	}
970	if v.VaultName == nil {
971		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
972	}
973	if v.UploadId == nil {
974		invalidParams.Add(smithy.NewErrParamRequired("UploadId"))
975	}
976	if invalidParams.Len() > 0 {
977		return invalidParams
978	} else {
979		return nil
980	}
981}
982
983func validateOpCompleteVaultLockInput(v *CompleteVaultLockInput) error {
984	if v == nil {
985		return nil
986	}
987	invalidParams := smithy.InvalidParamsError{Context: "CompleteVaultLockInput"}
988	if v.AccountId == nil {
989		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
990	}
991	if v.VaultName == nil {
992		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
993	}
994	if v.LockId == nil {
995		invalidParams.Add(smithy.NewErrParamRequired("LockId"))
996	}
997	if invalidParams.Len() > 0 {
998		return invalidParams
999	} else {
1000		return nil
1001	}
1002}
1003
1004func validateOpCreateVaultInput(v *CreateVaultInput) error {
1005	if v == nil {
1006		return nil
1007	}
1008	invalidParams := smithy.InvalidParamsError{Context: "CreateVaultInput"}
1009	if v.AccountId == nil {
1010		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1011	}
1012	if v.VaultName == nil {
1013		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
1014	}
1015	if invalidParams.Len() > 0 {
1016		return invalidParams
1017	} else {
1018		return nil
1019	}
1020}
1021
1022func validateOpDeleteArchiveInput(v *DeleteArchiveInput) error {
1023	if v == nil {
1024		return nil
1025	}
1026	invalidParams := smithy.InvalidParamsError{Context: "DeleteArchiveInput"}
1027	if v.AccountId == nil {
1028		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1029	}
1030	if v.VaultName == nil {
1031		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
1032	}
1033	if v.ArchiveId == nil {
1034		invalidParams.Add(smithy.NewErrParamRequired("ArchiveId"))
1035	}
1036	if invalidParams.Len() > 0 {
1037		return invalidParams
1038	} else {
1039		return nil
1040	}
1041}
1042
1043func validateOpDeleteVaultAccessPolicyInput(v *DeleteVaultAccessPolicyInput) error {
1044	if v == nil {
1045		return nil
1046	}
1047	invalidParams := smithy.InvalidParamsError{Context: "DeleteVaultAccessPolicyInput"}
1048	if v.AccountId == nil {
1049		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1050	}
1051	if v.VaultName == nil {
1052		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
1053	}
1054	if invalidParams.Len() > 0 {
1055		return invalidParams
1056	} else {
1057		return nil
1058	}
1059}
1060
1061func validateOpDeleteVaultInput(v *DeleteVaultInput) error {
1062	if v == nil {
1063		return nil
1064	}
1065	invalidParams := smithy.InvalidParamsError{Context: "DeleteVaultInput"}
1066	if v.AccountId == nil {
1067		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1068	}
1069	if v.VaultName == nil {
1070		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
1071	}
1072	if invalidParams.Len() > 0 {
1073		return invalidParams
1074	} else {
1075		return nil
1076	}
1077}
1078
1079func validateOpDeleteVaultNotificationsInput(v *DeleteVaultNotificationsInput) error {
1080	if v == nil {
1081		return nil
1082	}
1083	invalidParams := smithy.InvalidParamsError{Context: "DeleteVaultNotificationsInput"}
1084	if v.AccountId == nil {
1085		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1086	}
1087	if v.VaultName == nil {
1088		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
1089	}
1090	if invalidParams.Len() > 0 {
1091		return invalidParams
1092	} else {
1093		return nil
1094	}
1095}
1096
1097func validateOpDescribeJobInput(v *DescribeJobInput) error {
1098	if v == nil {
1099		return nil
1100	}
1101	invalidParams := smithy.InvalidParamsError{Context: "DescribeJobInput"}
1102	if v.AccountId == nil {
1103		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1104	}
1105	if v.VaultName == nil {
1106		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
1107	}
1108	if v.JobId == nil {
1109		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
1110	}
1111	if invalidParams.Len() > 0 {
1112		return invalidParams
1113	} else {
1114		return nil
1115	}
1116}
1117
1118func validateOpDescribeVaultInput(v *DescribeVaultInput) error {
1119	if v == nil {
1120		return nil
1121	}
1122	invalidParams := smithy.InvalidParamsError{Context: "DescribeVaultInput"}
1123	if v.AccountId == nil {
1124		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1125	}
1126	if v.VaultName == nil {
1127		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
1128	}
1129	if invalidParams.Len() > 0 {
1130		return invalidParams
1131	} else {
1132		return nil
1133	}
1134}
1135
1136func validateOpGetDataRetrievalPolicyInput(v *GetDataRetrievalPolicyInput) error {
1137	if v == nil {
1138		return nil
1139	}
1140	invalidParams := smithy.InvalidParamsError{Context: "GetDataRetrievalPolicyInput"}
1141	if v.AccountId == nil {
1142		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1143	}
1144	if invalidParams.Len() > 0 {
1145		return invalidParams
1146	} else {
1147		return nil
1148	}
1149}
1150
1151func validateOpGetJobOutputInput(v *GetJobOutputInput) error {
1152	if v == nil {
1153		return nil
1154	}
1155	invalidParams := smithy.InvalidParamsError{Context: "GetJobOutputInput"}
1156	if v.AccountId == nil {
1157		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1158	}
1159	if v.VaultName == nil {
1160		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
1161	}
1162	if v.JobId == nil {
1163		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
1164	}
1165	if invalidParams.Len() > 0 {
1166		return invalidParams
1167	} else {
1168		return nil
1169	}
1170}
1171
1172func validateOpGetVaultAccessPolicyInput(v *GetVaultAccessPolicyInput) error {
1173	if v == nil {
1174		return nil
1175	}
1176	invalidParams := smithy.InvalidParamsError{Context: "GetVaultAccessPolicyInput"}
1177	if v.AccountId == nil {
1178		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1179	}
1180	if v.VaultName == nil {
1181		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
1182	}
1183	if invalidParams.Len() > 0 {
1184		return invalidParams
1185	} else {
1186		return nil
1187	}
1188}
1189
1190func validateOpGetVaultLockInput(v *GetVaultLockInput) error {
1191	if v == nil {
1192		return nil
1193	}
1194	invalidParams := smithy.InvalidParamsError{Context: "GetVaultLockInput"}
1195	if v.AccountId == nil {
1196		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1197	}
1198	if v.VaultName == nil {
1199		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
1200	}
1201	if invalidParams.Len() > 0 {
1202		return invalidParams
1203	} else {
1204		return nil
1205	}
1206}
1207
1208func validateOpGetVaultNotificationsInput(v *GetVaultNotificationsInput) error {
1209	if v == nil {
1210		return nil
1211	}
1212	invalidParams := smithy.InvalidParamsError{Context: "GetVaultNotificationsInput"}
1213	if v.AccountId == nil {
1214		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1215	}
1216	if v.VaultName == nil {
1217		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
1218	}
1219	if invalidParams.Len() > 0 {
1220		return invalidParams
1221	} else {
1222		return nil
1223	}
1224}
1225
1226func validateOpInitiateJobInput(v *InitiateJobInput) error {
1227	if v == nil {
1228		return nil
1229	}
1230	invalidParams := smithy.InvalidParamsError{Context: "InitiateJobInput"}
1231	if v.AccountId == nil {
1232		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1233	}
1234	if v.VaultName == nil {
1235		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
1236	}
1237	if v.JobParameters != nil {
1238		if err := validateJobParameters(v.JobParameters); err != nil {
1239			invalidParams.AddNested("JobParameters", err.(smithy.InvalidParamsError))
1240		}
1241	}
1242	if invalidParams.Len() > 0 {
1243		return invalidParams
1244	} else {
1245		return nil
1246	}
1247}
1248
1249func validateOpInitiateMultipartUploadInput(v *InitiateMultipartUploadInput) error {
1250	if v == nil {
1251		return nil
1252	}
1253	invalidParams := smithy.InvalidParamsError{Context: "InitiateMultipartUploadInput"}
1254	if v.AccountId == nil {
1255		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1256	}
1257	if v.VaultName == nil {
1258		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
1259	}
1260	if invalidParams.Len() > 0 {
1261		return invalidParams
1262	} else {
1263		return nil
1264	}
1265}
1266
1267func validateOpInitiateVaultLockInput(v *InitiateVaultLockInput) error {
1268	if v == nil {
1269		return nil
1270	}
1271	invalidParams := smithy.InvalidParamsError{Context: "InitiateVaultLockInput"}
1272	if v.AccountId == nil {
1273		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1274	}
1275	if v.VaultName == nil {
1276		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
1277	}
1278	if invalidParams.Len() > 0 {
1279		return invalidParams
1280	} else {
1281		return nil
1282	}
1283}
1284
1285func validateOpListJobsInput(v *ListJobsInput) error {
1286	if v == nil {
1287		return nil
1288	}
1289	invalidParams := smithy.InvalidParamsError{Context: "ListJobsInput"}
1290	if v.AccountId == nil {
1291		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1292	}
1293	if v.VaultName == nil {
1294		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
1295	}
1296	if invalidParams.Len() > 0 {
1297		return invalidParams
1298	} else {
1299		return nil
1300	}
1301}
1302
1303func validateOpListMultipartUploadsInput(v *ListMultipartUploadsInput) error {
1304	if v == nil {
1305		return nil
1306	}
1307	invalidParams := smithy.InvalidParamsError{Context: "ListMultipartUploadsInput"}
1308	if v.AccountId == nil {
1309		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1310	}
1311	if v.VaultName == nil {
1312		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
1313	}
1314	if invalidParams.Len() > 0 {
1315		return invalidParams
1316	} else {
1317		return nil
1318	}
1319}
1320
1321func validateOpListPartsInput(v *ListPartsInput) error {
1322	if v == nil {
1323		return nil
1324	}
1325	invalidParams := smithy.InvalidParamsError{Context: "ListPartsInput"}
1326	if v.AccountId == nil {
1327		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1328	}
1329	if v.VaultName == nil {
1330		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
1331	}
1332	if v.UploadId == nil {
1333		invalidParams.Add(smithy.NewErrParamRequired("UploadId"))
1334	}
1335	if invalidParams.Len() > 0 {
1336		return invalidParams
1337	} else {
1338		return nil
1339	}
1340}
1341
1342func validateOpListProvisionedCapacityInput(v *ListProvisionedCapacityInput) error {
1343	if v == nil {
1344		return nil
1345	}
1346	invalidParams := smithy.InvalidParamsError{Context: "ListProvisionedCapacityInput"}
1347	if v.AccountId == nil {
1348		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1349	}
1350	if invalidParams.Len() > 0 {
1351		return invalidParams
1352	} else {
1353		return nil
1354	}
1355}
1356
1357func validateOpListTagsForVaultInput(v *ListTagsForVaultInput) error {
1358	if v == nil {
1359		return nil
1360	}
1361	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForVaultInput"}
1362	if v.AccountId == nil {
1363		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1364	}
1365	if v.VaultName == nil {
1366		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
1367	}
1368	if invalidParams.Len() > 0 {
1369		return invalidParams
1370	} else {
1371		return nil
1372	}
1373}
1374
1375func validateOpListVaultsInput(v *ListVaultsInput) error {
1376	if v == nil {
1377		return nil
1378	}
1379	invalidParams := smithy.InvalidParamsError{Context: "ListVaultsInput"}
1380	if v.AccountId == nil {
1381		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1382	}
1383	if invalidParams.Len() > 0 {
1384		return invalidParams
1385	} else {
1386		return nil
1387	}
1388}
1389
1390func validateOpPurchaseProvisionedCapacityInput(v *PurchaseProvisionedCapacityInput) error {
1391	if v == nil {
1392		return nil
1393	}
1394	invalidParams := smithy.InvalidParamsError{Context: "PurchaseProvisionedCapacityInput"}
1395	if v.AccountId == nil {
1396		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1397	}
1398	if invalidParams.Len() > 0 {
1399		return invalidParams
1400	} else {
1401		return nil
1402	}
1403}
1404
1405func validateOpRemoveTagsFromVaultInput(v *RemoveTagsFromVaultInput) error {
1406	if v == nil {
1407		return nil
1408	}
1409	invalidParams := smithy.InvalidParamsError{Context: "RemoveTagsFromVaultInput"}
1410	if v.AccountId == nil {
1411		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1412	}
1413	if v.VaultName == nil {
1414		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
1415	}
1416	if invalidParams.Len() > 0 {
1417		return invalidParams
1418	} else {
1419		return nil
1420	}
1421}
1422
1423func validateOpSetDataRetrievalPolicyInput(v *SetDataRetrievalPolicyInput) error {
1424	if v == nil {
1425		return nil
1426	}
1427	invalidParams := smithy.InvalidParamsError{Context: "SetDataRetrievalPolicyInput"}
1428	if v.AccountId == nil {
1429		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1430	}
1431	if invalidParams.Len() > 0 {
1432		return invalidParams
1433	} else {
1434		return nil
1435	}
1436}
1437
1438func validateOpSetVaultAccessPolicyInput(v *SetVaultAccessPolicyInput) error {
1439	if v == nil {
1440		return nil
1441	}
1442	invalidParams := smithy.InvalidParamsError{Context: "SetVaultAccessPolicyInput"}
1443	if v.AccountId == nil {
1444		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1445	}
1446	if v.VaultName == nil {
1447		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
1448	}
1449	if invalidParams.Len() > 0 {
1450		return invalidParams
1451	} else {
1452		return nil
1453	}
1454}
1455
1456func validateOpSetVaultNotificationsInput(v *SetVaultNotificationsInput) error {
1457	if v == nil {
1458		return nil
1459	}
1460	invalidParams := smithy.InvalidParamsError{Context: "SetVaultNotificationsInput"}
1461	if v.AccountId == nil {
1462		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1463	}
1464	if v.VaultName == nil {
1465		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
1466	}
1467	if invalidParams.Len() > 0 {
1468		return invalidParams
1469	} else {
1470		return nil
1471	}
1472}
1473
1474func validateOpUploadArchiveInput(v *UploadArchiveInput) error {
1475	if v == nil {
1476		return nil
1477	}
1478	invalidParams := smithy.InvalidParamsError{Context: "UploadArchiveInput"}
1479	if v.VaultName == nil {
1480		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
1481	}
1482	if v.AccountId == nil {
1483		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1484	}
1485	if invalidParams.Len() > 0 {
1486		return invalidParams
1487	} else {
1488		return nil
1489	}
1490}
1491
1492func validateOpUploadMultipartPartInput(v *UploadMultipartPartInput) error {
1493	if v == nil {
1494		return nil
1495	}
1496	invalidParams := smithy.InvalidParamsError{Context: "UploadMultipartPartInput"}
1497	if v.AccountId == nil {
1498		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
1499	}
1500	if v.VaultName == nil {
1501		invalidParams.Add(smithy.NewErrParamRequired("VaultName"))
1502	}
1503	if v.UploadId == nil {
1504		invalidParams.Add(smithy.NewErrParamRequired("UploadId"))
1505	}
1506	if invalidParams.Len() > 0 {
1507		return invalidParams
1508	} else {
1509		return nil
1510	}
1511}
1512