1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package datapipeline
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/datapipeline/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpActivatePipeline struct {
14}
15
16func (*validateOpActivatePipeline) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpActivatePipeline) 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.(*ActivatePipelineInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpActivatePipelineInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpAddTags struct {
34}
35
36func (*validateOpAddTags) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpAddTags) 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.(*AddTagsInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpAddTagsInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpCreatePipeline struct {
54}
55
56func (*validateOpCreatePipeline) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpCreatePipeline) 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.(*CreatePipelineInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpCreatePipelineInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpDeactivatePipeline struct {
74}
75
76func (*validateOpDeactivatePipeline) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpDeactivatePipeline) 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.(*DeactivatePipelineInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpDeactivatePipelineInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpDeletePipeline struct {
94}
95
96func (*validateOpDeletePipeline) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpDeletePipeline) 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.(*DeletePipelineInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpDeletePipelineInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpDescribeObjects struct {
114}
115
116func (*validateOpDescribeObjects) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpDescribeObjects) 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.(*DescribeObjectsInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpDescribeObjectsInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpDescribePipelines struct {
134}
135
136func (*validateOpDescribePipelines) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpDescribePipelines) 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.(*DescribePipelinesInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpDescribePipelinesInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpEvaluateExpression struct {
154}
155
156func (*validateOpEvaluateExpression) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpEvaluateExpression) 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.(*EvaluateExpressionInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpEvaluateExpressionInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpGetPipelineDefinition struct {
174}
175
176func (*validateOpGetPipelineDefinition) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpGetPipelineDefinition) 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.(*GetPipelineDefinitionInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpGetPipelineDefinitionInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpPollForTask struct {
194}
195
196func (*validateOpPollForTask) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpPollForTask) 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.(*PollForTaskInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpPollForTaskInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpPutPipelineDefinition struct {
214}
215
216func (*validateOpPutPipelineDefinition) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpPutPipelineDefinition) 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.(*PutPipelineDefinitionInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpPutPipelineDefinitionInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpQueryObjects struct {
234}
235
236func (*validateOpQueryObjects) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpQueryObjects) 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.(*QueryObjectsInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpQueryObjectsInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpRemoveTags struct {
254}
255
256func (*validateOpRemoveTags) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpRemoveTags) 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.(*RemoveTagsInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpRemoveTagsInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpReportTaskProgress struct {
274}
275
276func (*validateOpReportTaskProgress) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpReportTaskProgress) 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.(*ReportTaskProgressInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpReportTaskProgressInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpReportTaskRunnerHeartbeat struct {
294}
295
296func (*validateOpReportTaskRunnerHeartbeat) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpReportTaskRunnerHeartbeat) 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.(*ReportTaskRunnerHeartbeatInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpReportTaskRunnerHeartbeatInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpSetStatus struct {
314}
315
316func (*validateOpSetStatus) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpSetStatus) 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.(*SetStatusInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpSetStatusInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpSetTaskStatus struct {
334}
335
336func (*validateOpSetTaskStatus) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpSetTaskStatus) 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.(*SetTaskStatusInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpSetTaskStatusInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpValidatePipelineDefinition struct {
354}
355
356func (*validateOpValidatePipelineDefinition) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpValidatePipelineDefinition) 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.(*ValidatePipelineDefinitionInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpValidatePipelineDefinitionInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373func addOpActivatePipelineValidationMiddleware(stack *middleware.Stack) error {
374	return stack.Initialize.Add(&validateOpActivatePipeline{}, middleware.After)
375}
376
377func addOpAddTagsValidationMiddleware(stack *middleware.Stack) error {
378	return stack.Initialize.Add(&validateOpAddTags{}, middleware.After)
379}
380
381func addOpCreatePipelineValidationMiddleware(stack *middleware.Stack) error {
382	return stack.Initialize.Add(&validateOpCreatePipeline{}, middleware.After)
383}
384
385func addOpDeactivatePipelineValidationMiddleware(stack *middleware.Stack) error {
386	return stack.Initialize.Add(&validateOpDeactivatePipeline{}, middleware.After)
387}
388
389func addOpDeletePipelineValidationMiddleware(stack *middleware.Stack) error {
390	return stack.Initialize.Add(&validateOpDeletePipeline{}, middleware.After)
391}
392
393func addOpDescribeObjectsValidationMiddleware(stack *middleware.Stack) error {
394	return stack.Initialize.Add(&validateOpDescribeObjects{}, middleware.After)
395}
396
397func addOpDescribePipelinesValidationMiddleware(stack *middleware.Stack) error {
398	return stack.Initialize.Add(&validateOpDescribePipelines{}, middleware.After)
399}
400
401func addOpEvaluateExpressionValidationMiddleware(stack *middleware.Stack) error {
402	return stack.Initialize.Add(&validateOpEvaluateExpression{}, middleware.After)
403}
404
405func addOpGetPipelineDefinitionValidationMiddleware(stack *middleware.Stack) error {
406	return stack.Initialize.Add(&validateOpGetPipelineDefinition{}, middleware.After)
407}
408
409func addOpPollForTaskValidationMiddleware(stack *middleware.Stack) error {
410	return stack.Initialize.Add(&validateOpPollForTask{}, middleware.After)
411}
412
413func addOpPutPipelineDefinitionValidationMiddleware(stack *middleware.Stack) error {
414	return stack.Initialize.Add(&validateOpPutPipelineDefinition{}, middleware.After)
415}
416
417func addOpQueryObjectsValidationMiddleware(stack *middleware.Stack) error {
418	return stack.Initialize.Add(&validateOpQueryObjects{}, middleware.After)
419}
420
421func addOpRemoveTagsValidationMiddleware(stack *middleware.Stack) error {
422	return stack.Initialize.Add(&validateOpRemoveTags{}, middleware.After)
423}
424
425func addOpReportTaskProgressValidationMiddleware(stack *middleware.Stack) error {
426	return stack.Initialize.Add(&validateOpReportTaskProgress{}, middleware.After)
427}
428
429func addOpReportTaskRunnerHeartbeatValidationMiddleware(stack *middleware.Stack) error {
430	return stack.Initialize.Add(&validateOpReportTaskRunnerHeartbeat{}, middleware.After)
431}
432
433func addOpSetStatusValidationMiddleware(stack *middleware.Stack) error {
434	return stack.Initialize.Add(&validateOpSetStatus{}, middleware.After)
435}
436
437func addOpSetTaskStatusValidationMiddleware(stack *middleware.Stack) error {
438	return stack.Initialize.Add(&validateOpSetTaskStatus{}, middleware.After)
439}
440
441func addOpValidatePipelineDefinitionValidationMiddleware(stack *middleware.Stack) error {
442	return stack.Initialize.Add(&validateOpValidatePipelineDefinition{}, middleware.After)
443}
444
445func validateField(v *types.Field) error {
446	if v == nil {
447		return nil
448	}
449	invalidParams := smithy.InvalidParamsError{Context: "Field"}
450	if v.Key == nil {
451		invalidParams.Add(smithy.NewErrParamRequired("Key"))
452	}
453	if invalidParams.Len() > 0 {
454		return invalidParams
455	} else {
456		return nil
457	}
458}
459
460func validateFieldList(v []types.Field) error {
461	if v == nil {
462		return nil
463	}
464	invalidParams := smithy.InvalidParamsError{Context: "FieldList"}
465	for i := range v {
466		if err := validateField(&v[i]); err != nil {
467			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
468		}
469	}
470	if invalidParams.Len() > 0 {
471		return invalidParams
472	} else {
473		return nil
474	}
475}
476
477func validateParameterAttribute(v *types.ParameterAttribute) error {
478	if v == nil {
479		return nil
480	}
481	invalidParams := smithy.InvalidParamsError{Context: "ParameterAttribute"}
482	if v.Key == nil {
483		invalidParams.Add(smithy.NewErrParamRequired("Key"))
484	}
485	if v.StringValue == nil {
486		invalidParams.Add(smithy.NewErrParamRequired("StringValue"))
487	}
488	if invalidParams.Len() > 0 {
489		return invalidParams
490	} else {
491		return nil
492	}
493}
494
495func validateParameterAttributeList(v []types.ParameterAttribute) error {
496	if v == nil {
497		return nil
498	}
499	invalidParams := smithy.InvalidParamsError{Context: "ParameterAttributeList"}
500	for i := range v {
501		if err := validateParameterAttribute(&v[i]); err != nil {
502			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
503		}
504	}
505	if invalidParams.Len() > 0 {
506		return invalidParams
507	} else {
508		return nil
509	}
510}
511
512func validateParameterObject(v *types.ParameterObject) error {
513	if v == nil {
514		return nil
515	}
516	invalidParams := smithy.InvalidParamsError{Context: "ParameterObject"}
517	if v.Id == nil {
518		invalidParams.Add(smithy.NewErrParamRequired("Id"))
519	}
520	if v.Attributes == nil {
521		invalidParams.Add(smithy.NewErrParamRequired("Attributes"))
522	} else if v.Attributes != nil {
523		if err := validateParameterAttributeList(v.Attributes); err != nil {
524			invalidParams.AddNested("Attributes", err.(smithy.InvalidParamsError))
525		}
526	}
527	if invalidParams.Len() > 0 {
528		return invalidParams
529	} else {
530		return nil
531	}
532}
533
534func validateParameterObjectList(v []types.ParameterObject) error {
535	if v == nil {
536		return nil
537	}
538	invalidParams := smithy.InvalidParamsError{Context: "ParameterObjectList"}
539	for i := range v {
540		if err := validateParameterObject(&v[i]); err != nil {
541			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
542		}
543	}
544	if invalidParams.Len() > 0 {
545		return invalidParams
546	} else {
547		return nil
548	}
549}
550
551func validateParameterValue(v *types.ParameterValue) error {
552	if v == nil {
553		return nil
554	}
555	invalidParams := smithy.InvalidParamsError{Context: "ParameterValue"}
556	if v.Id == nil {
557		invalidParams.Add(smithy.NewErrParamRequired("Id"))
558	}
559	if v.StringValue == nil {
560		invalidParams.Add(smithy.NewErrParamRequired("StringValue"))
561	}
562	if invalidParams.Len() > 0 {
563		return invalidParams
564	} else {
565		return nil
566	}
567}
568
569func validateParameterValueList(v []types.ParameterValue) error {
570	if v == nil {
571		return nil
572	}
573	invalidParams := smithy.InvalidParamsError{Context: "ParameterValueList"}
574	for i := range v {
575		if err := validateParameterValue(&v[i]); err != nil {
576			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
577		}
578	}
579	if invalidParams.Len() > 0 {
580		return invalidParams
581	} else {
582		return nil
583	}
584}
585
586func validatePipelineObject(v *types.PipelineObject) error {
587	if v == nil {
588		return nil
589	}
590	invalidParams := smithy.InvalidParamsError{Context: "PipelineObject"}
591	if v.Id == nil {
592		invalidParams.Add(smithy.NewErrParamRequired("Id"))
593	}
594	if v.Name == nil {
595		invalidParams.Add(smithy.NewErrParamRequired("Name"))
596	}
597	if v.Fields == nil {
598		invalidParams.Add(smithy.NewErrParamRequired("Fields"))
599	} else if v.Fields != nil {
600		if err := validateFieldList(v.Fields); err != nil {
601			invalidParams.AddNested("Fields", err.(smithy.InvalidParamsError))
602		}
603	}
604	if invalidParams.Len() > 0 {
605		return invalidParams
606	} else {
607		return nil
608	}
609}
610
611func validatePipelineObjectList(v []types.PipelineObject) error {
612	if v == nil {
613		return nil
614	}
615	invalidParams := smithy.InvalidParamsError{Context: "PipelineObjectList"}
616	for i := range v {
617		if err := validatePipelineObject(&v[i]); err != nil {
618			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
619		}
620	}
621	if invalidParams.Len() > 0 {
622		return invalidParams
623	} else {
624		return nil
625	}
626}
627
628func validateTag(v *types.Tag) error {
629	if v == nil {
630		return nil
631	}
632	invalidParams := smithy.InvalidParamsError{Context: "Tag"}
633	if v.Key == nil {
634		invalidParams.Add(smithy.NewErrParamRequired("Key"))
635	}
636	if v.Value == nil {
637		invalidParams.Add(smithy.NewErrParamRequired("Value"))
638	}
639	if invalidParams.Len() > 0 {
640		return invalidParams
641	} else {
642		return nil
643	}
644}
645
646func validateTagList(v []types.Tag) error {
647	if v == nil {
648		return nil
649	}
650	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
651	for i := range v {
652		if err := validateTag(&v[i]); err != nil {
653			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
654		}
655	}
656	if invalidParams.Len() > 0 {
657		return invalidParams
658	} else {
659		return nil
660	}
661}
662
663func validateOpActivatePipelineInput(v *ActivatePipelineInput) error {
664	if v == nil {
665		return nil
666	}
667	invalidParams := smithy.InvalidParamsError{Context: "ActivatePipelineInput"}
668	if v.PipelineId == nil {
669		invalidParams.Add(smithy.NewErrParamRequired("PipelineId"))
670	}
671	if v.ParameterValues != nil {
672		if err := validateParameterValueList(v.ParameterValues); err != nil {
673			invalidParams.AddNested("ParameterValues", err.(smithy.InvalidParamsError))
674		}
675	}
676	if invalidParams.Len() > 0 {
677		return invalidParams
678	} else {
679		return nil
680	}
681}
682
683func validateOpAddTagsInput(v *AddTagsInput) error {
684	if v == nil {
685		return nil
686	}
687	invalidParams := smithy.InvalidParamsError{Context: "AddTagsInput"}
688	if v.PipelineId == nil {
689		invalidParams.Add(smithy.NewErrParamRequired("PipelineId"))
690	}
691	if v.Tags == nil {
692		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
693	} else if v.Tags != nil {
694		if err := validateTagList(v.Tags); err != nil {
695			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
696		}
697	}
698	if invalidParams.Len() > 0 {
699		return invalidParams
700	} else {
701		return nil
702	}
703}
704
705func validateOpCreatePipelineInput(v *CreatePipelineInput) error {
706	if v == nil {
707		return nil
708	}
709	invalidParams := smithy.InvalidParamsError{Context: "CreatePipelineInput"}
710	if v.Name == nil {
711		invalidParams.Add(smithy.NewErrParamRequired("Name"))
712	}
713	if v.UniqueId == nil {
714		invalidParams.Add(smithy.NewErrParamRequired("UniqueId"))
715	}
716	if v.Tags != nil {
717		if err := validateTagList(v.Tags); err != nil {
718			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
719		}
720	}
721	if invalidParams.Len() > 0 {
722		return invalidParams
723	} else {
724		return nil
725	}
726}
727
728func validateOpDeactivatePipelineInput(v *DeactivatePipelineInput) error {
729	if v == nil {
730		return nil
731	}
732	invalidParams := smithy.InvalidParamsError{Context: "DeactivatePipelineInput"}
733	if v.PipelineId == nil {
734		invalidParams.Add(smithy.NewErrParamRequired("PipelineId"))
735	}
736	if invalidParams.Len() > 0 {
737		return invalidParams
738	} else {
739		return nil
740	}
741}
742
743func validateOpDeletePipelineInput(v *DeletePipelineInput) error {
744	if v == nil {
745		return nil
746	}
747	invalidParams := smithy.InvalidParamsError{Context: "DeletePipelineInput"}
748	if v.PipelineId == nil {
749		invalidParams.Add(smithy.NewErrParamRequired("PipelineId"))
750	}
751	if invalidParams.Len() > 0 {
752		return invalidParams
753	} else {
754		return nil
755	}
756}
757
758func validateOpDescribeObjectsInput(v *DescribeObjectsInput) error {
759	if v == nil {
760		return nil
761	}
762	invalidParams := smithy.InvalidParamsError{Context: "DescribeObjectsInput"}
763	if v.PipelineId == nil {
764		invalidParams.Add(smithy.NewErrParamRequired("PipelineId"))
765	}
766	if v.ObjectIds == nil {
767		invalidParams.Add(smithy.NewErrParamRequired("ObjectIds"))
768	}
769	if invalidParams.Len() > 0 {
770		return invalidParams
771	} else {
772		return nil
773	}
774}
775
776func validateOpDescribePipelinesInput(v *DescribePipelinesInput) error {
777	if v == nil {
778		return nil
779	}
780	invalidParams := smithy.InvalidParamsError{Context: "DescribePipelinesInput"}
781	if v.PipelineIds == nil {
782		invalidParams.Add(smithy.NewErrParamRequired("PipelineIds"))
783	}
784	if invalidParams.Len() > 0 {
785		return invalidParams
786	} else {
787		return nil
788	}
789}
790
791func validateOpEvaluateExpressionInput(v *EvaluateExpressionInput) error {
792	if v == nil {
793		return nil
794	}
795	invalidParams := smithy.InvalidParamsError{Context: "EvaluateExpressionInput"}
796	if v.PipelineId == nil {
797		invalidParams.Add(smithy.NewErrParamRequired("PipelineId"))
798	}
799	if v.ObjectId == nil {
800		invalidParams.Add(smithy.NewErrParamRequired("ObjectId"))
801	}
802	if v.Expression == nil {
803		invalidParams.Add(smithy.NewErrParamRequired("Expression"))
804	}
805	if invalidParams.Len() > 0 {
806		return invalidParams
807	} else {
808		return nil
809	}
810}
811
812func validateOpGetPipelineDefinitionInput(v *GetPipelineDefinitionInput) error {
813	if v == nil {
814		return nil
815	}
816	invalidParams := smithy.InvalidParamsError{Context: "GetPipelineDefinitionInput"}
817	if v.PipelineId == nil {
818		invalidParams.Add(smithy.NewErrParamRequired("PipelineId"))
819	}
820	if invalidParams.Len() > 0 {
821		return invalidParams
822	} else {
823		return nil
824	}
825}
826
827func validateOpPollForTaskInput(v *PollForTaskInput) error {
828	if v == nil {
829		return nil
830	}
831	invalidParams := smithy.InvalidParamsError{Context: "PollForTaskInput"}
832	if v.WorkerGroup == nil {
833		invalidParams.Add(smithy.NewErrParamRequired("WorkerGroup"))
834	}
835	if invalidParams.Len() > 0 {
836		return invalidParams
837	} else {
838		return nil
839	}
840}
841
842func validateOpPutPipelineDefinitionInput(v *PutPipelineDefinitionInput) error {
843	if v == nil {
844		return nil
845	}
846	invalidParams := smithy.InvalidParamsError{Context: "PutPipelineDefinitionInput"}
847	if v.PipelineId == nil {
848		invalidParams.Add(smithy.NewErrParamRequired("PipelineId"))
849	}
850	if v.PipelineObjects == nil {
851		invalidParams.Add(smithy.NewErrParamRequired("PipelineObjects"))
852	} else if v.PipelineObjects != nil {
853		if err := validatePipelineObjectList(v.PipelineObjects); err != nil {
854			invalidParams.AddNested("PipelineObjects", err.(smithy.InvalidParamsError))
855		}
856	}
857	if v.ParameterObjects != nil {
858		if err := validateParameterObjectList(v.ParameterObjects); err != nil {
859			invalidParams.AddNested("ParameterObjects", err.(smithy.InvalidParamsError))
860		}
861	}
862	if v.ParameterValues != nil {
863		if err := validateParameterValueList(v.ParameterValues); err != nil {
864			invalidParams.AddNested("ParameterValues", err.(smithy.InvalidParamsError))
865		}
866	}
867	if invalidParams.Len() > 0 {
868		return invalidParams
869	} else {
870		return nil
871	}
872}
873
874func validateOpQueryObjectsInput(v *QueryObjectsInput) error {
875	if v == nil {
876		return nil
877	}
878	invalidParams := smithy.InvalidParamsError{Context: "QueryObjectsInput"}
879	if v.PipelineId == nil {
880		invalidParams.Add(smithy.NewErrParamRequired("PipelineId"))
881	}
882	if v.Sphere == nil {
883		invalidParams.Add(smithy.NewErrParamRequired("Sphere"))
884	}
885	if invalidParams.Len() > 0 {
886		return invalidParams
887	} else {
888		return nil
889	}
890}
891
892func validateOpRemoveTagsInput(v *RemoveTagsInput) error {
893	if v == nil {
894		return nil
895	}
896	invalidParams := smithy.InvalidParamsError{Context: "RemoveTagsInput"}
897	if v.PipelineId == nil {
898		invalidParams.Add(smithy.NewErrParamRequired("PipelineId"))
899	}
900	if v.TagKeys == nil {
901		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
902	}
903	if invalidParams.Len() > 0 {
904		return invalidParams
905	} else {
906		return nil
907	}
908}
909
910func validateOpReportTaskProgressInput(v *ReportTaskProgressInput) error {
911	if v == nil {
912		return nil
913	}
914	invalidParams := smithy.InvalidParamsError{Context: "ReportTaskProgressInput"}
915	if v.TaskId == nil {
916		invalidParams.Add(smithy.NewErrParamRequired("TaskId"))
917	}
918	if v.Fields != nil {
919		if err := validateFieldList(v.Fields); err != nil {
920			invalidParams.AddNested("Fields", err.(smithy.InvalidParamsError))
921		}
922	}
923	if invalidParams.Len() > 0 {
924		return invalidParams
925	} else {
926		return nil
927	}
928}
929
930func validateOpReportTaskRunnerHeartbeatInput(v *ReportTaskRunnerHeartbeatInput) error {
931	if v == nil {
932		return nil
933	}
934	invalidParams := smithy.InvalidParamsError{Context: "ReportTaskRunnerHeartbeatInput"}
935	if v.TaskrunnerId == nil {
936		invalidParams.Add(smithy.NewErrParamRequired("TaskrunnerId"))
937	}
938	if invalidParams.Len() > 0 {
939		return invalidParams
940	} else {
941		return nil
942	}
943}
944
945func validateOpSetStatusInput(v *SetStatusInput) error {
946	if v == nil {
947		return nil
948	}
949	invalidParams := smithy.InvalidParamsError{Context: "SetStatusInput"}
950	if v.PipelineId == nil {
951		invalidParams.Add(smithy.NewErrParamRequired("PipelineId"))
952	}
953	if v.ObjectIds == nil {
954		invalidParams.Add(smithy.NewErrParamRequired("ObjectIds"))
955	}
956	if v.Status == nil {
957		invalidParams.Add(smithy.NewErrParamRequired("Status"))
958	}
959	if invalidParams.Len() > 0 {
960		return invalidParams
961	} else {
962		return nil
963	}
964}
965
966func validateOpSetTaskStatusInput(v *SetTaskStatusInput) error {
967	if v == nil {
968		return nil
969	}
970	invalidParams := smithy.InvalidParamsError{Context: "SetTaskStatusInput"}
971	if v.TaskId == nil {
972		invalidParams.Add(smithy.NewErrParamRequired("TaskId"))
973	}
974	if len(v.TaskStatus) == 0 {
975		invalidParams.Add(smithy.NewErrParamRequired("TaskStatus"))
976	}
977	if invalidParams.Len() > 0 {
978		return invalidParams
979	} else {
980		return nil
981	}
982}
983
984func validateOpValidatePipelineDefinitionInput(v *ValidatePipelineDefinitionInput) error {
985	if v == nil {
986		return nil
987	}
988	invalidParams := smithy.InvalidParamsError{Context: "ValidatePipelineDefinitionInput"}
989	if v.PipelineId == nil {
990		invalidParams.Add(smithy.NewErrParamRequired("PipelineId"))
991	}
992	if v.PipelineObjects == nil {
993		invalidParams.Add(smithy.NewErrParamRequired("PipelineObjects"))
994	} else if v.PipelineObjects != nil {
995		if err := validatePipelineObjectList(v.PipelineObjects); err != nil {
996			invalidParams.AddNested("PipelineObjects", err.(smithy.InvalidParamsError))
997		}
998	}
999	if v.ParameterObjects != nil {
1000		if err := validateParameterObjectList(v.ParameterObjects); err != nil {
1001			invalidParams.AddNested("ParameterObjects", err.(smithy.InvalidParamsError))
1002		}
1003	}
1004	if v.ParameterValues != nil {
1005		if err := validateParameterValueList(v.ParameterValues); err != nil {
1006			invalidParams.AddNested("ParameterValues", err.(smithy.InvalidParamsError))
1007		}
1008	}
1009	if invalidParams.Len() > 0 {
1010		return invalidParams
1011	} else {
1012		return nil
1013	}
1014}
1015