1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package cloudhsmv2
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/cloudhsmv2/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpCopyBackupToRegion struct {
14}
15
16func (*validateOpCopyBackupToRegion) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpCopyBackupToRegion) 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.(*CopyBackupToRegionInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpCopyBackupToRegionInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpCreateCluster struct {
34}
35
36func (*validateOpCreateCluster) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpCreateCluster) 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.(*CreateClusterInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpCreateClusterInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpCreateHsm struct {
54}
55
56func (*validateOpCreateHsm) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpCreateHsm) 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.(*CreateHsmInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpCreateHsmInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpDeleteBackup struct {
74}
75
76func (*validateOpDeleteBackup) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpDeleteBackup) 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.(*DeleteBackupInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpDeleteBackupInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpDeleteCluster struct {
94}
95
96func (*validateOpDeleteCluster) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpDeleteCluster) 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.(*DeleteClusterInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpDeleteClusterInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpDeleteHsm struct {
114}
115
116func (*validateOpDeleteHsm) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpDeleteHsm) 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.(*DeleteHsmInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpDeleteHsmInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpInitializeCluster struct {
134}
135
136func (*validateOpInitializeCluster) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpInitializeCluster) 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.(*InitializeClusterInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpInitializeClusterInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpListTags struct {
154}
155
156func (*validateOpListTags) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpListTags) 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.(*ListTagsInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpListTagsInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpModifyBackupAttributes struct {
174}
175
176func (*validateOpModifyBackupAttributes) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpModifyBackupAttributes) 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.(*ModifyBackupAttributesInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpModifyBackupAttributesInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpModifyCluster struct {
194}
195
196func (*validateOpModifyCluster) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpModifyCluster) 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.(*ModifyClusterInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpModifyClusterInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpRestoreBackup struct {
214}
215
216func (*validateOpRestoreBackup) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpRestoreBackup) 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.(*RestoreBackupInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpRestoreBackupInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpTagResource struct {
234}
235
236func (*validateOpTagResource) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
241	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
242) {
243	input, ok := in.Parameters.(*TagResourceInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpTagResourceInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpUntagResource struct {
254}
255
256func (*validateOpUntagResource) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
261	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
262) {
263	input, ok := in.Parameters.(*UntagResourceInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpUntagResourceInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273func addOpCopyBackupToRegionValidationMiddleware(stack *middleware.Stack) error {
274	return stack.Initialize.Add(&validateOpCopyBackupToRegion{}, middleware.After)
275}
276
277func addOpCreateClusterValidationMiddleware(stack *middleware.Stack) error {
278	return stack.Initialize.Add(&validateOpCreateCluster{}, middleware.After)
279}
280
281func addOpCreateHsmValidationMiddleware(stack *middleware.Stack) error {
282	return stack.Initialize.Add(&validateOpCreateHsm{}, middleware.After)
283}
284
285func addOpDeleteBackupValidationMiddleware(stack *middleware.Stack) error {
286	return stack.Initialize.Add(&validateOpDeleteBackup{}, middleware.After)
287}
288
289func addOpDeleteClusterValidationMiddleware(stack *middleware.Stack) error {
290	return stack.Initialize.Add(&validateOpDeleteCluster{}, middleware.After)
291}
292
293func addOpDeleteHsmValidationMiddleware(stack *middleware.Stack) error {
294	return stack.Initialize.Add(&validateOpDeleteHsm{}, middleware.After)
295}
296
297func addOpInitializeClusterValidationMiddleware(stack *middleware.Stack) error {
298	return stack.Initialize.Add(&validateOpInitializeCluster{}, middleware.After)
299}
300
301func addOpListTagsValidationMiddleware(stack *middleware.Stack) error {
302	return stack.Initialize.Add(&validateOpListTags{}, middleware.After)
303}
304
305func addOpModifyBackupAttributesValidationMiddleware(stack *middleware.Stack) error {
306	return stack.Initialize.Add(&validateOpModifyBackupAttributes{}, middleware.After)
307}
308
309func addOpModifyClusterValidationMiddleware(stack *middleware.Stack) error {
310	return stack.Initialize.Add(&validateOpModifyCluster{}, middleware.After)
311}
312
313func addOpRestoreBackupValidationMiddleware(stack *middleware.Stack) error {
314	return stack.Initialize.Add(&validateOpRestoreBackup{}, middleware.After)
315}
316
317func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
318	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
319}
320
321func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
322	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
323}
324
325func validateTag(v *types.Tag) error {
326	if v == nil {
327		return nil
328	}
329	invalidParams := smithy.InvalidParamsError{Context: "Tag"}
330	if v.Key == nil {
331		invalidParams.Add(smithy.NewErrParamRequired("Key"))
332	}
333	if v.Value == nil {
334		invalidParams.Add(smithy.NewErrParamRequired("Value"))
335	}
336	if invalidParams.Len() > 0 {
337		return invalidParams
338	} else {
339		return nil
340	}
341}
342
343func validateTagList(v []types.Tag) error {
344	if v == nil {
345		return nil
346	}
347	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
348	for i := range v {
349		if err := validateTag(&v[i]); err != nil {
350			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
351		}
352	}
353	if invalidParams.Len() > 0 {
354		return invalidParams
355	} else {
356		return nil
357	}
358}
359
360func validateOpCopyBackupToRegionInput(v *CopyBackupToRegionInput) error {
361	if v == nil {
362		return nil
363	}
364	invalidParams := smithy.InvalidParamsError{Context: "CopyBackupToRegionInput"}
365	if v.DestinationRegion == nil {
366		invalidParams.Add(smithy.NewErrParamRequired("DestinationRegion"))
367	}
368	if v.BackupId == nil {
369		invalidParams.Add(smithy.NewErrParamRequired("BackupId"))
370	}
371	if v.TagList != nil {
372		if err := validateTagList(v.TagList); err != nil {
373			invalidParams.AddNested("TagList", err.(smithy.InvalidParamsError))
374		}
375	}
376	if invalidParams.Len() > 0 {
377		return invalidParams
378	} else {
379		return nil
380	}
381}
382
383func validateOpCreateClusterInput(v *CreateClusterInput) error {
384	if v == nil {
385		return nil
386	}
387	invalidParams := smithy.InvalidParamsError{Context: "CreateClusterInput"}
388	if v.HsmType == nil {
389		invalidParams.Add(smithy.NewErrParamRequired("HsmType"))
390	}
391	if v.SubnetIds == nil {
392		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
393	}
394	if v.TagList != nil {
395		if err := validateTagList(v.TagList); err != nil {
396			invalidParams.AddNested("TagList", err.(smithy.InvalidParamsError))
397		}
398	}
399	if invalidParams.Len() > 0 {
400		return invalidParams
401	} else {
402		return nil
403	}
404}
405
406func validateOpCreateHsmInput(v *CreateHsmInput) error {
407	if v == nil {
408		return nil
409	}
410	invalidParams := smithy.InvalidParamsError{Context: "CreateHsmInput"}
411	if v.ClusterId == nil {
412		invalidParams.Add(smithy.NewErrParamRequired("ClusterId"))
413	}
414	if v.AvailabilityZone == nil {
415		invalidParams.Add(smithy.NewErrParamRequired("AvailabilityZone"))
416	}
417	if invalidParams.Len() > 0 {
418		return invalidParams
419	} else {
420		return nil
421	}
422}
423
424func validateOpDeleteBackupInput(v *DeleteBackupInput) error {
425	if v == nil {
426		return nil
427	}
428	invalidParams := smithy.InvalidParamsError{Context: "DeleteBackupInput"}
429	if v.BackupId == nil {
430		invalidParams.Add(smithy.NewErrParamRequired("BackupId"))
431	}
432	if invalidParams.Len() > 0 {
433		return invalidParams
434	} else {
435		return nil
436	}
437}
438
439func validateOpDeleteClusterInput(v *DeleteClusterInput) error {
440	if v == nil {
441		return nil
442	}
443	invalidParams := smithy.InvalidParamsError{Context: "DeleteClusterInput"}
444	if v.ClusterId == nil {
445		invalidParams.Add(smithy.NewErrParamRequired("ClusterId"))
446	}
447	if invalidParams.Len() > 0 {
448		return invalidParams
449	} else {
450		return nil
451	}
452}
453
454func validateOpDeleteHsmInput(v *DeleteHsmInput) error {
455	if v == nil {
456		return nil
457	}
458	invalidParams := smithy.InvalidParamsError{Context: "DeleteHsmInput"}
459	if v.ClusterId == nil {
460		invalidParams.Add(smithy.NewErrParamRequired("ClusterId"))
461	}
462	if invalidParams.Len() > 0 {
463		return invalidParams
464	} else {
465		return nil
466	}
467}
468
469func validateOpInitializeClusterInput(v *InitializeClusterInput) error {
470	if v == nil {
471		return nil
472	}
473	invalidParams := smithy.InvalidParamsError{Context: "InitializeClusterInput"}
474	if v.ClusterId == nil {
475		invalidParams.Add(smithy.NewErrParamRequired("ClusterId"))
476	}
477	if v.SignedCert == nil {
478		invalidParams.Add(smithy.NewErrParamRequired("SignedCert"))
479	}
480	if v.TrustAnchor == nil {
481		invalidParams.Add(smithy.NewErrParamRequired("TrustAnchor"))
482	}
483	if invalidParams.Len() > 0 {
484		return invalidParams
485	} else {
486		return nil
487	}
488}
489
490func validateOpListTagsInput(v *ListTagsInput) error {
491	if v == nil {
492		return nil
493	}
494	invalidParams := smithy.InvalidParamsError{Context: "ListTagsInput"}
495	if v.ResourceId == nil {
496		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
497	}
498	if invalidParams.Len() > 0 {
499		return invalidParams
500	} else {
501		return nil
502	}
503}
504
505func validateOpModifyBackupAttributesInput(v *ModifyBackupAttributesInput) error {
506	if v == nil {
507		return nil
508	}
509	invalidParams := smithy.InvalidParamsError{Context: "ModifyBackupAttributesInput"}
510	if v.BackupId == nil {
511		invalidParams.Add(smithy.NewErrParamRequired("BackupId"))
512	}
513	if v.NeverExpires == nil {
514		invalidParams.Add(smithy.NewErrParamRequired("NeverExpires"))
515	}
516	if invalidParams.Len() > 0 {
517		return invalidParams
518	} else {
519		return nil
520	}
521}
522
523func validateOpModifyClusterInput(v *ModifyClusterInput) error {
524	if v == nil {
525		return nil
526	}
527	invalidParams := smithy.InvalidParamsError{Context: "ModifyClusterInput"}
528	if v.BackupRetentionPolicy == nil {
529		invalidParams.Add(smithy.NewErrParamRequired("BackupRetentionPolicy"))
530	}
531	if v.ClusterId == nil {
532		invalidParams.Add(smithy.NewErrParamRequired("ClusterId"))
533	}
534	if invalidParams.Len() > 0 {
535		return invalidParams
536	} else {
537		return nil
538	}
539}
540
541func validateOpRestoreBackupInput(v *RestoreBackupInput) error {
542	if v == nil {
543		return nil
544	}
545	invalidParams := smithy.InvalidParamsError{Context: "RestoreBackupInput"}
546	if v.BackupId == nil {
547		invalidParams.Add(smithy.NewErrParamRequired("BackupId"))
548	}
549	if invalidParams.Len() > 0 {
550		return invalidParams
551	} else {
552		return nil
553	}
554}
555
556func validateOpTagResourceInput(v *TagResourceInput) error {
557	if v == nil {
558		return nil
559	}
560	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
561	if v.ResourceId == nil {
562		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
563	}
564	if v.TagList == nil {
565		invalidParams.Add(smithy.NewErrParamRequired("TagList"))
566	} else if v.TagList != nil {
567		if err := validateTagList(v.TagList); err != nil {
568			invalidParams.AddNested("TagList", err.(smithy.InvalidParamsError))
569		}
570	}
571	if invalidParams.Len() > 0 {
572		return invalidParams
573	} else {
574		return nil
575	}
576}
577
578func validateOpUntagResourceInput(v *UntagResourceInput) error {
579	if v == nil {
580		return nil
581	}
582	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
583	if v.ResourceId == nil {
584		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
585	}
586	if v.TagKeyList == nil {
587		invalidParams.Add(smithy.NewErrParamRequired("TagKeyList"))
588	}
589	if invalidParams.Len() > 0 {
590		return invalidParams
591	} else {
592		return nil
593	}
594}
595