1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package fsx
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/fsx/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpAssociateFileSystemAliases struct {
14}
15
16func (*validateOpAssociateFileSystemAliases) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpAssociateFileSystemAliases) 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.(*AssociateFileSystemAliasesInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpAssociateFileSystemAliasesInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpCancelDataRepositoryTask struct {
34}
35
36func (*validateOpCancelDataRepositoryTask) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpCancelDataRepositoryTask) 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.(*CancelDataRepositoryTaskInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpCancelDataRepositoryTaskInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpCreateBackup struct {
54}
55
56func (*validateOpCreateBackup) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpCreateBackup) 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.(*CreateBackupInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpCreateBackupInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpCreateDataRepositoryTask struct {
74}
75
76func (*validateOpCreateDataRepositoryTask) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpCreateDataRepositoryTask) 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.(*CreateDataRepositoryTaskInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpCreateDataRepositoryTaskInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpCreateFileSystemFromBackup struct {
94}
95
96func (*validateOpCreateFileSystemFromBackup) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpCreateFileSystemFromBackup) 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.(*CreateFileSystemFromBackupInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpCreateFileSystemFromBackupInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpCreateFileSystem struct {
114}
115
116func (*validateOpCreateFileSystem) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpCreateFileSystem) 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.(*CreateFileSystemInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpCreateFileSystemInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpDeleteBackup struct {
134}
135
136func (*validateOpDeleteBackup) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpDeleteBackup) 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.(*DeleteBackupInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpDeleteBackupInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpDeleteFileSystem struct {
154}
155
156func (*validateOpDeleteFileSystem) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpDeleteFileSystem) 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.(*DeleteFileSystemInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpDeleteFileSystemInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpDescribeFileSystemAliases struct {
174}
175
176func (*validateOpDescribeFileSystemAliases) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpDescribeFileSystemAliases) 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.(*DescribeFileSystemAliasesInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpDescribeFileSystemAliasesInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpDisassociateFileSystemAliases struct {
194}
195
196func (*validateOpDisassociateFileSystemAliases) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpDisassociateFileSystemAliases) 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.(*DisassociateFileSystemAliasesInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpDisassociateFileSystemAliasesInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpListTagsForResource struct {
214}
215
216func (*validateOpListTagsForResource) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpListTagsForResourceInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpTagResource struct {
234}
235
236func (*validateOpTagResource) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpTagResource) 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.(*TagResourceInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpTagResourceInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpUntagResource struct {
254}
255
256func (*validateOpUntagResource) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpUntagResource) 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.(*UntagResourceInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpUntagResourceInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpUpdateFileSystem struct {
274}
275
276func (*validateOpUpdateFileSystem) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpUpdateFileSystem) 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.(*UpdateFileSystemInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpUpdateFileSystemInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293func addOpAssociateFileSystemAliasesValidationMiddleware(stack *middleware.Stack) error {
294	return stack.Initialize.Add(&validateOpAssociateFileSystemAliases{}, middleware.After)
295}
296
297func addOpCancelDataRepositoryTaskValidationMiddleware(stack *middleware.Stack) error {
298	return stack.Initialize.Add(&validateOpCancelDataRepositoryTask{}, middleware.After)
299}
300
301func addOpCreateBackupValidationMiddleware(stack *middleware.Stack) error {
302	return stack.Initialize.Add(&validateOpCreateBackup{}, middleware.After)
303}
304
305func addOpCreateDataRepositoryTaskValidationMiddleware(stack *middleware.Stack) error {
306	return stack.Initialize.Add(&validateOpCreateDataRepositoryTask{}, middleware.After)
307}
308
309func addOpCreateFileSystemFromBackupValidationMiddleware(stack *middleware.Stack) error {
310	return stack.Initialize.Add(&validateOpCreateFileSystemFromBackup{}, middleware.After)
311}
312
313func addOpCreateFileSystemValidationMiddleware(stack *middleware.Stack) error {
314	return stack.Initialize.Add(&validateOpCreateFileSystem{}, middleware.After)
315}
316
317func addOpDeleteBackupValidationMiddleware(stack *middleware.Stack) error {
318	return stack.Initialize.Add(&validateOpDeleteBackup{}, middleware.After)
319}
320
321func addOpDeleteFileSystemValidationMiddleware(stack *middleware.Stack) error {
322	return stack.Initialize.Add(&validateOpDeleteFileSystem{}, middleware.After)
323}
324
325func addOpDescribeFileSystemAliasesValidationMiddleware(stack *middleware.Stack) error {
326	return stack.Initialize.Add(&validateOpDescribeFileSystemAliases{}, middleware.After)
327}
328
329func addOpDisassociateFileSystemAliasesValidationMiddleware(stack *middleware.Stack) error {
330	return stack.Initialize.Add(&validateOpDisassociateFileSystemAliases{}, middleware.After)
331}
332
333func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
334	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
335}
336
337func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
338	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
339}
340
341func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
342	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
343}
344
345func addOpUpdateFileSystemValidationMiddleware(stack *middleware.Stack) error {
346	return stack.Initialize.Add(&validateOpUpdateFileSystem{}, middleware.After)
347}
348
349func validateCompletionReport(v *types.CompletionReport) error {
350	if v == nil {
351		return nil
352	}
353	invalidParams := smithy.InvalidParamsError{Context: "CompletionReport"}
354	if v.Enabled == nil {
355		invalidParams.Add(smithy.NewErrParamRequired("Enabled"))
356	}
357	if invalidParams.Len() > 0 {
358		return invalidParams
359	} else {
360		return nil
361	}
362}
363
364func validateCreateFileSystemWindowsConfiguration(v *types.CreateFileSystemWindowsConfiguration) error {
365	if v == nil {
366		return nil
367	}
368	invalidParams := smithy.InvalidParamsError{Context: "CreateFileSystemWindowsConfiguration"}
369	if v.SelfManagedActiveDirectoryConfiguration != nil {
370		if err := validateSelfManagedActiveDirectoryConfiguration(v.SelfManagedActiveDirectoryConfiguration); err != nil {
371			invalidParams.AddNested("SelfManagedActiveDirectoryConfiguration", err.(smithy.InvalidParamsError))
372		}
373	}
374	if v.ThroughputCapacity == nil {
375		invalidParams.Add(smithy.NewErrParamRequired("ThroughputCapacity"))
376	}
377	if invalidParams.Len() > 0 {
378		return invalidParams
379	} else {
380		return nil
381	}
382}
383
384func validateDeleteFileSystemLustreConfiguration(v *types.DeleteFileSystemLustreConfiguration) error {
385	if v == nil {
386		return nil
387	}
388	invalidParams := smithy.InvalidParamsError{Context: "DeleteFileSystemLustreConfiguration"}
389	if v.FinalBackupTags != nil {
390		if err := validateTags(v.FinalBackupTags); err != nil {
391			invalidParams.AddNested("FinalBackupTags", err.(smithy.InvalidParamsError))
392		}
393	}
394	if invalidParams.Len() > 0 {
395		return invalidParams
396	} else {
397		return nil
398	}
399}
400
401func validateDeleteFileSystemWindowsConfiguration(v *types.DeleteFileSystemWindowsConfiguration) error {
402	if v == nil {
403		return nil
404	}
405	invalidParams := smithy.InvalidParamsError{Context: "DeleteFileSystemWindowsConfiguration"}
406	if v.FinalBackupTags != nil {
407		if err := validateTags(v.FinalBackupTags); err != nil {
408			invalidParams.AddNested("FinalBackupTags", err.(smithy.InvalidParamsError))
409		}
410	}
411	if invalidParams.Len() > 0 {
412		return invalidParams
413	} else {
414		return nil
415	}
416}
417
418func validateSelfManagedActiveDirectoryConfiguration(v *types.SelfManagedActiveDirectoryConfiguration) error {
419	if v == nil {
420		return nil
421	}
422	invalidParams := smithy.InvalidParamsError{Context: "SelfManagedActiveDirectoryConfiguration"}
423	if v.DomainName == nil {
424		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
425	}
426	if v.UserName == nil {
427		invalidParams.Add(smithy.NewErrParamRequired("UserName"))
428	}
429	if v.Password == nil {
430		invalidParams.Add(smithy.NewErrParamRequired("Password"))
431	}
432	if v.DnsIps == nil {
433		invalidParams.Add(smithy.NewErrParamRequired("DnsIps"))
434	}
435	if invalidParams.Len() > 0 {
436		return invalidParams
437	} else {
438		return nil
439	}
440}
441
442func validateTag(v *types.Tag) error {
443	if v == nil {
444		return nil
445	}
446	invalidParams := smithy.InvalidParamsError{Context: "Tag"}
447	if v.Key == nil {
448		invalidParams.Add(smithy.NewErrParamRequired("Key"))
449	}
450	if v.Value == nil {
451		invalidParams.Add(smithy.NewErrParamRequired("Value"))
452	}
453	if invalidParams.Len() > 0 {
454		return invalidParams
455	} else {
456		return nil
457	}
458}
459
460func validateTags(v []types.Tag) error {
461	if v == nil {
462		return nil
463	}
464	invalidParams := smithy.InvalidParamsError{Context: "Tags"}
465	for i := range v {
466		if err := validateTag(&v[i]); err != nil {
467			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
468		}
469	}
470	if invalidParams.Len() > 0 {
471		return invalidParams
472	} else {
473		return nil
474	}
475}
476
477func validateOpAssociateFileSystemAliasesInput(v *AssociateFileSystemAliasesInput) error {
478	if v == nil {
479		return nil
480	}
481	invalidParams := smithy.InvalidParamsError{Context: "AssociateFileSystemAliasesInput"}
482	if v.FileSystemId == nil {
483		invalidParams.Add(smithy.NewErrParamRequired("FileSystemId"))
484	}
485	if v.Aliases == nil {
486		invalidParams.Add(smithy.NewErrParamRequired("Aliases"))
487	}
488	if invalidParams.Len() > 0 {
489		return invalidParams
490	} else {
491		return nil
492	}
493}
494
495func validateOpCancelDataRepositoryTaskInput(v *CancelDataRepositoryTaskInput) error {
496	if v == nil {
497		return nil
498	}
499	invalidParams := smithy.InvalidParamsError{Context: "CancelDataRepositoryTaskInput"}
500	if v.TaskId == nil {
501		invalidParams.Add(smithy.NewErrParamRequired("TaskId"))
502	}
503	if invalidParams.Len() > 0 {
504		return invalidParams
505	} else {
506		return nil
507	}
508}
509
510func validateOpCreateBackupInput(v *CreateBackupInput) error {
511	if v == nil {
512		return nil
513	}
514	invalidParams := smithy.InvalidParamsError{Context: "CreateBackupInput"}
515	if v.FileSystemId == nil {
516		invalidParams.Add(smithy.NewErrParamRequired("FileSystemId"))
517	}
518	if v.Tags != nil {
519		if err := validateTags(v.Tags); err != nil {
520			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
521		}
522	}
523	if invalidParams.Len() > 0 {
524		return invalidParams
525	} else {
526		return nil
527	}
528}
529
530func validateOpCreateDataRepositoryTaskInput(v *CreateDataRepositoryTaskInput) error {
531	if v == nil {
532		return nil
533	}
534	invalidParams := smithy.InvalidParamsError{Context: "CreateDataRepositoryTaskInput"}
535	if len(v.Type) == 0 {
536		invalidParams.Add(smithy.NewErrParamRequired("Type"))
537	}
538	if v.FileSystemId == nil {
539		invalidParams.Add(smithy.NewErrParamRequired("FileSystemId"))
540	}
541	if v.Report == nil {
542		invalidParams.Add(smithy.NewErrParamRequired("Report"))
543	} else if v.Report != nil {
544		if err := validateCompletionReport(v.Report); err != nil {
545			invalidParams.AddNested("Report", err.(smithy.InvalidParamsError))
546		}
547	}
548	if v.Tags != nil {
549		if err := validateTags(v.Tags); err != nil {
550			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
551		}
552	}
553	if invalidParams.Len() > 0 {
554		return invalidParams
555	} else {
556		return nil
557	}
558}
559
560func validateOpCreateFileSystemFromBackupInput(v *CreateFileSystemFromBackupInput) error {
561	if v == nil {
562		return nil
563	}
564	invalidParams := smithy.InvalidParamsError{Context: "CreateFileSystemFromBackupInput"}
565	if v.BackupId == nil {
566		invalidParams.Add(smithy.NewErrParamRequired("BackupId"))
567	}
568	if v.SubnetIds == nil {
569		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
570	}
571	if v.Tags != nil {
572		if err := validateTags(v.Tags); err != nil {
573			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
574		}
575	}
576	if v.WindowsConfiguration != nil {
577		if err := validateCreateFileSystemWindowsConfiguration(v.WindowsConfiguration); err != nil {
578			invalidParams.AddNested("WindowsConfiguration", err.(smithy.InvalidParamsError))
579		}
580	}
581	if invalidParams.Len() > 0 {
582		return invalidParams
583	} else {
584		return nil
585	}
586}
587
588func validateOpCreateFileSystemInput(v *CreateFileSystemInput) error {
589	if v == nil {
590		return nil
591	}
592	invalidParams := smithy.InvalidParamsError{Context: "CreateFileSystemInput"}
593	if len(v.FileSystemType) == 0 {
594		invalidParams.Add(smithy.NewErrParamRequired("FileSystemType"))
595	}
596	if v.StorageCapacity == nil {
597		invalidParams.Add(smithy.NewErrParamRequired("StorageCapacity"))
598	}
599	if v.SubnetIds == nil {
600		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
601	}
602	if v.Tags != nil {
603		if err := validateTags(v.Tags); err != nil {
604			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
605		}
606	}
607	if v.WindowsConfiguration != nil {
608		if err := validateCreateFileSystemWindowsConfiguration(v.WindowsConfiguration); err != nil {
609			invalidParams.AddNested("WindowsConfiguration", err.(smithy.InvalidParamsError))
610		}
611	}
612	if invalidParams.Len() > 0 {
613		return invalidParams
614	} else {
615		return nil
616	}
617}
618
619func validateOpDeleteBackupInput(v *DeleteBackupInput) error {
620	if v == nil {
621		return nil
622	}
623	invalidParams := smithy.InvalidParamsError{Context: "DeleteBackupInput"}
624	if v.BackupId == nil {
625		invalidParams.Add(smithy.NewErrParamRequired("BackupId"))
626	}
627	if invalidParams.Len() > 0 {
628		return invalidParams
629	} else {
630		return nil
631	}
632}
633
634func validateOpDeleteFileSystemInput(v *DeleteFileSystemInput) error {
635	if v == nil {
636		return nil
637	}
638	invalidParams := smithy.InvalidParamsError{Context: "DeleteFileSystemInput"}
639	if v.FileSystemId == nil {
640		invalidParams.Add(smithy.NewErrParamRequired("FileSystemId"))
641	}
642	if v.WindowsConfiguration != nil {
643		if err := validateDeleteFileSystemWindowsConfiguration(v.WindowsConfiguration); err != nil {
644			invalidParams.AddNested("WindowsConfiguration", err.(smithy.InvalidParamsError))
645		}
646	}
647	if v.LustreConfiguration != nil {
648		if err := validateDeleteFileSystemLustreConfiguration(v.LustreConfiguration); err != nil {
649			invalidParams.AddNested("LustreConfiguration", err.(smithy.InvalidParamsError))
650		}
651	}
652	if invalidParams.Len() > 0 {
653		return invalidParams
654	} else {
655		return nil
656	}
657}
658
659func validateOpDescribeFileSystemAliasesInput(v *DescribeFileSystemAliasesInput) error {
660	if v == nil {
661		return nil
662	}
663	invalidParams := smithy.InvalidParamsError{Context: "DescribeFileSystemAliasesInput"}
664	if v.FileSystemId == nil {
665		invalidParams.Add(smithy.NewErrParamRequired("FileSystemId"))
666	}
667	if invalidParams.Len() > 0 {
668		return invalidParams
669	} else {
670		return nil
671	}
672}
673
674func validateOpDisassociateFileSystemAliasesInput(v *DisassociateFileSystemAliasesInput) error {
675	if v == nil {
676		return nil
677	}
678	invalidParams := smithy.InvalidParamsError{Context: "DisassociateFileSystemAliasesInput"}
679	if v.FileSystemId == nil {
680		invalidParams.Add(smithy.NewErrParamRequired("FileSystemId"))
681	}
682	if v.Aliases == nil {
683		invalidParams.Add(smithy.NewErrParamRequired("Aliases"))
684	}
685	if invalidParams.Len() > 0 {
686		return invalidParams
687	} else {
688		return nil
689	}
690}
691
692func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
693	if v == nil {
694		return nil
695	}
696	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
697	if v.ResourceARN == nil {
698		invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
699	}
700	if invalidParams.Len() > 0 {
701		return invalidParams
702	} else {
703		return nil
704	}
705}
706
707func validateOpTagResourceInput(v *TagResourceInput) error {
708	if v == nil {
709		return nil
710	}
711	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
712	if v.ResourceARN == nil {
713		invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
714	}
715	if v.Tags == nil {
716		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
717	} else if v.Tags != nil {
718		if err := validateTags(v.Tags); err != nil {
719			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
720		}
721	}
722	if invalidParams.Len() > 0 {
723		return invalidParams
724	} else {
725		return nil
726	}
727}
728
729func validateOpUntagResourceInput(v *UntagResourceInput) error {
730	if v == nil {
731		return nil
732	}
733	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
734	if v.ResourceARN == nil {
735		invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
736	}
737	if v.TagKeys == nil {
738		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
739	}
740	if invalidParams.Len() > 0 {
741		return invalidParams
742	} else {
743		return nil
744	}
745}
746
747func validateOpUpdateFileSystemInput(v *UpdateFileSystemInput) error {
748	if v == nil {
749		return nil
750	}
751	invalidParams := smithy.InvalidParamsError{Context: "UpdateFileSystemInput"}
752	if v.FileSystemId == nil {
753		invalidParams.Add(smithy.NewErrParamRequired("FileSystemId"))
754	}
755	if invalidParams.Len() > 0 {
756		return invalidParams
757	} else {
758		return nil
759	}
760}
761