1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package appstream
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/appstream/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpAssociateFleet struct {
14}
15
16func (*validateOpAssociateFleet) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpAssociateFleet) 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.(*AssociateFleetInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpAssociateFleetInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpBatchAssociateUserStack struct {
34}
35
36func (*validateOpBatchAssociateUserStack) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpBatchAssociateUserStack) 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.(*BatchAssociateUserStackInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpBatchAssociateUserStackInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpBatchDisassociateUserStack struct {
54}
55
56func (*validateOpBatchDisassociateUserStack) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpBatchDisassociateUserStack) 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.(*BatchDisassociateUserStackInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpBatchDisassociateUserStackInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpCopyImage struct {
74}
75
76func (*validateOpCopyImage) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpCopyImage) 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.(*CopyImageInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpCopyImageInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpCreateDirectoryConfig struct {
94}
95
96func (*validateOpCreateDirectoryConfig) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpCreateDirectoryConfig) 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.(*CreateDirectoryConfigInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpCreateDirectoryConfigInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpCreateFleet struct {
114}
115
116func (*validateOpCreateFleet) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpCreateFleet) 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.(*CreateFleetInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpCreateFleetInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpCreateImageBuilder struct {
134}
135
136func (*validateOpCreateImageBuilder) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpCreateImageBuilder) 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.(*CreateImageBuilderInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpCreateImageBuilderInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpCreateImageBuilderStreamingURL struct {
154}
155
156func (*validateOpCreateImageBuilderStreamingURL) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpCreateImageBuilderStreamingURL) 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.(*CreateImageBuilderStreamingURLInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpCreateImageBuilderStreamingURLInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpCreateStack struct {
174}
175
176func (*validateOpCreateStack) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpCreateStack) 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.(*CreateStackInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpCreateStackInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpCreateStreamingURL struct {
194}
195
196func (*validateOpCreateStreamingURL) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpCreateStreamingURL) 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.(*CreateStreamingURLInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpCreateStreamingURLInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpCreateUpdatedImage struct {
214}
215
216func (*validateOpCreateUpdatedImage) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpCreateUpdatedImage) 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.(*CreateUpdatedImageInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpCreateUpdatedImageInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpCreateUser struct {
234}
235
236func (*validateOpCreateUser) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpCreateUser) 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.(*CreateUserInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpCreateUserInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpDeleteDirectoryConfig struct {
254}
255
256func (*validateOpDeleteDirectoryConfig) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpDeleteDirectoryConfig) 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.(*DeleteDirectoryConfigInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpDeleteDirectoryConfigInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpDeleteFleet struct {
274}
275
276func (*validateOpDeleteFleet) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpDeleteFleet) 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.(*DeleteFleetInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpDeleteFleetInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpDeleteImageBuilder struct {
294}
295
296func (*validateOpDeleteImageBuilder) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpDeleteImageBuilder) 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.(*DeleteImageBuilderInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpDeleteImageBuilderInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpDeleteImage struct {
314}
315
316func (*validateOpDeleteImage) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpDeleteImage) 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.(*DeleteImageInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpDeleteImageInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpDeleteImagePermissions struct {
334}
335
336func (*validateOpDeleteImagePermissions) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpDeleteImagePermissions) 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.(*DeleteImagePermissionsInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpDeleteImagePermissionsInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpDeleteStack struct {
354}
355
356func (*validateOpDeleteStack) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpDeleteStack) 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.(*DeleteStackInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpDeleteStackInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpDeleteUser struct {
374}
375
376func (*validateOpDeleteUser) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpDeleteUser) 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.(*DeleteUserInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpDeleteUserInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpDescribeImagePermissions struct {
394}
395
396func (*validateOpDescribeImagePermissions) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpDescribeImagePermissions) 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.(*DescribeImagePermissionsInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpDescribeImagePermissionsInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpDescribeSessions struct {
414}
415
416func (*validateOpDescribeSessions) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpDescribeSessions) 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.(*DescribeSessionsInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpDescribeSessionsInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpDescribeUsers struct {
434}
435
436func (*validateOpDescribeUsers) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpDescribeUsers) 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.(*DescribeUsersInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpDescribeUsersInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpDisableUser struct {
454}
455
456func (*validateOpDisableUser) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpDisableUser) 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.(*DisableUserInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpDisableUserInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpDisassociateFleet struct {
474}
475
476func (*validateOpDisassociateFleet) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpDisassociateFleet) 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.(*DisassociateFleetInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpDisassociateFleetInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpEnableUser struct {
494}
495
496func (*validateOpEnableUser) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpEnableUser) 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.(*EnableUserInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpEnableUserInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpExpireSession struct {
514}
515
516func (*validateOpExpireSession) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpExpireSession) 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.(*ExpireSessionInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpExpireSessionInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpListAssociatedFleets struct {
534}
535
536func (*validateOpListAssociatedFleets) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpListAssociatedFleets) 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.(*ListAssociatedFleetsInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpListAssociatedFleetsInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpListAssociatedStacks struct {
554}
555
556func (*validateOpListAssociatedStacks) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpListAssociatedStacks) 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.(*ListAssociatedStacksInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpListAssociatedStacksInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpListTagsForResource struct {
574}
575
576func (*validateOpListTagsForResource) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpListTagsForResourceInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpStartFleet struct {
594}
595
596func (*validateOpStartFleet) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpStartFleet) 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.(*StartFleetInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpStartFleetInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpStartImageBuilder struct {
614}
615
616func (*validateOpStartImageBuilder) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpStartImageBuilder) 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.(*StartImageBuilderInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpStartImageBuilderInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpStopFleet struct {
634}
635
636func (*validateOpStopFleet) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpStopFleet) 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.(*StopFleetInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpStopFleetInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653type validateOpStopImageBuilder struct {
654}
655
656func (*validateOpStopImageBuilder) ID() string {
657	return "OperationInputValidation"
658}
659
660func (m *validateOpStopImageBuilder) 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.(*StopImageBuilderInput)
664	if !ok {
665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666	}
667	if err := validateOpStopImageBuilderInput(input); err != nil {
668		return out, metadata, err
669	}
670	return next.HandleInitialize(ctx, in)
671}
672
673type validateOpTagResource struct {
674}
675
676func (*validateOpTagResource) ID() string {
677	return "OperationInputValidation"
678}
679
680func (m *validateOpTagResource) 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.(*TagResourceInput)
684	if !ok {
685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
686	}
687	if err := validateOpTagResourceInput(input); err != nil {
688		return out, metadata, err
689	}
690	return next.HandleInitialize(ctx, in)
691}
692
693type validateOpUntagResource struct {
694}
695
696func (*validateOpUntagResource) ID() string {
697	return "OperationInputValidation"
698}
699
700func (m *validateOpUntagResource) 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.(*UntagResourceInput)
704	if !ok {
705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
706	}
707	if err := validateOpUntagResourceInput(input); err != nil {
708		return out, metadata, err
709	}
710	return next.HandleInitialize(ctx, in)
711}
712
713type validateOpUpdateDirectoryConfig struct {
714}
715
716func (*validateOpUpdateDirectoryConfig) ID() string {
717	return "OperationInputValidation"
718}
719
720func (m *validateOpUpdateDirectoryConfig) 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.(*UpdateDirectoryConfigInput)
724	if !ok {
725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
726	}
727	if err := validateOpUpdateDirectoryConfigInput(input); err != nil {
728		return out, metadata, err
729	}
730	return next.HandleInitialize(ctx, in)
731}
732
733type validateOpUpdateFleet struct {
734}
735
736func (*validateOpUpdateFleet) ID() string {
737	return "OperationInputValidation"
738}
739
740func (m *validateOpUpdateFleet) 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.(*UpdateFleetInput)
744	if !ok {
745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
746	}
747	if err := validateOpUpdateFleetInput(input); err != nil {
748		return out, metadata, err
749	}
750	return next.HandleInitialize(ctx, in)
751}
752
753type validateOpUpdateImagePermissions struct {
754}
755
756func (*validateOpUpdateImagePermissions) ID() string {
757	return "OperationInputValidation"
758}
759
760func (m *validateOpUpdateImagePermissions) 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.(*UpdateImagePermissionsInput)
764	if !ok {
765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
766	}
767	if err := validateOpUpdateImagePermissionsInput(input); err != nil {
768		return out, metadata, err
769	}
770	return next.HandleInitialize(ctx, in)
771}
772
773type validateOpUpdateStack struct {
774}
775
776func (*validateOpUpdateStack) ID() string {
777	return "OperationInputValidation"
778}
779
780func (m *validateOpUpdateStack) 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.(*UpdateStackInput)
784	if !ok {
785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
786	}
787	if err := validateOpUpdateStackInput(input); err != nil {
788		return out, metadata, err
789	}
790	return next.HandleInitialize(ctx, in)
791}
792
793func addOpAssociateFleetValidationMiddleware(stack *middleware.Stack) error {
794	return stack.Initialize.Add(&validateOpAssociateFleet{}, middleware.After)
795}
796
797func addOpBatchAssociateUserStackValidationMiddleware(stack *middleware.Stack) error {
798	return stack.Initialize.Add(&validateOpBatchAssociateUserStack{}, middleware.After)
799}
800
801func addOpBatchDisassociateUserStackValidationMiddleware(stack *middleware.Stack) error {
802	return stack.Initialize.Add(&validateOpBatchDisassociateUserStack{}, middleware.After)
803}
804
805func addOpCopyImageValidationMiddleware(stack *middleware.Stack) error {
806	return stack.Initialize.Add(&validateOpCopyImage{}, middleware.After)
807}
808
809func addOpCreateDirectoryConfigValidationMiddleware(stack *middleware.Stack) error {
810	return stack.Initialize.Add(&validateOpCreateDirectoryConfig{}, middleware.After)
811}
812
813func addOpCreateFleetValidationMiddleware(stack *middleware.Stack) error {
814	return stack.Initialize.Add(&validateOpCreateFleet{}, middleware.After)
815}
816
817func addOpCreateImageBuilderValidationMiddleware(stack *middleware.Stack) error {
818	return stack.Initialize.Add(&validateOpCreateImageBuilder{}, middleware.After)
819}
820
821func addOpCreateImageBuilderStreamingURLValidationMiddleware(stack *middleware.Stack) error {
822	return stack.Initialize.Add(&validateOpCreateImageBuilderStreamingURL{}, middleware.After)
823}
824
825func addOpCreateStackValidationMiddleware(stack *middleware.Stack) error {
826	return stack.Initialize.Add(&validateOpCreateStack{}, middleware.After)
827}
828
829func addOpCreateStreamingURLValidationMiddleware(stack *middleware.Stack) error {
830	return stack.Initialize.Add(&validateOpCreateStreamingURL{}, middleware.After)
831}
832
833func addOpCreateUpdatedImageValidationMiddleware(stack *middleware.Stack) error {
834	return stack.Initialize.Add(&validateOpCreateUpdatedImage{}, middleware.After)
835}
836
837func addOpCreateUserValidationMiddleware(stack *middleware.Stack) error {
838	return stack.Initialize.Add(&validateOpCreateUser{}, middleware.After)
839}
840
841func addOpDeleteDirectoryConfigValidationMiddleware(stack *middleware.Stack) error {
842	return stack.Initialize.Add(&validateOpDeleteDirectoryConfig{}, middleware.After)
843}
844
845func addOpDeleteFleetValidationMiddleware(stack *middleware.Stack) error {
846	return stack.Initialize.Add(&validateOpDeleteFleet{}, middleware.After)
847}
848
849func addOpDeleteImageBuilderValidationMiddleware(stack *middleware.Stack) error {
850	return stack.Initialize.Add(&validateOpDeleteImageBuilder{}, middleware.After)
851}
852
853func addOpDeleteImageValidationMiddleware(stack *middleware.Stack) error {
854	return stack.Initialize.Add(&validateOpDeleteImage{}, middleware.After)
855}
856
857func addOpDeleteImagePermissionsValidationMiddleware(stack *middleware.Stack) error {
858	return stack.Initialize.Add(&validateOpDeleteImagePermissions{}, middleware.After)
859}
860
861func addOpDeleteStackValidationMiddleware(stack *middleware.Stack) error {
862	return stack.Initialize.Add(&validateOpDeleteStack{}, middleware.After)
863}
864
865func addOpDeleteUserValidationMiddleware(stack *middleware.Stack) error {
866	return stack.Initialize.Add(&validateOpDeleteUser{}, middleware.After)
867}
868
869func addOpDescribeImagePermissionsValidationMiddleware(stack *middleware.Stack) error {
870	return stack.Initialize.Add(&validateOpDescribeImagePermissions{}, middleware.After)
871}
872
873func addOpDescribeSessionsValidationMiddleware(stack *middleware.Stack) error {
874	return stack.Initialize.Add(&validateOpDescribeSessions{}, middleware.After)
875}
876
877func addOpDescribeUsersValidationMiddleware(stack *middleware.Stack) error {
878	return stack.Initialize.Add(&validateOpDescribeUsers{}, middleware.After)
879}
880
881func addOpDisableUserValidationMiddleware(stack *middleware.Stack) error {
882	return stack.Initialize.Add(&validateOpDisableUser{}, middleware.After)
883}
884
885func addOpDisassociateFleetValidationMiddleware(stack *middleware.Stack) error {
886	return stack.Initialize.Add(&validateOpDisassociateFleet{}, middleware.After)
887}
888
889func addOpEnableUserValidationMiddleware(stack *middleware.Stack) error {
890	return stack.Initialize.Add(&validateOpEnableUser{}, middleware.After)
891}
892
893func addOpExpireSessionValidationMiddleware(stack *middleware.Stack) error {
894	return stack.Initialize.Add(&validateOpExpireSession{}, middleware.After)
895}
896
897func addOpListAssociatedFleetsValidationMiddleware(stack *middleware.Stack) error {
898	return stack.Initialize.Add(&validateOpListAssociatedFleets{}, middleware.After)
899}
900
901func addOpListAssociatedStacksValidationMiddleware(stack *middleware.Stack) error {
902	return stack.Initialize.Add(&validateOpListAssociatedStacks{}, middleware.After)
903}
904
905func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
906	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
907}
908
909func addOpStartFleetValidationMiddleware(stack *middleware.Stack) error {
910	return stack.Initialize.Add(&validateOpStartFleet{}, middleware.After)
911}
912
913func addOpStartImageBuilderValidationMiddleware(stack *middleware.Stack) error {
914	return stack.Initialize.Add(&validateOpStartImageBuilder{}, middleware.After)
915}
916
917func addOpStopFleetValidationMiddleware(stack *middleware.Stack) error {
918	return stack.Initialize.Add(&validateOpStopFleet{}, middleware.After)
919}
920
921func addOpStopImageBuilderValidationMiddleware(stack *middleware.Stack) error {
922	return stack.Initialize.Add(&validateOpStopImageBuilder{}, middleware.After)
923}
924
925func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
926	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
927}
928
929func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
930	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
931}
932
933func addOpUpdateDirectoryConfigValidationMiddleware(stack *middleware.Stack) error {
934	return stack.Initialize.Add(&validateOpUpdateDirectoryConfig{}, middleware.After)
935}
936
937func addOpUpdateFleetValidationMiddleware(stack *middleware.Stack) error {
938	return stack.Initialize.Add(&validateOpUpdateFleet{}, middleware.After)
939}
940
941func addOpUpdateImagePermissionsValidationMiddleware(stack *middleware.Stack) error {
942	return stack.Initialize.Add(&validateOpUpdateImagePermissions{}, middleware.After)
943}
944
945func addOpUpdateStackValidationMiddleware(stack *middleware.Stack) error {
946	return stack.Initialize.Add(&validateOpUpdateStack{}, middleware.After)
947}
948
949func validateAccessEndpoint(v *types.AccessEndpoint) error {
950	if v == nil {
951		return nil
952	}
953	invalidParams := smithy.InvalidParamsError{Context: "AccessEndpoint"}
954	if len(v.EndpointType) == 0 {
955		invalidParams.Add(smithy.NewErrParamRequired("EndpointType"))
956	}
957	if invalidParams.Len() > 0 {
958		return invalidParams
959	} else {
960		return nil
961	}
962}
963
964func validateAccessEndpointList(v []types.AccessEndpoint) error {
965	if v == nil {
966		return nil
967	}
968	invalidParams := smithy.InvalidParamsError{Context: "AccessEndpointList"}
969	for i := range v {
970		if err := validateAccessEndpoint(&v[i]); err != nil {
971			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
972		}
973	}
974	if invalidParams.Len() > 0 {
975		return invalidParams
976	} else {
977		return nil
978	}
979}
980
981func validateApplicationSettings(v *types.ApplicationSettings) error {
982	if v == nil {
983		return nil
984	}
985	invalidParams := smithy.InvalidParamsError{Context: "ApplicationSettings"}
986	if invalidParams.Len() > 0 {
987		return invalidParams
988	} else {
989		return nil
990	}
991}
992
993func validateComputeCapacity(v *types.ComputeCapacity) error {
994	if v == nil {
995		return nil
996	}
997	invalidParams := smithy.InvalidParamsError{Context: "ComputeCapacity"}
998	if v.DesiredInstances == nil {
999		invalidParams.Add(smithy.NewErrParamRequired("DesiredInstances"))
1000	}
1001	if invalidParams.Len() > 0 {
1002		return invalidParams
1003	} else {
1004		return nil
1005	}
1006}
1007
1008func validateServiceAccountCredentials(v *types.ServiceAccountCredentials) error {
1009	if v == nil {
1010		return nil
1011	}
1012	invalidParams := smithy.InvalidParamsError{Context: "ServiceAccountCredentials"}
1013	if v.AccountName == nil {
1014		invalidParams.Add(smithy.NewErrParamRequired("AccountName"))
1015	}
1016	if v.AccountPassword == nil {
1017		invalidParams.Add(smithy.NewErrParamRequired("AccountPassword"))
1018	}
1019	if invalidParams.Len() > 0 {
1020		return invalidParams
1021	} else {
1022		return nil
1023	}
1024}
1025
1026func validateStorageConnector(v *types.StorageConnector) error {
1027	if v == nil {
1028		return nil
1029	}
1030	invalidParams := smithy.InvalidParamsError{Context: "StorageConnector"}
1031	if len(v.ConnectorType) == 0 {
1032		invalidParams.Add(smithy.NewErrParamRequired("ConnectorType"))
1033	}
1034	if invalidParams.Len() > 0 {
1035		return invalidParams
1036	} else {
1037		return nil
1038	}
1039}
1040
1041func validateStorageConnectorList(v []types.StorageConnector) error {
1042	if v == nil {
1043		return nil
1044	}
1045	invalidParams := smithy.InvalidParamsError{Context: "StorageConnectorList"}
1046	for i := range v {
1047		if err := validateStorageConnector(&v[i]); err != nil {
1048			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1049		}
1050	}
1051	if invalidParams.Len() > 0 {
1052		return invalidParams
1053	} else {
1054		return nil
1055	}
1056}
1057
1058func validateUserSetting(v *types.UserSetting) error {
1059	if v == nil {
1060		return nil
1061	}
1062	invalidParams := smithy.InvalidParamsError{Context: "UserSetting"}
1063	if len(v.Action) == 0 {
1064		invalidParams.Add(smithy.NewErrParamRequired("Action"))
1065	}
1066	if len(v.Permission) == 0 {
1067		invalidParams.Add(smithy.NewErrParamRequired("Permission"))
1068	}
1069	if invalidParams.Len() > 0 {
1070		return invalidParams
1071	} else {
1072		return nil
1073	}
1074}
1075
1076func validateUserSettingList(v []types.UserSetting) error {
1077	if v == nil {
1078		return nil
1079	}
1080	invalidParams := smithy.InvalidParamsError{Context: "UserSettingList"}
1081	for i := range v {
1082		if err := validateUserSetting(&v[i]); err != nil {
1083			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1084		}
1085	}
1086	if invalidParams.Len() > 0 {
1087		return invalidParams
1088	} else {
1089		return nil
1090	}
1091}
1092
1093func validateUserStackAssociation(v *types.UserStackAssociation) error {
1094	if v == nil {
1095		return nil
1096	}
1097	invalidParams := smithy.InvalidParamsError{Context: "UserStackAssociation"}
1098	if v.StackName == nil {
1099		invalidParams.Add(smithy.NewErrParamRequired("StackName"))
1100	}
1101	if v.UserName == nil {
1102		invalidParams.Add(smithy.NewErrParamRequired("UserName"))
1103	}
1104	if len(v.AuthenticationType) == 0 {
1105		invalidParams.Add(smithy.NewErrParamRequired("AuthenticationType"))
1106	}
1107	if invalidParams.Len() > 0 {
1108		return invalidParams
1109	} else {
1110		return nil
1111	}
1112}
1113
1114func validateUserStackAssociationList(v []types.UserStackAssociation) error {
1115	if v == nil {
1116		return nil
1117	}
1118	invalidParams := smithy.InvalidParamsError{Context: "UserStackAssociationList"}
1119	for i := range v {
1120		if err := validateUserStackAssociation(&v[i]); err != nil {
1121			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1122		}
1123	}
1124	if invalidParams.Len() > 0 {
1125		return invalidParams
1126	} else {
1127		return nil
1128	}
1129}
1130
1131func validateOpAssociateFleetInput(v *AssociateFleetInput) error {
1132	if v == nil {
1133		return nil
1134	}
1135	invalidParams := smithy.InvalidParamsError{Context: "AssociateFleetInput"}
1136	if v.FleetName == nil {
1137		invalidParams.Add(smithy.NewErrParamRequired("FleetName"))
1138	}
1139	if v.StackName == nil {
1140		invalidParams.Add(smithy.NewErrParamRequired("StackName"))
1141	}
1142	if invalidParams.Len() > 0 {
1143		return invalidParams
1144	} else {
1145		return nil
1146	}
1147}
1148
1149func validateOpBatchAssociateUserStackInput(v *BatchAssociateUserStackInput) error {
1150	if v == nil {
1151		return nil
1152	}
1153	invalidParams := smithy.InvalidParamsError{Context: "BatchAssociateUserStackInput"}
1154	if v.UserStackAssociations == nil {
1155		invalidParams.Add(smithy.NewErrParamRequired("UserStackAssociations"))
1156	} else if v.UserStackAssociations != nil {
1157		if err := validateUserStackAssociationList(v.UserStackAssociations); err != nil {
1158			invalidParams.AddNested("UserStackAssociations", err.(smithy.InvalidParamsError))
1159		}
1160	}
1161	if invalidParams.Len() > 0 {
1162		return invalidParams
1163	} else {
1164		return nil
1165	}
1166}
1167
1168func validateOpBatchDisassociateUserStackInput(v *BatchDisassociateUserStackInput) error {
1169	if v == nil {
1170		return nil
1171	}
1172	invalidParams := smithy.InvalidParamsError{Context: "BatchDisassociateUserStackInput"}
1173	if v.UserStackAssociations == nil {
1174		invalidParams.Add(smithy.NewErrParamRequired("UserStackAssociations"))
1175	} else if v.UserStackAssociations != nil {
1176		if err := validateUserStackAssociationList(v.UserStackAssociations); err != nil {
1177			invalidParams.AddNested("UserStackAssociations", err.(smithy.InvalidParamsError))
1178		}
1179	}
1180	if invalidParams.Len() > 0 {
1181		return invalidParams
1182	} else {
1183		return nil
1184	}
1185}
1186
1187func validateOpCopyImageInput(v *CopyImageInput) error {
1188	if v == nil {
1189		return nil
1190	}
1191	invalidParams := smithy.InvalidParamsError{Context: "CopyImageInput"}
1192	if v.SourceImageName == nil {
1193		invalidParams.Add(smithy.NewErrParamRequired("SourceImageName"))
1194	}
1195	if v.DestinationImageName == nil {
1196		invalidParams.Add(smithy.NewErrParamRequired("DestinationImageName"))
1197	}
1198	if v.DestinationRegion == nil {
1199		invalidParams.Add(smithy.NewErrParamRequired("DestinationRegion"))
1200	}
1201	if invalidParams.Len() > 0 {
1202		return invalidParams
1203	} else {
1204		return nil
1205	}
1206}
1207
1208func validateOpCreateDirectoryConfigInput(v *CreateDirectoryConfigInput) error {
1209	if v == nil {
1210		return nil
1211	}
1212	invalidParams := smithy.InvalidParamsError{Context: "CreateDirectoryConfigInput"}
1213	if v.DirectoryName == nil {
1214		invalidParams.Add(smithy.NewErrParamRequired("DirectoryName"))
1215	}
1216	if v.OrganizationalUnitDistinguishedNames == nil {
1217		invalidParams.Add(smithy.NewErrParamRequired("OrganizationalUnitDistinguishedNames"))
1218	}
1219	if v.ServiceAccountCredentials != nil {
1220		if err := validateServiceAccountCredentials(v.ServiceAccountCredentials); err != nil {
1221			invalidParams.AddNested("ServiceAccountCredentials", err.(smithy.InvalidParamsError))
1222		}
1223	}
1224	if invalidParams.Len() > 0 {
1225		return invalidParams
1226	} else {
1227		return nil
1228	}
1229}
1230
1231func validateOpCreateFleetInput(v *CreateFleetInput) error {
1232	if v == nil {
1233		return nil
1234	}
1235	invalidParams := smithy.InvalidParamsError{Context: "CreateFleetInput"}
1236	if v.Name == nil {
1237		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1238	}
1239	if v.InstanceType == nil {
1240		invalidParams.Add(smithy.NewErrParamRequired("InstanceType"))
1241	}
1242	if v.ComputeCapacity == nil {
1243		invalidParams.Add(smithy.NewErrParamRequired("ComputeCapacity"))
1244	} else if v.ComputeCapacity != nil {
1245		if err := validateComputeCapacity(v.ComputeCapacity); err != nil {
1246			invalidParams.AddNested("ComputeCapacity", err.(smithy.InvalidParamsError))
1247		}
1248	}
1249	if invalidParams.Len() > 0 {
1250		return invalidParams
1251	} else {
1252		return nil
1253	}
1254}
1255
1256func validateOpCreateImageBuilderInput(v *CreateImageBuilderInput) error {
1257	if v == nil {
1258		return nil
1259	}
1260	invalidParams := smithy.InvalidParamsError{Context: "CreateImageBuilderInput"}
1261	if v.Name == nil {
1262		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1263	}
1264	if v.InstanceType == nil {
1265		invalidParams.Add(smithy.NewErrParamRequired("InstanceType"))
1266	}
1267	if v.AccessEndpoints != nil {
1268		if err := validateAccessEndpointList(v.AccessEndpoints); err != nil {
1269			invalidParams.AddNested("AccessEndpoints", err.(smithy.InvalidParamsError))
1270		}
1271	}
1272	if invalidParams.Len() > 0 {
1273		return invalidParams
1274	} else {
1275		return nil
1276	}
1277}
1278
1279func validateOpCreateImageBuilderStreamingURLInput(v *CreateImageBuilderStreamingURLInput) error {
1280	if v == nil {
1281		return nil
1282	}
1283	invalidParams := smithy.InvalidParamsError{Context: "CreateImageBuilderStreamingURLInput"}
1284	if v.Name == nil {
1285		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1286	}
1287	if invalidParams.Len() > 0 {
1288		return invalidParams
1289	} else {
1290		return nil
1291	}
1292}
1293
1294func validateOpCreateStackInput(v *CreateStackInput) error {
1295	if v == nil {
1296		return nil
1297	}
1298	invalidParams := smithy.InvalidParamsError{Context: "CreateStackInput"}
1299	if v.Name == nil {
1300		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1301	}
1302	if v.StorageConnectors != nil {
1303		if err := validateStorageConnectorList(v.StorageConnectors); err != nil {
1304			invalidParams.AddNested("StorageConnectors", err.(smithy.InvalidParamsError))
1305		}
1306	}
1307	if v.UserSettings != nil {
1308		if err := validateUserSettingList(v.UserSettings); err != nil {
1309			invalidParams.AddNested("UserSettings", err.(smithy.InvalidParamsError))
1310		}
1311	}
1312	if v.ApplicationSettings != nil {
1313		if err := validateApplicationSettings(v.ApplicationSettings); err != nil {
1314			invalidParams.AddNested("ApplicationSettings", err.(smithy.InvalidParamsError))
1315		}
1316	}
1317	if v.AccessEndpoints != nil {
1318		if err := validateAccessEndpointList(v.AccessEndpoints); err != nil {
1319			invalidParams.AddNested("AccessEndpoints", err.(smithy.InvalidParamsError))
1320		}
1321	}
1322	if invalidParams.Len() > 0 {
1323		return invalidParams
1324	} else {
1325		return nil
1326	}
1327}
1328
1329func validateOpCreateStreamingURLInput(v *CreateStreamingURLInput) error {
1330	if v == nil {
1331		return nil
1332	}
1333	invalidParams := smithy.InvalidParamsError{Context: "CreateStreamingURLInput"}
1334	if v.StackName == nil {
1335		invalidParams.Add(smithy.NewErrParamRequired("StackName"))
1336	}
1337	if v.FleetName == nil {
1338		invalidParams.Add(smithy.NewErrParamRequired("FleetName"))
1339	}
1340	if v.UserId == nil {
1341		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
1342	}
1343	if invalidParams.Len() > 0 {
1344		return invalidParams
1345	} else {
1346		return nil
1347	}
1348}
1349
1350func validateOpCreateUpdatedImageInput(v *CreateUpdatedImageInput) error {
1351	if v == nil {
1352		return nil
1353	}
1354	invalidParams := smithy.InvalidParamsError{Context: "CreateUpdatedImageInput"}
1355	if v.ExistingImageName == nil {
1356		invalidParams.Add(smithy.NewErrParamRequired("ExistingImageName"))
1357	}
1358	if v.NewImageName == nil {
1359		invalidParams.Add(smithy.NewErrParamRequired("NewImageName"))
1360	}
1361	if invalidParams.Len() > 0 {
1362		return invalidParams
1363	} else {
1364		return nil
1365	}
1366}
1367
1368func validateOpCreateUserInput(v *CreateUserInput) error {
1369	if v == nil {
1370		return nil
1371	}
1372	invalidParams := smithy.InvalidParamsError{Context: "CreateUserInput"}
1373	if v.UserName == nil {
1374		invalidParams.Add(smithy.NewErrParamRequired("UserName"))
1375	}
1376	if len(v.AuthenticationType) == 0 {
1377		invalidParams.Add(smithy.NewErrParamRequired("AuthenticationType"))
1378	}
1379	if invalidParams.Len() > 0 {
1380		return invalidParams
1381	} else {
1382		return nil
1383	}
1384}
1385
1386func validateOpDeleteDirectoryConfigInput(v *DeleteDirectoryConfigInput) error {
1387	if v == nil {
1388		return nil
1389	}
1390	invalidParams := smithy.InvalidParamsError{Context: "DeleteDirectoryConfigInput"}
1391	if v.DirectoryName == nil {
1392		invalidParams.Add(smithy.NewErrParamRequired("DirectoryName"))
1393	}
1394	if invalidParams.Len() > 0 {
1395		return invalidParams
1396	} else {
1397		return nil
1398	}
1399}
1400
1401func validateOpDeleteFleetInput(v *DeleteFleetInput) error {
1402	if v == nil {
1403		return nil
1404	}
1405	invalidParams := smithy.InvalidParamsError{Context: "DeleteFleetInput"}
1406	if v.Name == nil {
1407		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1408	}
1409	if invalidParams.Len() > 0 {
1410		return invalidParams
1411	} else {
1412		return nil
1413	}
1414}
1415
1416func validateOpDeleteImageBuilderInput(v *DeleteImageBuilderInput) error {
1417	if v == nil {
1418		return nil
1419	}
1420	invalidParams := smithy.InvalidParamsError{Context: "DeleteImageBuilderInput"}
1421	if v.Name == nil {
1422		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1423	}
1424	if invalidParams.Len() > 0 {
1425		return invalidParams
1426	} else {
1427		return nil
1428	}
1429}
1430
1431func validateOpDeleteImageInput(v *DeleteImageInput) error {
1432	if v == nil {
1433		return nil
1434	}
1435	invalidParams := smithy.InvalidParamsError{Context: "DeleteImageInput"}
1436	if v.Name == nil {
1437		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1438	}
1439	if invalidParams.Len() > 0 {
1440		return invalidParams
1441	} else {
1442		return nil
1443	}
1444}
1445
1446func validateOpDeleteImagePermissionsInput(v *DeleteImagePermissionsInput) error {
1447	if v == nil {
1448		return nil
1449	}
1450	invalidParams := smithy.InvalidParamsError{Context: "DeleteImagePermissionsInput"}
1451	if v.Name == nil {
1452		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1453	}
1454	if v.SharedAccountId == nil {
1455		invalidParams.Add(smithy.NewErrParamRequired("SharedAccountId"))
1456	}
1457	if invalidParams.Len() > 0 {
1458		return invalidParams
1459	} else {
1460		return nil
1461	}
1462}
1463
1464func validateOpDeleteStackInput(v *DeleteStackInput) error {
1465	if v == nil {
1466		return nil
1467	}
1468	invalidParams := smithy.InvalidParamsError{Context: "DeleteStackInput"}
1469	if v.Name == nil {
1470		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1471	}
1472	if invalidParams.Len() > 0 {
1473		return invalidParams
1474	} else {
1475		return nil
1476	}
1477}
1478
1479func validateOpDeleteUserInput(v *DeleteUserInput) error {
1480	if v == nil {
1481		return nil
1482	}
1483	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserInput"}
1484	if v.UserName == nil {
1485		invalidParams.Add(smithy.NewErrParamRequired("UserName"))
1486	}
1487	if len(v.AuthenticationType) == 0 {
1488		invalidParams.Add(smithy.NewErrParamRequired("AuthenticationType"))
1489	}
1490	if invalidParams.Len() > 0 {
1491		return invalidParams
1492	} else {
1493		return nil
1494	}
1495}
1496
1497func validateOpDescribeImagePermissionsInput(v *DescribeImagePermissionsInput) error {
1498	if v == nil {
1499		return nil
1500	}
1501	invalidParams := smithy.InvalidParamsError{Context: "DescribeImagePermissionsInput"}
1502	if v.Name == nil {
1503		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1504	}
1505	if invalidParams.Len() > 0 {
1506		return invalidParams
1507	} else {
1508		return nil
1509	}
1510}
1511
1512func validateOpDescribeSessionsInput(v *DescribeSessionsInput) error {
1513	if v == nil {
1514		return nil
1515	}
1516	invalidParams := smithy.InvalidParamsError{Context: "DescribeSessionsInput"}
1517	if v.StackName == nil {
1518		invalidParams.Add(smithy.NewErrParamRequired("StackName"))
1519	}
1520	if v.FleetName == nil {
1521		invalidParams.Add(smithy.NewErrParamRequired("FleetName"))
1522	}
1523	if invalidParams.Len() > 0 {
1524		return invalidParams
1525	} else {
1526		return nil
1527	}
1528}
1529
1530func validateOpDescribeUsersInput(v *DescribeUsersInput) error {
1531	if v == nil {
1532		return nil
1533	}
1534	invalidParams := smithy.InvalidParamsError{Context: "DescribeUsersInput"}
1535	if len(v.AuthenticationType) == 0 {
1536		invalidParams.Add(smithy.NewErrParamRequired("AuthenticationType"))
1537	}
1538	if invalidParams.Len() > 0 {
1539		return invalidParams
1540	} else {
1541		return nil
1542	}
1543}
1544
1545func validateOpDisableUserInput(v *DisableUserInput) error {
1546	if v == nil {
1547		return nil
1548	}
1549	invalidParams := smithy.InvalidParamsError{Context: "DisableUserInput"}
1550	if v.UserName == nil {
1551		invalidParams.Add(smithy.NewErrParamRequired("UserName"))
1552	}
1553	if len(v.AuthenticationType) == 0 {
1554		invalidParams.Add(smithy.NewErrParamRequired("AuthenticationType"))
1555	}
1556	if invalidParams.Len() > 0 {
1557		return invalidParams
1558	} else {
1559		return nil
1560	}
1561}
1562
1563func validateOpDisassociateFleetInput(v *DisassociateFleetInput) error {
1564	if v == nil {
1565		return nil
1566	}
1567	invalidParams := smithy.InvalidParamsError{Context: "DisassociateFleetInput"}
1568	if v.FleetName == nil {
1569		invalidParams.Add(smithy.NewErrParamRequired("FleetName"))
1570	}
1571	if v.StackName == nil {
1572		invalidParams.Add(smithy.NewErrParamRequired("StackName"))
1573	}
1574	if invalidParams.Len() > 0 {
1575		return invalidParams
1576	} else {
1577		return nil
1578	}
1579}
1580
1581func validateOpEnableUserInput(v *EnableUserInput) error {
1582	if v == nil {
1583		return nil
1584	}
1585	invalidParams := smithy.InvalidParamsError{Context: "EnableUserInput"}
1586	if v.UserName == nil {
1587		invalidParams.Add(smithy.NewErrParamRequired("UserName"))
1588	}
1589	if len(v.AuthenticationType) == 0 {
1590		invalidParams.Add(smithy.NewErrParamRequired("AuthenticationType"))
1591	}
1592	if invalidParams.Len() > 0 {
1593		return invalidParams
1594	} else {
1595		return nil
1596	}
1597}
1598
1599func validateOpExpireSessionInput(v *ExpireSessionInput) error {
1600	if v == nil {
1601		return nil
1602	}
1603	invalidParams := smithy.InvalidParamsError{Context: "ExpireSessionInput"}
1604	if v.SessionId == nil {
1605		invalidParams.Add(smithy.NewErrParamRequired("SessionId"))
1606	}
1607	if invalidParams.Len() > 0 {
1608		return invalidParams
1609	} else {
1610		return nil
1611	}
1612}
1613
1614func validateOpListAssociatedFleetsInput(v *ListAssociatedFleetsInput) error {
1615	if v == nil {
1616		return nil
1617	}
1618	invalidParams := smithy.InvalidParamsError{Context: "ListAssociatedFleetsInput"}
1619	if v.StackName == nil {
1620		invalidParams.Add(smithy.NewErrParamRequired("StackName"))
1621	}
1622	if invalidParams.Len() > 0 {
1623		return invalidParams
1624	} else {
1625		return nil
1626	}
1627}
1628
1629func validateOpListAssociatedStacksInput(v *ListAssociatedStacksInput) error {
1630	if v == nil {
1631		return nil
1632	}
1633	invalidParams := smithy.InvalidParamsError{Context: "ListAssociatedStacksInput"}
1634	if v.FleetName == nil {
1635		invalidParams.Add(smithy.NewErrParamRequired("FleetName"))
1636	}
1637	if invalidParams.Len() > 0 {
1638		return invalidParams
1639	} else {
1640		return nil
1641	}
1642}
1643
1644func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
1645	if v == nil {
1646		return nil
1647	}
1648	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
1649	if v.ResourceArn == nil {
1650		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1651	}
1652	if invalidParams.Len() > 0 {
1653		return invalidParams
1654	} else {
1655		return nil
1656	}
1657}
1658
1659func validateOpStartFleetInput(v *StartFleetInput) error {
1660	if v == nil {
1661		return nil
1662	}
1663	invalidParams := smithy.InvalidParamsError{Context: "StartFleetInput"}
1664	if v.Name == nil {
1665		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1666	}
1667	if invalidParams.Len() > 0 {
1668		return invalidParams
1669	} else {
1670		return nil
1671	}
1672}
1673
1674func validateOpStartImageBuilderInput(v *StartImageBuilderInput) error {
1675	if v == nil {
1676		return nil
1677	}
1678	invalidParams := smithy.InvalidParamsError{Context: "StartImageBuilderInput"}
1679	if v.Name == nil {
1680		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1681	}
1682	if invalidParams.Len() > 0 {
1683		return invalidParams
1684	} else {
1685		return nil
1686	}
1687}
1688
1689func validateOpStopFleetInput(v *StopFleetInput) error {
1690	if v == nil {
1691		return nil
1692	}
1693	invalidParams := smithy.InvalidParamsError{Context: "StopFleetInput"}
1694	if v.Name == nil {
1695		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1696	}
1697	if invalidParams.Len() > 0 {
1698		return invalidParams
1699	} else {
1700		return nil
1701	}
1702}
1703
1704func validateOpStopImageBuilderInput(v *StopImageBuilderInput) error {
1705	if v == nil {
1706		return nil
1707	}
1708	invalidParams := smithy.InvalidParamsError{Context: "StopImageBuilderInput"}
1709	if v.Name == nil {
1710		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1711	}
1712	if invalidParams.Len() > 0 {
1713		return invalidParams
1714	} else {
1715		return nil
1716	}
1717}
1718
1719func validateOpTagResourceInput(v *TagResourceInput) error {
1720	if v == nil {
1721		return nil
1722	}
1723	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
1724	if v.ResourceArn == nil {
1725		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1726	}
1727	if v.Tags == nil {
1728		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
1729	}
1730	if invalidParams.Len() > 0 {
1731		return invalidParams
1732	} else {
1733		return nil
1734	}
1735}
1736
1737func validateOpUntagResourceInput(v *UntagResourceInput) error {
1738	if v == nil {
1739		return nil
1740	}
1741	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
1742	if v.ResourceArn == nil {
1743		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1744	}
1745	if v.TagKeys == nil {
1746		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
1747	}
1748	if invalidParams.Len() > 0 {
1749		return invalidParams
1750	} else {
1751		return nil
1752	}
1753}
1754
1755func validateOpUpdateDirectoryConfigInput(v *UpdateDirectoryConfigInput) error {
1756	if v == nil {
1757		return nil
1758	}
1759	invalidParams := smithy.InvalidParamsError{Context: "UpdateDirectoryConfigInput"}
1760	if v.DirectoryName == nil {
1761		invalidParams.Add(smithy.NewErrParamRequired("DirectoryName"))
1762	}
1763	if v.ServiceAccountCredentials != nil {
1764		if err := validateServiceAccountCredentials(v.ServiceAccountCredentials); err != nil {
1765			invalidParams.AddNested("ServiceAccountCredentials", err.(smithy.InvalidParamsError))
1766		}
1767	}
1768	if invalidParams.Len() > 0 {
1769		return invalidParams
1770	} else {
1771		return nil
1772	}
1773}
1774
1775func validateOpUpdateFleetInput(v *UpdateFleetInput) error {
1776	if v == nil {
1777		return nil
1778	}
1779	invalidParams := smithy.InvalidParamsError{Context: "UpdateFleetInput"}
1780	if v.ComputeCapacity != nil {
1781		if err := validateComputeCapacity(v.ComputeCapacity); err != nil {
1782			invalidParams.AddNested("ComputeCapacity", err.(smithy.InvalidParamsError))
1783		}
1784	}
1785	if invalidParams.Len() > 0 {
1786		return invalidParams
1787	} else {
1788		return nil
1789	}
1790}
1791
1792func validateOpUpdateImagePermissionsInput(v *UpdateImagePermissionsInput) error {
1793	if v == nil {
1794		return nil
1795	}
1796	invalidParams := smithy.InvalidParamsError{Context: "UpdateImagePermissionsInput"}
1797	if v.Name == nil {
1798		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1799	}
1800	if v.SharedAccountId == nil {
1801		invalidParams.Add(smithy.NewErrParamRequired("SharedAccountId"))
1802	}
1803	if v.ImagePermissions == nil {
1804		invalidParams.Add(smithy.NewErrParamRequired("ImagePermissions"))
1805	}
1806	if invalidParams.Len() > 0 {
1807		return invalidParams
1808	} else {
1809		return nil
1810	}
1811}
1812
1813func validateOpUpdateStackInput(v *UpdateStackInput) error {
1814	if v == nil {
1815		return nil
1816	}
1817	invalidParams := smithy.InvalidParamsError{Context: "UpdateStackInput"}
1818	if v.Name == nil {
1819		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1820	}
1821	if v.StorageConnectors != nil {
1822		if err := validateStorageConnectorList(v.StorageConnectors); err != nil {
1823			invalidParams.AddNested("StorageConnectors", err.(smithy.InvalidParamsError))
1824		}
1825	}
1826	if v.UserSettings != nil {
1827		if err := validateUserSettingList(v.UserSettings); err != nil {
1828			invalidParams.AddNested("UserSettings", err.(smithy.InvalidParamsError))
1829		}
1830	}
1831	if v.ApplicationSettings != nil {
1832		if err := validateApplicationSettings(v.ApplicationSettings); err != nil {
1833			invalidParams.AddNested("ApplicationSettings", err.(smithy.InvalidParamsError))
1834		}
1835	}
1836	if v.AccessEndpoints != nil {
1837		if err := validateAccessEndpointList(v.AccessEndpoints); err != nil {
1838			invalidParams.AddNested("AccessEndpoints", err.(smithy.InvalidParamsError))
1839		}
1840	}
1841	if invalidParams.Len() > 0 {
1842		return invalidParams
1843	} else {
1844		return nil
1845	}
1846}
1847