1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package opsworks
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/opsworks/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpAssignInstance struct {
14}
15
16func (*validateOpAssignInstance) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpAssignInstance) 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.(*AssignInstanceInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpAssignInstanceInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpAssignVolume struct {
34}
35
36func (*validateOpAssignVolume) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpAssignVolume) 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.(*AssignVolumeInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpAssignVolumeInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpAssociateElasticIp struct {
54}
55
56func (*validateOpAssociateElasticIp) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpAssociateElasticIp) 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.(*AssociateElasticIpInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpAssociateElasticIpInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpAttachElasticLoadBalancer struct {
74}
75
76func (*validateOpAttachElasticLoadBalancer) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpAttachElasticLoadBalancer) 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.(*AttachElasticLoadBalancerInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpAttachElasticLoadBalancerInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpCloneStack struct {
94}
95
96func (*validateOpCloneStack) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpCloneStack) 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.(*CloneStackInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpCloneStackInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpCreateApp struct {
114}
115
116func (*validateOpCreateApp) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpCreateApp) 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.(*CreateAppInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpCreateAppInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpCreateDeployment struct {
134}
135
136func (*validateOpCreateDeployment) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpCreateDeployment) 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.(*CreateDeploymentInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpCreateDeploymentInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpCreateInstance struct {
154}
155
156func (*validateOpCreateInstance) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpCreateInstance) 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.(*CreateInstanceInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpCreateInstanceInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpCreateLayer struct {
174}
175
176func (*validateOpCreateLayer) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpCreateLayer) 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.(*CreateLayerInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpCreateLayerInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpCreateStack struct {
194}
195
196func (*validateOpCreateStack) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpCreateStack) 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.(*CreateStackInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpCreateStackInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpCreateUserProfile struct {
214}
215
216func (*validateOpCreateUserProfile) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpCreateUserProfile) 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.(*CreateUserProfileInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpCreateUserProfileInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpDeleteApp struct {
234}
235
236func (*validateOpDeleteApp) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpDeleteApp) 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.(*DeleteAppInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpDeleteAppInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpDeleteInstance struct {
254}
255
256func (*validateOpDeleteInstance) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpDeleteInstance) 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.(*DeleteInstanceInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpDeleteInstanceInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpDeleteLayer struct {
274}
275
276func (*validateOpDeleteLayer) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpDeleteLayer) 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.(*DeleteLayerInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpDeleteLayerInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpDeleteStack struct {
294}
295
296func (*validateOpDeleteStack) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpDeleteStack) 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.(*DeleteStackInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpDeleteStackInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpDeleteUserProfile struct {
314}
315
316func (*validateOpDeleteUserProfile) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpDeleteUserProfile) 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.(*DeleteUserProfileInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpDeleteUserProfileInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpDeregisterEcsCluster struct {
334}
335
336func (*validateOpDeregisterEcsCluster) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpDeregisterEcsCluster) 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.(*DeregisterEcsClusterInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpDeregisterEcsClusterInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpDeregisterElasticIp struct {
354}
355
356func (*validateOpDeregisterElasticIp) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpDeregisterElasticIp) 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.(*DeregisterElasticIpInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpDeregisterElasticIpInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpDeregisterInstance struct {
374}
375
376func (*validateOpDeregisterInstance) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpDeregisterInstance) 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.(*DeregisterInstanceInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpDeregisterInstanceInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpDeregisterRdsDbInstance struct {
394}
395
396func (*validateOpDeregisterRdsDbInstance) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpDeregisterRdsDbInstance) 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.(*DeregisterRdsDbInstanceInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpDeregisterRdsDbInstanceInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpDeregisterVolume struct {
414}
415
416func (*validateOpDeregisterVolume) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpDeregisterVolume) 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.(*DeregisterVolumeInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpDeregisterVolumeInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpDescribeLoadBasedAutoScaling struct {
434}
435
436func (*validateOpDescribeLoadBasedAutoScaling) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpDescribeLoadBasedAutoScaling) 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.(*DescribeLoadBasedAutoScalingInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpDescribeLoadBasedAutoScalingInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpDescribeRdsDbInstances struct {
454}
455
456func (*validateOpDescribeRdsDbInstances) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpDescribeRdsDbInstances) 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.(*DescribeRdsDbInstancesInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpDescribeRdsDbInstancesInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpDescribeStackProvisioningParameters struct {
474}
475
476func (*validateOpDescribeStackProvisioningParameters) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpDescribeStackProvisioningParameters) 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.(*DescribeStackProvisioningParametersInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpDescribeStackProvisioningParametersInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpDescribeStackSummary struct {
494}
495
496func (*validateOpDescribeStackSummary) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpDescribeStackSummary) 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.(*DescribeStackSummaryInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpDescribeStackSummaryInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpDescribeTimeBasedAutoScaling struct {
514}
515
516func (*validateOpDescribeTimeBasedAutoScaling) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpDescribeTimeBasedAutoScaling) 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.(*DescribeTimeBasedAutoScalingInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpDescribeTimeBasedAutoScalingInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpDetachElasticLoadBalancer struct {
534}
535
536func (*validateOpDetachElasticLoadBalancer) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpDetachElasticLoadBalancer) 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.(*DetachElasticLoadBalancerInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpDetachElasticLoadBalancerInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpDisassociateElasticIp struct {
554}
555
556func (*validateOpDisassociateElasticIp) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpDisassociateElasticIp) 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.(*DisassociateElasticIpInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpDisassociateElasticIpInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpGetHostnameSuggestion struct {
574}
575
576func (*validateOpGetHostnameSuggestion) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpGetHostnameSuggestion) 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.(*GetHostnameSuggestionInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpGetHostnameSuggestionInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpGrantAccess struct {
594}
595
596func (*validateOpGrantAccess) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpGrantAccess) 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.(*GrantAccessInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpGrantAccessInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpListTags struct {
614}
615
616func (*validateOpListTags) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpListTags) 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.(*ListTagsInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpListTagsInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpRebootInstance struct {
634}
635
636func (*validateOpRebootInstance) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpRebootInstance) 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.(*RebootInstanceInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpRebootInstanceInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653type validateOpRegisterEcsCluster struct {
654}
655
656func (*validateOpRegisterEcsCluster) ID() string {
657	return "OperationInputValidation"
658}
659
660func (m *validateOpRegisterEcsCluster) 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.(*RegisterEcsClusterInput)
664	if !ok {
665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666	}
667	if err := validateOpRegisterEcsClusterInput(input); err != nil {
668		return out, metadata, err
669	}
670	return next.HandleInitialize(ctx, in)
671}
672
673type validateOpRegisterElasticIp struct {
674}
675
676func (*validateOpRegisterElasticIp) ID() string {
677	return "OperationInputValidation"
678}
679
680func (m *validateOpRegisterElasticIp) 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.(*RegisterElasticIpInput)
684	if !ok {
685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
686	}
687	if err := validateOpRegisterElasticIpInput(input); err != nil {
688		return out, metadata, err
689	}
690	return next.HandleInitialize(ctx, in)
691}
692
693type validateOpRegisterInstance struct {
694}
695
696func (*validateOpRegisterInstance) ID() string {
697	return "OperationInputValidation"
698}
699
700func (m *validateOpRegisterInstance) 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.(*RegisterInstanceInput)
704	if !ok {
705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
706	}
707	if err := validateOpRegisterInstanceInput(input); err != nil {
708		return out, metadata, err
709	}
710	return next.HandleInitialize(ctx, in)
711}
712
713type validateOpRegisterRdsDbInstance struct {
714}
715
716func (*validateOpRegisterRdsDbInstance) ID() string {
717	return "OperationInputValidation"
718}
719
720func (m *validateOpRegisterRdsDbInstance) 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.(*RegisterRdsDbInstanceInput)
724	if !ok {
725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
726	}
727	if err := validateOpRegisterRdsDbInstanceInput(input); err != nil {
728		return out, metadata, err
729	}
730	return next.HandleInitialize(ctx, in)
731}
732
733type validateOpRegisterVolume struct {
734}
735
736func (*validateOpRegisterVolume) ID() string {
737	return "OperationInputValidation"
738}
739
740func (m *validateOpRegisterVolume) 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.(*RegisterVolumeInput)
744	if !ok {
745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
746	}
747	if err := validateOpRegisterVolumeInput(input); err != nil {
748		return out, metadata, err
749	}
750	return next.HandleInitialize(ctx, in)
751}
752
753type validateOpSetLoadBasedAutoScaling struct {
754}
755
756func (*validateOpSetLoadBasedAutoScaling) ID() string {
757	return "OperationInputValidation"
758}
759
760func (m *validateOpSetLoadBasedAutoScaling) 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.(*SetLoadBasedAutoScalingInput)
764	if !ok {
765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
766	}
767	if err := validateOpSetLoadBasedAutoScalingInput(input); err != nil {
768		return out, metadata, err
769	}
770	return next.HandleInitialize(ctx, in)
771}
772
773type validateOpSetPermission struct {
774}
775
776func (*validateOpSetPermission) ID() string {
777	return "OperationInputValidation"
778}
779
780func (m *validateOpSetPermission) 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.(*SetPermissionInput)
784	if !ok {
785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
786	}
787	if err := validateOpSetPermissionInput(input); err != nil {
788		return out, metadata, err
789	}
790	return next.HandleInitialize(ctx, in)
791}
792
793type validateOpSetTimeBasedAutoScaling struct {
794}
795
796func (*validateOpSetTimeBasedAutoScaling) ID() string {
797	return "OperationInputValidation"
798}
799
800func (m *validateOpSetTimeBasedAutoScaling) 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.(*SetTimeBasedAutoScalingInput)
804	if !ok {
805		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
806	}
807	if err := validateOpSetTimeBasedAutoScalingInput(input); err != nil {
808		return out, metadata, err
809	}
810	return next.HandleInitialize(ctx, in)
811}
812
813type validateOpStartInstance struct {
814}
815
816func (*validateOpStartInstance) ID() string {
817	return "OperationInputValidation"
818}
819
820func (m *validateOpStartInstance) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
821	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
822) {
823	input, ok := in.Parameters.(*StartInstanceInput)
824	if !ok {
825		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
826	}
827	if err := validateOpStartInstanceInput(input); err != nil {
828		return out, metadata, err
829	}
830	return next.HandleInitialize(ctx, in)
831}
832
833type validateOpStartStack struct {
834}
835
836func (*validateOpStartStack) ID() string {
837	return "OperationInputValidation"
838}
839
840func (m *validateOpStartStack) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
841	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
842) {
843	input, ok := in.Parameters.(*StartStackInput)
844	if !ok {
845		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
846	}
847	if err := validateOpStartStackInput(input); err != nil {
848		return out, metadata, err
849	}
850	return next.HandleInitialize(ctx, in)
851}
852
853type validateOpStopInstance struct {
854}
855
856func (*validateOpStopInstance) ID() string {
857	return "OperationInputValidation"
858}
859
860func (m *validateOpStopInstance) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
861	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
862) {
863	input, ok := in.Parameters.(*StopInstanceInput)
864	if !ok {
865		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
866	}
867	if err := validateOpStopInstanceInput(input); err != nil {
868		return out, metadata, err
869	}
870	return next.HandleInitialize(ctx, in)
871}
872
873type validateOpStopStack struct {
874}
875
876func (*validateOpStopStack) ID() string {
877	return "OperationInputValidation"
878}
879
880func (m *validateOpStopStack) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
881	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
882) {
883	input, ok := in.Parameters.(*StopStackInput)
884	if !ok {
885		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
886	}
887	if err := validateOpStopStackInput(input); err != nil {
888		return out, metadata, err
889	}
890	return next.HandleInitialize(ctx, in)
891}
892
893type validateOpTagResource struct {
894}
895
896func (*validateOpTagResource) ID() string {
897	return "OperationInputValidation"
898}
899
900func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
901	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
902) {
903	input, ok := in.Parameters.(*TagResourceInput)
904	if !ok {
905		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
906	}
907	if err := validateOpTagResourceInput(input); err != nil {
908		return out, metadata, err
909	}
910	return next.HandleInitialize(ctx, in)
911}
912
913type validateOpUnassignInstance struct {
914}
915
916func (*validateOpUnassignInstance) ID() string {
917	return "OperationInputValidation"
918}
919
920func (m *validateOpUnassignInstance) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
921	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
922) {
923	input, ok := in.Parameters.(*UnassignInstanceInput)
924	if !ok {
925		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
926	}
927	if err := validateOpUnassignInstanceInput(input); err != nil {
928		return out, metadata, err
929	}
930	return next.HandleInitialize(ctx, in)
931}
932
933type validateOpUnassignVolume struct {
934}
935
936func (*validateOpUnassignVolume) ID() string {
937	return "OperationInputValidation"
938}
939
940func (m *validateOpUnassignVolume) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
941	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
942) {
943	input, ok := in.Parameters.(*UnassignVolumeInput)
944	if !ok {
945		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
946	}
947	if err := validateOpUnassignVolumeInput(input); err != nil {
948		return out, metadata, err
949	}
950	return next.HandleInitialize(ctx, in)
951}
952
953type validateOpUntagResource struct {
954}
955
956func (*validateOpUntagResource) ID() string {
957	return "OperationInputValidation"
958}
959
960func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
961	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
962) {
963	input, ok := in.Parameters.(*UntagResourceInput)
964	if !ok {
965		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
966	}
967	if err := validateOpUntagResourceInput(input); err != nil {
968		return out, metadata, err
969	}
970	return next.HandleInitialize(ctx, in)
971}
972
973type validateOpUpdateApp struct {
974}
975
976func (*validateOpUpdateApp) ID() string {
977	return "OperationInputValidation"
978}
979
980func (m *validateOpUpdateApp) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
981	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
982) {
983	input, ok := in.Parameters.(*UpdateAppInput)
984	if !ok {
985		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
986	}
987	if err := validateOpUpdateAppInput(input); err != nil {
988		return out, metadata, err
989	}
990	return next.HandleInitialize(ctx, in)
991}
992
993type validateOpUpdateElasticIp struct {
994}
995
996func (*validateOpUpdateElasticIp) ID() string {
997	return "OperationInputValidation"
998}
999
1000func (m *validateOpUpdateElasticIp) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1001	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1002) {
1003	input, ok := in.Parameters.(*UpdateElasticIpInput)
1004	if !ok {
1005		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1006	}
1007	if err := validateOpUpdateElasticIpInput(input); err != nil {
1008		return out, metadata, err
1009	}
1010	return next.HandleInitialize(ctx, in)
1011}
1012
1013type validateOpUpdateInstance struct {
1014}
1015
1016func (*validateOpUpdateInstance) ID() string {
1017	return "OperationInputValidation"
1018}
1019
1020func (m *validateOpUpdateInstance) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1021	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1022) {
1023	input, ok := in.Parameters.(*UpdateInstanceInput)
1024	if !ok {
1025		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1026	}
1027	if err := validateOpUpdateInstanceInput(input); err != nil {
1028		return out, metadata, err
1029	}
1030	return next.HandleInitialize(ctx, in)
1031}
1032
1033type validateOpUpdateLayer struct {
1034}
1035
1036func (*validateOpUpdateLayer) ID() string {
1037	return "OperationInputValidation"
1038}
1039
1040func (m *validateOpUpdateLayer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1041	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1042) {
1043	input, ok := in.Parameters.(*UpdateLayerInput)
1044	if !ok {
1045		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1046	}
1047	if err := validateOpUpdateLayerInput(input); err != nil {
1048		return out, metadata, err
1049	}
1050	return next.HandleInitialize(ctx, in)
1051}
1052
1053type validateOpUpdateRdsDbInstance struct {
1054}
1055
1056func (*validateOpUpdateRdsDbInstance) ID() string {
1057	return "OperationInputValidation"
1058}
1059
1060func (m *validateOpUpdateRdsDbInstance) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1061	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1062) {
1063	input, ok := in.Parameters.(*UpdateRdsDbInstanceInput)
1064	if !ok {
1065		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1066	}
1067	if err := validateOpUpdateRdsDbInstanceInput(input); err != nil {
1068		return out, metadata, err
1069	}
1070	return next.HandleInitialize(ctx, in)
1071}
1072
1073type validateOpUpdateStack struct {
1074}
1075
1076func (*validateOpUpdateStack) ID() string {
1077	return "OperationInputValidation"
1078}
1079
1080func (m *validateOpUpdateStack) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1081	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1082) {
1083	input, ok := in.Parameters.(*UpdateStackInput)
1084	if !ok {
1085		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1086	}
1087	if err := validateOpUpdateStackInput(input); err != nil {
1088		return out, metadata, err
1089	}
1090	return next.HandleInitialize(ctx, in)
1091}
1092
1093type validateOpUpdateUserProfile struct {
1094}
1095
1096func (*validateOpUpdateUserProfile) ID() string {
1097	return "OperationInputValidation"
1098}
1099
1100func (m *validateOpUpdateUserProfile) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1101	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1102) {
1103	input, ok := in.Parameters.(*UpdateUserProfileInput)
1104	if !ok {
1105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1106	}
1107	if err := validateOpUpdateUserProfileInput(input); err != nil {
1108		return out, metadata, err
1109	}
1110	return next.HandleInitialize(ctx, in)
1111}
1112
1113type validateOpUpdateVolume struct {
1114}
1115
1116func (*validateOpUpdateVolume) ID() string {
1117	return "OperationInputValidation"
1118}
1119
1120func (m *validateOpUpdateVolume) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1121	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1122) {
1123	input, ok := in.Parameters.(*UpdateVolumeInput)
1124	if !ok {
1125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1126	}
1127	if err := validateOpUpdateVolumeInput(input); err != nil {
1128		return out, metadata, err
1129	}
1130	return next.HandleInitialize(ctx, in)
1131}
1132
1133func addOpAssignInstanceValidationMiddleware(stack *middleware.Stack) error {
1134	return stack.Initialize.Add(&validateOpAssignInstance{}, middleware.After)
1135}
1136
1137func addOpAssignVolumeValidationMiddleware(stack *middleware.Stack) error {
1138	return stack.Initialize.Add(&validateOpAssignVolume{}, middleware.After)
1139}
1140
1141func addOpAssociateElasticIpValidationMiddleware(stack *middleware.Stack) error {
1142	return stack.Initialize.Add(&validateOpAssociateElasticIp{}, middleware.After)
1143}
1144
1145func addOpAttachElasticLoadBalancerValidationMiddleware(stack *middleware.Stack) error {
1146	return stack.Initialize.Add(&validateOpAttachElasticLoadBalancer{}, middleware.After)
1147}
1148
1149func addOpCloneStackValidationMiddleware(stack *middleware.Stack) error {
1150	return stack.Initialize.Add(&validateOpCloneStack{}, middleware.After)
1151}
1152
1153func addOpCreateAppValidationMiddleware(stack *middleware.Stack) error {
1154	return stack.Initialize.Add(&validateOpCreateApp{}, middleware.After)
1155}
1156
1157func addOpCreateDeploymentValidationMiddleware(stack *middleware.Stack) error {
1158	return stack.Initialize.Add(&validateOpCreateDeployment{}, middleware.After)
1159}
1160
1161func addOpCreateInstanceValidationMiddleware(stack *middleware.Stack) error {
1162	return stack.Initialize.Add(&validateOpCreateInstance{}, middleware.After)
1163}
1164
1165func addOpCreateLayerValidationMiddleware(stack *middleware.Stack) error {
1166	return stack.Initialize.Add(&validateOpCreateLayer{}, middleware.After)
1167}
1168
1169func addOpCreateStackValidationMiddleware(stack *middleware.Stack) error {
1170	return stack.Initialize.Add(&validateOpCreateStack{}, middleware.After)
1171}
1172
1173func addOpCreateUserProfileValidationMiddleware(stack *middleware.Stack) error {
1174	return stack.Initialize.Add(&validateOpCreateUserProfile{}, middleware.After)
1175}
1176
1177func addOpDeleteAppValidationMiddleware(stack *middleware.Stack) error {
1178	return stack.Initialize.Add(&validateOpDeleteApp{}, middleware.After)
1179}
1180
1181func addOpDeleteInstanceValidationMiddleware(stack *middleware.Stack) error {
1182	return stack.Initialize.Add(&validateOpDeleteInstance{}, middleware.After)
1183}
1184
1185func addOpDeleteLayerValidationMiddleware(stack *middleware.Stack) error {
1186	return stack.Initialize.Add(&validateOpDeleteLayer{}, middleware.After)
1187}
1188
1189func addOpDeleteStackValidationMiddleware(stack *middleware.Stack) error {
1190	return stack.Initialize.Add(&validateOpDeleteStack{}, middleware.After)
1191}
1192
1193func addOpDeleteUserProfileValidationMiddleware(stack *middleware.Stack) error {
1194	return stack.Initialize.Add(&validateOpDeleteUserProfile{}, middleware.After)
1195}
1196
1197func addOpDeregisterEcsClusterValidationMiddleware(stack *middleware.Stack) error {
1198	return stack.Initialize.Add(&validateOpDeregisterEcsCluster{}, middleware.After)
1199}
1200
1201func addOpDeregisterElasticIpValidationMiddleware(stack *middleware.Stack) error {
1202	return stack.Initialize.Add(&validateOpDeregisterElasticIp{}, middleware.After)
1203}
1204
1205func addOpDeregisterInstanceValidationMiddleware(stack *middleware.Stack) error {
1206	return stack.Initialize.Add(&validateOpDeregisterInstance{}, middleware.After)
1207}
1208
1209func addOpDeregisterRdsDbInstanceValidationMiddleware(stack *middleware.Stack) error {
1210	return stack.Initialize.Add(&validateOpDeregisterRdsDbInstance{}, middleware.After)
1211}
1212
1213func addOpDeregisterVolumeValidationMiddleware(stack *middleware.Stack) error {
1214	return stack.Initialize.Add(&validateOpDeregisterVolume{}, middleware.After)
1215}
1216
1217func addOpDescribeLoadBasedAutoScalingValidationMiddleware(stack *middleware.Stack) error {
1218	return stack.Initialize.Add(&validateOpDescribeLoadBasedAutoScaling{}, middleware.After)
1219}
1220
1221func addOpDescribeRdsDbInstancesValidationMiddleware(stack *middleware.Stack) error {
1222	return stack.Initialize.Add(&validateOpDescribeRdsDbInstances{}, middleware.After)
1223}
1224
1225func addOpDescribeStackProvisioningParametersValidationMiddleware(stack *middleware.Stack) error {
1226	return stack.Initialize.Add(&validateOpDescribeStackProvisioningParameters{}, middleware.After)
1227}
1228
1229func addOpDescribeStackSummaryValidationMiddleware(stack *middleware.Stack) error {
1230	return stack.Initialize.Add(&validateOpDescribeStackSummary{}, middleware.After)
1231}
1232
1233func addOpDescribeTimeBasedAutoScalingValidationMiddleware(stack *middleware.Stack) error {
1234	return stack.Initialize.Add(&validateOpDescribeTimeBasedAutoScaling{}, middleware.After)
1235}
1236
1237func addOpDetachElasticLoadBalancerValidationMiddleware(stack *middleware.Stack) error {
1238	return stack.Initialize.Add(&validateOpDetachElasticLoadBalancer{}, middleware.After)
1239}
1240
1241func addOpDisassociateElasticIpValidationMiddleware(stack *middleware.Stack) error {
1242	return stack.Initialize.Add(&validateOpDisassociateElasticIp{}, middleware.After)
1243}
1244
1245func addOpGetHostnameSuggestionValidationMiddleware(stack *middleware.Stack) error {
1246	return stack.Initialize.Add(&validateOpGetHostnameSuggestion{}, middleware.After)
1247}
1248
1249func addOpGrantAccessValidationMiddleware(stack *middleware.Stack) error {
1250	return stack.Initialize.Add(&validateOpGrantAccess{}, middleware.After)
1251}
1252
1253func addOpListTagsValidationMiddleware(stack *middleware.Stack) error {
1254	return stack.Initialize.Add(&validateOpListTags{}, middleware.After)
1255}
1256
1257func addOpRebootInstanceValidationMiddleware(stack *middleware.Stack) error {
1258	return stack.Initialize.Add(&validateOpRebootInstance{}, middleware.After)
1259}
1260
1261func addOpRegisterEcsClusterValidationMiddleware(stack *middleware.Stack) error {
1262	return stack.Initialize.Add(&validateOpRegisterEcsCluster{}, middleware.After)
1263}
1264
1265func addOpRegisterElasticIpValidationMiddleware(stack *middleware.Stack) error {
1266	return stack.Initialize.Add(&validateOpRegisterElasticIp{}, middleware.After)
1267}
1268
1269func addOpRegisterInstanceValidationMiddleware(stack *middleware.Stack) error {
1270	return stack.Initialize.Add(&validateOpRegisterInstance{}, middleware.After)
1271}
1272
1273func addOpRegisterRdsDbInstanceValidationMiddleware(stack *middleware.Stack) error {
1274	return stack.Initialize.Add(&validateOpRegisterRdsDbInstance{}, middleware.After)
1275}
1276
1277func addOpRegisterVolumeValidationMiddleware(stack *middleware.Stack) error {
1278	return stack.Initialize.Add(&validateOpRegisterVolume{}, middleware.After)
1279}
1280
1281func addOpSetLoadBasedAutoScalingValidationMiddleware(stack *middleware.Stack) error {
1282	return stack.Initialize.Add(&validateOpSetLoadBasedAutoScaling{}, middleware.After)
1283}
1284
1285func addOpSetPermissionValidationMiddleware(stack *middleware.Stack) error {
1286	return stack.Initialize.Add(&validateOpSetPermission{}, middleware.After)
1287}
1288
1289func addOpSetTimeBasedAutoScalingValidationMiddleware(stack *middleware.Stack) error {
1290	return stack.Initialize.Add(&validateOpSetTimeBasedAutoScaling{}, middleware.After)
1291}
1292
1293func addOpStartInstanceValidationMiddleware(stack *middleware.Stack) error {
1294	return stack.Initialize.Add(&validateOpStartInstance{}, middleware.After)
1295}
1296
1297func addOpStartStackValidationMiddleware(stack *middleware.Stack) error {
1298	return stack.Initialize.Add(&validateOpStartStack{}, middleware.After)
1299}
1300
1301func addOpStopInstanceValidationMiddleware(stack *middleware.Stack) error {
1302	return stack.Initialize.Add(&validateOpStopInstance{}, middleware.After)
1303}
1304
1305func addOpStopStackValidationMiddleware(stack *middleware.Stack) error {
1306	return stack.Initialize.Add(&validateOpStopStack{}, middleware.After)
1307}
1308
1309func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
1310	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
1311}
1312
1313func addOpUnassignInstanceValidationMiddleware(stack *middleware.Stack) error {
1314	return stack.Initialize.Add(&validateOpUnassignInstance{}, middleware.After)
1315}
1316
1317func addOpUnassignVolumeValidationMiddleware(stack *middleware.Stack) error {
1318	return stack.Initialize.Add(&validateOpUnassignVolume{}, middleware.After)
1319}
1320
1321func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
1322	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
1323}
1324
1325func addOpUpdateAppValidationMiddleware(stack *middleware.Stack) error {
1326	return stack.Initialize.Add(&validateOpUpdateApp{}, middleware.After)
1327}
1328
1329func addOpUpdateElasticIpValidationMiddleware(stack *middleware.Stack) error {
1330	return stack.Initialize.Add(&validateOpUpdateElasticIp{}, middleware.After)
1331}
1332
1333func addOpUpdateInstanceValidationMiddleware(stack *middleware.Stack) error {
1334	return stack.Initialize.Add(&validateOpUpdateInstance{}, middleware.After)
1335}
1336
1337func addOpUpdateLayerValidationMiddleware(stack *middleware.Stack) error {
1338	return stack.Initialize.Add(&validateOpUpdateLayer{}, middleware.After)
1339}
1340
1341func addOpUpdateRdsDbInstanceValidationMiddleware(stack *middleware.Stack) error {
1342	return stack.Initialize.Add(&validateOpUpdateRdsDbInstance{}, middleware.After)
1343}
1344
1345func addOpUpdateStackValidationMiddleware(stack *middleware.Stack) error {
1346	return stack.Initialize.Add(&validateOpUpdateStack{}, middleware.After)
1347}
1348
1349func addOpUpdateUserProfileValidationMiddleware(stack *middleware.Stack) error {
1350	return stack.Initialize.Add(&validateOpUpdateUserProfile{}, middleware.After)
1351}
1352
1353func addOpUpdateVolumeValidationMiddleware(stack *middleware.Stack) error {
1354	return stack.Initialize.Add(&validateOpUpdateVolume{}, middleware.After)
1355}
1356
1357func validateDeploymentCommand(v *types.DeploymentCommand) error {
1358	if v == nil {
1359		return nil
1360	}
1361	invalidParams := smithy.InvalidParamsError{Context: "DeploymentCommand"}
1362	if len(v.Name) == 0 {
1363		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1364	}
1365	if invalidParams.Len() > 0 {
1366		return invalidParams
1367	} else {
1368		return nil
1369	}
1370}
1371
1372func validateEnvironmentVariable(v *types.EnvironmentVariable) error {
1373	if v == nil {
1374		return nil
1375	}
1376	invalidParams := smithy.InvalidParamsError{Context: "EnvironmentVariable"}
1377	if v.Key == nil {
1378		invalidParams.Add(smithy.NewErrParamRequired("Key"))
1379	}
1380	if v.Value == nil {
1381		invalidParams.Add(smithy.NewErrParamRequired("Value"))
1382	}
1383	if invalidParams.Len() > 0 {
1384		return invalidParams
1385	} else {
1386		return nil
1387	}
1388}
1389
1390func validateEnvironmentVariables(v []types.EnvironmentVariable) error {
1391	if v == nil {
1392		return nil
1393	}
1394	invalidParams := smithy.InvalidParamsError{Context: "EnvironmentVariables"}
1395	for i := range v {
1396		if err := validateEnvironmentVariable(&v[i]); err != nil {
1397			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1398		}
1399	}
1400	if invalidParams.Len() > 0 {
1401		return invalidParams
1402	} else {
1403		return nil
1404	}
1405}
1406
1407func validateSslConfiguration(v *types.SslConfiguration) error {
1408	if v == nil {
1409		return nil
1410	}
1411	invalidParams := smithy.InvalidParamsError{Context: "SslConfiguration"}
1412	if v.Certificate == nil {
1413		invalidParams.Add(smithy.NewErrParamRequired("Certificate"))
1414	}
1415	if v.PrivateKey == nil {
1416		invalidParams.Add(smithy.NewErrParamRequired("PrivateKey"))
1417	}
1418	if invalidParams.Len() > 0 {
1419		return invalidParams
1420	} else {
1421		return nil
1422	}
1423}
1424
1425func validateVolumeConfiguration(v *types.VolumeConfiguration) error {
1426	if v == nil {
1427		return nil
1428	}
1429	invalidParams := smithy.InvalidParamsError{Context: "VolumeConfiguration"}
1430	if v.MountPoint == nil {
1431		invalidParams.Add(smithy.NewErrParamRequired("MountPoint"))
1432	}
1433	if v.NumberOfDisks == nil {
1434		invalidParams.Add(smithy.NewErrParamRequired("NumberOfDisks"))
1435	}
1436	if v.Size == nil {
1437		invalidParams.Add(smithy.NewErrParamRequired("Size"))
1438	}
1439	if invalidParams.Len() > 0 {
1440		return invalidParams
1441	} else {
1442		return nil
1443	}
1444}
1445
1446func validateVolumeConfigurations(v []types.VolumeConfiguration) error {
1447	if v == nil {
1448		return nil
1449	}
1450	invalidParams := smithy.InvalidParamsError{Context: "VolumeConfigurations"}
1451	for i := range v {
1452		if err := validateVolumeConfiguration(&v[i]); err != nil {
1453			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1454		}
1455	}
1456	if invalidParams.Len() > 0 {
1457		return invalidParams
1458	} else {
1459		return nil
1460	}
1461}
1462
1463func validateOpAssignInstanceInput(v *AssignInstanceInput) error {
1464	if v == nil {
1465		return nil
1466	}
1467	invalidParams := smithy.InvalidParamsError{Context: "AssignInstanceInput"}
1468	if v.InstanceId == nil {
1469		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
1470	}
1471	if v.LayerIds == nil {
1472		invalidParams.Add(smithy.NewErrParamRequired("LayerIds"))
1473	}
1474	if invalidParams.Len() > 0 {
1475		return invalidParams
1476	} else {
1477		return nil
1478	}
1479}
1480
1481func validateOpAssignVolumeInput(v *AssignVolumeInput) error {
1482	if v == nil {
1483		return nil
1484	}
1485	invalidParams := smithy.InvalidParamsError{Context: "AssignVolumeInput"}
1486	if v.VolumeId == nil {
1487		invalidParams.Add(smithy.NewErrParamRequired("VolumeId"))
1488	}
1489	if invalidParams.Len() > 0 {
1490		return invalidParams
1491	} else {
1492		return nil
1493	}
1494}
1495
1496func validateOpAssociateElasticIpInput(v *AssociateElasticIpInput) error {
1497	if v == nil {
1498		return nil
1499	}
1500	invalidParams := smithy.InvalidParamsError{Context: "AssociateElasticIpInput"}
1501	if v.ElasticIp == nil {
1502		invalidParams.Add(smithy.NewErrParamRequired("ElasticIp"))
1503	}
1504	if invalidParams.Len() > 0 {
1505		return invalidParams
1506	} else {
1507		return nil
1508	}
1509}
1510
1511func validateOpAttachElasticLoadBalancerInput(v *AttachElasticLoadBalancerInput) error {
1512	if v == nil {
1513		return nil
1514	}
1515	invalidParams := smithy.InvalidParamsError{Context: "AttachElasticLoadBalancerInput"}
1516	if v.ElasticLoadBalancerName == nil {
1517		invalidParams.Add(smithy.NewErrParamRequired("ElasticLoadBalancerName"))
1518	}
1519	if v.LayerId == nil {
1520		invalidParams.Add(smithy.NewErrParamRequired("LayerId"))
1521	}
1522	if invalidParams.Len() > 0 {
1523		return invalidParams
1524	} else {
1525		return nil
1526	}
1527}
1528
1529func validateOpCloneStackInput(v *CloneStackInput) error {
1530	if v == nil {
1531		return nil
1532	}
1533	invalidParams := smithy.InvalidParamsError{Context: "CloneStackInput"}
1534	if v.SourceStackId == nil {
1535		invalidParams.Add(smithy.NewErrParamRequired("SourceStackId"))
1536	}
1537	if v.ServiceRoleArn == nil {
1538		invalidParams.Add(smithy.NewErrParamRequired("ServiceRoleArn"))
1539	}
1540	if invalidParams.Len() > 0 {
1541		return invalidParams
1542	} else {
1543		return nil
1544	}
1545}
1546
1547func validateOpCreateAppInput(v *CreateAppInput) error {
1548	if v == nil {
1549		return nil
1550	}
1551	invalidParams := smithy.InvalidParamsError{Context: "CreateAppInput"}
1552	if v.StackId == nil {
1553		invalidParams.Add(smithy.NewErrParamRequired("StackId"))
1554	}
1555	if v.Name == nil {
1556		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1557	}
1558	if len(v.Type) == 0 {
1559		invalidParams.Add(smithy.NewErrParamRequired("Type"))
1560	}
1561	if v.SslConfiguration != nil {
1562		if err := validateSslConfiguration(v.SslConfiguration); err != nil {
1563			invalidParams.AddNested("SslConfiguration", err.(smithy.InvalidParamsError))
1564		}
1565	}
1566	if v.Environment != nil {
1567		if err := validateEnvironmentVariables(v.Environment); err != nil {
1568			invalidParams.AddNested("Environment", err.(smithy.InvalidParamsError))
1569		}
1570	}
1571	if invalidParams.Len() > 0 {
1572		return invalidParams
1573	} else {
1574		return nil
1575	}
1576}
1577
1578func validateOpCreateDeploymentInput(v *CreateDeploymentInput) error {
1579	if v == nil {
1580		return nil
1581	}
1582	invalidParams := smithy.InvalidParamsError{Context: "CreateDeploymentInput"}
1583	if v.StackId == nil {
1584		invalidParams.Add(smithy.NewErrParamRequired("StackId"))
1585	}
1586	if v.Command == nil {
1587		invalidParams.Add(smithy.NewErrParamRequired("Command"))
1588	} else if v.Command != nil {
1589		if err := validateDeploymentCommand(v.Command); err != nil {
1590			invalidParams.AddNested("Command", err.(smithy.InvalidParamsError))
1591		}
1592	}
1593	if invalidParams.Len() > 0 {
1594		return invalidParams
1595	} else {
1596		return nil
1597	}
1598}
1599
1600func validateOpCreateInstanceInput(v *CreateInstanceInput) error {
1601	if v == nil {
1602		return nil
1603	}
1604	invalidParams := smithy.InvalidParamsError{Context: "CreateInstanceInput"}
1605	if v.StackId == nil {
1606		invalidParams.Add(smithy.NewErrParamRequired("StackId"))
1607	}
1608	if v.LayerIds == nil {
1609		invalidParams.Add(smithy.NewErrParamRequired("LayerIds"))
1610	}
1611	if v.InstanceType == nil {
1612		invalidParams.Add(smithy.NewErrParamRequired("InstanceType"))
1613	}
1614	if invalidParams.Len() > 0 {
1615		return invalidParams
1616	} else {
1617		return nil
1618	}
1619}
1620
1621func validateOpCreateLayerInput(v *CreateLayerInput) error {
1622	if v == nil {
1623		return nil
1624	}
1625	invalidParams := smithy.InvalidParamsError{Context: "CreateLayerInput"}
1626	if v.StackId == nil {
1627		invalidParams.Add(smithy.NewErrParamRequired("StackId"))
1628	}
1629	if len(v.Type) == 0 {
1630		invalidParams.Add(smithy.NewErrParamRequired("Type"))
1631	}
1632	if v.Name == nil {
1633		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1634	}
1635	if v.Shortname == nil {
1636		invalidParams.Add(smithy.NewErrParamRequired("Shortname"))
1637	}
1638	if v.VolumeConfigurations != nil {
1639		if err := validateVolumeConfigurations(v.VolumeConfigurations); err != nil {
1640			invalidParams.AddNested("VolumeConfigurations", err.(smithy.InvalidParamsError))
1641		}
1642	}
1643	if invalidParams.Len() > 0 {
1644		return invalidParams
1645	} else {
1646		return nil
1647	}
1648}
1649
1650func validateOpCreateStackInput(v *CreateStackInput) error {
1651	if v == nil {
1652		return nil
1653	}
1654	invalidParams := smithy.InvalidParamsError{Context: "CreateStackInput"}
1655	if v.Name == nil {
1656		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1657	}
1658	if v.Region == nil {
1659		invalidParams.Add(smithy.NewErrParamRequired("Region"))
1660	}
1661	if v.ServiceRoleArn == nil {
1662		invalidParams.Add(smithy.NewErrParamRequired("ServiceRoleArn"))
1663	}
1664	if v.DefaultInstanceProfileArn == nil {
1665		invalidParams.Add(smithy.NewErrParamRequired("DefaultInstanceProfileArn"))
1666	}
1667	if invalidParams.Len() > 0 {
1668		return invalidParams
1669	} else {
1670		return nil
1671	}
1672}
1673
1674func validateOpCreateUserProfileInput(v *CreateUserProfileInput) error {
1675	if v == nil {
1676		return nil
1677	}
1678	invalidParams := smithy.InvalidParamsError{Context: "CreateUserProfileInput"}
1679	if v.IamUserArn == nil {
1680		invalidParams.Add(smithy.NewErrParamRequired("IamUserArn"))
1681	}
1682	if invalidParams.Len() > 0 {
1683		return invalidParams
1684	} else {
1685		return nil
1686	}
1687}
1688
1689func validateOpDeleteAppInput(v *DeleteAppInput) error {
1690	if v == nil {
1691		return nil
1692	}
1693	invalidParams := smithy.InvalidParamsError{Context: "DeleteAppInput"}
1694	if v.AppId == nil {
1695		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1696	}
1697	if invalidParams.Len() > 0 {
1698		return invalidParams
1699	} else {
1700		return nil
1701	}
1702}
1703
1704func validateOpDeleteInstanceInput(v *DeleteInstanceInput) error {
1705	if v == nil {
1706		return nil
1707	}
1708	invalidParams := smithy.InvalidParamsError{Context: "DeleteInstanceInput"}
1709	if v.InstanceId == nil {
1710		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
1711	}
1712	if invalidParams.Len() > 0 {
1713		return invalidParams
1714	} else {
1715		return nil
1716	}
1717}
1718
1719func validateOpDeleteLayerInput(v *DeleteLayerInput) error {
1720	if v == nil {
1721		return nil
1722	}
1723	invalidParams := smithy.InvalidParamsError{Context: "DeleteLayerInput"}
1724	if v.LayerId == nil {
1725		invalidParams.Add(smithy.NewErrParamRequired("LayerId"))
1726	}
1727	if invalidParams.Len() > 0 {
1728		return invalidParams
1729	} else {
1730		return nil
1731	}
1732}
1733
1734func validateOpDeleteStackInput(v *DeleteStackInput) error {
1735	if v == nil {
1736		return nil
1737	}
1738	invalidParams := smithy.InvalidParamsError{Context: "DeleteStackInput"}
1739	if v.StackId == nil {
1740		invalidParams.Add(smithy.NewErrParamRequired("StackId"))
1741	}
1742	if invalidParams.Len() > 0 {
1743		return invalidParams
1744	} else {
1745		return nil
1746	}
1747}
1748
1749func validateOpDeleteUserProfileInput(v *DeleteUserProfileInput) error {
1750	if v == nil {
1751		return nil
1752	}
1753	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserProfileInput"}
1754	if v.IamUserArn == nil {
1755		invalidParams.Add(smithy.NewErrParamRequired("IamUserArn"))
1756	}
1757	if invalidParams.Len() > 0 {
1758		return invalidParams
1759	} else {
1760		return nil
1761	}
1762}
1763
1764func validateOpDeregisterEcsClusterInput(v *DeregisterEcsClusterInput) error {
1765	if v == nil {
1766		return nil
1767	}
1768	invalidParams := smithy.InvalidParamsError{Context: "DeregisterEcsClusterInput"}
1769	if v.EcsClusterArn == nil {
1770		invalidParams.Add(smithy.NewErrParamRequired("EcsClusterArn"))
1771	}
1772	if invalidParams.Len() > 0 {
1773		return invalidParams
1774	} else {
1775		return nil
1776	}
1777}
1778
1779func validateOpDeregisterElasticIpInput(v *DeregisterElasticIpInput) error {
1780	if v == nil {
1781		return nil
1782	}
1783	invalidParams := smithy.InvalidParamsError{Context: "DeregisterElasticIpInput"}
1784	if v.ElasticIp == nil {
1785		invalidParams.Add(smithy.NewErrParamRequired("ElasticIp"))
1786	}
1787	if invalidParams.Len() > 0 {
1788		return invalidParams
1789	} else {
1790		return nil
1791	}
1792}
1793
1794func validateOpDeregisterInstanceInput(v *DeregisterInstanceInput) error {
1795	if v == nil {
1796		return nil
1797	}
1798	invalidParams := smithy.InvalidParamsError{Context: "DeregisterInstanceInput"}
1799	if v.InstanceId == nil {
1800		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
1801	}
1802	if invalidParams.Len() > 0 {
1803		return invalidParams
1804	} else {
1805		return nil
1806	}
1807}
1808
1809func validateOpDeregisterRdsDbInstanceInput(v *DeregisterRdsDbInstanceInput) error {
1810	if v == nil {
1811		return nil
1812	}
1813	invalidParams := smithy.InvalidParamsError{Context: "DeregisterRdsDbInstanceInput"}
1814	if v.RdsDbInstanceArn == nil {
1815		invalidParams.Add(smithy.NewErrParamRequired("RdsDbInstanceArn"))
1816	}
1817	if invalidParams.Len() > 0 {
1818		return invalidParams
1819	} else {
1820		return nil
1821	}
1822}
1823
1824func validateOpDeregisterVolumeInput(v *DeregisterVolumeInput) error {
1825	if v == nil {
1826		return nil
1827	}
1828	invalidParams := smithy.InvalidParamsError{Context: "DeregisterVolumeInput"}
1829	if v.VolumeId == nil {
1830		invalidParams.Add(smithy.NewErrParamRequired("VolumeId"))
1831	}
1832	if invalidParams.Len() > 0 {
1833		return invalidParams
1834	} else {
1835		return nil
1836	}
1837}
1838
1839func validateOpDescribeLoadBasedAutoScalingInput(v *DescribeLoadBasedAutoScalingInput) error {
1840	if v == nil {
1841		return nil
1842	}
1843	invalidParams := smithy.InvalidParamsError{Context: "DescribeLoadBasedAutoScalingInput"}
1844	if v.LayerIds == nil {
1845		invalidParams.Add(smithy.NewErrParamRequired("LayerIds"))
1846	}
1847	if invalidParams.Len() > 0 {
1848		return invalidParams
1849	} else {
1850		return nil
1851	}
1852}
1853
1854func validateOpDescribeRdsDbInstancesInput(v *DescribeRdsDbInstancesInput) error {
1855	if v == nil {
1856		return nil
1857	}
1858	invalidParams := smithy.InvalidParamsError{Context: "DescribeRdsDbInstancesInput"}
1859	if v.StackId == nil {
1860		invalidParams.Add(smithy.NewErrParamRequired("StackId"))
1861	}
1862	if invalidParams.Len() > 0 {
1863		return invalidParams
1864	} else {
1865		return nil
1866	}
1867}
1868
1869func validateOpDescribeStackProvisioningParametersInput(v *DescribeStackProvisioningParametersInput) error {
1870	if v == nil {
1871		return nil
1872	}
1873	invalidParams := smithy.InvalidParamsError{Context: "DescribeStackProvisioningParametersInput"}
1874	if v.StackId == nil {
1875		invalidParams.Add(smithy.NewErrParamRequired("StackId"))
1876	}
1877	if invalidParams.Len() > 0 {
1878		return invalidParams
1879	} else {
1880		return nil
1881	}
1882}
1883
1884func validateOpDescribeStackSummaryInput(v *DescribeStackSummaryInput) error {
1885	if v == nil {
1886		return nil
1887	}
1888	invalidParams := smithy.InvalidParamsError{Context: "DescribeStackSummaryInput"}
1889	if v.StackId == nil {
1890		invalidParams.Add(smithy.NewErrParamRequired("StackId"))
1891	}
1892	if invalidParams.Len() > 0 {
1893		return invalidParams
1894	} else {
1895		return nil
1896	}
1897}
1898
1899func validateOpDescribeTimeBasedAutoScalingInput(v *DescribeTimeBasedAutoScalingInput) error {
1900	if v == nil {
1901		return nil
1902	}
1903	invalidParams := smithy.InvalidParamsError{Context: "DescribeTimeBasedAutoScalingInput"}
1904	if v.InstanceIds == nil {
1905		invalidParams.Add(smithy.NewErrParamRequired("InstanceIds"))
1906	}
1907	if invalidParams.Len() > 0 {
1908		return invalidParams
1909	} else {
1910		return nil
1911	}
1912}
1913
1914func validateOpDetachElasticLoadBalancerInput(v *DetachElasticLoadBalancerInput) error {
1915	if v == nil {
1916		return nil
1917	}
1918	invalidParams := smithy.InvalidParamsError{Context: "DetachElasticLoadBalancerInput"}
1919	if v.ElasticLoadBalancerName == nil {
1920		invalidParams.Add(smithy.NewErrParamRequired("ElasticLoadBalancerName"))
1921	}
1922	if v.LayerId == nil {
1923		invalidParams.Add(smithy.NewErrParamRequired("LayerId"))
1924	}
1925	if invalidParams.Len() > 0 {
1926		return invalidParams
1927	} else {
1928		return nil
1929	}
1930}
1931
1932func validateOpDisassociateElasticIpInput(v *DisassociateElasticIpInput) error {
1933	if v == nil {
1934		return nil
1935	}
1936	invalidParams := smithy.InvalidParamsError{Context: "DisassociateElasticIpInput"}
1937	if v.ElasticIp == nil {
1938		invalidParams.Add(smithy.NewErrParamRequired("ElasticIp"))
1939	}
1940	if invalidParams.Len() > 0 {
1941		return invalidParams
1942	} else {
1943		return nil
1944	}
1945}
1946
1947func validateOpGetHostnameSuggestionInput(v *GetHostnameSuggestionInput) error {
1948	if v == nil {
1949		return nil
1950	}
1951	invalidParams := smithy.InvalidParamsError{Context: "GetHostnameSuggestionInput"}
1952	if v.LayerId == nil {
1953		invalidParams.Add(smithy.NewErrParamRequired("LayerId"))
1954	}
1955	if invalidParams.Len() > 0 {
1956		return invalidParams
1957	} else {
1958		return nil
1959	}
1960}
1961
1962func validateOpGrantAccessInput(v *GrantAccessInput) error {
1963	if v == nil {
1964		return nil
1965	}
1966	invalidParams := smithy.InvalidParamsError{Context: "GrantAccessInput"}
1967	if v.InstanceId == nil {
1968		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
1969	}
1970	if invalidParams.Len() > 0 {
1971		return invalidParams
1972	} else {
1973		return nil
1974	}
1975}
1976
1977func validateOpListTagsInput(v *ListTagsInput) error {
1978	if v == nil {
1979		return nil
1980	}
1981	invalidParams := smithy.InvalidParamsError{Context: "ListTagsInput"}
1982	if v.ResourceArn == nil {
1983		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1984	}
1985	if invalidParams.Len() > 0 {
1986		return invalidParams
1987	} else {
1988		return nil
1989	}
1990}
1991
1992func validateOpRebootInstanceInput(v *RebootInstanceInput) error {
1993	if v == nil {
1994		return nil
1995	}
1996	invalidParams := smithy.InvalidParamsError{Context: "RebootInstanceInput"}
1997	if v.InstanceId == nil {
1998		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
1999	}
2000	if invalidParams.Len() > 0 {
2001		return invalidParams
2002	} else {
2003		return nil
2004	}
2005}
2006
2007func validateOpRegisterEcsClusterInput(v *RegisterEcsClusterInput) error {
2008	if v == nil {
2009		return nil
2010	}
2011	invalidParams := smithy.InvalidParamsError{Context: "RegisterEcsClusterInput"}
2012	if v.EcsClusterArn == nil {
2013		invalidParams.Add(smithy.NewErrParamRequired("EcsClusterArn"))
2014	}
2015	if v.StackId == nil {
2016		invalidParams.Add(smithy.NewErrParamRequired("StackId"))
2017	}
2018	if invalidParams.Len() > 0 {
2019		return invalidParams
2020	} else {
2021		return nil
2022	}
2023}
2024
2025func validateOpRegisterElasticIpInput(v *RegisterElasticIpInput) error {
2026	if v == nil {
2027		return nil
2028	}
2029	invalidParams := smithy.InvalidParamsError{Context: "RegisterElasticIpInput"}
2030	if v.ElasticIp == nil {
2031		invalidParams.Add(smithy.NewErrParamRequired("ElasticIp"))
2032	}
2033	if v.StackId == nil {
2034		invalidParams.Add(smithy.NewErrParamRequired("StackId"))
2035	}
2036	if invalidParams.Len() > 0 {
2037		return invalidParams
2038	} else {
2039		return nil
2040	}
2041}
2042
2043func validateOpRegisterInstanceInput(v *RegisterInstanceInput) error {
2044	if v == nil {
2045		return nil
2046	}
2047	invalidParams := smithy.InvalidParamsError{Context: "RegisterInstanceInput"}
2048	if v.StackId == nil {
2049		invalidParams.Add(smithy.NewErrParamRequired("StackId"))
2050	}
2051	if invalidParams.Len() > 0 {
2052		return invalidParams
2053	} else {
2054		return nil
2055	}
2056}
2057
2058func validateOpRegisterRdsDbInstanceInput(v *RegisterRdsDbInstanceInput) error {
2059	if v == nil {
2060		return nil
2061	}
2062	invalidParams := smithy.InvalidParamsError{Context: "RegisterRdsDbInstanceInput"}
2063	if v.StackId == nil {
2064		invalidParams.Add(smithy.NewErrParamRequired("StackId"))
2065	}
2066	if v.RdsDbInstanceArn == nil {
2067		invalidParams.Add(smithy.NewErrParamRequired("RdsDbInstanceArn"))
2068	}
2069	if v.DbUser == nil {
2070		invalidParams.Add(smithy.NewErrParamRequired("DbUser"))
2071	}
2072	if v.DbPassword == nil {
2073		invalidParams.Add(smithy.NewErrParamRequired("DbPassword"))
2074	}
2075	if invalidParams.Len() > 0 {
2076		return invalidParams
2077	} else {
2078		return nil
2079	}
2080}
2081
2082func validateOpRegisterVolumeInput(v *RegisterVolumeInput) error {
2083	if v == nil {
2084		return nil
2085	}
2086	invalidParams := smithy.InvalidParamsError{Context: "RegisterVolumeInput"}
2087	if v.StackId == nil {
2088		invalidParams.Add(smithy.NewErrParamRequired("StackId"))
2089	}
2090	if invalidParams.Len() > 0 {
2091		return invalidParams
2092	} else {
2093		return nil
2094	}
2095}
2096
2097func validateOpSetLoadBasedAutoScalingInput(v *SetLoadBasedAutoScalingInput) error {
2098	if v == nil {
2099		return nil
2100	}
2101	invalidParams := smithy.InvalidParamsError{Context: "SetLoadBasedAutoScalingInput"}
2102	if v.LayerId == nil {
2103		invalidParams.Add(smithy.NewErrParamRequired("LayerId"))
2104	}
2105	if invalidParams.Len() > 0 {
2106		return invalidParams
2107	} else {
2108		return nil
2109	}
2110}
2111
2112func validateOpSetPermissionInput(v *SetPermissionInput) error {
2113	if v == nil {
2114		return nil
2115	}
2116	invalidParams := smithy.InvalidParamsError{Context: "SetPermissionInput"}
2117	if v.StackId == nil {
2118		invalidParams.Add(smithy.NewErrParamRequired("StackId"))
2119	}
2120	if v.IamUserArn == nil {
2121		invalidParams.Add(smithy.NewErrParamRequired("IamUserArn"))
2122	}
2123	if invalidParams.Len() > 0 {
2124		return invalidParams
2125	} else {
2126		return nil
2127	}
2128}
2129
2130func validateOpSetTimeBasedAutoScalingInput(v *SetTimeBasedAutoScalingInput) error {
2131	if v == nil {
2132		return nil
2133	}
2134	invalidParams := smithy.InvalidParamsError{Context: "SetTimeBasedAutoScalingInput"}
2135	if v.InstanceId == nil {
2136		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
2137	}
2138	if invalidParams.Len() > 0 {
2139		return invalidParams
2140	} else {
2141		return nil
2142	}
2143}
2144
2145func validateOpStartInstanceInput(v *StartInstanceInput) error {
2146	if v == nil {
2147		return nil
2148	}
2149	invalidParams := smithy.InvalidParamsError{Context: "StartInstanceInput"}
2150	if v.InstanceId == nil {
2151		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
2152	}
2153	if invalidParams.Len() > 0 {
2154		return invalidParams
2155	} else {
2156		return nil
2157	}
2158}
2159
2160func validateOpStartStackInput(v *StartStackInput) error {
2161	if v == nil {
2162		return nil
2163	}
2164	invalidParams := smithy.InvalidParamsError{Context: "StartStackInput"}
2165	if v.StackId == nil {
2166		invalidParams.Add(smithy.NewErrParamRequired("StackId"))
2167	}
2168	if invalidParams.Len() > 0 {
2169		return invalidParams
2170	} else {
2171		return nil
2172	}
2173}
2174
2175func validateOpStopInstanceInput(v *StopInstanceInput) error {
2176	if v == nil {
2177		return nil
2178	}
2179	invalidParams := smithy.InvalidParamsError{Context: "StopInstanceInput"}
2180	if v.InstanceId == nil {
2181		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
2182	}
2183	if invalidParams.Len() > 0 {
2184		return invalidParams
2185	} else {
2186		return nil
2187	}
2188}
2189
2190func validateOpStopStackInput(v *StopStackInput) error {
2191	if v == nil {
2192		return nil
2193	}
2194	invalidParams := smithy.InvalidParamsError{Context: "StopStackInput"}
2195	if v.StackId == nil {
2196		invalidParams.Add(smithy.NewErrParamRequired("StackId"))
2197	}
2198	if invalidParams.Len() > 0 {
2199		return invalidParams
2200	} else {
2201		return nil
2202	}
2203}
2204
2205func validateOpTagResourceInput(v *TagResourceInput) error {
2206	if v == nil {
2207		return nil
2208	}
2209	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
2210	if v.ResourceArn == nil {
2211		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
2212	}
2213	if v.Tags == nil {
2214		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
2215	}
2216	if invalidParams.Len() > 0 {
2217		return invalidParams
2218	} else {
2219		return nil
2220	}
2221}
2222
2223func validateOpUnassignInstanceInput(v *UnassignInstanceInput) error {
2224	if v == nil {
2225		return nil
2226	}
2227	invalidParams := smithy.InvalidParamsError{Context: "UnassignInstanceInput"}
2228	if v.InstanceId == nil {
2229		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
2230	}
2231	if invalidParams.Len() > 0 {
2232		return invalidParams
2233	} else {
2234		return nil
2235	}
2236}
2237
2238func validateOpUnassignVolumeInput(v *UnassignVolumeInput) error {
2239	if v == nil {
2240		return nil
2241	}
2242	invalidParams := smithy.InvalidParamsError{Context: "UnassignVolumeInput"}
2243	if v.VolumeId == nil {
2244		invalidParams.Add(smithy.NewErrParamRequired("VolumeId"))
2245	}
2246	if invalidParams.Len() > 0 {
2247		return invalidParams
2248	} else {
2249		return nil
2250	}
2251}
2252
2253func validateOpUntagResourceInput(v *UntagResourceInput) error {
2254	if v == nil {
2255		return nil
2256	}
2257	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
2258	if v.ResourceArn == nil {
2259		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
2260	}
2261	if v.TagKeys == nil {
2262		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
2263	}
2264	if invalidParams.Len() > 0 {
2265		return invalidParams
2266	} else {
2267		return nil
2268	}
2269}
2270
2271func validateOpUpdateAppInput(v *UpdateAppInput) error {
2272	if v == nil {
2273		return nil
2274	}
2275	invalidParams := smithy.InvalidParamsError{Context: "UpdateAppInput"}
2276	if v.AppId == nil {
2277		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
2278	}
2279	if v.SslConfiguration != nil {
2280		if err := validateSslConfiguration(v.SslConfiguration); err != nil {
2281			invalidParams.AddNested("SslConfiguration", err.(smithy.InvalidParamsError))
2282		}
2283	}
2284	if v.Environment != nil {
2285		if err := validateEnvironmentVariables(v.Environment); err != nil {
2286			invalidParams.AddNested("Environment", err.(smithy.InvalidParamsError))
2287		}
2288	}
2289	if invalidParams.Len() > 0 {
2290		return invalidParams
2291	} else {
2292		return nil
2293	}
2294}
2295
2296func validateOpUpdateElasticIpInput(v *UpdateElasticIpInput) error {
2297	if v == nil {
2298		return nil
2299	}
2300	invalidParams := smithy.InvalidParamsError{Context: "UpdateElasticIpInput"}
2301	if v.ElasticIp == nil {
2302		invalidParams.Add(smithy.NewErrParamRequired("ElasticIp"))
2303	}
2304	if invalidParams.Len() > 0 {
2305		return invalidParams
2306	} else {
2307		return nil
2308	}
2309}
2310
2311func validateOpUpdateInstanceInput(v *UpdateInstanceInput) error {
2312	if v == nil {
2313		return nil
2314	}
2315	invalidParams := smithy.InvalidParamsError{Context: "UpdateInstanceInput"}
2316	if v.InstanceId == nil {
2317		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
2318	}
2319	if invalidParams.Len() > 0 {
2320		return invalidParams
2321	} else {
2322		return nil
2323	}
2324}
2325
2326func validateOpUpdateLayerInput(v *UpdateLayerInput) error {
2327	if v == nil {
2328		return nil
2329	}
2330	invalidParams := smithy.InvalidParamsError{Context: "UpdateLayerInput"}
2331	if v.LayerId == nil {
2332		invalidParams.Add(smithy.NewErrParamRequired("LayerId"))
2333	}
2334	if v.VolumeConfigurations != nil {
2335		if err := validateVolumeConfigurations(v.VolumeConfigurations); err != nil {
2336			invalidParams.AddNested("VolumeConfigurations", err.(smithy.InvalidParamsError))
2337		}
2338	}
2339	if invalidParams.Len() > 0 {
2340		return invalidParams
2341	} else {
2342		return nil
2343	}
2344}
2345
2346func validateOpUpdateRdsDbInstanceInput(v *UpdateRdsDbInstanceInput) error {
2347	if v == nil {
2348		return nil
2349	}
2350	invalidParams := smithy.InvalidParamsError{Context: "UpdateRdsDbInstanceInput"}
2351	if v.RdsDbInstanceArn == nil {
2352		invalidParams.Add(smithy.NewErrParamRequired("RdsDbInstanceArn"))
2353	}
2354	if invalidParams.Len() > 0 {
2355		return invalidParams
2356	} else {
2357		return nil
2358	}
2359}
2360
2361func validateOpUpdateStackInput(v *UpdateStackInput) error {
2362	if v == nil {
2363		return nil
2364	}
2365	invalidParams := smithy.InvalidParamsError{Context: "UpdateStackInput"}
2366	if v.StackId == nil {
2367		invalidParams.Add(smithy.NewErrParamRequired("StackId"))
2368	}
2369	if invalidParams.Len() > 0 {
2370		return invalidParams
2371	} else {
2372		return nil
2373	}
2374}
2375
2376func validateOpUpdateUserProfileInput(v *UpdateUserProfileInput) error {
2377	if v == nil {
2378		return nil
2379	}
2380	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserProfileInput"}
2381	if v.IamUserArn == nil {
2382		invalidParams.Add(smithy.NewErrParamRequired("IamUserArn"))
2383	}
2384	if invalidParams.Len() > 0 {
2385		return invalidParams
2386	} else {
2387		return nil
2388	}
2389}
2390
2391func validateOpUpdateVolumeInput(v *UpdateVolumeInput) error {
2392	if v == nil {
2393		return nil
2394	}
2395	invalidParams := smithy.InvalidParamsError{Context: "UpdateVolumeInput"}
2396	if v.VolumeId == nil {
2397		invalidParams.Add(smithy.NewErrParamRequired("VolumeId"))
2398	}
2399	if invalidParams.Len() > 0 {
2400		return invalidParams
2401	} else {
2402		return nil
2403	}
2404}
2405