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