1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package storagegateway
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/storagegateway/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpActivateGateway struct {
14}
15
16func (*validateOpActivateGateway) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpActivateGateway) 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.(*ActivateGatewayInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpActivateGatewayInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpAddCache struct {
34}
35
36func (*validateOpAddCache) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpAddCache) 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.(*AddCacheInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpAddCacheInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpAddTagsToResource struct {
54}
55
56func (*validateOpAddTagsToResource) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpAddTagsToResource) 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.(*AddTagsToResourceInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpAddTagsToResourceInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpAddUploadBuffer struct {
74}
75
76func (*validateOpAddUploadBuffer) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpAddUploadBuffer) 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.(*AddUploadBufferInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpAddUploadBufferInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpAddWorkingStorage struct {
94}
95
96func (*validateOpAddWorkingStorage) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpAddWorkingStorage) 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.(*AddWorkingStorageInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpAddWorkingStorageInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpAssignTapePool struct {
114}
115
116func (*validateOpAssignTapePool) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpAssignTapePool) 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.(*AssignTapePoolInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpAssignTapePoolInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpAttachVolume struct {
134}
135
136func (*validateOpAttachVolume) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpAttachVolume) 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.(*AttachVolumeInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpAttachVolumeInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpCancelArchival struct {
154}
155
156func (*validateOpCancelArchival) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpCancelArchival) 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.(*CancelArchivalInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpCancelArchivalInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpCancelRetrieval struct {
174}
175
176func (*validateOpCancelRetrieval) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpCancelRetrieval) 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.(*CancelRetrievalInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpCancelRetrievalInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpCreateCachediSCSIVolume struct {
194}
195
196func (*validateOpCreateCachediSCSIVolume) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpCreateCachediSCSIVolume) 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.(*CreateCachediSCSIVolumeInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpCreateCachediSCSIVolumeInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpCreateNFSFileShare struct {
214}
215
216func (*validateOpCreateNFSFileShare) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpCreateNFSFileShare) 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.(*CreateNFSFileShareInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpCreateNFSFileShareInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpCreateSMBFileShare struct {
234}
235
236func (*validateOpCreateSMBFileShare) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpCreateSMBFileShare) 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.(*CreateSMBFileShareInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpCreateSMBFileShareInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpCreateSnapshotFromVolumeRecoveryPoint struct {
254}
255
256func (*validateOpCreateSnapshotFromVolumeRecoveryPoint) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpCreateSnapshotFromVolumeRecoveryPoint) 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.(*CreateSnapshotFromVolumeRecoveryPointInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpCreateSnapshotFromVolumeRecoveryPointInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpCreateSnapshot struct {
274}
275
276func (*validateOpCreateSnapshot) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpCreateSnapshot) 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.(*CreateSnapshotInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpCreateSnapshotInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpCreateStorediSCSIVolume struct {
294}
295
296func (*validateOpCreateStorediSCSIVolume) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpCreateStorediSCSIVolume) 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.(*CreateStorediSCSIVolumeInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpCreateStorediSCSIVolumeInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpCreateTapePool struct {
314}
315
316func (*validateOpCreateTapePool) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpCreateTapePool) 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.(*CreateTapePoolInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpCreateTapePoolInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpCreateTapes struct {
334}
335
336func (*validateOpCreateTapes) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpCreateTapes) 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.(*CreateTapesInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpCreateTapesInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpCreateTapeWithBarcode struct {
354}
355
356func (*validateOpCreateTapeWithBarcode) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpCreateTapeWithBarcode) 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.(*CreateTapeWithBarcodeInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpCreateTapeWithBarcodeInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpDeleteAutomaticTapeCreationPolicy struct {
374}
375
376func (*validateOpDeleteAutomaticTapeCreationPolicy) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpDeleteAutomaticTapeCreationPolicy) 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.(*DeleteAutomaticTapeCreationPolicyInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpDeleteAutomaticTapeCreationPolicyInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpDeleteBandwidthRateLimit struct {
394}
395
396func (*validateOpDeleteBandwidthRateLimit) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpDeleteBandwidthRateLimit) 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.(*DeleteBandwidthRateLimitInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpDeleteBandwidthRateLimitInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpDeleteChapCredentials struct {
414}
415
416func (*validateOpDeleteChapCredentials) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpDeleteChapCredentials) 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.(*DeleteChapCredentialsInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpDeleteChapCredentialsInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpDeleteFileShare struct {
434}
435
436func (*validateOpDeleteFileShare) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpDeleteFileShare) 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.(*DeleteFileShareInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpDeleteFileShareInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpDeleteGateway struct {
454}
455
456func (*validateOpDeleteGateway) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpDeleteGateway) 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.(*DeleteGatewayInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpDeleteGatewayInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpDeleteSnapshotSchedule struct {
474}
475
476func (*validateOpDeleteSnapshotSchedule) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpDeleteSnapshotSchedule) 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.(*DeleteSnapshotScheduleInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpDeleteSnapshotScheduleInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpDeleteTapeArchive struct {
494}
495
496func (*validateOpDeleteTapeArchive) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpDeleteTapeArchive) 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.(*DeleteTapeArchiveInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpDeleteTapeArchiveInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpDeleteTape struct {
514}
515
516func (*validateOpDeleteTape) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpDeleteTape) 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.(*DeleteTapeInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpDeleteTapeInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpDeleteTapePool struct {
534}
535
536func (*validateOpDeleteTapePool) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpDeleteTapePool) 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.(*DeleteTapePoolInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpDeleteTapePoolInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpDeleteVolume struct {
554}
555
556func (*validateOpDeleteVolume) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpDeleteVolume) 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.(*DeleteVolumeInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpDeleteVolumeInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpDescribeAvailabilityMonitorTest struct {
574}
575
576func (*validateOpDescribeAvailabilityMonitorTest) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpDescribeAvailabilityMonitorTest) 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.(*DescribeAvailabilityMonitorTestInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpDescribeAvailabilityMonitorTestInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpDescribeBandwidthRateLimit struct {
594}
595
596func (*validateOpDescribeBandwidthRateLimit) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpDescribeBandwidthRateLimit) 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.(*DescribeBandwidthRateLimitInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpDescribeBandwidthRateLimitInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpDescribeBandwidthRateLimitSchedule struct {
614}
615
616func (*validateOpDescribeBandwidthRateLimitSchedule) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpDescribeBandwidthRateLimitSchedule) 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.(*DescribeBandwidthRateLimitScheduleInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpDescribeBandwidthRateLimitScheduleInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpDescribeCachediSCSIVolumes struct {
634}
635
636func (*validateOpDescribeCachediSCSIVolumes) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpDescribeCachediSCSIVolumes) 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.(*DescribeCachediSCSIVolumesInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpDescribeCachediSCSIVolumesInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653type validateOpDescribeCache struct {
654}
655
656func (*validateOpDescribeCache) ID() string {
657	return "OperationInputValidation"
658}
659
660func (m *validateOpDescribeCache) 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.(*DescribeCacheInput)
664	if !ok {
665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666	}
667	if err := validateOpDescribeCacheInput(input); err != nil {
668		return out, metadata, err
669	}
670	return next.HandleInitialize(ctx, in)
671}
672
673type validateOpDescribeChapCredentials struct {
674}
675
676func (*validateOpDescribeChapCredentials) ID() string {
677	return "OperationInputValidation"
678}
679
680func (m *validateOpDescribeChapCredentials) 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.(*DescribeChapCredentialsInput)
684	if !ok {
685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
686	}
687	if err := validateOpDescribeChapCredentialsInput(input); err != nil {
688		return out, metadata, err
689	}
690	return next.HandleInitialize(ctx, in)
691}
692
693type validateOpDescribeGatewayInformation struct {
694}
695
696func (*validateOpDescribeGatewayInformation) ID() string {
697	return "OperationInputValidation"
698}
699
700func (m *validateOpDescribeGatewayInformation) 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.(*DescribeGatewayInformationInput)
704	if !ok {
705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
706	}
707	if err := validateOpDescribeGatewayInformationInput(input); err != nil {
708		return out, metadata, err
709	}
710	return next.HandleInitialize(ctx, in)
711}
712
713type validateOpDescribeMaintenanceStartTime struct {
714}
715
716func (*validateOpDescribeMaintenanceStartTime) ID() string {
717	return "OperationInputValidation"
718}
719
720func (m *validateOpDescribeMaintenanceStartTime) 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.(*DescribeMaintenanceStartTimeInput)
724	if !ok {
725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
726	}
727	if err := validateOpDescribeMaintenanceStartTimeInput(input); err != nil {
728		return out, metadata, err
729	}
730	return next.HandleInitialize(ctx, in)
731}
732
733type validateOpDescribeNFSFileShares struct {
734}
735
736func (*validateOpDescribeNFSFileShares) ID() string {
737	return "OperationInputValidation"
738}
739
740func (m *validateOpDescribeNFSFileShares) 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.(*DescribeNFSFileSharesInput)
744	if !ok {
745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
746	}
747	if err := validateOpDescribeNFSFileSharesInput(input); err != nil {
748		return out, metadata, err
749	}
750	return next.HandleInitialize(ctx, in)
751}
752
753type validateOpDescribeSMBFileShares struct {
754}
755
756func (*validateOpDescribeSMBFileShares) ID() string {
757	return "OperationInputValidation"
758}
759
760func (m *validateOpDescribeSMBFileShares) 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.(*DescribeSMBFileSharesInput)
764	if !ok {
765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
766	}
767	if err := validateOpDescribeSMBFileSharesInput(input); err != nil {
768		return out, metadata, err
769	}
770	return next.HandleInitialize(ctx, in)
771}
772
773type validateOpDescribeSMBSettings struct {
774}
775
776func (*validateOpDescribeSMBSettings) ID() string {
777	return "OperationInputValidation"
778}
779
780func (m *validateOpDescribeSMBSettings) 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.(*DescribeSMBSettingsInput)
784	if !ok {
785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
786	}
787	if err := validateOpDescribeSMBSettingsInput(input); err != nil {
788		return out, metadata, err
789	}
790	return next.HandleInitialize(ctx, in)
791}
792
793type validateOpDescribeSnapshotSchedule struct {
794}
795
796func (*validateOpDescribeSnapshotSchedule) ID() string {
797	return "OperationInputValidation"
798}
799
800func (m *validateOpDescribeSnapshotSchedule) 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.(*DescribeSnapshotScheduleInput)
804	if !ok {
805		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
806	}
807	if err := validateOpDescribeSnapshotScheduleInput(input); err != nil {
808		return out, metadata, err
809	}
810	return next.HandleInitialize(ctx, in)
811}
812
813type validateOpDescribeStorediSCSIVolumes struct {
814}
815
816func (*validateOpDescribeStorediSCSIVolumes) ID() string {
817	return "OperationInputValidation"
818}
819
820func (m *validateOpDescribeStorediSCSIVolumes) 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.(*DescribeStorediSCSIVolumesInput)
824	if !ok {
825		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
826	}
827	if err := validateOpDescribeStorediSCSIVolumesInput(input); err != nil {
828		return out, metadata, err
829	}
830	return next.HandleInitialize(ctx, in)
831}
832
833type validateOpDescribeTapeRecoveryPoints struct {
834}
835
836func (*validateOpDescribeTapeRecoveryPoints) ID() string {
837	return "OperationInputValidation"
838}
839
840func (m *validateOpDescribeTapeRecoveryPoints) 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.(*DescribeTapeRecoveryPointsInput)
844	if !ok {
845		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
846	}
847	if err := validateOpDescribeTapeRecoveryPointsInput(input); err != nil {
848		return out, metadata, err
849	}
850	return next.HandleInitialize(ctx, in)
851}
852
853type validateOpDescribeTapes struct {
854}
855
856func (*validateOpDescribeTapes) ID() string {
857	return "OperationInputValidation"
858}
859
860func (m *validateOpDescribeTapes) 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.(*DescribeTapesInput)
864	if !ok {
865		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
866	}
867	if err := validateOpDescribeTapesInput(input); err != nil {
868		return out, metadata, err
869	}
870	return next.HandleInitialize(ctx, in)
871}
872
873type validateOpDescribeUploadBuffer struct {
874}
875
876func (*validateOpDescribeUploadBuffer) ID() string {
877	return "OperationInputValidation"
878}
879
880func (m *validateOpDescribeUploadBuffer) 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.(*DescribeUploadBufferInput)
884	if !ok {
885		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
886	}
887	if err := validateOpDescribeUploadBufferInput(input); err != nil {
888		return out, metadata, err
889	}
890	return next.HandleInitialize(ctx, in)
891}
892
893type validateOpDescribeVTLDevices struct {
894}
895
896func (*validateOpDescribeVTLDevices) ID() string {
897	return "OperationInputValidation"
898}
899
900func (m *validateOpDescribeVTLDevices) 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.(*DescribeVTLDevicesInput)
904	if !ok {
905		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
906	}
907	if err := validateOpDescribeVTLDevicesInput(input); err != nil {
908		return out, metadata, err
909	}
910	return next.HandleInitialize(ctx, in)
911}
912
913type validateOpDescribeWorkingStorage struct {
914}
915
916func (*validateOpDescribeWorkingStorage) ID() string {
917	return "OperationInputValidation"
918}
919
920func (m *validateOpDescribeWorkingStorage) 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.(*DescribeWorkingStorageInput)
924	if !ok {
925		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
926	}
927	if err := validateOpDescribeWorkingStorageInput(input); err != nil {
928		return out, metadata, err
929	}
930	return next.HandleInitialize(ctx, in)
931}
932
933type validateOpDetachVolume struct {
934}
935
936func (*validateOpDetachVolume) ID() string {
937	return "OperationInputValidation"
938}
939
940func (m *validateOpDetachVolume) 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.(*DetachVolumeInput)
944	if !ok {
945		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
946	}
947	if err := validateOpDetachVolumeInput(input); err != nil {
948		return out, metadata, err
949	}
950	return next.HandleInitialize(ctx, in)
951}
952
953type validateOpDisableGateway struct {
954}
955
956func (*validateOpDisableGateway) ID() string {
957	return "OperationInputValidation"
958}
959
960func (m *validateOpDisableGateway) 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.(*DisableGatewayInput)
964	if !ok {
965		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
966	}
967	if err := validateOpDisableGatewayInput(input); err != nil {
968		return out, metadata, err
969	}
970	return next.HandleInitialize(ctx, in)
971}
972
973type validateOpJoinDomain struct {
974}
975
976func (*validateOpJoinDomain) ID() string {
977	return "OperationInputValidation"
978}
979
980func (m *validateOpJoinDomain) 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.(*JoinDomainInput)
984	if !ok {
985		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
986	}
987	if err := validateOpJoinDomainInput(input); err != nil {
988		return out, metadata, err
989	}
990	return next.HandleInitialize(ctx, in)
991}
992
993type validateOpListLocalDisks struct {
994}
995
996func (*validateOpListLocalDisks) ID() string {
997	return "OperationInputValidation"
998}
999
1000func (m *validateOpListLocalDisks) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1001	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1002) {
1003	input, ok := in.Parameters.(*ListLocalDisksInput)
1004	if !ok {
1005		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1006	}
1007	if err := validateOpListLocalDisksInput(input); err != nil {
1008		return out, metadata, err
1009	}
1010	return next.HandleInitialize(ctx, in)
1011}
1012
1013type validateOpListTagsForResource struct {
1014}
1015
1016func (*validateOpListTagsForResource) ID() string {
1017	return "OperationInputValidation"
1018}
1019
1020func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1021	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1022) {
1023	input, ok := in.Parameters.(*ListTagsForResourceInput)
1024	if !ok {
1025		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1026	}
1027	if err := validateOpListTagsForResourceInput(input); err != nil {
1028		return out, metadata, err
1029	}
1030	return next.HandleInitialize(ctx, in)
1031}
1032
1033type validateOpListVolumeInitiators struct {
1034}
1035
1036func (*validateOpListVolumeInitiators) ID() string {
1037	return "OperationInputValidation"
1038}
1039
1040func (m *validateOpListVolumeInitiators) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1041	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1042) {
1043	input, ok := in.Parameters.(*ListVolumeInitiatorsInput)
1044	if !ok {
1045		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1046	}
1047	if err := validateOpListVolumeInitiatorsInput(input); err != nil {
1048		return out, metadata, err
1049	}
1050	return next.HandleInitialize(ctx, in)
1051}
1052
1053type validateOpListVolumeRecoveryPoints struct {
1054}
1055
1056func (*validateOpListVolumeRecoveryPoints) ID() string {
1057	return "OperationInputValidation"
1058}
1059
1060func (m *validateOpListVolumeRecoveryPoints) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1061	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1062) {
1063	input, ok := in.Parameters.(*ListVolumeRecoveryPointsInput)
1064	if !ok {
1065		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1066	}
1067	if err := validateOpListVolumeRecoveryPointsInput(input); err != nil {
1068		return out, metadata, err
1069	}
1070	return next.HandleInitialize(ctx, in)
1071}
1072
1073type validateOpNotifyWhenUploaded struct {
1074}
1075
1076func (*validateOpNotifyWhenUploaded) ID() string {
1077	return "OperationInputValidation"
1078}
1079
1080func (m *validateOpNotifyWhenUploaded) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1081	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1082) {
1083	input, ok := in.Parameters.(*NotifyWhenUploadedInput)
1084	if !ok {
1085		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1086	}
1087	if err := validateOpNotifyWhenUploadedInput(input); err != nil {
1088		return out, metadata, err
1089	}
1090	return next.HandleInitialize(ctx, in)
1091}
1092
1093type validateOpRefreshCache struct {
1094}
1095
1096func (*validateOpRefreshCache) ID() string {
1097	return "OperationInputValidation"
1098}
1099
1100func (m *validateOpRefreshCache) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1101	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1102) {
1103	input, ok := in.Parameters.(*RefreshCacheInput)
1104	if !ok {
1105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1106	}
1107	if err := validateOpRefreshCacheInput(input); err != nil {
1108		return out, metadata, err
1109	}
1110	return next.HandleInitialize(ctx, in)
1111}
1112
1113type validateOpRemoveTagsFromResource struct {
1114}
1115
1116func (*validateOpRemoveTagsFromResource) ID() string {
1117	return "OperationInputValidation"
1118}
1119
1120func (m *validateOpRemoveTagsFromResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1121	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1122) {
1123	input, ok := in.Parameters.(*RemoveTagsFromResourceInput)
1124	if !ok {
1125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1126	}
1127	if err := validateOpRemoveTagsFromResourceInput(input); err != nil {
1128		return out, metadata, err
1129	}
1130	return next.HandleInitialize(ctx, in)
1131}
1132
1133type validateOpResetCache struct {
1134}
1135
1136func (*validateOpResetCache) ID() string {
1137	return "OperationInputValidation"
1138}
1139
1140func (m *validateOpResetCache) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1141	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1142) {
1143	input, ok := in.Parameters.(*ResetCacheInput)
1144	if !ok {
1145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1146	}
1147	if err := validateOpResetCacheInput(input); err != nil {
1148		return out, metadata, err
1149	}
1150	return next.HandleInitialize(ctx, in)
1151}
1152
1153type validateOpRetrieveTapeArchive struct {
1154}
1155
1156func (*validateOpRetrieveTapeArchive) ID() string {
1157	return "OperationInputValidation"
1158}
1159
1160func (m *validateOpRetrieveTapeArchive) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1161	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1162) {
1163	input, ok := in.Parameters.(*RetrieveTapeArchiveInput)
1164	if !ok {
1165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1166	}
1167	if err := validateOpRetrieveTapeArchiveInput(input); err != nil {
1168		return out, metadata, err
1169	}
1170	return next.HandleInitialize(ctx, in)
1171}
1172
1173type validateOpRetrieveTapeRecoveryPoint struct {
1174}
1175
1176func (*validateOpRetrieveTapeRecoveryPoint) ID() string {
1177	return "OperationInputValidation"
1178}
1179
1180func (m *validateOpRetrieveTapeRecoveryPoint) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1181	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1182) {
1183	input, ok := in.Parameters.(*RetrieveTapeRecoveryPointInput)
1184	if !ok {
1185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1186	}
1187	if err := validateOpRetrieveTapeRecoveryPointInput(input); err != nil {
1188		return out, metadata, err
1189	}
1190	return next.HandleInitialize(ctx, in)
1191}
1192
1193type validateOpSetLocalConsolePassword struct {
1194}
1195
1196func (*validateOpSetLocalConsolePassword) ID() string {
1197	return "OperationInputValidation"
1198}
1199
1200func (m *validateOpSetLocalConsolePassword) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1201	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1202) {
1203	input, ok := in.Parameters.(*SetLocalConsolePasswordInput)
1204	if !ok {
1205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1206	}
1207	if err := validateOpSetLocalConsolePasswordInput(input); err != nil {
1208		return out, metadata, err
1209	}
1210	return next.HandleInitialize(ctx, in)
1211}
1212
1213type validateOpSetSMBGuestPassword struct {
1214}
1215
1216func (*validateOpSetSMBGuestPassword) ID() string {
1217	return "OperationInputValidation"
1218}
1219
1220func (m *validateOpSetSMBGuestPassword) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1221	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1222) {
1223	input, ok := in.Parameters.(*SetSMBGuestPasswordInput)
1224	if !ok {
1225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1226	}
1227	if err := validateOpSetSMBGuestPasswordInput(input); err != nil {
1228		return out, metadata, err
1229	}
1230	return next.HandleInitialize(ctx, in)
1231}
1232
1233type validateOpShutdownGateway struct {
1234}
1235
1236func (*validateOpShutdownGateway) ID() string {
1237	return "OperationInputValidation"
1238}
1239
1240func (m *validateOpShutdownGateway) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1241	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1242) {
1243	input, ok := in.Parameters.(*ShutdownGatewayInput)
1244	if !ok {
1245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1246	}
1247	if err := validateOpShutdownGatewayInput(input); err != nil {
1248		return out, metadata, err
1249	}
1250	return next.HandleInitialize(ctx, in)
1251}
1252
1253type validateOpStartAvailabilityMonitorTest struct {
1254}
1255
1256func (*validateOpStartAvailabilityMonitorTest) ID() string {
1257	return "OperationInputValidation"
1258}
1259
1260func (m *validateOpStartAvailabilityMonitorTest) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1261	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1262) {
1263	input, ok := in.Parameters.(*StartAvailabilityMonitorTestInput)
1264	if !ok {
1265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1266	}
1267	if err := validateOpStartAvailabilityMonitorTestInput(input); err != nil {
1268		return out, metadata, err
1269	}
1270	return next.HandleInitialize(ctx, in)
1271}
1272
1273type validateOpStartGateway struct {
1274}
1275
1276func (*validateOpStartGateway) ID() string {
1277	return "OperationInputValidation"
1278}
1279
1280func (m *validateOpStartGateway) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1281	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1282) {
1283	input, ok := in.Parameters.(*StartGatewayInput)
1284	if !ok {
1285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1286	}
1287	if err := validateOpStartGatewayInput(input); err != nil {
1288		return out, metadata, err
1289	}
1290	return next.HandleInitialize(ctx, in)
1291}
1292
1293type validateOpUpdateAutomaticTapeCreationPolicy struct {
1294}
1295
1296func (*validateOpUpdateAutomaticTapeCreationPolicy) ID() string {
1297	return "OperationInputValidation"
1298}
1299
1300func (m *validateOpUpdateAutomaticTapeCreationPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1301	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1302) {
1303	input, ok := in.Parameters.(*UpdateAutomaticTapeCreationPolicyInput)
1304	if !ok {
1305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1306	}
1307	if err := validateOpUpdateAutomaticTapeCreationPolicyInput(input); err != nil {
1308		return out, metadata, err
1309	}
1310	return next.HandleInitialize(ctx, in)
1311}
1312
1313type validateOpUpdateBandwidthRateLimit struct {
1314}
1315
1316func (*validateOpUpdateBandwidthRateLimit) ID() string {
1317	return "OperationInputValidation"
1318}
1319
1320func (m *validateOpUpdateBandwidthRateLimit) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1321	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1322) {
1323	input, ok := in.Parameters.(*UpdateBandwidthRateLimitInput)
1324	if !ok {
1325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1326	}
1327	if err := validateOpUpdateBandwidthRateLimitInput(input); err != nil {
1328		return out, metadata, err
1329	}
1330	return next.HandleInitialize(ctx, in)
1331}
1332
1333type validateOpUpdateBandwidthRateLimitSchedule struct {
1334}
1335
1336func (*validateOpUpdateBandwidthRateLimitSchedule) ID() string {
1337	return "OperationInputValidation"
1338}
1339
1340func (m *validateOpUpdateBandwidthRateLimitSchedule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1341	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1342) {
1343	input, ok := in.Parameters.(*UpdateBandwidthRateLimitScheduleInput)
1344	if !ok {
1345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1346	}
1347	if err := validateOpUpdateBandwidthRateLimitScheduleInput(input); err != nil {
1348		return out, metadata, err
1349	}
1350	return next.HandleInitialize(ctx, in)
1351}
1352
1353type validateOpUpdateChapCredentials struct {
1354}
1355
1356func (*validateOpUpdateChapCredentials) ID() string {
1357	return "OperationInputValidation"
1358}
1359
1360func (m *validateOpUpdateChapCredentials) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1361	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1362) {
1363	input, ok := in.Parameters.(*UpdateChapCredentialsInput)
1364	if !ok {
1365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1366	}
1367	if err := validateOpUpdateChapCredentialsInput(input); err != nil {
1368		return out, metadata, err
1369	}
1370	return next.HandleInitialize(ctx, in)
1371}
1372
1373type validateOpUpdateGatewayInformation struct {
1374}
1375
1376func (*validateOpUpdateGatewayInformation) ID() string {
1377	return "OperationInputValidation"
1378}
1379
1380func (m *validateOpUpdateGatewayInformation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1381	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1382) {
1383	input, ok := in.Parameters.(*UpdateGatewayInformationInput)
1384	if !ok {
1385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1386	}
1387	if err := validateOpUpdateGatewayInformationInput(input); err != nil {
1388		return out, metadata, err
1389	}
1390	return next.HandleInitialize(ctx, in)
1391}
1392
1393type validateOpUpdateGatewaySoftwareNow struct {
1394}
1395
1396func (*validateOpUpdateGatewaySoftwareNow) ID() string {
1397	return "OperationInputValidation"
1398}
1399
1400func (m *validateOpUpdateGatewaySoftwareNow) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1401	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1402) {
1403	input, ok := in.Parameters.(*UpdateGatewaySoftwareNowInput)
1404	if !ok {
1405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1406	}
1407	if err := validateOpUpdateGatewaySoftwareNowInput(input); err != nil {
1408		return out, metadata, err
1409	}
1410	return next.HandleInitialize(ctx, in)
1411}
1412
1413type validateOpUpdateMaintenanceStartTime struct {
1414}
1415
1416func (*validateOpUpdateMaintenanceStartTime) ID() string {
1417	return "OperationInputValidation"
1418}
1419
1420func (m *validateOpUpdateMaintenanceStartTime) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1421	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1422) {
1423	input, ok := in.Parameters.(*UpdateMaintenanceStartTimeInput)
1424	if !ok {
1425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1426	}
1427	if err := validateOpUpdateMaintenanceStartTimeInput(input); err != nil {
1428		return out, metadata, err
1429	}
1430	return next.HandleInitialize(ctx, in)
1431}
1432
1433type validateOpUpdateNFSFileShare struct {
1434}
1435
1436func (*validateOpUpdateNFSFileShare) ID() string {
1437	return "OperationInputValidation"
1438}
1439
1440func (m *validateOpUpdateNFSFileShare) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1441	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1442) {
1443	input, ok := in.Parameters.(*UpdateNFSFileShareInput)
1444	if !ok {
1445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1446	}
1447	if err := validateOpUpdateNFSFileShareInput(input); err != nil {
1448		return out, metadata, err
1449	}
1450	return next.HandleInitialize(ctx, in)
1451}
1452
1453type validateOpUpdateSMBFileShare struct {
1454}
1455
1456func (*validateOpUpdateSMBFileShare) ID() string {
1457	return "OperationInputValidation"
1458}
1459
1460func (m *validateOpUpdateSMBFileShare) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1461	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1462) {
1463	input, ok := in.Parameters.(*UpdateSMBFileShareInput)
1464	if !ok {
1465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1466	}
1467	if err := validateOpUpdateSMBFileShareInput(input); err != nil {
1468		return out, metadata, err
1469	}
1470	return next.HandleInitialize(ctx, in)
1471}
1472
1473type validateOpUpdateSMBFileShareVisibility struct {
1474}
1475
1476func (*validateOpUpdateSMBFileShareVisibility) ID() string {
1477	return "OperationInputValidation"
1478}
1479
1480func (m *validateOpUpdateSMBFileShareVisibility) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1481	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1482) {
1483	input, ok := in.Parameters.(*UpdateSMBFileShareVisibilityInput)
1484	if !ok {
1485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1486	}
1487	if err := validateOpUpdateSMBFileShareVisibilityInput(input); err != nil {
1488		return out, metadata, err
1489	}
1490	return next.HandleInitialize(ctx, in)
1491}
1492
1493type validateOpUpdateSMBSecurityStrategy struct {
1494}
1495
1496func (*validateOpUpdateSMBSecurityStrategy) ID() string {
1497	return "OperationInputValidation"
1498}
1499
1500func (m *validateOpUpdateSMBSecurityStrategy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1501	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1502) {
1503	input, ok := in.Parameters.(*UpdateSMBSecurityStrategyInput)
1504	if !ok {
1505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1506	}
1507	if err := validateOpUpdateSMBSecurityStrategyInput(input); err != nil {
1508		return out, metadata, err
1509	}
1510	return next.HandleInitialize(ctx, in)
1511}
1512
1513type validateOpUpdateSnapshotSchedule struct {
1514}
1515
1516func (*validateOpUpdateSnapshotSchedule) ID() string {
1517	return "OperationInputValidation"
1518}
1519
1520func (m *validateOpUpdateSnapshotSchedule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1521	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1522) {
1523	input, ok := in.Parameters.(*UpdateSnapshotScheduleInput)
1524	if !ok {
1525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1526	}
1527	if err := validateOpUpdateSnapshotScheduleInput(input); err != nil {
1528		return out, metadata, err
1529	}
1530	return next.HandleInitialize(ctx, in)
1531}
1532
1533type validateOpUpdateVTLDeviceType struct {
1534}
1535
1536func (*validateOpUpdateVTLDeviceType) ID() string {
1537	return "OperationInputValidation"
1538}
1539
1540func (m *validateOpUpdateVTLDeviceType) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1541	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1542) {
1543	input, ok := in.Parameters.(*UpdateVTLDeviceTypeInput)
1544	if !ok {
1545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1546	}
1547	if err := validateOpUpdateVTLDeviceTypeInput(input); err != nil {
1548		return out, metadata, err
1549	}
1550	return next.HandleInitialize(ctx, in)
1551}
1552
1553func addOpActivateGatewayValidationMiddleware(stack *middleware.Stack) error {
1554	return stack.Initialize.Add(&validateOpActivateGateway{}, middleware.After)
1555}
1556
1557func addOpAddCacheValidationMiddleware(stack *middleware.Stack) error {
1558	return stack.Initialize.Add(&validateOpAddCache{}, middleware.After)
1559}
1560
1561func addOpAddTagsToResourceValidationMiddleware(stack *middleware.Stack) error {
1562	return stack.Initialize.Add(&validateOpAddTagsToResource{}, middleware.After)
1563}
1564
1565func addOpAddUploadBufferValidationMiddleware(stack *middleware.Stack) error {
1566	return stack.Initialize.Add(&validateOpAddUploadBuffer{}, middleware.After)
1567}
1568
1569func addOpAddWorkingStorageValidationMiddleware(stack *middleware.Stack) error {
1570	return stack.Initialize.Add(&validateOpAddWorkingStorage{}, middleware.After)
1571}
1572
1573func addOpAssignTapePoolValidationMiddleware(stack *middleware.Stack) error {
1574	return stack.Initialize.Add(&validateOpAssignTapePool{}, middleware.After)
1575}
1576
1577func addOpAttachVolumeValidationMiddleware(stack *middleware.Stack) error {
1578	return stack.Initialize.Add(&validateOpAttachVolume{}, middleware.After)
1579}
1580
1581func addOpCancelArchivalValidationMiddleware(stack *middleware.Stack) error {
1582	return stack.Initialize.Add(&validateOpCancelArchival{}, middleware.After)
1583}
1584
1585func addOpCancelRetrievalValidationMiddleware(stack *middleware.Stack) error {
1586	return stack.Initialize.Add(&validateOpCancelRetrieval{}, middleware.After)
1587}
1588
1589func addOpCreateCachediSCSIVolumeValidationMiddleware(stack *middleware.Stack) error {
1590	return stack.Initialize.Add(&validateOpCreateCachediSCSIVolume{}, middleware.After)
1591}
1592
1593func addOpCreateNFSFileShareValidationMiddleware(stack *middleware.Stack) error {
1594	return stack.Initialize.Add(&validateOpCreateNFSFileShare{}, middleware.After)
1595}
1596
1597func addOpCreateSMBFileShareValidationMiddleware(stack *middleware.Stack) error {
1598	return stack.Initialize.Add(&validateOpCreateSMBFileShare{}, middleware.After)
1599}
1600
1601func addOpCreateSnapshotFromVolumeRecoveryPointValidationMiddleware(stack *middleware.Stack) error {
1602	return stack.Initialize.Add(&validateOpCreateSnapshotFromVolumeRecoveryPoint{}, middleware.After)
1603}
1604
1605func addOpCreateSnapshotValidationMiddleware(stack *middleware.Stack) error {
1606	return stack.Initialize.Add(&validateOpCreateSnapshot{}, middleware.After)
1607}
1608
1609func addOpCreateStorediSCSIVolumeValidationMiddleware(stack *middleware.Stack) error {
1610	return stack.Initialize.Add(&validateOpCreateStorediSCSIVolume{}, middleware.After)
1611}
1612
1613func addOpCreateTapePoolValidationMiddleware(stack *middleware.Stack) error {
1614	return stack.Initialize.Add(&validateOpCreateTapePool{}, middleware.After)
1615}
1616
1617func addOpCreateTapesValidationMiddleware(stack *middleware.Stack) error {
1618	return stack.Initialize.Add(&validateOpCreateTapes{}, middleware.After)
1619}
1620
1621func addOpCreateTapeWithBarcodeValidationMiddleware(stack *middleware.Stack) error {
1622	return stack.Initialize.Add(&validateOpCreateTapeWithBarcode{}, middleware.After)
1623}
1624
1625func addOpDeleteAutomaticTapeCreationPolicyValidationMiddleware(stack *middleware.Stack) error {
1626	return stack.Initialize.Add(&validateOpDeleteAutomaticTapeCreationPolicy{}, middleware.After)
1627}
1628
1629func addOpDeleteBandwidthRateLimitValidationMiddleware(stack *middleware.Stack) error {
1630	return stack.Initialize.Add(&validateOpDeleteBandwidthRateLimit{}, middleware.After)
1631}
1632
1633func addOpDeleteChapCredentialsValidationMiddleware(stack *middleware.Stack) error {
1634	return stack.Initialize.Add(&validateOpDeleteChapCredentials{}, middleware.After)
1635}
1636
1637func addOpDeleteFileShareValidationMiddleware(stack *middleware.Stack) error {
1638	return stack.Initialize.Add(&validateOpDeleteFileShare{}, middleware.After)
1639}
1640
1641func addOpDeleteGatewayValidationMiddleware(stack *middleware.Stack) error {
1642	return stack.Initialize.Add(&validateOpDeleteGateway{}, middleware.After)
1643}
1644
1645func addOpDeleteSnapshotScheduleValidationMiddleware(stack *middleware.Stack) error {
1646	return stack.Initialize.Add(&validateOpDeleteSnapshotSchedule{}, middleware.After)
1647}
1648
1649func addOpDeleteTapeArchiveValidationMiddleware(stack *middleware.Stack) error {
1650	return stack.Initialize.Add(&validateOpDeleteTapeArchive{}, middleware.After)
1651}
1652
1653func addOpDeleteTapeValidationMiddleware(stack *middleware.Stack) error {
1654	return stack.Initialize.Add(&validateOpDeleteTape{}, middleware.After)
1655}
1656
1657func addOpDeleteTapePoolValidationMiddleware(stack *middleware.Stack) error {
1658	return stack.Initialize.Add(&validateOpDeleteTapePool{}, middleware.After)
1659}
1660
1661func addOpDeleteVolumeValidationMiddleware(stack *middleware.Stack) error {
1662	return stack.Initialize.Add(&validateOpDeleteVolume{}, middleware.After)
1663}
1664
1665func addOpDescribeAvailabilityMonitorTestValidationMiddleware(stack *middleware.Stack) error {
1666	return stack.Initialize.Add(&validateOpDescribeAvailabilityMonitorTest{}, middleware.After)
1667}
1668
1669func addOpDescribeBandwidthRateLimitValidationMiddleware(stack *middleware.Stack) error {
1670	return stack.Initialize.Add(&validateOpDescribeBandwidthRateLimit{}, middleware.After)
1671}
1672
1673func addOpDescribeBandwidthRateLimitScheduleValidationMiddleware(stack *middleware.Stack) error {
1674	return stack.Initialize.Add(&validateOpDescribeBandwidthRateLimitSchedule{}, middleware.After)
1675}
1676
1677func addOpDescribeCachediSCSIVolumesValidationMiddleware(stack *middleware.Stack) error {
1678	return stack.Initialize.Add(&validateOpDescribeCachediSCSIVolumes{}, middleware.After)
1679}
1680
1681func addOpDescribeCacheValidationMiddleware(stack *middleware.Stack) error {
1682	return stack.Initialize.Add(&validateOpDescribeCache{}, middleware.After)
1683}
1684
1685func addOpDescribeChapCredentialsValidationMiddleware(stack *middleware.Stack) error {
1686	return stack.Initialize.Add(&validateOpDescribeChapCredentials{}, middleware.After)
1687}
1688
1689func addOpDescribeGatewayInformationValidationMiddleware(stack *middleware.Stack) error {
1690	return stack.Initialize.Add(&validateOpDescribeGatewayInformation{}, middleware.After)
1691}
1692
1693func addOpDescribeMaintenanceStartTimeValidationMiddleware(stack *middleware.Stack) error {
1694	return stack.Initialize.Add(&validateOpDescribeMaintenanceStartTime{}, middleware.After)
1695}
1696
1697func addOpDescribeNFSFileSharesValidationMiddleware(stack *middleware.Stack) error {
1698	return stack.Initialize.Add(&validateOpDescribeNFSFileShares{}, middleware.After)
1699}
1700
1701func addOpDescribeSMBFileSharesValidationMiddleware(stack *middleware.Stack) error {
1702	return stack.Initialize.Add(&validateOpDescribeSMBFileShares{}, middleware.After)
1703}
1704
1705func addOpDescribeSMBSettingsValidationMiddleware(stack *middleware.Stack) error {
1706	return stack.Initialize.Add(&validateOpDescribeSMBSettings{}, middleware.After)
1707}
1708
1709func addOpDescribeSnapshotScheduleValidationMiddleware(stack *middleware.Stack) error {
1710	return stack.Initialize.Add(&validateOpDescribeSnapshotSchedule{}, middleware.After)
1711}
1712
1713func addOpDescribeStorediSCSIVolumesValidationMiddleware(stack *middleware.Stack) error {
1714	return stack.Initialize.Add(&validateOpDescribeStorediSCSIVolumes{}, middleware.After)
1715}
1716
1717func addOpDescribeTapeRecoveryPointsValidationMiddleware(stack *middleware.Stack) error {
1718	return stack.Initialize.Add(&validateOpDescribeTapeRecoveryPoints{}, middleware.After)
1719}
1720
1721func addOpDescribeTapesValidationMiddleware(stack *middleware.Stack) error {
1722	return stack.Initialize.Add(&validateOpDescribeTapes{}, middleware.After)
1723}
1724
1725func addOpDescribeUploadBufferValidationMiddleware(stack *middleware.Stack) error {
1726	return stack.Initialize.Add(&validateOpDescribeUploadBuffer{}, middleware.After)
1727}
1728
1729func addOpDescribeVTLDevicesValidationMiddleware(stack *middleware.Stack) error {
1730	return stack.Initialize.Add(&validateOpDescribeVTLDevices{}, middleware.After)
1731}
1732
1733func addOpDescribeWorkingStorageValidationMiddleware(stack *middleware.Stack) error {
1734	return stack.Initialize.Add(&validateOpDescribeWorkingStorage{}, middleware.After)
1735}
1736
1737func addOpDetachVolumeValidationMiddleware(stack *middleware.Stack) error {
1738	return stack.Initialize.Add(&validateOpDetachVolume{}, middleware.After)
1739}
1740
1741func addOpDisableGatewayValidationMiddleware(stack *middleware.Stack) error {
1742	return stack.Initialize.Add(&validateOpDisableGateway{}, middleware.After)
1743}
1744
1745func addOpJoinDomainValidationMiddleware(stack *middleware.Stack) error {
1746	return stack.Initialize.Add(&validateOpJoinDomain{}, middleware.After)
1747}
1748
1749func addOpListLocalDisksValidationMiddleware(stack *middleware.Stack) error {
1750	return stack.Initialize.Add(&validateOpListLocalDisks{}, middleware.After)
1751}
1752
1753func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
1754	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
1755}
1756
1757func addOpListVolumeInitiatorsValidationMiddleware(stack *middleware.Stack) error {
1758	return stack.Initialize.Add(&validateOpListVolumeInitiators{}, middleware.After)
1759}
1760
1761func addOpListVolumeRecoveryPointsValidationMiddleware(stack *middleware.Stack) error {
1762	return stack.Initialize.Add(&validateOpListVolumeRecoveryPoints{}, middleware.After)
1763}
1764
1765func addOpNotifyWhenUploadedValidationMiddleware(stack *middleware.Stack) error {
1766	return stack.Initialize.Add(&validateOpNotifyWhenUploaded{}, middleware.After)
1767}
1768
1769func addOpRefreshCacheValidationMiddleware(stack *middleware.Stack) error {
1770	return stack.Initialize.Add(&validateOpRefreshCache{}, middleware.After)
1771}
1772
1773func addOpRemoveTagsFromResourceValidationMiddleware(stack *middleware.Stack) error {
1774	return stack.Initialize.Add(&validateOpRemoveTagsFromResource{}, middleware.After)
1775}
1776
1777func addOpResetCacheValidationMiddleware(stack *middleware.Stack) error {
1778	return stack.Initialize.Add(&validateOpResetCache{}, middleware.After)
1779}
1780
1781func addOpRetrieveTapeArchiveValidationMiddleware(stack *middleware.Stack) error {
1782	return stack.Initialize.Add(&validateOpRetrieveTapeArchive{}, middleware.After)
1783}
1784
1785func addOpRetrieveTapeRecoveryPointValidationMiddleware(stack *middleware.Stack) error {
1786	return stack.Initialize.Add(&validateOpRetrieveTapeRecoveryPoint{}, middleware.After)
1787}
1788
1789func addOpSetLocalConsolePasswordValidationMiddleware(stack *middleware.Stack) error {
1790	return stack.Initialize.Add(&validateOpSetLocalConsolePassword{}, middleware.After)
1791}
1792
1793func addOpSetSMBGuestPasswordValidationMiddleware(stack *middleware.Stack) error {
1794	return stack.Initialize.Add(&validateOpSetSMBGuestPassword{}, middleware.After)
1795}
1796
1797func addOpShutdownGatewayValidationMiddleware(stack *middleware.Stack) error {
1798	return stack.Initialize.Add(&validateOpShutdownGateway{}, middleware.After)
1799}
1800
1801func addOpStartAvailabilityMonitorTestValidationMiddleware(stack *middleware.Stack) error {
1802	return stack.Initialize.Add(&validateOpStartAvailabilityMonitorTest{}, middleware.After)
1803}
1804
1805func addOpStartGatewayValidationMiddleware(stack *middleware.Stack) error {
1806	return stack.Initialize.Add(&validateOpStartGateway{}, middleware.After)
1807}
1808
1809func addOpUpdateAutomaticTapeCreationPolicyValidationMiddleware(stack *middleware.Stack) error {
1810	return stack.Initialize.Add(&validateOpUpdateAutomaticTapeCreationPolicy{}, middleware.After)
1811}
1812
1813func addOpUpdateBandwidthRateLimitValidationMiddleware(stack *middleware.Stack) error {
1814	return stack.Initialize.Add(&validateOpUpdateBandwidthRateLimit{}, middleware.After)
1815}
1816
1817func addOpUpdateBandwidthRateLimitScheduleValidationMiddleware(stack *middleware.Stack) error {
1818	return stack.Initialize.Add(&validateOpUpdateBandwidthRateLimitSchedule{}, middleware.After)
1819}
1820
1821func addOpUpdateChapCredentialsValidationMiddleware(stack *middleware.Stack) error {
1822	return stack.Initialize.Add(&validateOpUpdateChapCredentials{}, middleware.After)
1823}
1824
1825func addOpUpdateGatewayInformationValidationMiddleware(stack *middleware.Stack) error {
1826	return stack.Initialize.Add(&validateOpUpdateGatewayInformation{}, middleware.After)
1827}
1828
1829func addOpUpdateGatewaySoftwareNowValidationMiddleware(stack *middleware.Stack) error {
1830	return stack.Initialize.Add(&validateOpUpdateGatewaySoftwareNow{}, middleware.After)
1831}
1832
1833func addOpUpdateMaintenanceStartTimeValidationMiddleware(stack *middleware.Stack) error {
1834	return stack.Initialize.Add(&validateOpUpdateMaintenanceStartTime{}, middleware.After)
1835}
1836
1837func addOpUpdateNFSFileShareValidationMiddleware(stack *middleware.Stack) error {
1838	return stack.Initialize.Add(&validateOpUpdateNFSFileShare{}, middleware.After)
1839}
1840
1841func addOpUpdateSMBFileShareValidationMiddleware(stack *middleware.Stack) error {
1842	return stack.Initialize.Add(&validateOpUpdateSMBFileShare{}, middleware.After)
1843}
1844
1845func addOpUpdateSMBFileShareVisibilityValidationMiddleware(stack *middleware.Stack) error {
1846	return stack.Initialize.Add(&validateOpUpdateSMBFileShareVisibility{}, middleware.After)
1847}
1848
1849func addOpUpdateSMBSecurityStrategyValidationMiddleware(stack *middleware.Stack) error {
1850	return stack.Initialize.Add(&validateOpUpdateSMBSecurityStrategy{}, middleware.After)
1851}
1852
1853func addOpUpdateSnapshotScheduleValidationMiddleware(stack *middleware.Stack) error {
1854	return stack.Initialize.Add(&validateOpUpdateSnapshotSchedule{}, middleware.After)
1855}
1856
1857func addOpUpdateVTLDeviceTypeValidationMiddleware(stack *middleware.Stack) error {
1858	return stack.Initialize.Add(&validateOpUpdateVTLDeviceType{}, middleware.After)
1859}
1860
1861func validateAutomaticTapeCreationRule(v *types.AutomaticTapeCreationRule) error {
1862	if v == nil {
1863		return nil
1864	}
1865	invalidParams := smithy.InvalidParamsError{Context: "AutomaticTapeCreationRule"}
1866	if v.TapeBarcodePrefix == nil {
1867		invalidParams.Add(smithy.NewErrParamRequired("TapeBarcodePrefix"))
1868	}
1869	if v.PoolId == nil {
1870		invalidParams.Add(smithy.NewErrParamRequired("PoolId"))
1871	}
1872	if v.TapeSizeInBytes == nil {
1873		invalidParams.Add(smithy.NewErrParamRequired("TapeSizeInBytes"))
1874	}
1875	if v.MinimumNumTapes == nil {
1876		invalidParams.Add(smithy.NewErrParamRequired("MinimumNumTapes"))
1877	}
1878	if invalidParams.Len() > 0 {
1879		return invalidParams
1880	} else {
1881		return nil
1882	}
1883}
1884
1885func validateAutomaticTapeCreationRules(v []types.AutomaticTapeCreationRule) error {
1886	if v == nil {
1887		return nil
1888	}
1889	invalidParams := smithy.InvalidParamsError{Context: "AutomaticTapeCreationRules"}
1890	for i := range v {
1891		if err := validateAutomaticTapeCreationRule(&v[i]); err != nil {
1892			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1893		}
1894	}
1895	if invalidParams.Len() > 0 {
1896		return invalidParams
1897	} else {
1898		return nil
1899	}
1900}
1901
1902func validateBandwidthRateLimitInterval(v *types.BandwidthRateLimitInterval) error {
1903	if v == nil {
1904		return nil
1905	}
1906	invalidParams := smithy.InvalidParamsError{Context: "BandwidthRateLimitInterval"}
1907	if v.StartHourOfDay == nil {
1908		invalidParams.Add(smithy.NewErrParamRequired("StartHourOfDay"))
1909	}
1910	if v.StartMinuteOfHour == nil {
1911		invalidParams.Add(smithy.NewErrParamRequired("StartMinuteOfHour"))
1912	}
1913	if v.EndHourOfDay == nil {
1914		invalidParams.Add(smithy.NewErrParamRequired("EndHourOfDay"))
1915	}
1916	if v.EndMinuteOfHour == nil {
1917		invalidParams.Add(smithy.NewErrParamRequired("EndMinuteOfHour"))
1918	}
1919	if v.DaysOfWeek == nil {
1920		invalidParams.Add(smithy.NewErrParamRequired("DaysOfWeek"))
1921	}
1922	if invalidParams.Len() > 0 {
1923		return invalidParams
1924	} else {
1925		return nil
1926	}
1927}
1928
1929func validateBandwidthRateLimitIntervals(v []types.BandwidthRateLimitInterval) error {
1930	if v == nil {
1931		return nil
1932	}
1933	invalidParams := smithy.InvalidParamsError{Context: "BandwidthRateLimitIntervals"}
1934	for i := range v {
1935		if err := validateBandwidthRateLimitInterval(&v[i]); err != nil {
1936			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1937		}
1938	}
1939	if invalidParams.Len() > 0 {
1940		return invalidParams
1941	} else {
1942		return nil
1943	}
1944}
1945
1946func validateTag(v *types.Tag) error {
1947	if v == nil {
1948		return nil
1949	}
1950	invalidParams := smithy.InvalidParamsError{Context: "Tag"}
1951	if v.Key == nil {
1952		invalidParams.Add(smithy.NewErrParamRequired("Key"))
1953	}
1954	if v.Value == nil {
1955		invalidParams.Add(smithy.NewErrParamRequired("Value"))
1956	}
1957	if invalidParams.Len() > 0 {
1958		return invalidParams
1959	} else {
1960		return nil
1961	}
1962}
1963
1964func validateTags(v []types.Tag) error {
1965	if v == nil {
1966		return nil
1967	}
1968	invalidParams := smithy.InvalidParamsError{Context: "Tags"}
1969	for i := range v {
1970		if err := validateTag(&v[i]); err != nil {
1971			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1972		}
1973	}
1974	if invalidParams.Len() > 0 {
1975		return invalidParams
1976	} else {
1977		return nil
1978	}
1979}
1980
1981func validateOpActivateGatewayInput(v *ActivateGatewayInput) error {
1982	if v == nil {
1983		return nil
1984	}
1985	invalidParams := smithy.InvalidParamsError{Context: "ActivateGatewayInput"}
1986	if v.ActivationKey == nil {
1987		invalidParams.Add(smithy.NewErrParamRequired("ActivationKey"))
1988	}
1989	if v.GatewayName == nil {
1990		invalidParams.Add(smithy.NewErrParamRequired("GatewayName"))
1991	}
1992	if v.GatewayTimezone == nil {
1993		invalidParams.Add(smithy.NewErrParamRequired("GatewayTimezone"))
1994	}
1995	if v.GatewayRegion == nil {
1996		invalidParams.Add(smithy.NewErrParamRequired("GatewayRegion"))
1997	}
1998	if v.Tags != nil {
1999		if err := validateTags(v.Tags); err != nil {
2000			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
2001		}
2002	}
2003	if invalidParams.Len() > 0 {
2004		return invalidParams
2005	} else {
2006		return nil
2007	}
2008}
2009
2010func validateOpAddCacheInput(v *AddCacheInput) error {
2011	if v == nil {
2012		return nil
2013	}
2014	invalidParams := smithy.InvalidParamsError{Context: "AddCacheInput"}
2015	if v.GatewayARN == nil {
2016		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2017	}
2018	if v.DiskIds == nil {
2019		invalidParams.Add(smithy.NewErrParamRequired("DiskIds"))
2020	}
2021	if invalidParams.Len() > 0 {
2022		return invalidParams
2023	} else {
2024		return nil
2025	}
2026}
2027
2028func validateOpAddTagsToResourceInput(v *AddTagsToResourceInput) error {
2029	if v == nil {
2030		return nil
2031	}
2032	invalidParams := smithy.InvalidParamsError{Context: "AddTagsToResourceInput"}
2033	if v.ResourceARN == nil {
2034		invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
2035	}
2036	if v.Tags == nil {
2037		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
2038	} else if v.Tags != nil {
2039		if err := validateTags(v.Tags); err != nil {
2040			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
2041		}
2042	}
2043	if invalidParams.Len() > 0 {
2044		return invalidParams
2045	} else {
2046		return nil
2047	}
2048}
2049
2050func validateOpAddUploadBufferInput(v *AddUploadBufferInput) error {
2051	if v == nil {
2052		return nil
2053	}
2054	invalidParams := smithy.InvalidParamsError{Context: "AddUploadBufferInput"}
2055	if v.GatewayARN == nil {
2056		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2057	}
2058	if v.DiskIds == nil {
2059		invalidParams.Add(smithy.NewErrParamRequired("DiskIds"))
2060	}
2061	if invalidParams.Len() > 0 {
2062		return invalidParams
2063	} else {
2064		return nil
2065	}
2066}
2067
2068func validateOpAddWorkingStorageInput(v *AddWorkingStorageInput) error {
2069	if v == nil {
2070		return nil
2071	}
2072	invalidParams := smithy.InvalidParamsError{Context: "AddWorkingStorageInput"}
2073	if v.GatewayARN == nil {
2074		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2075	}
2076	if v.DiskIds == nil {
2077		invalidParams.Add(smithy.NewErrParamRequired("DiskIds"))
2078	}
2079	if invalidParams.Len() > 0 {
2080		return invalidParams
2081	} else {
2082		return nil
2083	}
2084}
2085
2086func validateOpAssignTapePoolInput(v *AssignTapePoolInput) error {
2087	if v == nil {
2088		return nil
2089	}
2090	invalidParams := smithy.InvalidParamsError{Context: "AssignTapePoolInput"}
2091	if v.TapeARN == nil {
2092		invalidParams.Add(smithy.NewErrParamRequired("TapeARN"))
2093	}
2094	if v.PoolId == nil {
2095		invalidParams.Add(smithy.NewErrParamRequired("PoolId"))
2096	}
2097	if invalidParams.Len() > 0 {
2098		return invalidParams
2099	} else {
2100		return nil
2101	}
2102}
2103
2104func validateOpAttachVolumeInput(v *AttachVolumeInput) error {
2105	if v == nil {
2106		return nil
2107	}
2108	invalidParams := smithy.InvalidParamsError{Context: "AttachVolumeInput"}
2109	if v.GatewayARN == nil {
2110		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2111	}
2112	if v.VolumeARN == nil {
2113		invalidParams.Add(smithy.NewErrParamRequired("VolumeARN"))
2114	}
2115	if v.NetworkInterfaceId == nil {
2116		invalidParams.Add(smithy.NewErrParamRequired("NetworkInterfaceId"))
2117	}
2118	if invalidParams.Len() > 0 {
2119		return invalidParams
2120	} else {
2121		return nil
2122	}
2123}
2124
2125func validateOpCancelArchivalInput(v *CancelArchivalInput) error {
2126	if v == nil {
2127		return nil
2128	}
2129	invalidParams := smithy.InvalidParamsError{Context: "CancelArchivalInput"}
2130	if v.GatewayARN == nil {
2131		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2132	}
2133	if v.TapeARN == nil {
2134		invalidParams.Add(smithy.NewErrParamRequired("TapeARN"))
2135	}
2136	if invalidParams.Len() > 0 {
2137		return invalidParams
2138	} else {
2139		return nil
2140	}
2141}
2142
2143func validateOpCancelRetrievalInput(v *CancelRetrievalInput) error {
2144	if v == nil {
2145		return nil
2146	}
2147	invalidParams := smithy.InvalidParamsError{Context: "CancelRetrievalInput"}
2148	if v.GatewayARN == nil {
2149		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2150	}
2151	if v.TapeARN == nil {
2152		invalidParams.Add(smithy.NewErrParamRequired("TapeARN"))
2153	}
2154	if invalidParams.Len() > 0 {
2155		return invalidParams
2156	} else {
2157		return nil
2158	}
2159}
2160
2161func validateOpCreateCachediSCSIVolumeInput(v *CreateCachediSCSIVolumeInput) error {
2162	if v == nil {
2163		return nil
2164	}
2165	invalidParams := smithy.InvalidParamsError{Context: "CreateCachediSCSIVolumeInput"}
2166	if v.GatewayARN == nil {
2167		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2168	}
2169	if v.TargetName == nil {
2170		invalidParams.Add(smithy.NewErrParamRequired("TargetName"))
2171	}
2172	if v.NetworkInterfaceId == nil {
2173		invalidParams.Add(smithy.NewErrParamRequired("NetworkInterfaceId"))
2174	}
2175	if v.ClientToken == nil {
2176		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
2177	}
2178	if v.Tags != nil {
2179		if err := validateTags(v.Tags); err != nil {
2180			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
2181		}
2182	}
2183	if invalidParams.Len() > 0 {
2184		return invalidParams
2185	} else {
2186		return nil
2187	}
2188}
2189
2190func validateOpCreateNFSFileShareInput(v *CreateNFSFileShareInput) error {
2191	if v == nil {
2192		return nil
2193	}
2194	invalidParams := smithy.InvalidParamsError{Context: "CreateNFSFileShareInput"}
2195	if v.ClientToken == nil {
2196		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
2197	}
2198	if v.GatewayARN == nil {
2199		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2200	}
2201	if v.Role == nil {
2202		invalidParams.Add(smithy.NewErrParamRequired("Role"))
2203	}
2204	if v.LocationARN == nil {
2205		invalidParams.Add(smithy.NewErrParamRequired("LocationARN"))
2206	}
2207	if v.Tags != nil {
2208		if err := validateTags(v.Tags); err != nil {
2209			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
2210		}
2211	}
2212	if invalidParams.Len() > 0 {
2213		return invalidParams
2214	} else {
2215		return nil
2216	}
2217}
2218
2219func validateOpCreateSMBFileShareInput(v *CreateSMBFileShareInput) error {
2220	if v == nil {
2221		return nil
2222	}
2223	invalidParams := smithy.InvalidParamsError{Context: "CreateSMBFileShareInput"}
2224	if v.ClientToken == nil {
2225		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
2226	}
2227	if v.GatewayARN == nil {
2228		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2229	}
2230	if v.Role == nil {
2231		invalidParams.Add(smithy.NewErrParamRequired("Role"))
2232	}
2233	if v.LocationARN == nil {
2234		invalidParams.Add(smithy.NewErrParamRequired("LocationARN"))
2235	}
2236	if v.Tags != nil {
2237		if err := validateTags(v.Tags); err != nil {
2238			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
2239		}
2240	}
2241	if invalidParams.Len() > 0 {
2242		return invalidParams
2243	} else {
2244		return nil
2245	}
2246}
2247
2248func validateOpCreateSnapshotFromVolumeRecoveryPointInput(v *CreateSnapshotFromVolumeRecoveryPointInput) error {
2249	if v == nil {
2250		return nil
2251	}
2252	invalidParams := smithy.InvalidParamsError{Context: "CreateSnapshotFromVolumeRecoveryPointInput"}
2253	if v.VolumeARN == nil {
2254		invalidParams.Add(smithy.NewErrParamRequired("VolumeARN"))
2255	}
2256	if v.SnapshotDescription == nil {
2257		invalidParams.Add(smithy.NewErrParamRequired("SnapshotDescription"))
2258	}
2259	if v.Tags != nil {
2260		if err := validateTags(v.Tags); err != nil {
2261			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
2262		}
2263	}
2264	if invalidParams.Len() > 0 {
2265		return invalidParams
2266	} else {
2267		return nil
2268	}
2269}
2270
2271func validateOpCreateSnapshotInput(v *CreateSnapshotInput) error {
2272	if v == nil {
2273		return nil
2274	}
2275	invalidParams := smithy.InvalidParamsError{Context: "CreateSnapshotInput"}
2276	if v.VolumeARN == nil {
2277		invalidParams.Add(smithy.NewErrParamRequired("VolumeARN"))
2278	}
2279	if v.SnapshotDescription == nil {
2280		invalidParams.Add(smithy.NewErrParamRequired("SnapshotDescription"))
2281	}
2282	if v.Tags != nil {
2283		if err := validateTags(v.Tags); err != nil {
2284			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
2285		}
2286	}
2287	if invalidParams.Len() > 0 {
2288		return invalidParams
2289	} else {
2290		return nil
2291	}
2292}
2293
2294func validateOpCreateStorediSCSIVolumeInput(v *CreateStorediSCSIVolumeInput) error {
2295	if v == nil {
2296		return nil
2297	}
2298	invalidParams := smithy.InvalidParamsError{Context: "CreateStorediSCSIVolumeInput"}
2299	if v.GatewayARN == nil {
2300		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2301	}
2302	if v.DiskId == nil {
2303		invalidParams.Add(smithy.NewErrParamRequired("DiskId"))
2304	}
2305	if v.TargetName == nil {
2306		invalidParams.Add(smithy.NewErrParamRequired("TargetName"))
2307	}
2308	if v.NetworkInterfaceId == nil {
2309		invalidParams.Add(smithy.NewErrParamRequired("NetworkInterfaceId"))
2310	}
2311	if v.Tags != nil {
2312		if err := validateTags(v.Tags); err != nil {
2313			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
2314		}
2315	}
2316	if invalidParams.Len() > 0 {
2317		return invalidParams
2318	} else {
2319		return nil
2320	}
2321}
2322
2323func validateOpCreateTapePoolInput(v *CreateTapePoolInput) error {
2324	if v == nil {
2325		return nil
2326	}
2327	invalidParams := smithy.InvalidParamsError{Context: "CreateTapePoolInput"}
2328	if v.PoolName == nil {
2329		invalidParams.Add(smithy.NewErrParamRequired("PoolName"))
2330	}
2331	if len(v.StorageClass) == 0 {
2332		invalidParams.Add(smithy.NewErrParamRequired("StorageClass"))
2333	}
2334	if v.Tags != nil {
2335		if err := validateTags(v.Tags); err != nil {
2336			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
2337		}
2338	}
2339	if invalidParams.Len() > 0 {
2340		return invalidParams
2341	} else {
2342		return nil
2343	}
2344}
2345
2346func validateOpCreateTapesInput(v *CreateTapesInput) error {
2347	if v == nil {
2348		return nil
2349	}
2350	invalidParams := smithy.InvalidParamsError{Context: "CreateTapesInput"}
2351	if v.GatewayARN == nil {
2352		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2353	}
2354	if v.TapeSizeInBytes == nil {
2355		invalidParams.Add(smithy.NewErrParamRequired("TapeSizeInBytes"))
2356	}
2357	if v.ClientToken == nil {
2358		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
2359	}
2360	if v.NumTapesToCreate == nil {
2361		invalidParams.Add(smithy.NewErrParamRequired("NumTapesToCreate"))
2362	}
2363	if v.TapeBarcodePrefix == nil {
2364		invalidParams.Add(smithy.NewErrParamRequired("TapeBarcodePrefix"))
2365	}
2366	if v.Tags != nil {
2367		if err := validateTags(v.Tags); err != nil {
2368			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
2369		}
2370	}
2371	if invalidParams.Len() > 0 {
2372		return invalidParams
2373	} else {
2374		return nil
2375	}
2376}
2377
2378func validateOpCreateTapeWithBarcodeInput(v *CreateTapeWithBarcodeInput) error {
2379	if v == nil {
2380		return nil
2381	}
2382	invalidParams := smithy.InvalidParamsError{Context: "CreateTapeWithBarcodeInput"}
2383	if v.GatewayARN == nil {
2384		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2385	}
2386	if v.TapeSizeInBytes == nil {
2387		invalidParams.Add(smithy.NewErrParamRequired("TapeSizeInBytes"))
2388	}
2389	if v.TapeBarcode == nil {
2390		invalidParams.Add(smithy.NewErrParamRequired("TapeBarcode"))
2391	}
2392	if v.Tags != nil {
2393		if err := validateTags(v.Tags); err != nil {
2394			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
2395		}
2396	}
2397	if invalidParams.Len() > 0 {
2398		return invalidParams
2399	} else {
2400		return nil
2401	}
2402}
2403
2404func validateOpDeleteAutomaticTapeCreationPolicyInput(v *DeleteAutomaticTapeCreationPolicyInput) error {
2405	if v == nil {
2406		return nil
2407	}
2408	invalidParams := smithy.InvalidParamsError{Context: "DeleteAutomaticTapeCreationPolicyInput"}
2409	if v.GatewayARN == nil {
2410		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2411	}
2412	if invalidParams.Len() > 0 {
2413		return invalidParams
2414	} else {
2415		return nil
2416	}
2417}
2418
2419func validateOpDeleteBandwidthRateLimitInput(v *DeleteBandwidthRateLimitInput) error {
2420	if v == nil {
2421		return nil
2422	}
2423	invalidParams := smithy.InvalidParamsError{Context: "DeleteBandwidthRateLimitInput"}
2424	if v.GatewayARN == nil {
2425		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2426	}
2427	if v.BandwidthType == nil {
2428		invalidParams.Add(smithy.NewErrParamRequired("BandwidthType"))
2429	}
2430	if invalidParams.Len() > 0 {
2431		return invalidParams
2432	} else {
2433		return nil
2434	}
2435}
2436
2437func validateOpDeleteChapCredentialsInput(v *DeleteChapCredentialsInput) error {
2438	if v == nil {
2439		return nil
2440	}
2441	invalidParams := smithy.InvalidParamsError{Context: "DeleteChapCredentialsInput"}
2442	if v.TargetARN == nil {
2443		invalidParams.Add(smithy.NewErrParamRequired("TargetARN"))
2444	}
2445	if v.InitiatorName == nil {
2446		invalidParams.Add(smithy.NewErrParamRequired("InitiatorName"))
2447	}
2448	if invalidParams.Len() > 0 {
2449		return invalidParams
2450	} else {
2451		return nil
2452	}
2453}
2454
2455func validateOpDeleteFileShareInput(v *DeleteFileShareInput) error {
2456	if v == nil {
2457		return nil
2458	}
2459	invalidParams := smithy.InvalidParamsError{Context: "DeleteFileShareInput"}
2460	if v.FileShareARN == nil {
2461		invalidParams.Add(smithy.NewErrParamRequired("FileShareARN"))
2462	}
2463	if invalidParams.Len() > 0 {
2464		return invalidParams
2465	} else {
2466		return nil
2467	}
2468}
2469
2470func validateOpDeleteGatewayInput(v *DeleteGatewayInput) error {
2471	if v == nil {
2472		return nil
2473	}
2474	invalidParams := smithy.InvalidParamsError{Context: "DeleteGatewayInput"}
2475	if v.GatewayARN == nil {
2476		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2477	}
2478	if invalidParams.Len() > 0 {
2479		return invalidParams
2480	} else {
2481		return nil
2482	}
2483}
2484
2485func validateOpDeleteSnapshotScheduleInput(v *DeleteSnapshotScheduleInput) error {
2486	if v == nil {
2487		return nil
2488	}
2489	invalidParams := smithy.InvalidParamsError{Context: "DeleteSnapshotScheduleInput"}
2490	if v.VolumeARN == nil {
2491		invalidParams.Add(smithy.NewErrParamRequired("VolumeARN"))
2492	}
2493	if invalidParams.Len() > 0 {
2494		return invalidParams
2495	} else {
2496		return nil
2497	}
2498}
2499
2500func validateOpDeleteTapeArchiveInput(v *DeleteTapeArchiveInput) error {
2501	if v == nil {
2502		return nil
2503	}
2504	invalidParams := smithy.InvalidParamsError{Context: "DeleteTapeArchiveInput"}
2505	if v.TapeARN == nil {
2506		invalidParams.Add(smithy.NewErrParamRequired("TapeARN"))
2507	}
2508	if invalidParams.Len() > 0 {
2509		return invalidParams
2510	} else {
2511		return nil
2512	}
2513}
2514
2515func validateOpDeleteTapeInput(v *DeleteTapeInput) error {
2516	if v == nil {
2517		return nil
2518	}
2519	invalidParams := smithy.InvalidParamsError{Context: "DeleteTapeInput"}
2520	if v.GatewayARN == nil {
2521		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2522	}
2523	if v.TapeARN == nil {
2524		invalidParams.Add(smithy.NewErrParamRequired("TapeARN"))
2525	}
2526	if invalidParams.Len() > 0 {
2527		return invalidParams
2528	} else {
2529		return nil
2530	}
2531}
2532
2533func validateOpDeleteTapePoolInput(v *DeleteTapePoolInput) error {
2534	if v == nil {
2535		return nil
2536	}
2537	invalidParams := smithy.InvalidParamsError{Context: "DeleteTapePoolInput"}
2538	if v.PoolARN == nil {
2539		invalidParams.Add(smithy.NewErrParamRequired("PoolARN"))
2540	}
2541	if invalidParams.Len() > 0 {
2542		return invalidParams
2543	} else {
2544		return nil
2545	}
2546}
2547
2548func validateOpDeleteVolumeInput(v *DeleteVolumeInput) error {
2549	if v == nil {
2550		return nil
2551	}
2552	invalidParams := smithy.InvalidParamsError{Context: "DeleteVolumeInput"}
2553	if v.VolumeARN == nil {
2554		invalidParams.Add(smithy.NewErrParamRequired("VolumeARN"))
2555	}
2556	if invalidParams.Len() > 0 {
2557		return invalidParams
2558	} else {
2559		return nil
2560	}
2561}
2562
2563func validateOpDescribeAvailabilityMonitorTestInput(v *DescribeAvailabilityMonitorTestInput) error {
2564	if v == nil {
2565		return nil
2566	}
2567	invalidParams := smithy.InvalidParamsError{Context: "DescribeAvailabilityMonitorTestInput"}
2568	if v.GatewayARN == nil {
2569		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2570	}
2571	if invalidParams.Len() > 0 {
2572		return invalidParams
2573	} else {
2574		return nil
2575	}
2576}
2577
2578func validateOpDescribeBandwidthRateLimitInput(v *DescribeBandwidthRateLimitInput) error {
2579	if v == nil {
2580		return nil
2581	}
2582	invalidParams := smithy.InvalidParamsError{Context: "DescribeBandwidthRateLimitInput"}
2583	if v.GatewayARN == nil {
2584		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2585	}
2586	if invalidParams.Len() > 0 {
2587		return invalidParams
2588	} else {
2589		return nil
2590	}
2591}
2592
2593func validateOpDescribeBandwidthRateLimitScheduleInput(v *DescribeBandwidthRateLimitScheduleInput) error {
2594	if v == nil {
2595		return nil
2596	}
2597	invalidParams := smithy.InvalidParamsError{Context: "DescribeBandwidthRateLimitScheduleInput"}
2598	if v.GatewayARN == nil {
2599		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2600	}
2601	if invalidParams.Len() > 0 {
2602		return invalidParams
2603	} else {
2604		return nil
2605	}
2606}
2607
2608func validateOpDescribeCachediSCSIVolumesInput(v *DescribeCachediSCSIVolumesInput) error {
2609	if v == nil {
2610		return nil
2611	}
2612	invalidParams := smithy.InvalidParamsError{Context: "DescribeCachediSCSIVolumesInput"}
2613	if v.VolumeARNs == nil {
2614		invalidParams.Add(smithy.NewErrParamRequired("VolumeARNs"))
2615	}
2616	if invalidParams.Len() > 0 {
2617		return invalidParams
2618	} else {
2619		return nil
2620	}
2621}
2622
2623func validateOpDescribeCacheInput(v *DescribeCacheInput) error {
2624	if v == nil {
2625		return nil
2626	}
2627	invalidParams := smithy.InvalidParamsError{Context: "DescribeCacheInput"}
2628	if v.GatewayARN == nil {
2629		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2630	}
2631	if invalidParams.Len() > 0 {
2632		return invalidParams
2633	} else {
2634		return nil
2635	}
2636}
2637
2638func validateOpDescribeChapCredentialsInput(v *DescribeChapCredentialsInput) error {
2639	if v == nil {
2640		return nil
2641	}
2642	invalidParams := smithy.InvalidParamsError{Context: "DescribeChapCredentialsInput"}
2643	if v.TargetARN == nil {
2644		invalidParams.Add(smithy.NewErrParamRequired("TargetARN"))
2645	}
2646	if invalidParams.Len() > 0 {
2647		return invalidParams
2648	} else {
2649		return nil
2650	}
2651}
2652
2653func validateOpDescribeGatewayInformationInput(v *DescribeGatewayInformationInput) error {
2654	if v == nil {
2655		return nil
2656	}
2657	invalidParams := smithy.InvalidParamsError{Context: "DescribeGatewayInformationInput"}
2658	if v.GatewayARN == nil {
2659		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2660	}
2661	if invalidParams.Len() > 0 {
2662		return invalidParams
2663	} else {
2664		return nil
2665	}
2666}
2667
2668func validateOpDescribeMaintenanceStartTimeInput(v *DescribeMaintenanceStartTimeInput) error {
2669	if v == nil {
2670		return nil
2671	}
2672	invalidParams := smithy.InvalidParamsError{Context: "DescribeMaintenanceStartTimeInput"}
2673	if v.GatewayARN == nil {
2674		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2675	}
2676	if invalidParams.Len() > 0 {
2677		return invalidParams
2678	} else {
2679		return nil
2680	}
2681}
2682
2683func validateOpDescribeNFSFileSharesInput(v *DescribeNFSFileSharesInput) error {
2684	if v == nil {
2685		return nil
2686	}
2687	invalidParams := smithy.InvalidParamsError{Context: "DescribeNFSFileSharesInput"}
2688	if v.FileShareARNList == nil {
2689		invalidParams.Add(smithy.NewErrParamRequired("FileShareARNList"))
2690	}
2691	if invalidParams.Len() > 0 {
2692		return invalidParams
2693	} else {
2694		return nil
2695	}
2696}
2697
2698func validateOpDescribeSMBFileSharesInput(v *DescribeSMBFileSharesInput) error {
2699	if v == nil {
2700		return nil
2701	}
2702	invalidParams := smithy.InvalidParamsError{Context: "DescribeSMBFileSharesInput"}
2703	if v.FileShareARNList == nil {
2704		invalidParams.Add(smithy.NewErrParamRequired("FileShareARNList"))
2705	}
2706	if invalidParams.Len() > 0 {
2707		return invalidParams
2708	} else {
2709		return nil
2710	}
2711}
2712
2713func validateOpDescribeSMBSettingsInput(v *DescribeSMBSettingsInput) error {
2714	if v == nil {
2715		return nil
2716	}
2717	invalidParams := smithy.InvalidParamsError{Context: "DescribeSMBSettingsInput"}
2718	if v.GatewayARN == nil {
2719		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2720	}
2721	if invalidParams.Len() > 0 {
2722		return invalidParams
2723	} else {
2724		return nil
2725	}
2726}
2727
2728func validateOpDescribeSnapshotScheduleInput(v *DescribeSnapshotScheduleInput) error {
2729	if v == nil {
2730		return nil
2731	}
2732	invalidParams := smithy.InvalidParamsError{Context: "DescribeSnapshotScheduleInput"}
2733	if v.VolumeARN == nil {
2734		invalidParams.Add(smithy.NewErrParamRequired("VolumeARN"))
2735	}
2736	if invalidParams.Len() > 0 {
2737		return invalidParams
2738	} else {
2739		return nil
2740	}
2741}
2742
2743func validateOpDescribeStorediSCSIVolumesInput(v *DescribeStorediSCSIVolumesInput) error {
2744	if v == nil {
2745		return nil
2746	}
2747	invalidParams := smithy.InvalidParamsError{Context: "DescribeStorediSCSIVolumesInput"}
2748	if v.VolumeARNs == nil {
2749		invalidParams.Add(smithy.NewErrParamRequired("VolumeARNs"))
2750	}
2751	if invalidParams.Len() > 0 {
2752		return invalidParams
2753	} else {
2754		return nil
2755	}
2756}
2757
2758func validateOpDescribeTapeRecoveryPointsInput(v *DescribeTapeRecoveryPointsInput) error {
2759	if v == nil {
2760		return nil
2761	}
2762	invalidParams := smithy.InvalidParamsError{Context: "DescribeTapeRecoveryPointsInput"}
2763	if v.GatewayARN == nil {
2764		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2765	}
2766	if invalidParams.Len() > 0 {
2767		return invalidParams
2768	} else {
2769		return nil
2770	}
2771}
2772
2773func validateOpDescribeTapesInput(v *DescribeTapesInput) error {
2774	if v == nil {
2775		return nil
2776	}
2777	invalidParams := smithy.InvalidParamsError{Context: "DescribeTapesInput"}
2778	if v.GatewayARN == nil {
2779		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2780	}
2781	if invalidParams.Len() > 0 {
2782		return invalidParams
2783	} else {
2784		return nil
2785	}
2786}
2787
2788func validateOpDescribeUploadBufferInput(v *DescribeUploadBufferInput) error {
2789	if v == nil {
2790		return nil
2791	}
2792	invalidParams := smithy.InvalidParamsError{Context: "DescribeUploadBufferInput"}
2793	if v.GatewayARN == nil {
2794		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2795	}
2796	if invalidParams.Len() > 0 {
2797		return invalidParams
2798	} else {
2799		return nil
2800	}
2801}
2802
2803func validateOpDescribeVTLDevicesInput(v *DescribeVTLDevicesInput) error {
2804	if v == nil {
2805		return nil
2806	}
2807	invalidParams := smithy.InvalidParamsError{Context: "DescribeVTLDevicesInput"}
2808	if v.GatewayARN == nil {
2809		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2810	}
2811	if invalidParams.Len() > 0 {
2812		return invalidParams
2813	} else {
2814		return nil
2815	}
2816}
2817
2818func validateOpDescribeWorkingStorageInput(v *DescribeWorkingStorageInput) error {
2819	if v == nil {
2820		return nil
2821	}
2822	invalidParams := smithy.InvalidParamsError{Context: "DescribeWorkingStorageInput"}
2823	if v.GatewayARN == nil {
2824		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2825	}
2826	if invalidParams.Len() > 0 {
2827		return invalidParams
2828	} else {
2829		return nil
2830	}
2831}
2832
2833func validateOpDetachVolumeInput(v *DetachVolumeInput) error {
2834	if v == nil {
2835		return nil
2836	}
2837	invalidParams := smithy.InvalidParamsError{Context: "DetachVolumeInput"}
2838	if v.VolumeARN == nil {
2839		invalidParams.Add(smithy.NewErrParamRequired("VolumeARN"))
2840	}
2841	if invalidParams.Len() > 0 {
2842		return invalidParams
2843	} else {
2844		return nil
2845	}
2846}
2847
2848func validateOpDisableGatewayInput(v *DisableGatewayInput) error {
2849	if v == nil {
2850		return nil
2851	}
2852	invalidParams := smithy.InvalidParamsError{Context: "DisableGatewayInput"}
2853	if v.GatewayARN == nil {
2854		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2855	}
2856	if invalidParams.Len() > 0 {
2857		return invalidParams
2858	} else {
2859		return nil
2860	}
2861}
2862
2863func validateOpJoinDomainInput(v *JoinDomainInput) error {
2864	if v == nil {
2865		return nil
2866	}
2867	invalidParams := smithy.InvalidParamsError{Context: "JoinDomainInput"}
2868	if v.GatewayARN == nil {
2869		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2870	}
2871	if v.DomainName == nil {
2872		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
2873	}
2874	if v.UserName == nil {
2875		invalidParams.Add(smithy.NewErrParamRequired("UserName"))
2876	}
2877	if v.Password == nil {
2878		invalidParams.Add(smithy.NewErrParamRequired("Password"))
2879	}
2880	if invalidParams.Len() > 0 {
2881		return invalidParams
2882	} else {
2883		return nil
2884	}
2885}
2886
2887func validateOpListLocalDisksInput(v *ListLocalDisksInput) error {
2888	if v == nil {
2889		return nil
2890	}
2891	invalidParams := smithy.InvalidParamsError{Context: "ListLocalDisksInput"}
2892	if v.GatewayARN == nil {
2893		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2894	}
2895	if invalidParams.Len() > 0 {
2896		return invalidParams
2897	} else {
2898		return nil
2899	}
2900}
2901
2902func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
2903	if v == nil {
2904		return nil
2905	}
2906	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
2907	if v.ResourceARN == nil {
2908		invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
2909	}
2910	if invalidParams.Len() > 0 {
2911		return invalidParams
2912	} else {
2913		return nil
2914	}
2915}
2916
2917func validateOpListVolumeInitiatorsInput(v *ListVolumeInitiatorsInput) error {
2918	if v == nil {
2919		return nil
2920	}
2921	invalidParams := smithy.InvalidParamsError{Context: "ListVolumeInitiatorsInput"}
2922	if v.VolumeARN == nil {
2923		invalidParams.Add(smithy.NewErrParamRequired("VolumeARN"))
2924	}
2925	if invalidParams.Len() > 0 {
2926		return invalidParams
2927	} else {
2928		return nil
2929	}
2930}
2931
2932func validateOpListVolumeRecoveryPointsInput(v *ListVolumeRecoveryPointsInput) error {
2933	if v == nil {
2934		return nil
2935	}
2936	invalidParams := smithy.InvalidParamsError{Context: "ListVolumeRecoveryPointsInput"}
2937	if v.GatewayARN == nil {
2938		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
2939	}
2940	if invalidParams.Len() > 0 {
2941		return invalidParams
2942	} else {
2943		return nil
2944	}
2945}
2946
2947func validateOpNotifyWhenUploadedInput(v *NotifyWhenUploadedInput) error {
2948	if v == nil {
2949		return nil
2950	}
2951	invalidParams := smithy.InvalidParamsError{Context: "NotifyWhenUploadedInput"}
2952	if v.FileShareARN == nil {
2953		invalidParams.Add(smithy.NewErrParamRequired("FileShareARN"))
2954	}
2955	if invalidParams.Len() > 0 {
2956		return invalidParams
2957	} else {
2958		return nil
2959	}
2960}
2961
2962func validateOpRefreshCacheInput(v *RefreshCacheInput) error {
2963	if v == nil {
2964		return nil
2965	}
2966	invalidParams := smithy.InvalidParamsError{Context: "RefreshCacheInput"}
2967	if v.FileShareARN == nil {
2968		invalidParams.Add(smithy.NewErrParamRequired("FileShareARN"))
2969	}
2970	if invalidParams.Len() > 0 {
2971		return invalidParams
2972	} else {
2973		return nil
2974	}
2975}
2976
2977func validateOpRemoveTagsFromResourceInput(v *RemoveTagsFromResourceInput) error {
2978	if v == nil {
2979		return nil
2980	}
2981	invalidParams := smithy.InvalidParamsError{Context: "RemoveTagsFromResourceInput"}
2982	if v.ResourceARN == nil {
2983		invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
2984	}
2985	if v.TagKeys == nil {
2986		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
2987	}
2988	if invalidParams.Len() > 0 {
2989		return invalidParams
2990	} else {
2991		return nil
2992	}
2993}
2994
2995func validateOpResetCacheInput(v *ResetCacheInput) error {
2996	if v == nil {
2997		return nil
2998	}
2999	invalidParams := smithy.InvalidParamsError{Context: "ResetCacheInput"}
3000	if v.GatewayARN == nil {
3001		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
3002	}
3003	if invalidParams.Len() > 0 {
3004		return invalidParams
3005	} else {
3006		return nil
3007	}
3008}
3009
3010func validateOpRetrieveTapeArchiveInput(v *RetrieveTapeArchiveInput) error {
3011	if v == nil {
3012		return nil
3013	}
3014	invalidParams := smithy.InvalidParamsError{Context: "RetrieveTapeArchiveInput"}
3015	if v.TapeARN == nil {
3016		invalidParams.Add(smithy.NewErrParamRequired("TapeARN"))
3017	}
3018	if v.GatewayARN == nil {
3019		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
3020	}
3021	if invalidParams.Len() > 0 {
3022		return invalidParams
3023	} else {
3024		return nil
3025	}
3026}
3027
3028func validateOpRetrieveTapeRecoveryPointInput(v *RetrieveTapeRecoveryPointInput) error {
3029	if v == nil {
3030		return nil
3031	}
3032	invalidParams := smithy.InvalidParamsError{Context: "RetrieveTapeRecoveryPointInput"}
3033	if v.TapeARN == nil {
3034		invalidParams.Add(smithy.NewErrParamRequired("TapeARN"))
3035	}
3036	if v.GatewayARN == nil {
3037		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
3038	}
3039	if invalidParams.Len() > 0 {
3040		return invalidParams
3041	} else {
3042		return nil
3043	}
3044}
3045
3046func validateOpSetLocalConsolePasswordInput(v *SetLocalConsolePasswordInput) error {
3047	if v == nil {
3048		return nil
3049	}
3050	invalidParams := smithy.InvalidParamsError{Context: "SetLocalConsolePasswordInput"}
3051	if v.GatewayARN == nil {
3052		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
3053	}
3054	if v.LocalConsolePassword == nil {
3055		invalidParams.Add(smithy.NewErrParamRequired("LocalConsolePassword"))
3056	}
3057	if invalidParams.Len() > 0 {
3058		return invalidParams
3059	} else {
3060		return nil
3061	}
3062}
3063
3064func validateOpSetSMBGuestPasswordInput(v *SetSMBGuestPasswordInput) error {
3065	if v == nil {
3066		return nil
3067	}
3068	invalidParams := smithy.InvalidParamsError{Context: "SetSMBGuestPasswordInput"}
3069	if v.GatewayARN == nil {
3070		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
3071	}
3072	if v.Password == nil {
3073		invalidParams.Add(smithy.NewErrParamRequired("Password"))
3074	}
3075	if invalidParams.Len() > 0 {
3076		return invalidParams
3077	} else {
3078		return nil
3079	}
3080}
3081
3082func validateOpShutdownGatewayInput(v *ShutdownGatewayInput) error {
3083	if v == nil {
3084		return nil
3085	}
3086	invalidParams := smithy.InvalidParamsError{Context: "ShutdownGatewayInput"}
3087	if v.GatewayARN == nil {
3088		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
3089	}
3090	if invalidParams.Len() > 0 {
3091		return invalidParams
3092	} else {
3093		return nil
3094	}
3095}
3096
3097func validateOpStartAvailabilityMonitorTestInput(v *StartAvailabilityMonitorTestInput) error {
3098	if v == nil {
3099		return nil
3100	}
3101	invalidParams := smithy.InvalidParamsError{Context: "StartAvailabilityMonitorTestInput"}
3102	if v.GatewayARN == nil {
3103		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
3104	}
3105	if invalidParams.Len() > 0 {
3106		return invalidParams
3107	} else {
3108		return nil
3109	}
3110}
3111
3112func validateOpStartGatewayInput(v *StartGatewayInput) error {
3113	if v == nil {
3114		return nil
3115	}
3116	invalidParams := smithy.InvalidParamsError{Context: "StartGatewayInput"}
3117	if v.GatewayARN == nil {
3118		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
3119	}
3120	if invalidParams.Len() > 0 {
3121		return invalidParams
3122	} else {
3123		return nil
3124	}
3125}
3126
3127func validateOpUpdateAutomaticTapeCreationPolicyInput(v *UpdateAutomaticTapeCreationPolicyInput) error {
3128	if v == nil {
3129		return nil
3130	}
3131	invalidParams := smithy.InvalidParamsError{Context: "UpdateAutomaticTapeCreationPolicyInput"}
3132	if v.AutomaticTapeCreationRules == nil {
3133		invalidParams.Add(smithy.NewErrParamRequired("AutomaticTapeCreationRules"))
3134	} else if v.AutomaticTapeCreationRules != nil {
3135		if err := validateAutomaticTapeCreationRules(v.AutomaticTapeCreationRules); err != nil {
3136			invalidParams.AddNested("AutomaticTapeCreationRules", err.(smithy.InvalidParamsError))
3137		}
3138	}
3139	if v.GatewayARN == nil {
3140		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
3141	}
3142	if invalidParams.Len() > 0 {
3143		return invalidParams
3144	} else {
3145		return nil
3146	}
3147}
3148
3149func validateOpUpdateBandwidthRateLimitInput(v *UpdateBandwidthRateLimitInput) error {
3150	if v == nil {
3151		return nil
3152	}
3153	invalidParams := smithy.InvalidParamsError{Context: "UpdateBandwidthRateLimitInput"}
3154	if v.GatewayARN == nil {
3155		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
3156	}
3157	if invalidParams.Len() > 0 {
3158		return invalidParams
3159	} else {
3160		return nil
3161	}
3162}
3163
3164func validateOpUpdateBandwidthRateLimitScheduleInput(v *UpdateBandwidthRateLimitScheduleInput) error {
3165	if v == nil {
3166		return nil
3167	}
3168	invalidParams := smithy.InvalidParamsError{Context: "UpdateBandwidthRateLimitScheduleInput"}
3169	if v.GatewayARN == nil {
3170		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
3171	}
3172	if v.BandwidthRateLimitIntervals == nil {
3173		invalidParams.Add(smithy.NewErrParamRequired("BandwidthRateLimitIntervals"))
3174	} else if v.BandwidthRateLimitIntervals != nil {
3175		if err := validateBandwidthRateLimitIntervals(v.BandwidthRateLimitIntervals); err != nil {
3176			invalidParams.AddNested("BandwidthRateLimitIntervals", err.(smithy.InvalidParamsError))
3177		}
3178	}
3179	if invalidParams.Len() > 0 {
3180		return invalidParams
3181	} else {
3182		return nil
3183	}
3184}
3185
3186func validateOpUpdateChapCredentialsInput(v *UpdateChapCredentialsInput) error {
3187	if v == nil {
3188		return nil
3189	}
3190	invalidParams := smithy.InvalidParamsError{Context: "UpdateChapCredentialsInput"}
3191	if v.TargetARN == nil {
3192		invalidParams.Add(smithy.NewErrParamRequired("TargetARN"))
3193	}
3194	if v.SecretToAuthenticateInitiator == nil {
3195		invalidParams.Add(smithy.NewErrParamRequired("SecretToAuthenticateInitiator"))
3196	}
3197	if v.InitiatorName == nil {
3198		invalidParams.Add(smithy.NewErrParamRequired("InitiatorName"))
3199	}
3200	if invalidParams.Len() > 0 {
3201		return invalidParams
3202	} else {
3203		return nil
3204	}
3205}
3206
3207func validateOpUpdateGatewayInformationInput(v *UpdateGatewayInformationInput) error {
3208	if v == nil {
3209		return nil
3210	}
3211	invalidParams := smithy.InvalidParamsError{Context: "UpdateGatewayInformationInput"}
3212	if v.GatewayARN == nil {
3213		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
3214	}
3215	if invalidParams.Len() > 0 {
3216		return invalidParams
3217	} else {
3218		return nil
3219	}
3220}
3221
3222func validateOpUpdateGatewaySoftwareNowInput(v *UpdateGatewaySoftwareNowInput) error {
3223	if v == nil {
3224		return nil
3225	}
3226	invalidParams := smithy.InvalidParamsError{Context: "UpdateGatewaySoftwareNowInput"}
3227	if v.GatewayARN == nil {
3228		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
3229	}
3230	if invalidParams.Len() > 0 {
3231		return invalidParams
3232	} else {
3233		return nil
3234	}
3235}
3236
3237func validateOpUpdateMaintenanceStartTimeInput(v *UpdateMaintenanceStartTimeInput) error {
3238	if v == nil {
3239		return nil
3240	}
3241	invalidParams := smithy.InvalidParamsError{Context: "UpdateMaintenanceStartTimeInput"}
3242	if v.GatewayARN == nil {
3243		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
3244	}
3245	if v.HourOfDay == nil {
3246		invalidParams.Add(smithy.NewErrParamRequired("HourOfDay"))
3247	}
3248	if v.MinuteOfHour == nil {
3249		invalidParams.Add(smithy.NewErrParamRequired("MinuteOfHour"))
3250	}
3251	if invalidParams.Len() > 0 {
3252		return invalidParams
3253	} else {
3254		return nil
3255	}
3256}
3257
3258func validateOpUpdateNFSFileShareInput(v *UpdateNFSFileShareInput) error {
3259	if v == nil {
3260		return nil
3261	}
3262	invalidParams := smithy.InvalidParamsError{Context: "UpdateNFSFileShareInput"}
3263	if v.FileShareARN == nil {
3264		invalidParams.Add(smithy.NewErrParamRequired("FileShareARN"))
3265	}
3266	if invalidParams.Len() > 0 {
3267		return invalidParams
3268	} else {
3269		return nil
3270	}
3271}
3272
3273func validateOpUpdateSMBFileShareInput(v *UpdateSMBFileShareInput) error {
3274	if v == nil {
3275		return nil
3276	}
3277	invalidParams := smithy.InvalidParamsError{Context: "UpdateSMBFileShareInput"}
3278	if v.FileShareARN == nil {
3279		invalidParams.Add(smithy.NewErrParamRequired("FileShareARN"))
3280	}
3281	if invalidParams.Len() > 0 {
3282		return invalidParams
3283	} else {
3284		return nil
3285	}
3286}
3287
3288func validateOpUpdateSMBFileShareVisibilityInput(v *UpdateSMBFileShareVisibilityInput) error {
3289	if v == nil {
3290		return nil
3291	}
3292	invalidParams := smithy.InvalidParamsError{Context: "UpdateSMBFileShareVisibilityInput"}
3293	if v.GatewayARN == nil {
3294		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
3295	}
3296	if v.FileSharesVisible == nil {
3297		invalidParams.Add(smithy.NewErrParamRequired("FileSharesVisible"))
3298	}
3299	if invalidParams.Len() > 0 {
3300		return invalidParams
3301	} else {
3302		return nil
3303	}
3304}
3305
3306func validateOpUpdateSMBSecurityStrategyInput(v *UpdateSMBSecurityStrategyInput) error {
3307	if v == nil {
3308		return nil
3309	}
3310	invalidParams := smithy.InvalidParamsError{Context: "UpdateSMBSecurityStrategyInput"}
3311	if v.GatewayARN == nil {
3312		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
3313	}
3314	if len(v.SMBSecurityStrategy) == 0 {
3315		invalidParams.Add(smithy.NewErrParamRequired("SMBSecurityStrategy"))
3316	}
3317	if invalidParams.Len() > 0 {
3318		return invalidParams
3319	} else {
3320		return nil
3321	}
3322}
3323
3324func validateOpUpdateSnapshotScheduleInput(v *UpdateSnapshotScheduleInput) error {
3325	if v == nil {
3326		return nil
3327	}
3328	invalidParams := smithy.InvalidParamsError{Context: "UpdateSnapshotScheduleInput"}
3329	if v.VolumeARN == nil {
3330		invalidParams.Add(smithy.NewErrParamRequired("VolumeARN"))
3331	}
3332	if v.StartAt == nil {
3333		invalidParams.Add(smithy.NewErrParamRequired("StartAt"))
3334	}
3335	if v.RecurrenceInHours == nil {
3336		invalidParams.Add(smithy.NewErrParamRequired("RecurrenceInHours"))
3337	}
3338	if v.Tags != nil {
3339		if err := validateTags(v.Tags); err != nil {
3340			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
3341		}
3342	}
3343	if invalidParams.Len() > 0 {
3344		return invalidParams
3345	} else {
3346		return nil
3347	}
3348}
3349
3350func validateOpUpdateVTLDeviceTypeInput(v *UpdateVTLDeviceTypeInput) error {
3351	if v == nil {
3352		return nil
3353	}
3354	invalidParams := smithy.InvalidParamsError{Context: "UpdateVTLDeviceTypeInput"}
3355	if v.VTLDeviceARN == nil {
3356		invalidParams.Add(smithy.NewErrParamRequired("VTLDeviceARN"))
3357	}
3358	if v.DeviceType == nil {
3359		invalidParams.Add(smithy.NewErrParamRequired("DeviceType"))
3360	}
3361	if invalidParams.Len() > 0 {
3362		return invalidParams
3363	} else {
3364		return nil
3365	}
3366}
3367