1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package mgn
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/mgn/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpChangeServerLifeCycleState struct {
14}
15
16func (*validateOpChangeServerLifeCycleState) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpChangeServerLifeCycleState) 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.(*ChangeServerLifeCycleStateInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpChangeServerLifeCycleStateInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpCreateReplicationConfigurationTemplate struct {
34}
35
36func (*validateOpCreateReplicationConfigurationTemplate) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpCreateReplicationConfigurationTemplate) 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.(*CreateReplicationConfigurationTemplateInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpCreateReplicationConfigurationTemplateInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpDeleteJob struct {
54}
55
56func (*validateOpDeleteJob) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpDeleteJob) 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.(*DeleteJobInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpDeleteJobInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpDeleteReplicationConfigurationTemplate struct {
74}
75
76func (*validateOpDeleteReplicationConfigurationTemplate) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpDeleteReplicationConfigurationTemplate) 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.(*DeleteReplicationConfigurationTemplateInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpDeleteReplicationConfigurationTemplateInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpDeleteSourceServer struct {
94}
95
96func (*validateOpDeleteSourceServer) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpDeleteSourceServer) 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.(*DeleteSourceServerInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpDeleteSourceServerInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpDescribeJobLogItems struct {
114}
115
116func (*validateOpDescribeJobLogItems) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpDescribeJobLogItems) 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.(*DescribeJobLogItemsInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpDescribeJobLogItemsInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpDescribeJobs struct {
134}
135
136func (*validateOpDescribeJobs) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpDescribeJobs) 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.(*DescribeJobsInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpDescribeJobsInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpDescribeReplicationConfigurationTemplates struct {
154}
155
156func (*validateOpDescribeReplicationConfigurationTemplates) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpDescribeReplicationConfigurationTemplates) 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.(*DescribeReplicationConfigurationTemplatesInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpDescribeReplicationConfigurationTemplatesInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpDescribeSourceServers struct {
174}
175
176func (*validateOpDescribeSourceServers) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpDescribeSourceServers) 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.(*DescribeSourceServersInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpDescribeSourceServersInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpDisconnectFromService struct {
194}
195
196func (*validateOpDisconnectFromService) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpDisconnectFromService) 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.(*DisconnectFromServiceInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpDisconnectFromServiceInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpFinalizeCutover struct {
214}
215
216func (*validateOpFinalizeCutover) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpFinalizeCutover) 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.(*FinalizeCutoverInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpFinalizeCutoverInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpGetLaunchConfiguration struct {
234}
235
236func (*validateOpGetLaunchConfiguration) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpGetLaunchConfiguration) 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.(*GetLaunchConfigurationInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpGetLaunchConfigurationInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpGetReplicationConfiguration struct {
254}
255
256func (*validateOpGetReplicationConfiguration) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpGetReplicationConfiguration) 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.(*GetReplicationConfigurationInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpGetReplicationConfigurationInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpListTagsForResource struct {
274}
275
276func (*validateOpListTagsForResource) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpListTagsForResourceInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpMarkAsArchived struct {
294}
295
296func (*validateOpMarkAsArchived) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpMarkAsArchived) 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.(*MarkAsArchivedInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpMarkAsArchivedInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpRetryDataReplication struct {
314}
315
316func (*validateOpRetryDataReplication) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpRetryDataReplication) 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.(*RetryDataReplicationInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpRetryDataReplicationInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpStartCutover struct {
334}
335
336func (*validateOpStartCutover) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpStartCutover) 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.(*StartCutoverInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpStartCutoverInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpStartTest struct {
354}
355
356func (*validateOpStartTest) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpStartTest) 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.(*StartTestInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpStartTestInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpTagResource struct {
374}
375
376func (*validateOpTagResource) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpTagResource) 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.(*TagResourceInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpTagResourceInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpTerminateTargetInstances struct {
394}
395
396func (*validateOpTerminateTargetInstances) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpTerminateTargetInstances) 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.(*TerminateTargetInstancesInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpTerminateTargetInstancesInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpUntagResource struct {
414}
415
416func (*validateOpUntagResource) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpUntagResource) 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.(*UntagResourceInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpUntagResourceInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpUpdateLaunchConfiguration struct {
434}
435
436func (*validateOpUpdateLaunchConfiguration) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpUpdateLaunchConfiguration) 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.(*UpdateLaunchConfigurationInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpUpdateLaunchConfigurationInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpUpdateReplicationConfiguration struct {
454}
455
456func (*validateOpUpdateReplicationConfiguration) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpUpdateReplicationConfiguration) 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.(*UpdateReplicationConfigurationInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpUpdateReplicationConfigurationInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpUpdateReplicationConfigurationTemplate struct {
474}
475
476func (*validateOpUpdateReplicationConfigurationTemplate) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpUpdateReplicationConfigurationTemplate) 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.(*UpdateReplicationConfigurationTemplateInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpUpdateReplicationConfigurationTemplateInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493func addOpChangeServerLifeCycleStateValidationMiddleware(stack *middleware.Stack) error {
494	return stack.Initialize.Add(&validateOpChangeServerLifeCycleState{}, middleware.After)
495}
496
497func addOpCreateReplicationConfigurationTemplateValidationMiddleware(stack *middleware.Stack) error {
498	return stack.Initialize.Add(&validateOpCreateReplicationConfigurationTemplate{}, middleware.After)
499}
500
501func addOpDeleteJobValidationMiddleware(stack *middleware.Stack) error {
502	return stack.Initialize.Add(&validateOpDeleteJob{}, middleware.After)
503}
504
505func addOpDeleteReplicationConfigurationTemplateValidationMiddleware(stack *middleware.Stack) error {
506	return stack.Initialize.Add(&validateOpDeleteReplicationConfigurationTemplate{}, middleware.After)
507}
508
509func addOpDeleteSourceServerValidationMiddleware(stack *middleware.Stack) error {
510	return stack.Initialize.Add(&validateOpDeleteSourceServer{}, middleware.After)
511}
512
513func addOpDescribeJobLogItemsValidationMiddleware(stack *middleware.Stack) error {
514	return stack.Initialize.Add(&validateOpDescribeJobLogItems{}, middleware.After)
515}
516
517func addOpDescribeJobsValidationMiddleware(stack *middleware.Stack) error {
518	return stack.Initialize.Add(&validateOpDescribeJobs{}, middleware.After)
519}
520
521func addOpDescribeReplicationConfigurationTemplatesValidationMiddleware(stack *middleware.Stack) error {
522	return stack.Initialize.Add(&validateOpDescribeReplicationConfigurationTemplates{}, middleware.After)
523}
524
525func addOpDescribeSourceServersValidationMiddleware(stack *middleware.Stack) error {
526	return stack.Initialize.Add(&validateOpDescribeSourceServers{}, middleware.After)
527}
528
529func addOpDisconnectFromServiceValidationMiddleware(stack *middleware.Stack) error {
530	return stack.Initialize.Add(&validateOpDisconnectFromService{}, middleware.After)
531}
532
533func addOpFinalizeCutoverValidationMiddleware(stack *middleware.Stack) error {
534	return stack.Initialize.Add(&validateOpFinalizeCutover{}, middleware.After)
535}
536
537func addOpGetLaunchConfigurationValidationMiddleware(stack *middleware.Stack) error {
538	return stack.Initialize.Add(&validateOpGetLaunchConfiguration{}, middleware.After)
539}
540
541func addOpGetReplicationConfigurationValidationMiddleware(stack *middleware.Stack) error {
542	return stack.Initialize.Add(&validateOpGetReplicationConfiguration{}, middleware.After)
543}
544
545func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
546	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
547}
548
549func addOpMarkAsArchivedValidationMiddleware(stack *middleware.Stack) error {
550	return stack.Initialize.Add(&validateOpMarkAsArchived{}, middleware.After)
551}
552
553func addOpRetryDataReplicationValidationMiddleware(stack *middleware.Stack) error {
554	return stack.Initialize.Add(&validateOpRetryDataReplication{}, middleware.After)
555}
556
557func addOpStartCutoverValidationMiddleware(stack *middleware.Stack) error {
558	return stack.Initialize.Add(&validateOpStartCutover{}, middleware.After)
559}
560
561func addOpStartTestValidationMiddleware(stack *middleware.Stack) error {
562	return stack.Initialize.Add(&validateOpStartTest{}, middleware.After)
563}
564
565func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
566	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
567}
568
569func addOpTerminateTargetInstancesValidationMiddleware(stack *middleware.Stack) error {
570	return stack.Initialize.Add(&validateOpTerminateTargetInstances{}, middleware.After)
571}
572
573func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
574	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
575}
576
577func addOpUpdateLaunchConfigurationValidationMiddleware(stack *middleware.Stack) error {
578	return stack.Initialize.Add(&validateOpUpdateLaunchConfiguration{}, middleware.After)
579}
580
581func addOpUpdateReplicationConfigurationValidationMiddleware(stack *middleware.Stack) error {
582	return stack.Initialize.Add(&validateOpUpdateReplicationConfiguration{}, middleware.After)
583}
584
585func addOpUpdateReplicationConfigurationTemplateValidationMiddleware(stack *middleware.Stack) error {
586	return stack.Initialize.Add(&validateOpUpdateReplicationConfigurationTemplate{}, middleware.After)
587}
588
589func validateChangeServerLifeCycleStateSourceServerLifecycle(v *types.ChangeServerLifeCycleStateSourceServerLifecycle) error {
590	if v == nil {
591		return nil
592	}
593	invalidParams := smithy.InvalidParamsError{Context: "ChangeServerLifeCycleStateSourceServerLifecycle"}
594	if len(v.State) == 0 {
595		invalidParams.Add(smithy.NewErrParamRequired("State"))
596	}
597	if invalidParams.Len() > 0 {
598		return invalidParams
599	} else {
600		return nil
601	}
602}
603
604func validateOpChangeServerLifeCycleStateInput(v *ChangeServerLifeCycleStateInput) error {
605	if v == nil {
606		return nil
607	}
608	invalidParams := smithy.InvalidParamsError{Context: "ChangeServerLifeCycleStateInput"}
609	if v.SourceServerID == nil {
610		invalidParams.Add(smithy.NewErrParamRequired("SourceServerID"))
611	}
612	if v.LifeCycle == nil {
613		invalidParams.Add(smithy.NewErrParamRequired("LifeCycle"))
614	} else if v.LifeCycle != nil {
615		if err := validateChangeServerLifeCycleStateSourceServerLifecycle(v.LifeCycle); err != nil {
616			invalidParams.AddNested("LifeCycle", err.(smithy.InvalidParamsError))
617		}
618	}
619	if invalidParams.Len() > 0 {
620		return invalidParams
621	} else {
622		return nil
623	}
624}
625
626func validateOpCreateReplicationConfigurationTemplateInput(v *CreateReplicationConfigurationTemplateInput) error {
627	if v == nil {
628		return nil
629	}
630	invalidParams := smithy.InvalidParamsError{Context: "CreateReplicationConfigurationTemplateInput"}
631	if v.StagingAreaSubnetId == nil {
632		invalidParams.Add(smithy.NewErrParamRequired("StagingAreaSubnetId"))
633	}
634	if v.AssociateDefaultSecurityGroup == nil {
635		invalidParams.Add(smithy.NewErrParamRequired("AssociateDefaultSecurityGroup"))
636	}
637	if v.ReplicationServersSecurityGroupsIDs == nil {
638		invalidParams.Add(smithy.NewErrParamRequired("ReplicationServersSecurityGroupsIDs"))
639	}
640	if v.ReplicationServerInstanceType == nil {
641		invalidParams.Add(smithy.NewErrParamRequired("ReplicationServerInstanceType"))
642	}
643	if v.UseDedicatedReplicationServer == nil {
644		invalidParams.Add(smithy.NewErrParamRequired("UseDedicatedReplicationServer"))
645	}
646	if len(v.DefaultLargeStagingDiskType) == 0 {
647		invalidParams.Add(smithy.NewErrParamRequired("DefaultLargeStagingDiskType"))
648	}
649	if len(v.EbsEncryption) == 0 {
650		invalidParams.Add(smithy.NewErrParamRequired("EbsEncryption"))
651	}
652	if len(v.DataPlaneRouting) == 0 {
653		invalidParams.Add(smithy.NewErrParamRequired("DataPlaneRouting"))
654	}
655	if v.CreatePublicIP == nil {
656		invalidParams.Add(smithy.NewErrParamRequired("CreatePublicIP"))
657	}
658	if v.StagingAreaTags == nil {
659		invalidParams.Add(smithy.NewErrParamRequired("StagingAreaTags"))
660	}
661	if invalidParams.Len() > 0 {
662		return invalidParams
663	} else {
664		return nil
665	}
666}
667
668func validateOpDeleteJobInput(v *DeleteJobInput) error {
669	if v == nil {
670		return nil
671	}
672	invalidParams := smithy.InvalidParamsError{Context: "DeleteJobInput"}
673	if v.JobID == nil {
674		invalidParams.Add(smithy.NewErrParamRequired("JobID"))
675	}
676	if invalidParams.Len() > 0 {
677		return invalidParams
678	} else {
679		return nil
680	}
681}
682
683func validateOpDeleteReplicationConfigurationTemplateInput(v *DeleteReplicationConfigurationTemplateInput) error {
684	if v == nil {
685		return nil
686	}
687	invalidParams := smithy.InvalidParamsError{Context: "DeleteReplicationConfigurationTemplateInput"}
688	if v.ReplicationConfigurationTemplateID == nil {
689		invalidParams.Add(smithy.NewErrParamRequired("ReplicationConfigurationTemplateID"))
690	}
691	if invalidParams.Len() > 0 {
692		return invalidParams
693	} else {
694		return nil
695	}
696}
697
698func validateOpDeleteSourceServerInput(v *DeleteSourceServerInput) error {
699	if v == nil {
700		return nil
701	}
702	invalidParams := smithy.InvalidParamsError{Context: "DeleteSourceServerInput"}
703	if v.SourceServerID == nil {
704		invalidParams.Add(smithy.NewErrParamRequired("SourceServerID"))
705	}
706	if invalidParams.Len() > 0 {
707		return invalidParams
708	} else {
709		return nil
710	}
711}
712
713func validateOpDescribeJobLogItemsInput(v *DescribeJobLogItemsInput) error {
714	if v == nil {
715		return nil
716	}
717	invalidParams := smithy.InvalidParamsError{Context: "DescribeJobLogItemsInput"}
718	if v.JobID == nil {
719		invalidParams.Add(smithy.NewErrParamRequired("JobID"))
720	}
721	if invalidParams.Len() > 0 {
722		return invalidParams
723	} else {
724		return nil
725	}
726}
727
728func validateOpDescribeJobsInput(v *DescribeJobsInput) error {
729	if v == nil {
730		return nil
731	}
732	invalidParams := smithy.InvalidParamsError{Context: "DescribeJobsInput"}
733	if v.Filters == nil {
734		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
735	}
736	if invalidParams.Len() > 0 {
737		return invalidParams
738	} else {
739		return nil
740	}
741}
742
743func validateOpDescribeReplicationConfigurationTemplatesInput(v *DescribeReplicationConfigurationTemplatesInput) error {
744	if v == nil {
745		return nil
746	}
747	invalidParams := smithy.InvalidParamsError{Context: "DescribeReplicationConfigurationTemplatesInput"}
748	if v.ReplicationConfigurationTemplateIDs == nil {
749		invalidParams.Add(smithy.NewErrParamRequired("ReplicationConfigurationTemplateIDs"))
750	}
751	if invalidParams.Len() > 0 {
752		return invalidParams
753	} else {
754		return nil
755	}
756}
757
758func validateOpDescribeSourceServersInput(v *DescribeSourceServersInput) error {
759	if v == nil {
760		return nil
761	}
762	invalidParams := smithy.InvalidParamsError{Context: "DescribeSourceServersInput"}
763	if v.Filters == nil {
764		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
765	}
766	if invalidParams.Len() > 0 {
767		return invalidParams
768	} else {
769		return nil
770	}
771}
772
773func validateOpDisconnectFromServiceInput(v *DisconnectFromServiceInput) error {
774	if v == nil {
775		return nil
776	}
777	invalidParams := smithy.InvalidParamsError{Context: "DisconnectFromServiceInput"}
778	if v.SourceServerID == nil {
779		invalidParams.Add(smithy.NewErrParamRequired("SourceServerID"))
780	}
781	if invalidParams.Len() > 0 {
782		return invalidParams
783	} else {
784		return nil
785	}
786}
787
788func validateOpFinalizeCutoverInput(v *FinalizeCutoverInput) error {
789	if v == nil {
790		return nil
791	}
792	invalidParams := smithy.InvalidParamsError{Context: "FinalizeCutoverInput"}
793	if v.SourceServerID == nil {
794		invalidParams.Add(smithy.NewErrParamRequired("SourceServerID"))
795	}
796	if invalidParams.Len() > 0 {
797		return invalidParams
798	} else {
799		return nil
800	}
801}
802
803func validateOpGetLaunchConfigurationInput(v *GetLaunchConfigurationInput) error {
804	if v == nil {
805		return nil
806	}
807	invalidParams := smithy.InvalidParamsError{Context: "GetLaunchConfigurationInput"}
808	if v.SourceServerID == nil {
809		invalidParams.Add(smithy.NewErrParamRequired("SourceServerID"))
810	}
811	if invalidParams.Len() > 0 {
812		return invalidParams
813	} else {
814		return nil
815	}
816}
817
818func validateOpGetReplicationConfigurationInput(v *GetReplicationConfigurationInput) error {
819	if v == nil {
820		return nil
821	}
822	invalidParams := smithy.InvalidParamsError{Context: "GetReplicationConfigurationInput"}
823	if v.SourceServerID == nil {
824		invalidParams.Add(smithy.NewErrParamRequired("SourceServerID"))
825	}
826	if invalidParams.Len() > 0 {
827		return invalidParams
828	} else {
829		return nil
830	}
831}
832
833func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
834	if v == nil {
835		return nil
836	}
837	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
838	if v.ResourceArn == nil {
839		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
840	}
841	if invalidParams.Len() > 0 {
842		return invalidParams
843	} else {
844		return nil
845	}
846}
847
848func validateOpMarkAsArchivedInput(v *MarkAsArchivedInput) error {
849	if v == nil {
850		return nil
851	}
852	invalidParams := smithy.InvalidParamsError{Context: "MarkAsArchivedInput"}
853	if v.SourceServerID == nil {
854		invalidParams.Add(smithy.NewErrParamRequired("SourceServerID"))
855	}
856	if invalidParams.Len() > 0 {
857		return invalidParams
858	} else {
859		return nil
860	}
861}
862
863func validateOpRetryDataReplicationInput(v *RetryDataReplicationInput) error {
864	if v == nil {
865		return nil
866	}
867	invalidParams := smithy.InvalidParamsError{Context: "RetryDataReplicationInput"}
868	if v.SourceServerID == nil {
869		invalidParams.Add(smithy.NewErrParamRequired("SourceServerID"))
870	}
871	if invalidParams.Len() > 0 {
872		return invalidParams
873	} else {
874		return nil
875	}
876}
877
878func validateOpStartCutoverInput(v *StartCutoverInput) error {
879	if v == nil {
880		return nil
881	}
882	invalidParams := smithy.InvalidParamsError{Context: "StartCutoverInput"}
883	if v.SourceServerIDs == nil {
884		invalidParams.Add(smithy.NewErrParamRequired("SourceServerIDs"))
885	}
886	if invalidParams.Len() > 0 {
887		return invalidParams
888	} else {
889		return nil
890	}
891}
892
893func validateOpStartTestInput(v *StartTestInput) error {
894	if v == nil {
895		return nil
896	}
897	invalidParams := smithy.InvalidParamsError{Context: "StartTestInput"}
898	if v.SourceServerIDs == nil {
899		invalidParams.Add(smithy.NewErrParamRequired("SourceServerIDs"))
900	}
901	if invalidParams.Len() > 0 {
902		return invalidParams
903	} else {
904		return nil
905	}
906}
907
908func validateOpTagResourceInput(v *TagResourceInput) error {
909	if v == nil {
910		return nil
911	}
912	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
913	if v.ResourceArn == nil {
914		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
915	}
916	if v.Tags == nil {
917		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
918	}
919	if invalidParams.Len() > 0 {
920		return invalidParams
921	} else {
922		return nil
923	}
924}
925
926func validateOpTerminateTargetInstancesInput(v *TerminateTargetInstancesInput) error {
927	if v == nil {
928		return nil
929	}
930	invalidParams := smithy.InvalidParamsError{Context: "TerminateTargetInstancesInput"}
931	if v.SourceServerIDs == nil {
932		invalidParams.Add(smithy.NewErrParamRequired("SourceServerIDs"))
933	}
934	if invalidParams.Len() > 0 {
935		return invalidParams
936	} else {
937		return nil
938	}
939}
940
941func validateOpUntagResourceInput(v *UntagResourceInput) error {
942	if v == nil {
943		return nil
944	}
945	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
946	if v.ResourceArn == nil {
947		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
948	}
949	if v.TagKeys == nil {
950		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
951	}
952	if invalidParams.Len() > 0 {
953		return invalidParams
954	} else {
955		return nil
956	}
957}
958
959func validateOpUpdateLaunchConfigurationInput(v *UpdateLaunchConfigurationInput) error {
960	if v == nil {
961		return nil
962	}
963	invalidParams := smithy.InvalidParamsError{Context: "UpdateLaunchConfigurationInput"}
964	if v.SourceServerID == nil {
965		invalidParams.Add(smithy.NewErrParamRequired("SourceServerID"))
966	}
967	if invalidParams.Len() > 0 {
968		return invalidParams
969	} else {
970		return nil
971	}
972}
973
974func validateOpUpdateReplicationConfigurationInput(v *UpdateReplicationConfigurationInput) error {
975	if v == nil {
976		return nil
977	}
978	invalidParams := smithy.InvalidParamsError{Context: "UpdateReplicationConfigurationInput"}
979	if v.SourceServerID == nil {
980		invalidParams.Add(smithy.NewErrParamRequired("SourceServerID"))
981	}
982	if invalidParams.Len() > 0 {
983		return invalidParams
984	} else {
985		return nil
986	}
987}
988
989func validateOpUpdateReplicationConfigurationTemplateInput(v *UpdateReplicationConfigurationTemplateInput) error {
990	if v == nil {
991		return nil
992	}
993	invalidParams := smithy.InvalidParamsError{Context: "UpdateReplicationConfigurationTemplateInput"}
994	if v.ReplicationConfigurationTemplateID == nil {
995		invalidParams.Add(smithy.NewErrParamRequired("ReplicationConfigurationTemplateID"))
996	}
997	if invalidParams.Len() > 0 {
998		return invalidParams
999	} else {
1000		return nil
1001	}
1002}
1003