1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package batch
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/batch/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpCancelJob struct {
14}
15
16func (*validateOpCancelJob) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpCancelJob) 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.(*CancelJobInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpCancelJobInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpCreateComputeEnvironment struct {
34}
35
36func (*validateOpCreateComputeEnvironment) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpCreateComputeEnvironment) 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.(*CreateComputeEnvironmentInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpCreateComputeEnvironmentInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpCreateJobQueue struct {
54}
55
56func (*validateOpCreateJobQueue) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpCreateJobQueue) 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.(*CreateJobQueueInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpCreateJobQueueInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpDeleteComputeEnvironment struct {
74}
75
76func (*validateOpDeleteComputeEnvironment) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpDeleteComputeEnvironment) 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.(*DeleteComputeEnvironmentInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpDeleteComputeEnvironmentInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpDeleteJobQueue struct {
94}
95
96func (*validateOpDeleteJobQueue) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpDeleteJobQueue) 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.(*DeleteJobQueueInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpDeleteJobQueueInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpDeregisterJobDefinition struct {
114}
115
116func (*validateOpDeregisterJobDefinition) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpDeregisterJobDefinition) 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.(*DeregisterJobDefinitionInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpDeregisterJobDefinitionInput(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 validateOpListTagsForResource struct {
154}
155
156func (*validateOpListTagsForResource) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpListTagsForResourceInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpRegisterJobDefinition struct {
174}
175
176func (*validateOpRegisterJobDefinition) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpRegisterJobDefinition) 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.(*RegisterJobDefinitionInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpRegisterJobDefinitionInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpSubmitJob struct {
194}
195
196func (*validateOpSubmitJob) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpSubmitJob) 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.(*SubmitJobInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpSubmitJobInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpTagResource struct {
214}
215
216func (*validateOpTagResource) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpTagResource) 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.(*TagResourceInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpTagResourceInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpTerminateJob struct {
234}
235
236func (*validateOpTerminateJob) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpTerminateJob) 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.(*TerminateJobInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpTerminateJobInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpUntagResource struct {
254}
255
256func (*validateOpUntagResource) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
261	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
262) {
263	input, ok := in.Parameters.(*UntagResourceInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpUntagResourceInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpUpdateComputeEnvironment struct {
274}
275
276func (*validateOpUpdateComputeEnvironment) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpUpdateComputeEnvironment) 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.(*UpdateComputeEnvironmentInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpUpdateComputeEnvironmentInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpUpdateJobQueue struct {
294}
295
296func (*validateOpUpdateJobQueue) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpUpdateJobQueue) 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.(*UpdateJobQueueInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpUpdateJobQueueInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313func addOpCancelJobValidationMiddleware(stack *middleware.Stack) error {
314	return stack.Initialize.Add(&validateOpCancelJob{}, middleware.After)
315}
316
317func addOpCreateComputeEnvironmentValidationMiddleware(stack *middleware.Stack) error {
318	return stack.Initialize.Add(&validateOpCreateComputeEnvironment{}, middleware.After)
319}
320
321func addOpCreateJobQueueValidationMiddleware(stack *middleware.Stack) error {
322	return stack.Initialize.Add(&validateOpCreateJobQueue{}, middleware.After)
323}
324
325func addOpDeleteComputeEnvironmentValidationMiddleware(stack *middleware.Stack) error {
326	return stack.Initialize.Add(&validateOpDeleteComputeEnvironment{}, middleware.After)
327}
328
329func addOpDeleteJobQueueValidationMiddleware(stack *middleware.Stack) error {
330	return stack.Initialize.Add(&validateOpDeleteJobQueue{}, middleware.After)
331}
332
333func addOpDeregisterJobDefinitionValidationMiddleware(stack *middleware.Stack) error {
334	return stack.Initialize.Add(&validateOpDeregisterJobDefinition{}, middleware.After)
335}
336
337func addOpDescribeJobsValidationMiddleware(stack *middleware.Stack) error {
338	return stack.Initialize.Add(&validateOpDescribeJobs{}, middleware.After)
339}
340
341func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
342	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
343}
344
345func addOpRegisterJobDefinitionValidationMiddleware(stack *middleware.Stack) error {
346	return stack.Initialize.Add(&validateOpRegisterJobDefinition{}, middleware.After)
347}
348
349func addOpSubmitJobValidationMiddleware(stack *middleware.Stack) error {
350	return stack.Initialize.Add(&validateOpSubmitJob{}, middleware.After)
351}
352
353func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
354	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
355}
356
357func addOpTerminateJobValidationMiddleware(stack *middleware.Stack) error {
358	return stack.Initialize.Add(&validateOpTerminateJob{}, middleware.After)
359}
360
361func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
362	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
363}
364
365func addOpUpdateComputeEnvironmentValidationMiddleware(stack *middleware.Stack) error {
366	return stack.Initialize.Add(&validateOpUpdateComputeEnvironment{}, middleware.After)
367}
368
369func addOpUpdateJobQueueValidationMiddleware(stack *middleware.Stack) error {
370	return stack.Initialize.Add(&validateOpUpdateJobQueue{}, middleware.After)
371}
372
373func validateComputeEnvironmentOrder(v *types.ComputeEnvironmentOrder) error {
374	if v == nil {
375		return nil
376	}
377	invalidParams := smithy.InvalidParamsError{Context: "ComputeEnvironmentOrder"}
378	if v.ComputeEnvironment == nil {
379		invalidParams.Add(smithy.NewErrParamRequired("ComputeEnvironment"))
380	}
381	if invalidParams.Len() > 0 {
382		return invalidParams
383	} else {
384		return nil
385	}
386}
387
388func validateComputeEnvironmentOrders(v []types.ComputeEnvironmentOrder) error {
389	if v == nil {
390		return nil
391	}
392	invalidParams := smithy.InvalidParamsError{Context: "ComputeEnvironmentOrders"}
393	for i := range v {
394		if err := validateComputeEnvironmentOrder(&v[i]); err != nil {
395			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
396		}
397	}
398	if invalidParams.Len() > 0 {
399		return invalidParams
400	} else {
401		return nil
402	}
403}
404
405func validateComputeResource(v *types.ComputeResource) error {
406	if v == nil {
407		return nil
408	}
409	invalidParams := smithy.InvalidParamsError{Context: "ComputeResource"}
410	if len(v.Type) == 0 {
411		invalidParams.Add(smithy.NewErrParamRequired("Type"))
412	}
413	if v.Subnets == nil {
414		invalidParams.Add(smithy.NewErrParamRequired("Subnets"))
415	}
416	if v.Ec2Configuration != nil {
417		if err := validateEc2ConfigurationList(v.Ec2Configuration); err != nil {
418			invalidParams.AddNested("Ec2Configuration", err.(smithy.InvalidParamsError))
419		}
420	}
421	if invalidParams.Len() > 0 {
422		return invalidParams
423	} else {
424		return nil
425	}
426}
427
428func validateContainerOverrides(v *types.ContainerOverrides) error {
429	if v == nil {
430		return nil
431	}
432	invalidParams := smithy.InvalidParamsError{Context: "ContainerOverrides"}
433	if v.ResourceRequirements != nil {
434		if err := validateResourceRequirements(v.ResourceRequirements); err != nil {
435			invalidParams.AddNested("ResourceRequirements", err.(smithy.InvalidParamsError))
436		}
437	}
438	if invalidParams.Len() > 0 {
439		return invalidParams
440	} else {
441		return nil
442	}
443}
444
445func validateContainerProperties(v *types.ContainerProperties) error {
446	if v == nil {
447		return nil
448	}
449	invalidParams := smithy.InvalidParamsError{Context: "ContainerProperties"}
450	if v.Ulimits != nil {
451		if err := validateUlimits(v.Ulimits); err != nil {
452			invalidParams.AddNested("Ulimits", err.(smithy.InvalidParamsError))
453		}
454	}
455	if v.ResourceRequirements != nil {
456		if err := validateResourceRequirements(v.ResourceRequirements); err != nil {
457			invalidParams.AddNested("ResourceRequirements", err.(smithy.InvalidParamsError))
458		}
459	}
460	if v.LinuxParameters != nil {
461		if err := validateLinuxParameters(v.LinuxParameters); err != nil {
462			invalidParams.AddNested("LinuxParameters", err.(smithy.InvalidParamsError))
463		}
464	}
465	if v.LogConfiguration != nil {
466		if err := validateLogConfiguration(v.LogConfiguration); err != nil {
467			invalidParams.AddNested("LogConfiguration", err.(smithy.InvalidParamsError))
468		}
469	}
470	if v.Secrets != nil {
471		if err := validateSecretList(v.Secrets); err != nil {
472			invalidParams.AddNested("Secrets", err.(smithy.InvalidParamsError))
473		}
474	}
475	if invalidParams.Len() > 0 {
476		return invalidParams
477	} else {
478		return nil
479	}
480}
481
482func validateDevice(v *types.Device) error {
483	if v == nil {
484		return nil
485	}
486	invalidParams := smithy.InvalidParamsError{Context: "Device"}
487	if v.HostPath == nil {
488		invalidParams.Add(smithy.NewErrParamRequired("HostPath"))
489	}
490	if invalidParams.Len() > 0 {
491		return invalidParams
492	} else {
493		return nil
494	}
495}
496
497func validateDevicesList(v []types.Device) error {
498	if v == nil {
499		return nil
500	}
501	invalidParams := smithy.InvalidParamsError{Context: "DevicesList"}
502	for i := range v {
503		if err := validateDevice(&v[i]); err != nil {
504			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
505		}
506	}
507	if invalidParams.Len() > 0 {
508		return invalidParams
509	} else {
510		return nil
511	}
512}
513
514func validateEc2Configuration(v *types.Ec2Configuration) error {
515	if v == nil {
516		return nil
517	}
518	invalidParams := smithy.InvalidParamsError{Context: "Ec2Configuration"}
519	if v.ImageType == nil {
520		invalidParams.Add(smithy.NewErrParamRequired("ImageType"))
521	}
522	if invalidParams.Len() > 0 {
523		return invalidParams
524	} else {
525		return nil
526	}
527}
528
529func validateEc2ConfigurationList(v []types.Ec2Configuration) error {
530	if v == nil {
531		return nil
532	}
533	invalidParams := smithy.InvalidParamsError{Context: "Ec2ConfigurationList"}
534	for i := range v {
535		if err := validateEc2Configuration(&v[i]); err != nil {
536			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
537		}
538	}
539	if invalidParams.Len() > 0 {
540		return invalidParams
541	} else {
542		return nil
543	}
544}
545
546func validateEvaluateOnExit(v *types.EvaluateOnExit) error {
547	if v == nil {
548		return nil
549	}
550	invalidParams := smithy.InvalidParamsError{Context: "EvaluateOnExit"}
551	if len(v.Action) == 0 {
552		invalidParams.Add(smithy.NewErrParamRequired("Action"))
553	}
554	if invalidParams.Len() > 0 {
555		return invalidParams
556	} else {
557		return nil
558	}
559}
560
561func validateEvaluateOnExitList(v []types.EvaluateOnExit) error {
562	if v == nil {
563		return nil
564	}
565	invalidParams := smithy.InvalidParamsError{Context: "EvaluateOnExitList"}
566	for i := range v {
567		if err := validateEvaluateOnExit(&v[i]); err != nil {
568			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
569		}
570	}
571	if invalidParams.Len() > 0 {
572		return invalidParams
573	} else {
574		return nil
575	}
576}
577
578func validateLinuxParameters(v *types.LinuxParameters) error {
579	if v == nil {
580		return nil
581	}
582	invalidParams := smithy.InvalidParamsError{Context: "LinuxParameters"}
583	if v.Devices != nil {
584		if err := validateDevicesList(v.Devices); err != nil {
585			invalidParams.AddNested("Devices", err.(smithy.InvalidParamsError))
586		}
587	}
588	if v.Tmpfs != nil {
589		if err := validateTmpfsList(v.Tmpfs); err != nil {
590			invalidParams.AddNested("Tmpfs", err.(smithy.InvalidParamsError))
591		}
592	}
593	if invalidParams.Len() > 0 {
594		return invalidParams
595	} else {
596		return nil
597	}
598}
599
600func validateLogConfiguration(v *types.LogConfiguration) error {
601	if v == nil {
602		return nil
603	}
604	invalidParams := smithy.InvalidParamsError{Context: "LogConfiguration"}
605	if len(v.LogDriver) == 0 {
606		invalidParams.Add(smithy.NewErrParamRequired("LogDriver"))
607	}
608	if v.SecretOptions != nil {
609		if err := validateSecretList(v.SecretOptions); err != nil {
610			invalidParams.AddNested("SecretOptions", err.(smithy.InvalidParamsError))
611		}
612	}
613	if invalidParams.Len() > 0 {
614		return invalidParams
615	} else {
616		return nil
617	}
618}
619
620func validateNodeOverrides(v *types.NodeOverrides) error {
621	if v == nil {
622		return nil
623	}
624	invalidParams := smithy.InvalidParamsError{Context: "NodeOverrides"}
625	if v.NodePropertyOverrides != nil {
626		if err := validateNodePropertyOverrides(v.NodePropertyOverrides); err != nil {
627			invalidParams.AddNested("NodePropertyOverrides", err.(smithy.InvalidParamsError))
628		}
629	}
630	if invalidParams.Len() > 0 {
631		return invalidParams
632	} else {
633		return nil
634	}
635}
636
637func validateNodeProperties(v *types.NodeProperties) error {
638	if v == nil {
639		return nil
640	}
641	invalidParams := smithy.InvalidParamsError{Context: "NodeProperties"}
642	if v.NodeRangeProperties == nil {
643		invalidParams.Add(smithy.NewErrParamRequired("NodeRangeProperties"))
644	} else if v.NodeRangeProperties != nil {
645		if err := validateNodeRangeProperties(v.NodeRangeProperties); err != nil {
646			invalidParams.AddNested("NodeRangeProperties", err.(smithy.InvalidParamsError))
647		}
648	}
649	if invalidParams.Len() > 0 {
650		return invalidParams
651	} else {
652		return nil
653	}
654}
655
656func validateNodePropertyOverride(v *types.NodePropertyOverride) error {
657	if v == nil {
658		return nil
659	}
660	invalidParams := smithy.InvalidParamsError{Context: "NodePropertyOverride"}
661	if v.TargetNodes == nil {
662		invalidParams.Add(smithy.NewErrParamRequired("TargetNodes"))
663	}
664	if v.ContainerOverrides != nil {
665		if err := validateContainerOverrides(v.ContainerOverrides); err != nil {
666			invalidParams.AddNested("ContainerOverrides", err.(smithy.InvalidParamsError))
667		}
668	}
669	if invalidParams.Len() > 0 {
670		return invalidParams
671	} else {
672		return nil
673	}
674}
675
676func validateNodePropertyOverrides(v []types.NodePropertyOverride) error {
677	if v == nil {
678		return nil
679	}
680	invalidParams := smithy.InvalidParamsError{Context: "NodePropertyOverrides"}
681	for i := range v {
682		if err := validateNodePropertyOverride(&v[i]); err != nil {
683			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
684		}
685	}
686	if invalidParams.Len() > 0 {
687		return invalidParams
688	} else {
689		return nil
690	}
691}
692
693func validateNodeRangeProperties(v []types.NodeRangeProperty) error {
694	if v == nil {
695		return nil
696	}
697	invalidParams := smithy.InvalidParamsError{Context: "NodeRangeProperties"}
698	for i := range v {
699		if err := validateNodeRangeProperty(&v[i]); err != nil {
700			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
701		}
702	}
703	if invalidParams.Len() > 0 {
704		return invalidParams
705	} else {
706		return nil
707	}
708}
709
710func validateNodeRangeProperty(v *types.NodeRangeProperty) error {
711	if v == nil {
712		return nil
713	}
714	invalidParams := smithy.InvalidParamsError{Context: "NodeRangeProperty"}
715	if v.TargetNodes == nil {
716		invalidParams.Add(smithy.NewErrParamRequired("TargetNodes"))
717	}
718	if v.Container != nil {
719		if err := validateContainerProperties(v.Container); err != nil {
720			invalidParams.AddNested("Container", err.(smithy.InvalidParamsError))
721		}
722	}
723	if invalidParams.Len() > 0 {
724		return invalidParams
725	} else {
726		return nil
727	}
728}
729
730func validateResourceRequirement(v *types.ResourceRequirement) error {
731	if v == nil {
732		return nil
733	}
734	invalidParams := smithy.InvalidParamsError{Context: "ResourceRequirement"}
735	if v.Value == nil {
736		invalidParams.Add(smithy.NewErrParamRequired("Value"))
737	}
738	if len(v.Type) == 0 {
739		invalidParams.Add(smithy.NewErrParamRequired("Type"))
740	}
741	if invalidParams.Len() > 0 {
742		return invalidParams
743	} else {
744		return nil
745	}
746}
747
748func validateResourceRequirements(v []types.ResourceRequirement) error {
749	if v == nil {
750		return nil
751	}
752	invalidParams := smithy.InvalidParamsError{Context: "ResourceRequirements"}
753	for i := range v {
754		if err := validateResourceRequirement(&v[i]); err != nil {
755			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
756		}
757	}
758	if invalidParams.Len() > 0 {
759		return invalidParams
760	} else {
761		return nil
762	}
763}
764
765func validateRetryStrategy(v *types.RetryStrategy) error {
766	if v == nil {
767		return nil
768	}
769	invalidParams := smithy.InvalidParamsError{Context: "RetryStrategy"}
770	if v.EvaluateOnExit != nil {
771		if err := validateEvaluateOnExitList(v.EvaluateOnExit); err != nil {
772			invalidParams.AddNested("EvaluateOnExit", err.(smithy.InvalidParamsError))
773		}
774	}
775	if invalidParams.Len() > 0 {
776		return invalidParams
777	} else {
778		return nil
779	}
780}
781
782func validateSecret(v *types.Secret) error {
783	if v == nil {
784		return nil
785	}
786	invalidParams := smithy.InvalidParamsError{Context: "Secret"}
787	if v.Name == nil {
788		invalidParams.Add(smithy.NewErrParamRequired("Name"))
789	}
790	if v.ValueFrom == nil {
791		invalidParams.Add(smithy.NewErrParamRequired("ValueFrom"))
792	}
793	if invalidParams.Len() > 0 {
794		return invalidParams
795	} else {
796		return nil
797	}
798}
799
800func validateSecretList(v []types.Secret) error {
801	if v == nil {
802		return nil
803	}
804	invalidParams := smithy.InvalidParamsError{Context: "SecretList"}
805	for i := range v {
806		if err := validateSecret(&v[i]); err != nil {
807			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
808		}
809	}
810	if invalidParams.Len() > 0 {
811		return invalidParams
812	} else {
813		return nil
814	}
815}
816
817func validateTmpfs(v *types.Tmpfs) error {
818	if v == nil {
819		return nil
820	}
821	invalidParams := smithy.InvalidParamsError{Context: "Tmpfs"}
822	if v.ContainerPath == nil {
823		invalidParams.Add(smithy.NewErrParamRequired("ContainerPath"))
824	}
825	if invalidParams.Len() > 0 {
826		return invalidParams
827	} else {
828		return nil
829	}
830}
831
832func validateTmpfsList(v []types.Tmpfs) error {
833	if v == nil {
834		return nil
835	}
836	invalidParams := smithy.InvalidParamsError{Context: "TmpfsList"}
837	for i := range v {
838		if err := validateTmpfs(&v[i]); err != nil {
839			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
840		}
841	}
842	if invalidParams.Len() > 0 {
843		return invalidParams
844	} else {
845		return nil
846	}
847}
848
849func validateUlimit(v *types.Ulimit) error {
850	if v == nil {
851		return nil
852	}
853	invalidParams := smithy.InvalidParamsError{Context: "Ulimit"}
854	if v.Name == nil {
855		invalidParams.Add(smithy.NewErrParamRequired("Name"))
856	}
857	if invalidParams.Len() > 0 {
858		return invalidParams
859	} else {
860		return nil
861	}
862}
863
864func validateUlimits(v []types.Ulimit) error {
865	if v == nil {
866		return nil
867	}
868	invalidParams := smithy.InvalidParamsError{Context: "Ulimits"}
869	for i := range v {
870		if err := validateUlimit(&v[i]); err != nil {
871			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
872		}
873	}
874	if invalidParams.Len() > 0 {
875		return invalidParams
876	} else {
877		return nil
878	}
879}
880
881func validateOpCancelJobInput(v *CancelJobInput) error {
882	if v == nil {
883		return nil
884	}
885	invalidParams := smithy.InvalidParamsError{Context: "CancelJobInput"}
886	if v.JobId == nil {
887		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
888	}
889	if v.Reason == nil {
890		invalidParams.Add(smithy.NewErrParamRequired("Reason"))
891	}
892	if invalidParams.Len() > 0 {
893		return invalidParams
894	} else {
895		return nil
896	}
897}
898
899func validateOpCreateComputeEnvironmentInput(v *CreateComputeEnvironmentInput) error {
900	if v == nil {
901		return nil
902	}
903	invalidParams := smithy.InvalidParamsError{Context: "CreateComputeEnvironmentInput"}
904	if v.ComputeEnvironmentName == nil {
905		invalidParams.Add(smithy.NewErrParamRequired("ComputeEnvironmentName"))
906	}
907	if len(v.Type) == 0 {
908		invalidParams.Add(smithy.NewErrParamRequired("Type"))
909	}
910	if v.ComputeResources != nil {
911		if err := validateComputeResource(v.ComputeResources); err != nil {
912			invalidParams.AddNested("ComputeResources", err.(smithy.InvalidParamsError))
913		}
914	}
915	if v.ServiceRole == nil {
916		invalidParams.Add(smithy.NewErrParamRequired("ServiceRole"))
917	}
918	if invalidParams.Len() > 0 {
919		return invalidParams
920	} else {
921		return nil
922	}
923}
924
925func validateOpCreateJobQueueInput(v *CreateJobQueueInput) error {
926	if v == nil {
927		return nil
928	}
929	invalidParams := smithy.InvalidParamsError{Context: "CreateJobQueueInput"}
930	if v.JobQueueName == nil {
931		invalidParams.Add(smithy.NewErrParamRequired("JobQueueName"))
932	}
933	if v.ComputeEnvironmentOrder == nil {
934		invalidParams.Add(smithy.NewErrParamRequired("ComputeEnvironmentOrder"))
935	} else if v.ComputeEnvironmentOrder != nil {
936		if err := validateComputeEnvironmentOrders(v.ComputeEnvironmentOrder); err != nil {
937			invalidParams.AddNested("ComputeEnvironmentOrder", err.(smithy.InvalidParamsError))
938		}
939	}
940	if invalidParams.Len() > 0 {
941		return invalidParams
942	} else {
943		return nil
944	}
945}
946
947func validateOpDeleteComputeEnvironmentInput(v *DeleteComputeEnvironmentInput) error {
948	if v == nil {
949		return nil
950	}
951	invalidParams := smithy.InvalidParamsError{Context: "DeleteComputeEnvironmentInput"}
952	if v.ComputeEnvironment == nil {
953		invalidParams.Add(smithy.NewErrParamRequired("ComputeEnvironment"))
954	}
955	if invalidParams.Len() > 0 {
956		return invalidParams
957	} else {
958		return nil
959	}
960}
961
962func validateOpDeleteJobQueueInput(v *DeleteJobQueueInput) error {
963	if v == nil {
964		return nil
965	}
966	invalidParams := smithy.InvalidParamsError{Context: "DeleteJobQueueInput"}
967	if v.JobQueue == nil {
968		invalidParams.Add(smithy.NewErrParamRequired("JobQueue"))
969	}
970	if invalidParams.Len() > 0 {
971		return invalidParams
972	} else {
973		return nil
974	}
975}
976
977func validateOpDeregisterJobDefinitionInput(v *DeregisterJobDefinitionInput) error {
978	if v == nil {
979		return nil
980	}
981	invalidParams := smithy.InvalidParamsError{Context: "DeregisterJobDefinitionInput"}
982	if v.JobDefinition == nil {
983		invalidParams.Add(smithy.NewErrParamRequired("JobDefinition"))
984	}
985	if invalidParams.Len() > 0 {
986		return invalidParams
987	} else {
988		return nil
989	}
990}
991
992func validateOpDescribeJobsInput(v *DescribeJobsInput) error {
993	if v == nil {
994		return nil
995	}
996	invalidParams := smithy.InvalidParamsError{Context: "DescribeJobsInput"}
997	if v.Jobs == nil {
998		invalidParams.Add(smithy.NewErrParamRequired("Jobs"))
999	}
1000	if invalidParams.Len() > 0 {
1001		return invalidParams
1002	} else {
1003		return nil
1004	}
1005}
1006
1007func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
1008	if v == nil {
1009		return nil
1010	}
1011	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
1012	if v.ResourceArn == nil {
1013		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1014	}
1015	if invalidParams.Len() > 0 {
1016		return invalidParams
1017	} else {
1018		return nil
1019	}
1020}
1021
1022func validateOpRegisterJobDefinitionInput(v *RegisterJobDefinitionInput) error {
1023	if v == nil {
1024		return nil
1025	}
1026	invalidParams := smithy.InvalidParamsError{Context: "RegisterJobDefinitionInput"}
1027	if v.JobDefinitionName == nil {
1028		invalidParams.Add(smithy.NewErrParamRequired("JobDefinitionName"))
1029	}
1030	if len(v.Type) == 0 {
1031		invalidParams.Add(smithy.NewErrParamRequired("Type"))
1032	}
1033	if v.ContainerProperties != nil {
1034		if err := validateContainerProperties(v.ContainerProperties); err != nil {
1035			invalidParams.AddNested("ContainerProperties", err.(smithy.InvalidParamsError))
1036		}
1037	}
1038	if v.NodeProperties != nil {
1039		if err := validateNodeProperties(v.NodeProperties); err != nil {
1040			invalidParams.AddNested("NodeProperties", err.(smithy.InvalidParamsError))
1041		}
1042	}
1043	if v.RetryStrategy != nil {
1044		if err := validateRetryStrategy(v.RetryStrategy); err != nil {
1045			invalidParams.AddNested("RetryStrategy", err.(smithy.InvalidParamsError))
1046		}
1047	}
1048	if invalidParams.Len() > 0 {
1049		return invalidParams
1050	} else {
1051		return nil
1052	}
1053}
1054
1055func validateOpSubmitJobInput(v *SubmitJobInput) error {
1056	if v == nil {
1057		return nil
1058	}
1059	invalidParams := smithy.InvalidParamsError{Context: "SubmitJobInput"}
1060	if v.JobName == nil {
1061		invalidParams.Add(smithy.NewErrParamRequired("JobName"))
1062	}
1063	if v.JobQueue == nil {
1064		invalidParams.Add(smithy.NewErrParamRequired("JobQueue"))
1065	}
1066	if v.JobDefinition == nil {
1067		invalidParams.Add(smithy.NewErrParamRequired("JobDefinition"))
1068	}
1069	if v.ContainerOverrides != nil {
1070		if err := validateContainerOverrides(v.ContainerOverrides); err != nil {
1071			invalidParams.AddNested("ContainerOverrides", err.(smithy.InvalidParamsError))
1072		}
1073	}
1074	if v.NodeOverrides != nil {
1075		if err := validateNodeOverrides(v.NodeOverrides); err != nil {
1076			invalidParams.AddNested("NodeOverrides", err.(smithy.InvalidParamsError))
1077		}
1078	}
1079	if v.RetryStrategy != nil {
1080		if err := validateRetryStrategy(v.RetryStrategy); err != nil {
1081			invalidParams.AddNested("RetryStrategy", err.(smithy.InvalidParamsError))
1082		}
1083	}
1084	if invalidParams.Len() > 0 {
1085		return invalidParams
1086	} else {
1087		return nil
1088	}
1089}
1090
1091func validateOpTagResourceInput(v *TagResourceInput) error {
1092	if v == nil {
1093		return nil
1094	}
1095	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
1096	if v.ResourceArn == nil {
1097		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1098	}
1099	if v.Tags == nil {
1100		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
1101	}
1102	if invalidParams.Len() > 0 {
1103		return invalidParams
1104	} else {
1105		return nil
1106	}
1107}
1108
1109func validateOpTerminateJobInput(v *TerminateJobInput) error {
1110	if v == nil {
1111		return nil
1112	}
1113	invalidParams := smithy.InvalidParamsError{Context: "TerminateJobInput"}
1114	if v.JobId == nil {
1115		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
1116	}
1117	if v.Reason == nil {
1118		invalidParams.Add(smithy.NewErrParamRequired("Reason"))
1119	}
1120	if invalidParams.Len() > 0 {
1121		return invalidParams
1122	} else {
1123		return nil
1124	}
1125}
1126
1127func validateOpUntagResourceInput(v *UntagResourceInput) error {
1128	if v == nil {
1129		return nil
1130	}
1131	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
1132	if v.ResourceArn == nil {
1133		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1134	}
1135	if v.TagKeys == nil {
1136		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
1137	}
1138	if invalidParams.Len() > 0 {
1139		return invalidParams
1140	} else {
1141		return nil
1142	}
1143}
1144
1145func validateOpUpdateComputeEnvironmentInput(v *UpdateComputeEnvironmentInput) error {
1146	if v == nil {
1147		return nil
1148	}
1149	invalidParams := smithy.InvalidParamsError{Context: "UpdateComputeEnvironmentInput"}
1150	if v.ComputeEnvironment == nil {
1151		invalidParams.Add(smithy.NewErrParamRequired("ComputeEnvironment"))
1152	}
1153	if invalidParams.Len() > 0 {
1154		return invalidParams
1155	} else {
1156		return nil
1157	}
1158}
1159
1160func validateOpUpdateJobQueueInput(v *UpdateJobQueueInput) error {
1161	if v == nil {
1162		return nil
1163	}
1164	invalidParams := smithy.InvalidParamsError{Context: "UpdateJobQueueInput"}
1165	if v.JobQueue == nil {
1166		invalidParams.Add(smithy.NewErrParamRequired("JobQueue"))
1167	}
1168	if v.ComputeEnvironmentOrder != nil {
1169		if err := validateComputeEnvironmentOrders(v.ComputeEnvironmentOrder); err != nil {
1170			invalidParams.AddNested("ComputeEnvironmentOrder", err.(smithy.InvalidParamsError))
1171		}
1172	}
1173	if invalidParams.Len() > 0 {
1174		return invalidParams
1175	} else {
1176		return nil
1177	}
1178}
1179