1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package workspaces
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/workspaces/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpAssociateConnectionAlias struct {
14}
15
16func (*validateOpAssociateConnectionAlias) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpAssociateConnectionAlias) 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.(*AssociateConnectionAliasInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpAssociateConnectionAliasInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpAssociateIpGroups struct {
34}
35
36func (*validateOpAssociateIpGroups) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpAssociateIpGroups) 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.(*AssociateIpGroupsInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpAssociateIpGroupsInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpAuthorizeIpRules struct {
54}
55
56func (*validateOpAuthorizeIpRules) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpAuthorizeIpRules) 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.(*AuthorizeIpRulesInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpAuthorizeIpRulesInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpCopyWorkspaceImage struct {
74}
75
76func (*validateOpCopyWorkspaceImage) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpCopyWorkspaceImage) 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.(*CopyWorkspaceImageInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpCopyWorkspaceImageInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpCreateConnectionAlias struct {
94}
95
96func (*validateOpCreateConnectionAlias) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpCreateConnectionAlias) 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.(*CreateConnectionAliasInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpCreateConnectionAliasInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpCreateIpGroup struct {
114}
115
116func (*validateOpCreateIpGroup) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpCreateIpGroup) 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.(*CreateIpGroupInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpCreateIpGroupInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpCreateTags struct {
134}
135
136func (*validateOpCreateTags) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpCreateTags) 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.(*CreateTagsInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpCreateTagsInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpCreateWorkspaceBundle struct {
154}
155
156func (*validateOpCreateWorkspaceBundle) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpCreateWorkspaceBundle) 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.(*CreateWorkspaceBundleInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpCreateWorkspaceBundleInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpCreateWorkspaces struct {
174}
175
176func (*validateOpCreateWorkspaces) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpCreateWorkspaces) 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.(*CreateWorkspacesInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpCreateWorkspacesInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpDeleteConnectionAlias struct {
194}
195
196func (*validateOpDeleteConnectionAlias) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpDeleteConnectionAlias) 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.(*DeleteConnectionAliasInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpDeleteConnectionAliasInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpDeleteIpGroup struct {
214}
215
216func (*validateOpDeleteIpGroup) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpDeleteIpGroup) 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.(*DeleteIpGroupInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpDeleteIpGroupInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpDeleteTags struct {
234}
235
236func (*validateOpDeleteTags) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpDeleteTags) 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.(*DeleteTagsInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpDeleteTagsInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpDeleteWorkspaceImage struct {
254}
255
256func (*validateOpDeleteWorkspaceImage) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpDeleteWorkspaceImage) 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.(*DeleteWorkspaceImageInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpDeleteWorkspaceImageInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpDeregisterWorkspaceDirectory struct {
274}
275
276func (*validateOpDeregisterWorkspaceDirectory) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpDeregisterWorkspaceDirectory) 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.(*DeregisterWorkspaceDirectoryInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpDeregisterWorkspaceDirectoryInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpDescribeClientProperties struct {
294}
295
296func (*validateOpDescribeClientProperties) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpDescribeClientProperties) 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.(*DescribeClientPropertiesInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpDescribeClientPropertiesInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpDescribeConnectionAliasPermissions struct {
314}
315
316func (*validateOpDescribeConnectionAliasPermissions) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpDescribeConnectionAliasPermissions) 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.(*DescribeConnectionAliasPermissionsInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpDescribeConnectionAliasPermissionsInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpDescribeTags struct {
334}
335
336func (*validateOpDescribeTags) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpDescribeTags) 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.(*DescribeTagsInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpDescribeTagsInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpDescribeWorkspaceImagePermissions struct {
354}
355
356func (*validateOpDescribeWorkspaceImagePermissions) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpDescribeWorkspaceImagePermissions) 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.(*DescribeWorkspaceImagePermissionsInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpDescribeWorkspaceImagePermissionsInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpDescribeWorkspaceSnapshots struct {
374}
375
376func (*validateOpDescribeWorkspaceSnapshots) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpDescribeWorkspaceSnapshots) 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.(*DescribeWorkspaceSnapshotsInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpDescribeWorkspaceSnapshotsInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpDisassociateConnectionAlias struct {
394}
395
396func (*validateOpDisassociateConnectionAlias) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpDisassociateConnectionAlias) 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.(*DisassociateConnectionAliasInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpDisassociateConnectionAliasInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpDisassociateIpGroups struct {
414}
415
416func (*validateOpDisassociateIpGroups) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpDisassociateIpGroups) 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.(*DisassociateIpGroupsInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpDisassociateIpGroupsInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpImportWorkspaceImage struct {
434}
435
436func (*validateOpImportWorkspaceImage) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpImportWorkspaceImage) 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.(*ImportWorkspaceImageInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpImportWorkspaceImageInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpListAvailableManagementCidrRanges struct {
454}
455
456func (*validateOpListAvailableManagementCidrRanges) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpListAvailableManagementCidrRanges) 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.(*ListAvailableManagementCidrRangesInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpListAvailableManagementCidrRangesInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpMigrateWorkspace struct {
474}
475
476func (*validateOpMigrateWorkspace) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpMigrateWorkspace) 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.(*MigrateWorkspaceInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpMigrateWorkspaceInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpModifyClientProperties struct {
494}
495
496func (*validateOpModifyClientProperties) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpModifyClientProperties) 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.(*ModifyClientPropertiesInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpModifyClientPropertiesInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpModifySelfservicePermissions struct {
514}
515
516func (*validateOpModifySelfservicePermissions) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpModifySelfservicePermissions) 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.(*ModifySelfservicePermissionsInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpModifySelfservicePermissionsInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpModifyWorkspaceAccessProperties struct {
534}
535
536func (*validateOpModifyWorkspaceAccessProperties) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpModifyWorkspaceAccessProperties) 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.(*ModifyWorkspaceAccessPropertiesInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpModifyWorkspaceAccessPropertiesInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpModifyWorkspaceCreationProperties struct {
554}
555
556func (*validateOpModifyWorkspaceCreationProperties) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpModifyWorkspaceCreationProperties) 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.(*ModifyWorkspaceCreationPropertiesInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpModifyWorkspaceCreationPropertiesInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpModifyWorkspaceProperties struct {
574}
575
576func (*validateOpModifyWorkspaceProperties) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpModifyWorkspaceProperties) 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.(*ModifyWorkspacePropertiesInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpModifyWorkspacePropertiesInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpModifyWorkspaceState struct {
594}
595
596func (*validateOpModifyWorkspaceState) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpModifyWorkspaceState) 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.(*ModifyWorkspaceStateInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpModifyWorkspaceStateInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpRebootWorkspaces struct {
614}
615
616func (*validateOpRebootWorkspaces) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpRebootWorkspaces) 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.(*RebootWorkspacesInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpRebootWorkspacesInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpRebuildWorkspaces struct {
634}
635
636func (*validateOpRebuildWorkspaces) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpRebuildWorkspaces) 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.(*RebuildWorkspacesInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpRebuildWorkspacesInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653type validateOpRegisterWorkspaceDirectory struct {
654}
655
656func (*validateOpRegisterWorkspaceDirectory) ID() string {
657	return "OperationInputValidation"
658}
659
660func (m *validateOpRegisterWorkspaceDirectory) 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.(*RegisterWorkspaceDirectoryInput)
664	if !ok {
665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666	}
667	if err := validateOpRegisterWorkspaceDirectoryInput(input); err != nil {
668		return out, metadata, err
669	}
670	return next.HandleInitialize(ctx, in)
671}
672
673type validateOpRestoreWorkspace struct {
674}
675
676func (*validateOpRestoreWorkspace) ID() string {
677	return "OperationInputValidation"
678}
679
680func (m *validateOpRestoreWorkspace) 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.(*RestoreWorkspaceInput)
684	if !ok {
685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
686	}
687	if err := validateOpRestoreWorkspaceInput(input); err != nil {
688		return out, metadata, err
689	}
690	return next.HandleInitialize(ctx, in)
691}
692
693type validateOpRevokeIpRules struct {
694}
695
696func (*validateOpRevokeIpRules) ID() string {
697	return "OperationInputValidation"
698}
699
700func (m *validateOpRevokeIpRules) 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.(*RevokeIpRulesInput)
704	if !ok {
705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
706	}
707	if err := validateOpRevokeIpRulesInput(input); err != nil {
708		return out, metadata, err
709	}
710	return next.HandleInitialize(ctx, in)
711}
712
713type validateOpStartWorkspaces struct {
714}
715
716func (*validateOpStartWorkspaces) ID() string {
717	return "OperationInputValidation"
718}
719
720func (m *validateOpStartWorkspaces) 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.(*StartWorkspacesInput)
724	if !ok {
725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
726	}
727	if err := validateOpStartWorkspacesInput(input); err != nil {
728		return out, metadata, err
729	}
730	return next.HandleInitialize(ctx, in)
731}
732
733type validateOpStopWorkspaces struct {
734}
735
736func (*validateOpStopWorkspaces) ID() string {
737	return "OperationInputValidation"
738}
739
740func (m *validateOpStopWorkspaces) 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.(*StopWorkspacesInput)
744	if !ok {
745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
746	}
747	if err := validateOpStopWorkspacesInput(input); err != nil {
748		return out, metadata, err
749	}
750	return next.HandleInitialize(ctx, in)
751}
752
753type validateOpTerminateWorkspaces struct {
754}
755
756func (*validateOpTerminateWorkspaces) ID() string {
757	return "OperationInputValidation"
758}
759
760func (m *validateOpTerminateWorkspaces) 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.(*TerminateWorkspacesInput)
764	if !ok {
765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
766	}
767	if err := validateOpTerminateWorkspacesInput(input); err != nil {
768		return out, metadata, err
769	}
770	return next.HandleInitialize(ctx, in)
771}
772
773type validateOpUpdateConnectionAliasPermission struct {
774}
775
776func (*validateOpUpdateConnectionAliasPermission) ID() string {
777	return "OperationInputValidation"
778}
779
780func (m *validateOpUpdateConnectionAliasPermission) 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.(*UpdateConnectionAliasPermissionInput)
784	if !ok {
785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
786	}
787	if err := validateOpUpdateConnectionAliasPermissionInput(input); err != nil {
788		return out, metadata, err
789	}
790	return next.HandleInitialize(ctx, in)
791}
792
793type validateOpUpdateRulesOfIpGroup struct {
794}
795
796func (*validateOpUpdateRulesOfIpGroup) ID() string {
797	return "OperationInputValidation"
798}
799
800func (m *validateOpUpdateRulesOfIpGroup) 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.(*UpdateRulesOfIpGroupInput)
804	if !ok {
805		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
806	}
807	if err := validateOpUpdateRulesOfIpGroupInput(input); err != nil {
808		return out, metadata, err
809	}
810	return next.HandleInitialize(ctx, in)
811}
812
813type validateOpUpdateWorkspaceImagePermission struct {
814}
815
816func (*validateOpUpdateWorkspaceImagePermission) ID() string {
817	return "OperationInputValidation"
818}
819
820func (m *validateOpUpdateWorkspaceImagePermission) 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.(*UpdateWorkspaceImagePermissionInput)
824	if !ok {
825		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
826	}
827	if err := validateOpUpdateWorkspaceImagePermissionInput(input); err != nil {
828		return out, metadata, err
829	}
830	return next.HandleInitialize(ctx, in)
831}
832
833func addOpAssociateConnectionAliasValidationMiddleware(stack *middleware.Stack) error {
834	return stack.Initialize.Add(&validateOpAssociateConnectionAlias{}, middleware.After)
835}
836
837func addOpAssociateIpGroupsValidationMiddleware(stack *middleware.Stack) error {
838	return stack.Initialize.Add(&validateOpAssociateIpGroups{}, middleware.After)
839}
840
841func addOpAuthorizeIpRulesValidationMiddleware(stack *middleware.Stack) error {
842	return stack.Initialize.Add(&validateOpAuthorizeIpRules{}, middleware.After)
843}
844
845func addOpCopyWorkspaceImageValidationMiddleware(stack *middleware.Stack) error {
846	return stack.Initialize.Add(&validateOpCopyWorkspaceImage{}, middleware.After)
847}
848
849func addOpCreateConnectionAliasValidationMiddleware(stack *middleware.Stack) error {
850	return stack.Initialize.Add(&validateOpCreateConnectionAlias{}, middleware.After)
851}
852
853func addOpCreateIpGroupValidationMiddleware(stack *middleware.Stack) error {
854	return stack.Initialize.Add(&validateOpCreateIpGroup{}, middleware.After)
855}
856
857func addOpCreateTagsValidationMiddleware(stack *middleware.Stack) error {
858	return stack.Initialize.Add(&validateOpCreateTags{}, middleware.After)
859}
860
861func addOpCreateWorkspaceBundleValidationMiddleware(stack *middleware.Stack) error {
862	return stack.Initialize.Add(&validateOpCreateWorkspaceBundle{}, middleware.After)
863}
864
865func addOpCreateWorkspacesValidationMiddleware(stack *middleware.Stack) error {
866	return stack.Initialize.Add(&validateOpCreateWorkspaces{}, middleware.After)
867}
868
869func addOpDeleteConnectionAliasValidationMiddleware(stack *middleware.Stack) error {
870	return stack.Initialize.Add(&validateOpDeleteConnectionAlias{}, middleware.After)
871}
872
873func addOpDeleteIpGroupValidationMiddleware(stack *middleware.Stack) error {
874	return stack.Initialize.Add(&validateOpDeleteIpGroup{}, middleware.After)
875}
876
877func addOpDeleteTagsValidationMiddleware(stack *middleware.Stack) error {
878	return stack.Initialize.Add(&validateOpDeleteTags{}, middleware.After)
879}
880
881func addOpDeleteWorkspaceImageValidationMiddleware(stack *middleware.Stack) error {
882	return stack.Initialize.Add(&validateOpDeleteWorkspaceImage{}, middleware.After)
883}
884
885func addOpDeregisterWorkspaceDirectoryValidationMiddleware(stack *middleware.Stack) error {
886	return stack.Initialize.Add(&validateOpDeregisterWorkspaceDirectory{}, middleware.After)
887}
888
889func addOpDescribeClientPropertiesValidationMiddleware(stack *middleware.Stack) error {
890	return stack.Initialize.Add(&validateOpDescribeClientProperties{}, middleware.After)
891}
892
893func addOpDescribeConnectionAliasPermissionsValidationMiddleware(stack *middleware.Stack) error {
894	return stack.Initialize.Add(&validateOpDescribeConnectionAliasPermissions{}, middleware.After)
895}
896
897func addOpDescribeTagsValidationMiddleware(stack *middleware.Stack) error {
898	return stack.Initialize.Add(&validateOpDescribeTags{}, middleware.After)
899}
900
901func addOpDescribeWorkspaceImagePermissionsValidationMiddleware(stack *middleware.Stack) error {
902	return stack.Initialize.Add(&validateOpDescribeWorkspaceImagePermissions{}, middleware.After)
903}
904
905func addOpDescribeWorkspaceSnapshotsValidationMiddleware(stack *middleware.Stack) error {
906	return stack.Initialize.Add(&validateOpDescribeWorkspaceSnapshots{}, middleware.After)
907}
908
909func addOpDisassociateConnectionAliasValidationMiddleware(stack *middleware.Stack) error {
910	return stack.Initialize.Add(&validateOpDisassociateConnectionAlias{}, middleware.After)
911}
912
913func addOpDisassociateIpGroupsValidationMiddleware(stack *middleware.Stack) error {
914	return stack.Initialize.Add(&validateOpDisassociateIpGroups{}, middleware.After)
915}
916
917func addOpImportWorkspaceImageValidationMiddleware(stack *middleware.Stack) error {
918	return stack.Initialize.Add(&validateOpImportWorkspaceImage{}, middleware.After)
919}
920
921func addOpListAvailableManagementCidrRangesValidationMiddleware(stack *middleware.Stack) error {
922	return stack.Initialize.Add(&validateOpListAvailableManagementCidrRanges{}, middleware.After)
923}
924
925func addOpMigrateWorkspaceValidationMiddleware(stack *middleware.Stack) error {
926	return stack.Initialize.Add(&validateOpMigrateWorkspace{}, middleware.After)
927}
928
929func addOpModifyClientPropertiesValidationMiddleware(stack *middleware.Stack) error {
930	return stack.Initialize.Add(&validateOpModifyClientProperties{}, middleware.After)
931}
932
933func addOpModifySelfservicePermissionsValidationMiddleware(stack *middleware.Stack) error {
934	return stack.Initialize.Add(&validateOpModifySelfservicePermissions{}, middleware.After)
935}
936
937func addOpModifyWorkspaceAccessPropertiesValidationMiddleware(stack *middleware.Stack) error {
938	return stack.Initialize.Add(&validateOpModifyWorkspaceAccessProperties{}, middleware.After)
939}
940
941func addOpModifyWorkspaceCreationPropertiesValidationMiddleware(stack *middleware.Stack) error {
942	return stack.Initialize.Add(&validateOpModifyWorkspaceCreationProperties{}, middleware.After)
943}
944
945func addOpModifyWorkspacePropertiesValidationMiddleware(stack *middleware.Stack) error {
946	return stack.Initialize.Add(&validateOpModifyWorkspaceProperties{}, middleware.After)
947}
948
949func addOpModifyWorkspaceStateValidationMiddleware(stack *middleware.Stack) error {
950	return stack.Initialize.Add(&validateOpModifyWorkspaceState{}, middleware.After)
951}
952
953func addOpRebootWorkspacesValidationMiddleware(stack *middleware.Stack) error {
954	return stack.Initialize.Add(&validateOpRebootWorkspaces{}, middleware.After)
955}
956
957func addOpRebuildWorkspacesValidationMiddleware(stack *middleware.Stack) error {
958	return stack.Initialize.Add(&validateOpRebuildWorkspaces{}, middleware.After)
959}
960
961func addOpRegisterWorkspaceDirectoryValidationMiddleware(stack *middleware.Stack) error {
962	return stack.Initialize.Add(&validateOpRegisterWorkspaceDirectory{}, middleware.After)
963}
964
965func addOpRestoreWorkspaceValidationMiddleware(stack *middleware.Stack) error {
966	return stack.Initialize.Add(&validateOpRestoreWorkspace{}, middleware.After)
967}
968
969func addOpRevokeIpRulesValidationMiddleware(stack *middleware.Stack) error {
970	return stack.Initialize.Add(&validateOpRevokeIpRules{}, middleware.After)
971}
972
973func addOpStartWorkspacesValidationMiddleware(stack *middleware.Stack) error {
974	return stack.Initialize.Add(&validateOpStartWorkspaces{}, middleware.After)
975}
976
977func addOpStopWorkspacesValidationMiddleware(stack *middleware.Stack) error {
978	return stack.Initialize.Add(&validateOpStopWorkspaces{}, middleware.After)
979}
980
981func addOpTerminateWorkspacesValidationMiddleware(stack *middleware.Stack) error {
982	return stack.Initialize.Add(&validateOpTerminateWorkspaces{}, middleware.After)
983}
984
985func addOpUpdateConnectionAliasPermissionValidationMiddleware(stack *middleware.Stack) error {
986	return stack.Initialize.Add(&validateOpUpdateConnectionAliasPermission{}, middleware.After)
987}
988
989func addOpUpdateRulesOfIpGroupValidationMiddleware(stack *middleware.Stack) error {
990	return stack.Initialize.Add(&validateOpUpdateRulesOfIpGroup{}, middleware.After)
991}
992
993func addOpUpdateWorkspaceImagePermissionValidationMiddleware(stack *middleware.Stack) error {
994	return stack.Initialize.Add(&validateOpUpdateWorkspaceImagePermission{}, middleware.After)
995}
996
997func validateConnectionAliasPermission(v *types.ConnectionAliasPermission) error {
998	if v == nil {
999		return nil
1000	}
1001	invalidParams := smithy.InvalidParamsError{Context: "ConnectionAliasPermission"}
1002	if v.SharedAccountId == nil {
1003		invalidParams.Add(smithy.NewErrParamRequired("SharedAccountId"))
1004	}
1005	if v.AllowAssociation == nil {
1006		invalidParams.Add(smithy.NewErrParamRequired("AllowAssociation"))
1007	}
1008	if invalidParams.Len() > 0 {
1009		return invalidParams
1010	} else {
1011		return nil
1012	}
1013}
1014
1015func validateRebootRequest(v *types.RebootRequest) error {
1016	if v == nil {
1017		return nil
1018	}
1019	invalidParams := smithy.InvalidParamsError{Context: "RebootRequest"}
1020	if v.WorkspaceId == nil {
1021		invalidParams.Add(smithy.NewErrParamRequired("WorkspaceId"))
1022	}
1023	if invalidParams.Len() > 0 {
1024		return invalidParams
1025	} else {
1026		return nil
1027	}
1028}
1029
1030func validateRebootWorkspaceRequests(v []types.RebootRequest) error {
1031	if v == nil {
1032		return nil
1033	}
1034	invalidParams := smithy.InvalidParamsError{Context: "RebootWorkspaceRequests"}
1035	for i := range v {
1036		if err := validateRebootRequest(&v[i]); err != nil {
1037			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1038		}
1039	}
1040	if invalidParams.Len() > 0 {
1041		return invalidParams
1042	} else {
1043		return nil
1044	}
1045}
1046
1047func validateRebuildRequest(v *types.RebuildRequest) error {
1048	if v == nil {
1049		return nil
1050	}
1051	invalidParams := smithy.InvalidParamsError{Context: "RebuildRequest"}
1052	if v.WorkspaceId == nil {
1053		invalidParams.Add(smithy.NewErrParamRequired("WorkspaceId"))
1054	}
1055	if invalidParams.Len() > 0 {
1056		return invalidParams
1057	} else {
1058		return nil
1059	}
1060}
1061
1062func validateRebuildWorkspaceRequests(v []types.RebuildRequest) error {
1063	if v == nil {
1064		return nil
1065	}
1066	invalidParams := smithy.InvalidParamsError{Context: "RebuildWorkspaceRequests"}
1067	for i := range v {
1068		if err := validateRebuildRequest(&v[i]); err != nil {
1069			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1070		}
1071	}
1072	if invalidParams.Len() > 0 {
1073		return invalidParams
1074	} else {
1075		return nil
1076	}
1077}
1078
1079func validateTag(v *types.Tag) error {
1080	if v == nil {
1081		return nil
1082	}
1083	invalidParams := smithy.InvalidParamsError{Context: "Tag"}
1084	if v.Key == nil {
1085		invalidParams.Add(smithy.NewErrParamRequired("Key"))
1086	}
1087	if invalidParams.Len() > 0 {
1088		return invalidParams
1089	} else {
1090		return nil
1091	}
1092}
1093
1094func validateTagList(v []types.Tag) error {
1095	if v == nil {
1096		return nil
1097	}
1098	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
1099	for i := range v {
1100		if err := validateTag(&v[i]); err != nil {
1101			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1102		}
1103	}
1104	if invalidParams.Len() > 0 {
1105		return invalidParams
1106	} else {
1107		return nil
1108	}
1109}
1110
1111func validateTerminateRequest(v *types.TerminateRequest) error {
1112	if v == nil {
1113		return nil
1114	}
1115	invalidParams := smithy.InvalidParamsError{Context: "TerminateRequest"}
1116	if v.WorkspaceId == nil {
1117		invalidParams.Add(smithy.NewErrParamRequired("WorkspaceId"))
1118	}
1119	if invalidParams.Len() > 0 {
1120		return invalidParams
1121	} else {
1122		return nil
1123	}
1124}
1125
1126func validateTerminateWorkspaceRequests(v []types.TerminateRequest) error {
1127	if v == nil {
1128		return nil
1129	}
1130	invalidParams := smithy.InvalidParamsError{Context: "TerminateWorkspaceRequests"}
1131	for i := range v {
1132		if err := validateTerminateRequest(&v[i]); err != nil {
1133			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1134		}
1135	}
1136	if invalidParams.Len() > 0 {
1137		return invalidParams
1138	} else {
1139		return nil
1140	}
1141}
1142
1143func validateWorkspaceRequest(v *types.WorkspaceRequest) error {
1144	if v == nil {
1145		return nil
1146	}
1147	invalidParams := smithy.InvalidParamsError{Context: "WorkspaceRequest"}
1148	if v.DirectoryId == nil {
1149		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
1150	}
1151	if v.UserName == nil {
1152		invalidParams.Add(smithy.NewErrParamRequired("UserName"))
1153	}
1154	if v.BundleId == nil {
1155		invalidParams.Add(smithy.NewErrParamRequired("BundleId"))
1156	}
1157	if v.Tags != nil {
1158		if err := validateTagList(v.Tags); err != nil {
1159			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1160		}
1161	}
1162	if invalidParams.Len() > 0 {
1163		return invalidParams
1164	} else {
1165		return nil
1166	}
1167}
1168
1169func validateWorkspaceRequestList(v []types.WorkspaceRequest) error {
1170	if v == nil {
1171		return nil
1172	}
1173	invalidParams := smithy.InvalidParamsError{Context: "WorkspaceRequestList"}
1174	for i := range v {
1175		if err := validateWorkspaceRequest(&v[i]); err != nil {
1176			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1177		}
1178	}
1179	if invalidParams.Len() > 0 {
1180		return invalidParams
1181	} else {
1182		return nil
1183	}
1184}
1185
1186func validateOpAssociateConnectionAliasInput(v *AssociateConnectionAliasInput) error {
1187	if v == nil {
1188		return nil
1189	}
1190	invalidParams := smithy.InvalidParamsError{Context: "AssociateConnectionAliasInput"}
1191	if v.AliasId == nil {
1192		invalidParams.Add(smithy.NewErrParamRequired("AliasId"))
1193	}
1194	if v.ResourceId == nil {
1195		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
1196	}
1197	if invalidParams.Len() > 0 {
1198		return invalidParams
1199	} else {
1200		return nil
1201	}
1202}
1203
1204func validateOpAssociateIpGroupsInput(v *AssociateIpGroupsInput) error {
1205	if v == nil {
1206		return nil
1207	}
1208	invalidParams := smithy.InvalidParamsError{Context: "AssociateIpGroupsInput"}
1209	if v.DirectoryId == nil {
1210		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
1211	}
1212	if v.GroupIds == nil {
1213		invalidParams.Add(smithy.NewErrParamRequired("GroupIds"))
1214	}
1215	if invalidParams.Len() > 0 {
1216		return invalidParams
1217	} else {
1218		return nil
1219	}
1220}
1221
1222func validateOpAuthorizeIpRulesInput(v *AuthorizeIpRulesInput) error {
1223	if v == nil {
1224		return nil
1225	}
1226	invalidParams := smithy.InvalidParamsError{Context: "AuthorizeIpRulesInput"}
1227	if v.GroupId == nil {
1228		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
1229	}
1230	if v.UserRules == nil {
1231		invalidParams.Add(smithy.NewErrParamRequired("UserRules"))
1232	}
1233	if invalidParams.Len() > 0 {
1234		return invalidParams
1235	} else {
1236		return nil
1237	}
1238}
1239
1240func validateOpCopyWorkspaceImageInput(v *CopyWorkspaceImageInput) error {
1241	if v == nil {
1242		return nil
1243	}
1244	invalidParams := smithy.InvalidParamsError{Context: "CopyWorkspaceImageInput"}
1245	if v.Name == nil {
1246		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1247	}
1248	if v.SourceImageId == nil {
1249		invalidParams.Add(smithy.NewErrParamRequired("SourceImageId"))
1250	}
1251	if v.SourceRegion == nil {
1252		invalidParams.Add(smithy.NewErrParamRequired("SourceRegion"))
1253	}
1254	if v.Tags != nil {
1255		if err := validateTagList(v.Tags); err != nil {
1256			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1257		}
1258	}
1259	if invalidParams.Len() > 0 {
1260		return invalidParams
1261	} else {
1262		return nil
1263	}
1264}
1265
1266func validateOpCreateConnectionAliasInput(v *CreateConnectionAliasInput) error {
1267	if v == nil {
1268		return nil
1269	}
1270	invalidParams := smithy.InvalidParamsError{Context: "CreateConnectionAliasInput"}
1271	if v.ConnectionString == nil {
1272		invalidParams.Add(smithy.NewErrParamRequired("ConnectionString"))
1273	}
1274	if v.Tags != nil {
1275		if err := validateTagList(v.Tags); err != nil {
1276			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1277		}
1278	}
1279	if invalidParams.Len() > 0 {
1280		return invalidParams
1281	} else {
1282		return nil
1283	}
1284}
1285
1286func validateOpCreateIpGroupInput(v *CreateIpGroupInput) error {
1287	if v == nil {
1288		return nil
1289	}
1290	invalidParams := smithy.InvalidParamsError{Context: "CreateIpGroupInput"}
1291	if v.GroupName == nil {
1292		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
1293	}
1294	if v.Tags != nil {
1295		if err := validateTagList(v.Tags); err != nil {
1296			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1297		}
1298	}
1299	if invalidParams.Len() > 0 {
1300		return invalidParams
1301	} else {
1302		return nil
1303	}
1304}
1305
1306func validateOpCreateTagsInput(v *CreateTagsInput) error {
1307	if v == nil {
1308		return nil
1309	}
1310	invalidParams := smithy.InvalidParamsError{Context: "CreateTagsInput"}
1311	if v.ResourceId == nil {
1312		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
1313	}
1314	if v.Tags == nil {
1315		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
1316	} else if v.Tags != nil {
1317		if err := validateTagList(v.Tags); err != nil {
1318			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1319		}
1320	}
1321	if invalidParams.Len() > 0 {
1322		return invalidParams
1323	} else {
1324		return nil
1325	}
1326}
1327
1328func validateOpCreateWorkspaceBundleInput(v *CreateWorkspaceBundleInput) error {
1329	if v == nil {
1330		return nil
1331	}
1332	invalidParams := smithy.InvalidParamsError{Context: "CreateWorkspaceBundleInput"}
1333	if v.BundleName == nil {
1334		invalidParams.Add(smithy.NewErrParamRequired("BundleName"))
1335	}
1336	if v.BundleDescription == nil {
1337		invalidParams.Add(smithy.NewErrParamRequired("BundleDescription"))
1338	}
1339	if v.ImageId == nil {
1340		invalidParams.Add(smithy.NewErrParamRequired("ImageId"))
1341	}
1342	if v.ComputeType == nil {
1343		invalidParams.Add(smithy.NewErrParamRequired("ComputeType"))
1344	}
1345	if v.UserStorage == nil {
1346		invalidParams.Add(smithy.NewErrParamRequired("UserStorage"))
1347	}
1348	if v.Tags != nil {
1349		if err := validateTagList(v.Tags); err != nil {
1350			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1351		}
1352	}
1353	if invalidParams.Len() > 0 {
1354		return invalidParams
1355	} else {
1356		return nil
1357	}
1358}
1359
1360func validateOpCreateWorkspacesInput(v *CreateWorkspacesInput) error {
1361	if v == nil {
1362		return nil
1363	}
1364	invalidParams := smithy.InvalidParamsError{Context: "CreateWorkspacesInput"}
1365	if v.Workspaces == nil {
1366		invalidParams.Add(smithy.NewErrParamRequired("Workspaces"))
1367	} else if v.Workspaces != nil {
1368		if err := validateWorkspaceRequestList(v.Workspaces); err != nil {
1369			invalidParams.AddNested("Workspaces", err.(smithy.InvalidParamsError))
1370		}
1371	}
1372	if invalidParams.Len() > 0 {
1373		return invalidParams
1374	} else {
1375		return nil
1376	}
1377}
1378
1379func validateOpDeleteConnectionAliasInput(v *DeleteConnectionAliasInput) error {
1380	if v == nil {
1381		return nil
1382	}
1383	invalidParams := smithy.InvalidParamsError{Context: "DeleteConnectionAliasInput"}
1384	if v.AliasId == nil {
1385		invalidParams.Add(smithy.NewErrParamRequired("AliasId"))
1386	}
1387	if invalidParams.Len() > 0 {
1388		return invalidParams
1389	} else {
1390		return nil
1391	}
1392}
1393
1394func validateOpDeleteIpGroupInput(v *DeleteIpGroupInput) error {
1395	if v == nil {
1396		return nil
1397	}
1398	invalidParams := smithy.InvalidParamsError{Context: "DeleteIpGroupInput"}
1399	if v.GroupId == nil {
1400		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
1401	}
1402	if invalidParams.Len() > 0 {
1403		return invalidParams
1404	} else {
1405		return nil
1406	}
1407}
1408
1409func validateOpDeleteTagsInput(v *DeleteTagsInput) error {
1410	if v == nil {
1411		return nil
1412	}
1413	invalidParams := smithy.InvalidParamsError{Context: "DeleteTagsInput"}
1414	if v.ResourceId == nil {
1415		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
1416	}
1417	if v.TagKeys == nil {
1418		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
1419	}
1420	if invalidParams.Len() > 0 {
1421		return invalidParams
1422	} else {
1423		return nil
1424	}
1425}
1426
1427func validateOpDeleteWorkspaceImageInput(v *DeleteWorkspaceImageInput) error {
1428	if v == nil {
1429		return nil
1430	}
1431	invalidParams := smithy.InvalidParamsError{Context: "DeleteWorkspaceImageInput"}
1432	if v.ImageId == nil {
1433		invalidParams.Add(smithy.NewErrParamRequired("ImageId"))
1434	}
1435	if invalidParams.Len() > 0 {
1436		return invalidParams
1437	} else {
1438		return nil
1439	}
1440}
1441
1442func validateOpDeregisterWorkspaceDirectoryInput(v *DeregisterWorkspaceDirectoryInput) error {
1443	if v == nil {
1444		return nil
1445	}
1446	invalidParams := smithy.InvalidParamsError{Context: "DeregisterWorkspaceDirectoryInput"}
1447	if v.DirectoryId == nil {
1448		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
1449	}
1450	if invalidParams.Len() > 0 {
1451		return invalidParams
1452	} else {
1453		return nil
1454	}
1455}
1456
1457func validateOpDescribeClientPropertiesInput(v *DescribeClientPropertiesInput) error {
1458	if v == nil {
1459		return nil
1460	}
1461	invalidParams := smithy.InvalidParamsError{Context: "DescribeClientPropertiesInput"}
1462	if v.ResourceIds == nil {
1463		invalidParams.Add(smithy.NewErrParamRequired("ResourceIds"))
1464	}
1465	if invalidParams.Len() > 0 {
1466		return invalidParams
1467	} else {
1468		return nil
1469	}
1470}
1471
1472func validateOpDescribeConnectionAliasPermissionsInput(v *DescribeConnectionAliasPermissionsInput) error {
1473	if v == nil {
1474		return nil
1475	}
1476	invalidParams := smithy.InvalidParamsError{Context: "DescribeConnectionAliasPermissionsInput"}
1477	if v.AliasId == nil {
1478		invalidParams.Add(smithy.NewErrParamRequired("AliasId"))
1479	}
1480	if invalidParams.Len() > 0 {
1481		return invalidParams
1482	} else {
1483		return nil
1484	}
1485}
1486
1487func validateOpDescribeTagsInput(v *DescribeTagsInput) error {
1488	if v == nil {
1489		return nil
1490	}
1491	invalidParams := smithy.InvalidParamsError{Context: "DescribeTagsInput"}
1492	if v.ResourceId == nil {
1493		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
1494	}
1495	if invalidParams.Len() > 0 {
1496		return invalidParams
1497	} else {
1498		return nil
1499	}
1500}
1501
1502func validateOpDescribeWorkspaceImagePermissionsInput(v *DescribeWorkspaceImagePermissionsInput) error {
1503	if v == nil {
1504		return nil
1505	}
1506	invalidParams := smithy.InvalidParamsError{Context: "DescribeWorkspaceImagePermissionsInput"}
1507	if v.ImageId == nil {
1508		invalidParams.Add(smithy.NewErrParamRequired("ImageId"))
1509	}
1510	if invalidParams.Len() > 0 {
1511		return invalidParams
1512	} else {
1513		return nil
1514	}
1515}
1516
1517func validateOpDescribeWorkspaceSnapshotsInput(v *DescribeWorkspaceSnapshotsInput) error {
1518	if v == nil {
1519		return nil
1520	}
1521	invalidParams := smithy.InvalidParamsError{Context: "DescribeWorkspaceSnapshotsInput"}
1522	if v.WorkspaceId == nil {
1523		invalidParams.Add(smithy.NewErrParamRequired("WorkspaceId"))
1524	}
1525	if invalidParams.Len() > 0 {
1526		return invalidParams
1527	} else {
1528		return nil
1529	}
1530}
1531
1532func validateOpDisassociateConnectionAliasInput(v *DisassociateConnectionAliasInput) error {
1533	if v == nil {
1534		return nil
1535	}
1536	invalidParams := smithy.InvalidParamsError{Context: "DisassociateConnectionAliasInput"}
1537	if v.AliasId == nil {
1538		invalidParams.Add(smithy.NewErrParamRequired("AliasId"))
1539	}
1540	if invalidParams.Len() > 0 {
1541		return invalidParams
1542	} else {
1543		return nil
1544	}
1545}
1546
1547func validateOpDisassociateIpGroupsInput(v *DisassociateIpGroupsInput) error {
1548	if v == nil {
1549		return nil
1550	}
1551	invalidParams := smithy.InvalidParamsError{Context: "DisassociateIpGroupsInput"}
1552	if v.DirectoryId == nil {
1553		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
1554	}
1555	if v.GroupIds == nil {
1556		invalidParams.Add(smithy.NewErrParamRequired("GroupIds"))
1557	}
1558	if invalidParams.Len() > 0 {
1559		return invalidParams
1560	} else {
1561		return nil
1562	}
1563}
1564
1565func validateOpImportWorkspaceImageInput(v *ImportWorkspaceImageInput) error {
1566	if v == nil {
1567		return nil
1568	}
1569	invalidParams := smithy.InvalidParamsError{Context: "ImportWorkspaceImageInput"}
1570	if v.Ec2ImageId == nil {
1571		invalidParams.Add(smithy.NewErrParamRequired("Ec2ImageId"))
1572	}
1573	if len(v.IngestionProcess) == 0 {
1574		invalidParams.Add(smithy.NewErrParamRequired("IngestionProcess"))
1575	}
1576	if v.ImageName == nil {
1577		invalidParams.Add(smithy.NewErrParamRequired("ImageName"))
1578	}
1579	if v.ImageDescription == nil {
1580		invalidParams.Add(smithy.NewErrParamRequired("ImageDescription"))
1581	}
1582	if v.Tags != nil {
1583		if err := validateTagList(v.Tags); err != nil {
1584			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1585		}
1586	}
1587	if invalidParams.Len() > 0 {
1588		return invalidParams
1589	} else {
1590		return nil
1591	}
1592}
1593
1594func validateOpListAvailableManagementCidrRangesInput(v *ListAvailableManagementCidrRangesInput) error {
1595	if v == nil {
1596		return nil
1597	}
1598	invalidParams := smithy.InvalidParamsError{Context: "ListAvailableManagementCidrRangesInput"}
1599	if v.ManagementCidrRangeConstraint == nil {
1600		invalidParams.Add(smithy.NewErrParamRequired("ManagementCidrRangeConstraint"))
1601	}
1602	if invalidParams.Len() > 0 {
1603		return invalidParams
1604	} else {
1605		return nil
1606	}
1607}
1608
1609func validateOpMigrateWorkspaceInput(v *MigrateWorkspaceInput) error {
1610	if v == nil {
1611		return nil
1612	}
1613	invalidParams := smithy.InvalidParamsError{Context: "MigrateWorkspaceInput"}
1614	if v.SourceWorkspaceId == nil {
1615		invalidParams.Add(smithy.NewErrParamRequired("SourceWorkspaceId"))
1616	}
1617	if v.BundleId == nil {
1618		invalidParams.Add(smithy.NewErrParamRequired("BundleId"))
1619	}
1620	if invalidParams.Len() > 0 {
1621		return invalidParams
1622	} else {
1623		return nil
1624	}
1625}
1626
1627func validateOpModifyClientPropertiesInput(v *ModifyClientPropertiesInput) error {
1628	if v == nil {
1629		return nil
1630	}
1631	invalidParams := smithy.InvalidParamsError{Context: "ModifyClientPropertiesInput"}
1632	if v.ResourceId == nil {
1633		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
1634	}
1635	if v.ClientProperties == nil {
1636		invalidParams.Add(smithy.NewErrParamRequired("ClientProperties"))
1637	}
1638	if invalidParams.Len() > 0 {
1639		return invalidParams
1640	} else {
1641		return nil
1642	}
1643}
1644
1645func validateOpModifySelfservicePermissionsInput(v *ModifySelfservicePermissionsInput) error {
1646	if v == nil {
1647		return nil
1648	}
1649	invalidParams := smithy.InvalidParamsError{Context: "ModifySelfservicePermissionsInput"}
1650	if v.ResourceId == nil {
1651		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
1652	}
1653	if v.SelfservicePermissions == nil {
1654		invalidParams.Add(smithy.NewErrParamRequired("SelfservicePermissions"))
1655	}
1656	if invalidParams.Len() > 0 {
1657		return invalidParams
1658	} else {
1659		return nil
1660	}
1661}
1662
1663func validateOpModifyWorkspaceAccessPropertiesInput(v *ModifyWorkspaceAccessPropertiesInput) error {
1664	if v == nil {
1665		return nil
1666	}
1667	invalidParams := smithy.InvalidParamsError{Context: "ModifyWorkspaceAccessPropertiesInput"}
1668	if v.ResourceId == nil {
1669		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
1670	}
1671	if v.WorkspaceAccessProperties == nil {
1672		invalidParams.Add(smithy.NewErrParamRequired("WorkspaceAccessProperties"))
1673	}
1674	if invalidParams.Len() > 0 {
1675		return invalidParams
1676	} else {
1677		return nil
1678	}
1679}
1680
1681func validateOpModifyWorkspaceCreationPropertiesInput(v *ModifyWorkspaceCreationPropertiesInput) error {
1682	if v == nil {
1683		return nil
1684	}
1685	invalidParams := smithy.InvalidParamsError{Context: "ModifyWorkspaceCreationPropertiesInput"}
1686	if v.ResourceId == nil {
1687		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
1688	}
1689	if v.WorkspaceCreationProperties == nil {
1690		invalidParams.Add(smithy.NewErrParamRequired("WorkspaceCreationProperties"))
1691	}
1692	if invalidParams.Len() > 0 {
1693		return invalidParams
1694	} else {
1695		return nil
1696	}
1697}
1698
1699func validateOpModifyWorkspacePropertiesInput(v *ModifyWorkspacePropertiesInput) error {
1700	if v == nil {
1701		return nil
1702	}
1703	invalidParams := smithy.InvalidParamsError{Context: "ModifyWorkspacePropertiesInput"}
1704	if v.WorkspaceId == nil {
1705		invalidParams.Add(smithy.NewErrParamRequired("WorkspaceId"))
1706	}
1707	if v.WorkspaceProperties == nil {
1708		invalidParams.Add(smithy.NewErrParamRequired("WorkspaceProperties"))
1709	}
1710	if invalidParams.Len() > 0 {
1711		return invalidParams
1712	} else {
1713		return nil
1714	}
1715}
1716
1717func validateOpModifyWorkspaceStateInput(v *ModifyWorkspaceStateInput) error {
1718	if v == nil {
1719		return nil
1720	}
1721	invalidParams := smithy.InvalidParamsError{Context: "ModifyWorkspaceStateInput"}
1722	if v.WorkspaceId == nil {
1723		invalidParams.Add(smithy.NewErrParamRequired("WorkspaceId"))
1724	}
1725	if len(v.WorkspaceState) == 0 {
1726		invalidParams.Add(smithy.NewErrParamRequired("WorkspaceState"))
1727	}
1728	if invalidParams.Len() > 0 {
1729		return invalidParams
1730	} else {
1731		return nil
1732	}
1733}
1734
1735func validateOpRebootWorkspacesInput(v *RebootWorkspacesInput) error {
1736	if v == nil {
1737		return nil
1738	}
1739	invalidParams := smithy.InvalidParamsError{Context: "RebootWorkspacesInput"}
1740	if v.RebootWorkspaceRequests == nil {
1741		invalidParams.Add(smithy.NewErrParamRequired("RebootWorkspaceRequests"))
1742	} else if v.RebootWorkspaceRequests != nil {
1743		if err := validateRebootWorkspaceRequests(v.RebootWorkspaceRequests); err != nil {
1744			invalidParams.AddNested("RebootWorkspaceRequests", err.(smithy.InvalidParamsError))
1745		}
1746	}
1747	if invalidParams.Len() > 0 {
1748		return invalidParams
1749	} else {
1750		return nil
1751	}
1752}
1753
1754func validateOpRebuildWorkspacesInput(v *RebuildWorkspacesInput) error {
1755	if v == nil {
1756		return nil
1757	}
1758	invalidParams := smithy.InvalidParamsError{Context: "RebuildWorkspacesInput"}
1759	if v.RebuildWorkspaceRequests == nil {
1760		invalidParams.Add(smithy.NewErrParamRequired("RebuildWorkspaceRequests"))
1761	} else if v.RebuildWorkspaceRequests != nil {
1762		if err := validateRebuildWorkspaceRequests(v.RebuildWorkspaceRequests); err != nil {
1763			invalidParams.AddNested("RebuildWorkspaceRequests", err.(smithy.InvalidParamsError))
1764		}
1765	}
1766	if invalidParams.Len() > 0 {
1767		return invalidParams
1768	} else {
1769		return nil
1770	}
1771}
1772
1773func validateOpRegisterWorkspaceDirectoryInput(v *RegisterWorkspaceDirectoryInput) error {
1774	if v == nil {
1775		return nil
1776	}
1777	invalidParams := smithy.InvalidParamsError{Context: "RegisterWorkspaceDirectoryInput"}
1778	if v.DirectoryId == nil {
1779		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
1780	}
1781	if v.EnableWorkDocs == nil {
1782		invalidParams.Add(smithy.NewErrParamRequired("EnableWorkDocs"))
1783	}
1784	if v.Tags != nil {
1785		if err := validateTagList(v.Tags); err != nil {
1786			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1787		}
1788	}
1789	if invalidParams.Len() > 0 {
1790		return invalidParams
1791	} else {
1792		return nil
1793	}
1794}
1795
1796func validateOpRestoreWorkspaceInput(v *RestoreWorkspaceInput) error {
1797	if v == nil {
1798		return nil
1799	}
1800	invalidParams := smithy.InvalidParamsError{Context: "RestoreWorkspaceInput"}
1801	if v.WorkspaceId == nil {
1802		invalidParams.Add(smithy.NewErrParamRequired("WorkspaceId"))
1803	}
1804	if invalidParams.Len() > 0 {
1805		return invalidParams
1806	} else {
1807		return nil
1808	}
1809}
1810
1811func validateOpRevokeIpRulesInput(v *RevokeIpRulesInput) error {
1812	if v == nil {
1813		return nil
1814	}
1815	invalidParams := smithy.InvalidParamsError{Context: "RevokeIpRulesInput"}
1816	if v.GroupId == nil {
1817		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
1818	}
1819	if v.UserRules == nil {
1820		invalidParams.Add(smithy.NewErrParamRequired("UserRules"))
1821	}
1822	if invalidParams.Len() > 0 {
1823		return invalidParams
1824	} else {
1825		return nil
1826	}
1827}
1828
1829func validateOpStartWorkspacesInput(v *StartWorkspacesInput) error {
1830	if v == nil {
1831		return nil
1832	}
1833	invalidParams := smithy.InvalidParamsError{Context: "StartWorkspacesInput"}
1834	if v.StartWorkspaceRequests == nil {
1835		invalidParams.Add(smithy.NewErrParamRequired("StartWorkspaceRequests"))
1836	}
1837	if invalidParams.Len() > 0 {
1838		return invalidParams
1839	} else {
1840		return nil
1841	}
1842}
1843
1844func validateOpStopWorkspacesInput(v *StopWorkspacesInput) error {
1845	if v == nil {
1846		return nil
1847	}
1848	invalidParams := smithy.InvalidParamsError{Context: "StopWorkspacesInput"}
1849	if v.StopWorkspaceRequests == nil {
1850		invalidParams.Add(smithy.NewErrParamRequired("StopWorkspaceRequests"))
1851	}
1852	if invalidParams.Len() > 0 {
1853		return invalidParams
1854	} else {
1855		return nil
1856	}
1857}
1858
1859func validateOpTerminateWorkspacesInput(v *TerminateWorkspacesInput) error {
1860	if v == nil {
1861		return nil
1862	}
1863	invalidParams := smithy.InvalidParamsError{Context: "TerminateWorkspacesInput"}
1864	if v.TerminateWorkspaceRequests == nil {
1865		invalidParams.Add(smithy.NewErrParamRequired("TerminateWorkspaceRequests"))
1866	} else if v.TerminateWorkspaceRequests != nil {
1867		if err := validateTerminateWorkspaceRequests(v.TerminateWorkspaceRequests); err != nil {
1868			invalidParams.AddNested("TerminateWorkspaceRequests", err.(smithy.InvalidParamsError))
1869		}
1870	}
1871	if invalidParams.Len() > 0 {
1872		return invalidParams
1873	} else {
1874		return nil
1875	}
1876}
1877
1878func validateOpUpdateConnectionAliasPermissionInput(v *UpdateConnectionAliasPermissionInput) error {
1879	if v == nil {
1880		return nil
1881	}
1882	invalidParams := smithy.InvalidParamsError{Context: "UpdateConnectionAliasPermissionInput"}
1883	if v.AliasId == nil {
1884		invalidParams.Add(smithy.NewErrParamRequired("AliasId"))
1885	}
1886	if v.ConnectionAliasPermission == nil {
1887		invalidParams.Add(smithy.NewErrParamRequired("ConnectionAliasPermission"))
1888	} else if v.ConnectionAliasPermission != nil {
1889		if err := validateConnectionAliasPermission(v.ConnectionAliasPermission); err != nil {
1890			invalidParams.AddNested("ConnectionAliasPermission", err.(smithy.InvalidParamsError))
1891		}
1892	}
1893	if invalidParams.Len() > 0 {
1894		return invalidParams
1895	} else {
1896		return nil
1897	}
1898}
1899
1900func validateOpUpdateRulesOfIpGroupInput(v *UpdateRulesOfIpGroupInput) error {
1901	if v == nil {
1902		return nil
1903	}
1904	invalidParams := smithy.InvalidParamsError{Context: "UpdateRulesOfIpGroupInput"}
1905	if v.GroupId == nil {
1906		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
1907	}
1908	if v.UserRules == nil {
1909		invalidParams.Add(smithy.NewErrParamRequired("UserRules"))
1910	}
1911	if invalidParams.Len() > 0 {
1912		return invalidParams
1913	} else {
1914		return nil
1915	}
1916}
1917
1918func validateOpUpdateWorkspaceImagePermissionInput(v *UpdateWorkspaceImagePermissionInput) error {
1919	if v == nil {
1920		return nil
1921	}
1922	invalidParams := smithy.InvalidParamsError{Context: "UpdateWorkspaceImagePermissionInput"}
1923	if v.ImageId == nil {
1924		invalidParams.Add(smithy.NewErrParamRequired("ImageId"))
1925	}
1926	if v.AllowCopyImage == nil {
1927		invalidParams.Add(smithy.NewErrParamRequired("AllowCopyImage"))
1928	}
1929	if v.SharedAccountId == nil {
1930		invalidParams.Add(smithy.NewErrParamRequired("SharedAccountId"))
1931	}
1932	if invalidParams.Len() > 0 {
1933		return invalidParams
1934	} else {
1935		return nil
1936	}
1937}
1938