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