1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package sfn
4
5import (
6	"context"
7	"fmt"
8	smithy "github.com/aws/smithy-go"
9	"github.com/aws/smithy-go/middleware"
10)
11
12type validateOpCreateActivity struct {
13}
14
15func (*validateOpCreateActivity) ID() string {
16	return "OperationInputValidation"
17}
18
19func (m *validateOpCreateActivity) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
20	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
21) {
22	input, ok := in.Parameters.(*CreateActivityInput)
23	if !ok {
24		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
25	}
26	if err := validateOpCreateActivityInput(input); err != nil {
27		return out, metadata, err
28	}
29	return next.HandleInitialize(ctx, in)
30}
31
32type validateOpCreateStateMachine struct {
33}
34
35func (*validateOpCreateStateMachine) ID() string {
36	return "OperationInputValidation"
37}
38
39func (m *validateOpCreateStateMachine) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
40	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
41) {
42	input, ok := in.Parameters.(*CreateStateMachineInput)
43	if !ok {
44		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
45	}
46	if err := validateOpCreateStateMachineInput(input); err != nil {
47		return out, metadata, err
48	}
49	return next.HandleInitialize(ctx, in)
50}
51
52type validateOpDeleteActivity struct {
53}
54
55func (*validateOpDeleteActivity) ID() string {
56	return "OperationInputValidation"
57}
58
59func (m *validateOpDeleteActivity) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
60	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
61) {
62	input, ok := in.Parameters.(*DeleteActivityInput)
63	if !ok {
64		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
65	}
66	if err := validateOpDeleteActivityInput(input); err != nil {
67		return out, metadata, err
68	}
69	return next.HandleInitialize(ctx, in)
70}
71
72type validateOpDeleteStateMachine struct {
73}
74
75func (*validateOpDeleteStateMachine) ID() string {
76	return "OperationInputValidation"
77}
78
79func (m *validateOpDeleteStateMachine) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
80	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
81) {
82	input, ok := in.Parameters.(*DeleteStateMachineInput)
83	if !ok {
84		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
85	}
86	if err := validateOpDeleteStateMachineInput(input); err != nil {
87		return out, metadata, err
88	}
89	return next.HandleInitialize(ctx, in)
90}
91
92type validateOpDescribeActivity struct {
93}
94
95func (*validateOpDescribeActivity) ID() string {
96	return "OperationInputValidation"
97}
98
99func (m *validateOpDescribeActivity) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
100	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
101) {
102	input, ok := in.Parameters.(*DescribeActivityInput)
103	if !ok {
104		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
105	}
106	if err := validateOpDescribeActivityInput(input); err != nil {
107		return out, metadata, err
108	}
109	return next.HandleInitialize(ctx, in)
110}
111
112type validateOpDescribeExecution struct {
113}
114
115func (*validateOpDescribeExecution) ID() string {
116	return "OperationInputValidation"
117}
118
119func (m *validateOpDescribeExecution) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
120	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
121) {
122	input, ok := in.Parameters.(*DescribeExecutionInput)
123	if !ok {
124		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
125	}
126	if err := validateOpDescribeExecutionInput(input); err != nil {
127		return out, metadata, err
128	}
129	return next.HandleInitialize(ctx, in)
130}
131
132type validateOpDescribeStateMachineForExecution struct {
133}
134
135func (*validateOpDescribeStateMachineForExecution) ID() string {
136	return "OperationInputValidation"
137}
138
139func (m *validateOpDescribeStateMachineForExecution) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
140	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
141) {
142	input, ok := in.Parameters.(*DescribeStateMachineForExecutionInput)
143	if !ok {
144		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
145	}
146	if err := validateOpDescribeStateMachineForExecutionInput(input); err != nil {
147		return out, metadata, err
148	}
149	return next.HandleInitialize(ctx, in)
150}
151
152type validateOpDescribeStateMachine struct {
153}
154
155func (*validateOpDescribeStateMachine) ID() string {
156	return "OperationInputValidation"
157}
158
159func (m *validateOpDescribeStateMachine) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
160	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
161) {
162	input, ok := in.Parameters.(*DescribeStateMachineInput)
163	if !ok {
164		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
165	}
166	if err := validateOpDescribeStateMachineInput(input); err != nil {
167		return out, metadata, err
168	}
169	return next.HandleInitialize(ctx, in)
170}
171
172type validateOpGetActivityTask struct {
173}
174
175func (*validateOpGetActivityTask) ID() string {
176	return "OperationInputValidation"
177}
178
179func (m *validateOpGetActivityTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
180	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
181) {
182	input, ok := in.Parameters.(*GetActivityTaskInput)
183	if !ok {
184		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
185	}
186	if err := validateOpGetActivityTaskInput(input); err != nil {
187		return out, metadata, err
188	}
189	return next.HandleInitialize(ctx, in)
190}
191
192type validateOpGetExecutionHistory struct {
193}
194
195func (*validateOpGetExecutionHistory) ID() string {
196	return "OperationInputValidation"
197}
198
199func (m *validateOpGetExecutionHistory) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
200	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
201) {
202	input, ok := in.Parameters.(*GetExecutionHistoryInput)
203	if !ok {
204		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
205	}
206	if err := validateOpGetExecutionHistoryInput(input); err != nil {
207		return out, metadata, err
208	}
209	return next.HandleInitialize(ctx, in)
210}
211
212type validateOpListExecutions struct {
213}
214
215func (*validateOpListExecutions) ID() string {
216	return "OperationInputValidation"
217}
218
219func (m *validateOpListExecutions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
220	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
221) {
222	input, ok := in.Parameters.(*ListExecutionsInput)
223	if !ok {
224		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
225	}
226	if err := validateOpListExecutionsInput(input); err != nil {
227		return out, metadata, err
228	}
229	return next.HandleInitialize(ctx, in)
230}
231
232type validateOpListTagsForResource struct {
233}
234
235func (*validateOpListTagsForResource) ID() string {
236	return "OperationInputValidation"
237}
238
239func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
240	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
241) {
242	input, ok := in.Parameters.(*ListTagsForResourceInput)
243	if !ok {
244		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
245	}
246	if err := validateOpListTagsForResourceInput(input); err != nil {
247		return out, metadata, err
248	}
249	return next.HandleInitialize(ctx, in)
250}
251
252type validateOpSendTaskFailure struct {
253}
254
255func (*validateOpSendTaskFailure) ID() string {
256	return "OperationInputValidation"
257}
258
259func (m *validateOpSendTaskFailure) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
260	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
261) {
262	input, ok := in.Parameters.(*SendTaskFailureInput)
263	if !ok {
264		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
265	}
266	if err := validateOpSendTaskFailureInput(input); err != nil {
267		return out, metadata, err
268	}
269	return next.HandleInitialize(ctx, in)
270}
271
272type validateOpSendTaskHeartbeat struct {
273}
274
275func (*validateOpSendTaskHeartbeat) ID() string {
276	return "OperationInputValidation"
277}
278
279func (m *validateOpSendTaskHeartbeat) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
280	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
281) {
282	input, ok := in.Parameters.(*SendTaskHeartbeatInput)
283	if !ok {
284		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
285	}
286	if err := validateOpSendTaskHeartbeatInput(input); err != nil {
287		return out, metadata, err
288	}
289	return next.HandleInitialize(ctx, in)
290}
291
292type validateOpSendTaskSuccess struct {
293}
294
295func (*validateOpSendTaskSuccess) ID() string {
296	return "OperationInputValidation"
297}
298
299func (m *validateOpSendTaskSuccess) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
300	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
301) {
302	input, ok := in.Parameters.(*SendTaskSuccessInput)
303	if !ok {
304		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
305	}
306	if err := validateOpSendTaskSuccessInput(input); err != nil {
307		return out, metadata, err
308	}
309	return next.HandleInitialize(ctx, in)
310}
311
312type validateOpStartExecution struct {
313}
314
315func (*validateOpStartExecution) ID() string {
316	return "OperationInputValidation"
317}
318
319func (m *validateOpStartExecution) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
320	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
321) {
322	input, ok := in.Parameters.(*StartExecutionInput)
323	if !ok {
324		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
325	}
326	if err := validateOpStartExecutionInput(input); err != nil {
327		return out, metadata, err
328	}
329	return next.HandleInitialize(ctx, in)
330}
331
332type validateOpStartSyncExecution struct {
333}
334
335func (*validateOpStartSyncExecution) ID() string {
336	return "OperationInputValidation"
337}
338
339func (m *validateOpStartSyncExecution) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
340	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
341) {
342	input, ok := in.Parameters.(*StartSyncExecutionInput)
343	if !ok {
344		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
345	}
346	if err := validateOpStartSyncExecutionInput(input); err != nil {
347		return out, metadata, err
348	}
349	return next.HandleInitialize(ctx, in)
350}
351
352type validateOpStopExecution struct {
353}
354
355func (*validateOpStopExecution) ID() string {
356	return "OperationInputValidation"
357}
358
359func (m *validateOpStopExecution) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
360	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
361) {
362	input, ok := in.Parameters.(*StopExecutionInput)
363	if !ok {
364		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
365	}
366	if err := validateOpStopExecutionInput(input); err != nil {
367		return out, metadata, err
368	}
369	return next.HandleInitialize(ctx, in)
370}
371
372type validateOpTagResource struct {
373}
374
375func (*validateOpTagResource) ID() string {
376	return "OperationInputValidation"
377}
378
379func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
380	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
381) {
382	input, ok := in.Parameters.(*TagResourceInput)
383	if !ok {
384		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
385	}
386	if err := validateOpTagResourceInput(input); err != nil {
387		return out, metadata, err
388	}
389	return next.HandleInitialize(ctx, in)
390}
391
392type validateOpUntagResource struct {
393}
394
395func (*validateOpUntagResource) ID() string {
396	return "OperationInputValidation"
397}
398
399func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
400	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
401) {
402	input, ok := in.Parameters.(*UntagResourceInput)
403	if !ok {
404		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
405	}
406	if err := validateOpUntagResourceInput(input); err != nil {
407		return out, metadata, err
408	}
409	return next.HandleInitialize(ctx, in)
410}
411
412type validateOpUpdateStateMachine struct {
413}
414
415func (*validateOpUpdateStateMachine) ID() string {
416	return "OperationInputValidation"
417}
418
419func (m *validateOpUpdateStateMachine) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
420	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
421) {
422	input, ok := in.Parameters.(*UpdateStateMachineInput)
423	if !ok {
424		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
425	}
426	if err := validateOpUpdateStateMachineInput(input); err != nil {
427		return out, metadata, err
428	}
429	return next.HandleInitialize(ctx, in)
430}
431
432func addOpCreateActivityValidationMiddleware(stack *middleware.Stack) error {
433	return stack.Initialize.Add(&validateOpCreateActivity{}, middleware.After)
434}
435
436func addOpCreateStateMachineValidationMiddleware(stack *middleware.Stack) error {
437	return stack.Initialize.Add(&validateOpCreateStateMachine{}, middleware.After)
438}
439
440func addOpDeleteActivityValidationMiddleware(stack *middleware.Stack) error {
441	return stack.Initialize.Add(&validateOpDeleteActivity{}, middleware.After)
442}
443
444func addOpDeleteStateMachineValidationMiddleware(stack *middleware.Stack) error {
445	return stack.Initialize.Add(&validateOpDeleteStateMachine{}, middleware.After)
446}
447
448func addOpDescribeActivityValidationMiddleware(stack *middleware.Stack) error {
449	return stack.Initialize.Add(&validateOpDescribeActivity{}, middleware.After)
450}
451
452func addOpDescribeExecutionValidationMiddleware(stack *middleware.Stack) error {
453	return stack.Initialize.Add(&validateOpDescribeExecution{}, middleware.After)
454}
455
456func addOpDescribeStateMachineForExecutionValidationMiddleware(stack *middleware.Stack) error {
457	return stack.Initialize.Add(&validateOpDescribeStateMachineForExecution{}, middleware.After)
458}
459
460func addOpDescribeStateMachineValidationMiddleware(stack *middleware.Stack) error {
461	return stack.Initialize.Add(&validateOpDescribeStateMachine{}, middleware.After)
462}
463
464func addOpGetActivityTaskValidationMiddleware(stack *middleware.Stack) error {
465	return stack.Initialize.Add(&validateOpGetActivityTask{}, middleware.After)
466}
467
468func addOpGetExecutionHistoryValidationMiddleware(stack *middleware.Stack) error {
469	return stack.Initialize.Add(&validateOpGetExecutionHistory{}, middleware.After)
470}
471
472func addOpListExecutionsValidationMiddleware(stack *middleware.Stack) error {
473	return stack.Initialize.Add(&validateOpListExecutions{}, middleware.After)
474}
475
476func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
477	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
478}
479
480func addOpSendTaskFailureValidationMiddleware(stack *middleware.Stack) error {
481	return stack.Initialize.Add(&validateOpSendTaskFailure{}, middleware.After)
482}
483
484func addOpSendTaskHeartbeatValidationMiddleware(stack *middleware.Stack) error {
485	return stack.Initialize.Add(&validateOpSendTaskHeartbeat{}, middleware.After)
486}
487
488func addOpSendTaskSuccessValidationMiddleware(stack *middleware.Stack) error {
489	return stack.Initialize.Add(&validateOpSendTaskSuccess{}, middleware.After)
490}
491
492func addOpStartExecutionValidationMiddleware(stack *middleware.Stack) error {
493	return stack.Initialize.Add(&validateOpStartExecution{}, middleware.After)
494}
495
496func addOpStartSyncExecutionValidationMiddleware(stack *middleware.Stack) error {
497	return stack.Initialize.Add(&validateOpStartSyncExecution{}, middleware.After)
498}
499
500func addOpStopExecutionValidationMiddleware(stack *middleware.Stack) error {
501	return stack.Initialize.Add(&validateOpStopExecution{}, middleware.After)
502}
503
504func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
505	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
506}
507
508func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
509	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
510}
511
512func addOpUpdateStateMachineValidationMiddleware(stack *middleware.Stack) error {
513	return stack.Initialize.Add(&validateOpUpdateStateMachine{}, middleware.After)
514}
515
516func validateOpCreateActivityInput(v *CreateActivityInput) error {
517	if v == nil {
518		return nil
519	}
520	invalidParams := smithy.InvalidParamsError{Context: "CreateActivityInput"}
521	if v.Name == nil {
522		invalidParams.Add(smithy.NewErrParamRequired("Name"))
523	}
524	if invalidParams.Len() > 0 {
525		return invalidParams
526	} else {
527		return nil
528	}
529}
530
531func validateOpCreateStateMachineInput(v *CreateStateMachineInput) error {
532	if v == nil {
533		return nil
534	}
535	invalidParams := smithy.InvalidParamsError{Context: "CreateStateMachineInput"}
536	if v.Name == nil {
537		invalidParams.Add(smithy.NewErrParamRequired("Name"))
538	}
539	if v.Definition == nil {
540		invalidParams.Add(smithy.NewErrParamRequired("Definition"))
541	}
542	if v.RoleArn == nil {
543		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
544	}
545	if invalidParams.Len() > 0 {
546		return invalidParams
547	} else {
548		return nil
549	}
550}
551
552func validateOpDeleteActivityInput(v *DeleteActivityInput) error {
553	if v == nil {
554		return nil
555	}
556	invalidParams := smithy.InvalidParamsError{Context: "DeleteActivityInput"}
557	if v.ActivityArn == nil {
558		invalidParams.Add(smithy.NewErrParamRequired("ActivityArn"))
559	}
560	if invalidParams.Len() > 0 {
561		return invalidParams
562	} else {
563		return nil
564	}
565}
566
567func validateOpDeleteStateMachineInput(v *DeleteStateMachineInput) error {
568	if v == nil {
569		return nil
570	}
571	invalidParams := smithy.InvalidParamsError{Context: "DeleteStateMachineInput"}
572	if v.StateMachineArn == nil {
573		invalidParams.Add(smithy.NewErrParamRequired("StateMachineArn"))
574	}
575	if invalidParams.Len() > 0 {
576		return invalidParams
577	} else {
578		return nil
579	}
580}
581
582func validateOpDescribeActivityInput(v *DescribeActivityInput) error {
583	if v == nil {
584		return nil
585	}
586	invalidParams := smithy.InvalidParamsError{Context: "DescribeActivityInput"}
587	if v.ActivityArn == nil {
588		invalidParams.Add(smithy.NewErrParamRequired("ActivityArn"))
589	}
590	if invalidParams.Len() > 0 {
591		return invalidParams
592	} else {
593		return nil
594	}
595}
596
597func validateOpDescribeExecutionInput(v *DescribeExecutionInput) error {
598	if v == nil {
599		return nil
600	}
601	invalidParams := smithy.InvalidParamsError{Context: "DescribeExecutionInput"}
602	if v.ExecutionArn == nil {
603		invalidParams.Add(smithy.NewErrParamRequired("ExecutionArn"))
604	}
605	if invalidParams.Len() > 0 {
606		return invalidParams
607	} else {
608		return nil
609	}
610}
611
612func validateOpDescribeStateMachineForExecutionInput(v *DescribeStateMachineForExecutionInput) error {
613	if v == nil {
614		return nil
615	}
616	invalidParams := smithy.InvalidParamsError{Context: "DescribeStateMachineForExecutionInput"}
617	if v.ExecutionArn == nil {
618		invalidParams.Add(smithy.NewErrParamRequired("ExecutionArn"))
619	}
620	if invalidParams.Len() > 0 {
621		return invalidParams
622	} else {
623		return nil
624	}
625}
626
627func validateOpDescribeStateMachineInput(v *DescribeStateMachineInput) error {
628	if v == nil {
629		return nil
630	}
631	invalidParams := smithy.InvalidParamsError{Context: "DescribeStateMachineInput"}
632	if v.StateMachineArn == nil {
633		invalidParams.Add(smithy.NewErrParamRequired("StateMachineArn"))
634	}
635	if invalidParams.Len() > 0 {
636		return invalidParams
637	} else {
638		return nil
639	}
640}
641
642func validateOpGetActivityTaskInput(v *GetActivityTaskInput) error {
643	if v == nil {
644		return nil
645	}
646	invalidParams := smithy.InvalidParamsError{Context: "GetActivityTaskInput"}
647	if v.ActivityArn == nil {
648		invalidParams.Add(smithy.NewErrParamRequired("ActivityArn"))
649	}
650	if invalidParams.Len() > 0 {
651		return invalidParams
652	} else {
653		return nil
654	}
655}
656
657func validateOpGetExecutionHistoryInput(v *GetExecutionHistoryInput) error {
658	if v == nil {
659		return nil
660	}
661	invalidParams := smithy.InvalidParamsError{Context: "GetExecutionHistoryInput"}
662	if v.ExecutionArn == nil {
663		invalidParams.Add(smithy.NewErrParamRequired("ExecutionArn"))
664	}
665	if invalidParams.Len() > 0 {
666		return invalidParams
667	} else {
668		return nil
669	}
670}
671
672func validateOpListExecutionsInput(v *ListExecutionsInput) error {
673	if v == nil {
674		return nil
675	}
676	invalidParams := smithy.InvalidParamsError{Context: "ListExecutionsInput"}
677	if v.StateMachineArn == nil {
678		invalidParams.Add(smithy.NewErrParamRequired("StateMachineArn"))
679	}
680	if invalidParams.Len() > 0 {
681		return invalidParams
682	} else {
683		return nil
684	}
685}
686
687func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
688	if v == nil {
689		return nil
690	}
691	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
692	if v.ResourceArn == nil {
693		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
694	}
695	if invalidParams.Len() > 0 {
696		return invalidParams
697	} else {
698		return nil
699	}
700}
701
702func validateOpSendTaskFailureInput(v *SendTaskFailureInput) error {
703	if v == nil {
704		return nil
705	}
706	invalidParams := smithy.InvalidParamsError{Context: "SendTaskFailureInput"}
707	if v.TaskToken == nil {
708		invalidParams.Add(smithy.NewErrParamRequired("TaskToken"))
709	}
710	if invalidParams.Len() > 0 {
711		return invalidParams
712	} else {
713		return nil
714	}
715}
716
717func validateOpSendTaskHeartbeatInput(v *SendTaskHeartbeatInput) error {
718	if v == nil {
719		return nil
720	}
721	invalidParams := smithy.InvalidParamsError{Context: "SendTaskHeartbeatInput"}
722	if v.TaskToken == nil {
723		invalidParams.Add(smithy.NewErrParamRequired("TaskToken"))
724	}
725	if invalidParams.Len() > 0 {
726		return invalidParams
727	} else {
728		return nil
729	}
730}
731
732func validateOpSendTaskSuccessInput(v *SendTaskSuccessInput) error {
733	if v == nil {
734		return nil
735	}
736	invalidParams := smithy.InvalidParamsError{Context: "SendTaskSuccessInput"}
737	if v.TaskToken == nil {
738		invalidParams.Add(smithy.NewErrParamRequired("TaskToken"))
739	}
740	if v.Output == nil {
741		invalidParams.Add(smithy.NewErrParamRequired("Output"))
742	}
743	if invalidParams.Len() > 0 {
744		return invalidParams
745	} else {
746		return nil
747	}
748}
749
750func validateOpStartExecutionInput(v *StartExecutionInput) error {
751	if v == nil {
752		return nil
753	}
754	invalidParams := smithy.InvalidParamsError{Context: "StartExecutionInput"}
755	if v.StateMachineArn == nil {
756		invalidParams.Add(smithy.NewErrParamRequired("StateMachineArn"))
757	}
758	if invalidParams.Len() > 0 {
759		return invalidParams
760	} else {
761		return nil
762	}
763}
764
765func validateOpStartSyncExecutionInput(v *StartSyncExecutionInput) error {
766	if v == nil {
767		return nil
768	}
769	invalidParams := smithy.InvalidParamsError{Context: "StartSyncExecutionInput"}
770	if v.StateMachineArn == nil {
771		invalidParams.Add(smithy.NewErrParamRequired("StateMachineArn"))
772	}
773	if invalidParams.Len() > 0 {
774		return invalidParams
775	} else {
776		return nil
777	}
778}
779
780func validateOpStopExecutionInput(v *StopExecutionInput) error {
781	if v == nil {
782		return nil
783	}
784	invalidParams := smithy.InvalidParamsError{Context: "StopExecutionInput"}
785	if v.ExecutionArn == nil {
786		invalidParams.Add(smithy.NewErrParamRequired("ExecutionArn"))
787	}
788	if invalidParams.Len() > 0 {
789		return invalidParams
790	} else {
791		return nil
792	}
793}
794
795func validateOpTagResourceInput(v *TagResourceInput) error {
796	if v == nil {
797		return nil
798	}
799	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
800	if v.ResourceArn == nil {
801		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
802	}
803	if v.Tags == nil {
804		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
805	}
806	if invalidParams.Len() > 0 {
807		return invalidParams
808	} else {
809		return nil
810	}
811}
812
813func validateOpUntagResourceInput(v *UntagResourceInput) error {
814	if v == nil {
815		return nil
816	}
817	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
818	if v.ResourceArn == nil {
819		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
820	}
821	if v.TagKeys == nil {
822		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
823	}
824	if invalidParams.Len() > 0 {
825		return invalidParams
826	} else {
827		return nil
828	}
829}
830
831func validateOpUpdateStateMachineInput(v *UpdateStateMachineInput) error {
832	if v == nil {
833		return nil
834	}
835	invalidParams := smithy.InvalidParamsError{Context: "UpdateStateMachineInput"}
836	if v.StateMachineArn == nil {
837		invalidParams.Add(smithy.NewErrParamRequired("StateMachineArn"))
838	}
839	if invalidParams.Len() > 0 {
840		return invalidParams
841	} else {
842		return nil
843	}
844}
845