1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package swf 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/swf/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpCountClosedWorkflowExecutions struct { 14} 15 16func (*validateOpCountClosedWorkflowExecutions) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpCountClosedWorkflowExecutions) 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.(*CountClosedWorkflowExecutionsInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpCountClosedWorkflowExecutionsInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpCountOpenWorkflowExecutions struct { 34} 35 36func (*validateOpCountOpenWorkflowExecutions) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpCountOpenWorkflowExecutions) 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.(*CountOpenWorkflowExecutionsInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpCountOpenWorkflowExecutionsInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpCountPendingActivityTasks struct { 54} 55 56func (*validateOpCountPendingActivityTasks) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpCountPendingActivityTasks) 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.(*CountPendingActivityTasksInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpCountPendingActivityTasksInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpCountPendingDecisionTasks struct { 74} 75 76func (*validateOpCountPendingDecisionTasks) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpCountPendingDecisionTasks) 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.(*CountPendingDecisionTasksInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpCountPendingDecisionTasksInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpDeprecateActivityType struct { 94} 95 96func (*validateOpDeprecateActivityType) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpDeprecateActivityType) 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.(*DeprecateActivityTypeInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpDeprecateActivityTypeInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpDeprecateDomain struct { 114} 115 116func (*validateOpDeprecateDomain) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpDeprecateDomain) 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.(*DeprecateDomainInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpDeprecateDomainInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpDeprecateWorkflowType struct { 134} 135 136func (*validateOpDeprecateWorkflowType) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpDeprecateWorkflowType) 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.(*DeprecateWorkflowTypeInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpDeprecateWorkflowTypeInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpDescribeActivityType struct { 154} 155 156func (*validateOpDescribeActivityType) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpDescribeActivityType) 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.(*DescribeActivityTypeInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpDescribeActivityTypeInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpDescribeDomain struct { 174} 175 176func (*validateOpDescribeDomain) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpDescribeDomain) 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.(*DescribeDomainInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpDescribeDomainInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpDescribeWorkflowExecution struct { 194} 195 196func (*validateOpDescribeWorkflowExecution) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpDescribeWorkflowExecution) 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.(*DescribeWorkflowExecutionInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpDescribeWorkflowExecutionInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpDescribeWorkflowType struct { 214} 215 216func (*validateOpDescribeWorkflowType) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpDescribeWorkflowType) 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.(*DescribeWorkflowTypeInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpDescribeWorkflowTypeInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpGetWorkflowExecutionHistory struct { 234} 235 236func (*validateOpGetWorkflowExecutionHistory) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpGetWorkflowExecutionHistory) 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.(*GetWorkflowExecutionHistoryInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpGetWorkflowExecutionHistoryInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpListActivityTypes struct { 254} 255 256func (*validateOpListActivityTypes) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpListActivityTypes) 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.(*ListActivityTypesInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpListActivityTypesInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpListClosedWorkflowExecutions struct { 274} 275 276func (*validateOpListClosedWorkflowExecutions) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpListClosedWorkflowExecutions) 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.(*ListClosedWorkflowExecutionsInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpListClosedWorkflowExecutionsInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpListDomains struct { 294} 295 296func (*validateOpListDomains) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpListDomains) 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.(*ListDomainsInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpListDomainsInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpListOpenWorkflowExecutions struct { 314} 315 316func (*validateOpListOpenWorkflowExecutions) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpListOpenWorkflowExecutions) 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.(*ListOpenWorkflowExecutionsInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpListOpenWorkflowExecutionsInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpListTagsForResource struct { 334} 335 336func (*validateOpListTagsForResource) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpListTagsForResourceInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpListWorkflowTypes struct { 354} 355 356func (*validateOpListWorkflowTypes) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpListWorkflowTypes) 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.(*ListWorkflowTypesInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpListWorkflowTypesInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpPollForActivityTask struct { 374} 375 376func (*validateOpPollForActivityTask) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpPollForActivityTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 381 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 382) { 383 input, ok := in.Parameters.(*PollForActivityTaskInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpPollForActivityTaskInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpPollForDecisionTask struct { 394} 395 396func (*validateOpPollForDecisionTask) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpPollForDecisionTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 401 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 402) { 403 input, ok := in.Parameters.(*PollForDecisionTaskInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpPollForDecisionTaskInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpRecordActivityTaskHeartbeat struct { 414} 415 416func (*validateOpRecordActivityTaskHeartbeat) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpRecordActivityTaskHeartbeat) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 421 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 422) { 423 input, ok := in.Parameters.(*RecordActivityTaskHeartbeatInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpRecordActivityTaskHeartbeatInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpRegisterActivityType struct { 434} 435 436func (*validateOpRegisterActivityType) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpRegisterActivityType) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 441 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 442) { 443 input, ok := in.Parameters.(*RegisterActivityTypeInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpRegisterActivityTypeInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpRegisterDomain struct { 454} 455 456func (*validateOpRegisterDomain) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpRegisterDomain) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 461 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 462) { 463 input, ok := in.Parameters.(*RegisterDomainInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpRegisterDomainInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473type validateOpRegisterWorkflowType struct { 474} 475 476func (*validateOpRegisterWorkflowType) ID() string { 477 return "OperationInputValidation" 478} 479 480func (m *validateOpRegisterWorkflowType) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 481 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 482) { 483 input, ok := in.Parameters.(*RegisterWorkflowTypeInput) 484 if !ok { 485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 486 } 487 if err := validateOpRegisterWorkflowTypeInput(input); err != nil { 488 return out, metadata, err 489 } 490 return next.HandleInitialize(ctx, in) 491} 492 493type validateOpRequestCancelWorkflowExecution struct { 494} 495 496func (*validateOpRequestCancelWorkflowExecution) ID() string { 497 return "OperationInputValidation" 498} 499 500func (m *validateOpRequestCancelWorkflowExecution) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 501 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 502) { 503 input, ok := in.Parameters.(*RequestCancelWorkflowExecutionInput) 504 if !ok { 505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 506 } 507 if err := validateOpRequestCancelWorkflowExecutionInput(input); err != nil { 508 return out, metadata, err 509 } 510 return next.HandleInitialize(ctx, in) 511} 512 513type validateOpRespondActivityTaskCanceled struct { 514} 515 516func (*validateOpRespondActivityTaskCanceled) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpRespondActivityTaskCanceled) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 521 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 522) { 523 input, ok := in.Parameters.(*RespondActivityTaskCanceledInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpRespondActivityTaskCanceledInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533type validateOpRespondActivityTaskCompleted struct { 534} 535 536func (*validateOpRespondActivityTaskCompleted) ID() string { 537 return "OperationInputValidation" 538} 539 540func (m *validateOpRespondActivityTaskCompleted) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 541 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 542) { 543 input, ok := in.Parameters.(*RespondActivityTaskCompletedInput) 544 if !ok { 545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 546 } 547 if err := validateOpRespondActivityTaskCompletedInput(input); err != nil { 548 return out, metadata, err 549 } 550 return next.HandleInitialize(ctx, in) 551} 552 553type validateOpRespondActivityTaskFailed struct { 554} 555 556func (*validateOpRespondActivityTaskFailed) ID() string { 557 return "OperationInputValidation" 558} 559 560func (m *validateOpRespondActivityTaskFailed) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 561 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 562) { 563 input, ok := in.Parameters.(*RespondActivityTaskFailedInput) 564 if !ok { 565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 566 } 567 if err := validateOpRespondActivityTaskFailedInput(input); err != nil { 568 return out, metadata, err 569 } 570 return next.HandleInitialize(ctx, in) 571} 572 573type validateOpRespondDecisionTaskCompleted struct { 574} 575 576func (*validateOpRespondDecisionTaskCompleted) ID() string { 577 return "OperationInputValidation" 578} 579 580func (m *validateOpRespondDecisionTaskCompleted) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 581 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 582) { 583 input, ok := in.Parameters.(*RespondDecisionTaskCompletedInput) 584 if !ok { 585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 586 } 587 if err := validateOpRespondDecisionTaskCompletedInput(input); err != nil { 588 return out, metadata, err 589 } 590 return next.HandleInitialize(ctx, in) 591} 592 593type validateOpSignalWorkflowExecution struct { 594} 595 596func (*validateOpSignalWorkflowExecution) ID() string { 597 return "OperationInputValidation" 598} 599 600func (m *validateOpSignalWorkflowExecution) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 601 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 602) { 603 input, ok := in.Parameters.(*SignalWorkflowExecutionInput) 604 if !ok { 605 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 606 } 607 if err := validateOpSignalWorkflowExecutionInput(input); err != nil { 608 return out, metadata, err 609 } 610 return next.HandleInitialize(ctx, in) 611} 612 613type validateOpStartWorkflowExecution struct { 614} 615 616func (*validateOpStartWorkflowExecution) ID() string { 617 return "OperationInputValidation" 618} 619 620func (m *validateOpStartWorkflowExecution) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 621 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 622) { 623 input, ok := in.Parameters.(*StartWorkflowExecutionInput) 624 if !ok { 625 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 626 } 627 if err := validateOpStartWorkflowExecutionInput(input); err != nil { 628 return out, metadata, err 629 } 630 return next.HandleInitialize(ctx, in) 631} 632 633type validateOpTagResource struct { 634} 635 636func (*validateOpTagResource) ID() string { 637 return "OperationInputValidation" 638} 639 640func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 641 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 642) { 643 input, ok := in.Parameters.(*TagResourceInput) 644 if !ok { 645 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 646 } 647 if err := validateOpTagResourceInput(input); err != nil { 648 return out, metadata, err 649 } 650 return next.HandleInitialize(ctx, in) 651} 652 653type validateOpTerminateWorkflowExecution struct { 654} 655 656func (*validateOpTerminateWorkflowExecution) ID() string { 657 return "OperationInputValidation" 658} 659 660func (m *validateOpTerminateWorkflowExecution) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 661 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 662) { 663 input, ok := in.Parameters.(*TerminateWorkflowExecutionInput) 664 if !ok { 665 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 666 } 667 if err := validateOpTerminateWorkflowExecutionInput(input); err != nil { 668 return out, metadata, err 669 } 670 return next.HandleInitialize(ctx, in) 671} 672 673type validateOpUndeprecateActivityType struct { 674} 675 676func (*validateOpUndeprecateActivityType) ID() string { 677 return "OperationInputValidation" 678} 679 680func (m *validateOpUndeprecateActivityType) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 681 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 682) { 683 input, ok := in.Parameters.(*UndeprecateActivityTypeInput) 684 if !ok { 685 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 686 } 687 if err := validateOpUndeprecateActivityTypeInput(input); err != nil { 688 return out, metadata, err 689 } 690 return next.HandleInitialize(ctx, in) 691} 692 693type validateOpUndeprecateDomain struct { 694} 695 696func (*validateOpUndeprecateDomain) ID() string { 697 return "OperationInputValidation" 698} 699 700func (m *validateOpUndeprecateDomain) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 701 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 702) { 703 input, ok := in.Parameters.(*UndeprecateDomainInput) 704 if !ok { 705 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 706 } 707 if err := validateOpUndeprecateDomainInput(input); err != nil { 708 return out, metadata, err 709 } 710 return next.HandleInitialize(ctx, in) 711} 712 713type validateOpUndeprecateWorkflowType struct { 714} 715 716func (*validateOpUndeprecateWorkflowType) ID() string { 717 return "OperationInputValidation" 718} 719 720func (m *validateOpUndeprecateWorkflowType) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 721 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 722) { 723 input, ok := in.Parameters.(*UndeprecateWorkflowTypeInput) 724 if !ok { 725 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 726 } 727 if err := validateOpUndeprecateWorkflowTypeInput(input); err != nil { 728 return out, metadata, err 729 } 730 return next.HandleInitialize(ctx, in) 731} 732 733type validateOpUntagResource struct { 734} 735 736func (*validateOpUntagResource) ID() string { 737 return "OperationInputValidation" 738} 739 740func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 741 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 742) { 743 input, ok := in.Parameters.(*UntagResourceInput) 744 if !ok { 745 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 746 } 747 if err := validateOpUntagResourceInput(input); err != nil { 748 return out, metadata, err 749 } 750 return next.HandleInitialize(ctx, in) 751} 752 753func addOpCountClosedWorkflowExecutionsValidationMiddleware(stack *middleware.Stack) error { 754 return stack.Initialize.Add(&validateOpCountClosedWorkflowExecutions{}, middleware.After) 755} 756 757func addOpCountOpenWorkflowExecutionsValidationMiddleware(stack *middleware.Stack) error { 758 return stack.Initialize.Add(&validateOpCountOpenWorkflowExecutions{}, middleware.After) 759} 760 761func addOpCountPendingActivityTasksValidationMiddleware(stack *middleware.Stack) error { 762 return stack.Initialize.Add(&validateOpCountPendingActivityTasks{}, middleware.After) 763} 764 765func addOpCountPendingDecisionTasksValidationMiddleware(stack *middleware.Stack) error { 766 return stack.Initialize.Add(&validateOpCountPendingDecisionTasks{}, middleware.After) 767} 768 769func addOpDeprecateActivityTypeValidationMiddleware(stack *middleware.Stack) error { 770 return stack.Initialize.Add(&validateOpDeprecateActivityType{}, middleware.After) 771} 772 773func addOpDeprecateDomainValidationMiddleware(stack *middleware.Stack) error { 774 return stack.Initialize.Add(&validateOpDeprecateDomain{}, middleware.After) 775} 776 777func addOpDeprecateWorkflowTypeValidationMiddleware(stack *middleware.Stack) error { 778 return stack.Initialize.Add(&validateOpDeprecateWorkflowType{}, middleware.After) 779} 780 781func addOpDescribeActivityTypeValidationMiddleware(stack *middleware.Stack) error { 782 return stack.Initialize.Add(&validateOpDescribeActivityType{}, middleware.After) 783} 784 785func addOpDescribeDomainValidationMiddleware(stack *middleware.Stack) error { 786 return stack.Initialize.Add(&validateOpDescribeDomain{}, middleware.After) 787} 788 789func addOpDescribeWorkflowExecutionValidationMiddleware(stack *middleware.Stack) error { 790 return stack.Initialize.Add(&validateOpDescribeWorkflowExecution{}, middleware.After) 791} 792 793func addOpDescribeWorkflowTypeValidationMiddleware(stack *middleware.Stack) error { 794 return stack.Initialize.Add(&validateOpDescribeWorkflowType{}, middleware.After) 795} 796 797func addOpGetWorkflowExecutionHistoryValidationMiddleware(stack *middleware.Stack) error { 798 return stack.Initialize.Add(&validateOpGetWorkflowExecutionHistory{}, middleware.After) 799} 800 801func addOpListActivityTypesValidationMiddleware(stack *middleware.Stack) error { 802 return stack.Initialize.Add(&validateOpListActivityTypes{}, middleware.After) 803} 804 805func addOpListClosedWorkflowExecutionsValidationMiddleware(stack *middleware.Stack) error { 806 return stack.Initialize.Add(&validateOpListClosedWorkflowExecutions{}, middleware.After) 807} 808 809func addOpListDomainsValidationMiddleware(stack *middleware.Stack) error { 810 return stack.Initialize.Add(&validateOpListDomains{}, middleware.After) 811} 812 813func addOpListOpenWorkflowExecutionsValidationMiddleware(stack *middleware.Stack) error { 814 return stack.Initialize.Add(&validateOpListOpenWorkflowExecutions{}, middleware.After) 815} 816 817func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 818 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 819} 820 821func addOpListWorkflowTypesValidationMiddleware(stack *middleware.Stack) error { 822 return stack.Initialize.Add(&validateOpListWorkflowTypes{}, middleware.After) 823} 824 825func addOpPollForActivityTaskValidationMiddleware(stack *middleware.Stack) error { 826 return stack.Initialize.Add(&validateOpPollForActivityTask{}, middleware.After) 827} 828 829func addOpPollForDecisionTaskValidationMiddleware(stack *middleware.Stack) error { 830 return stack.Initialize.Add(&validateOpPollForDecisionTask{}, middleware.After) 831} 832 833func addOpRecordActivityTaskHeartbeatValidationMiddleware(stack *middleware.Stack) error { 834 return stack.Initialize.Add(&validateOpRecordActivityTaskHeartbeat{}, middleware.After) 835} 836 837func addOpRegisterActivityTypeValidationMiddleware(stack *middleware.Stack) error { 838 return stack.Initialize.Add(&validateOpRegisterActivityType{}, middleware.After) 839} 840 841func addOpRegisterDomainValidationMiddleware(stack *middleware.Stack) error { 842 return stack.Initialize.Add(&validateOpRegisterDomain{}, middleware.After) 843} 844 845func addOpRegisterWorkflowTypeValidationMiddleware(stack *middleware.Stack) error { 846 return stack.Initialize.Add(&validateOpRegisterWorkflowType{}, middleware.After) 847} 848 849func addOpRequestCancelWorkflowExecutionValidationMiddleware(stack *middleware.Stack) error { 850 return stack.Initialize.Add(&validateOpRequestCancelWorkflowExecution{}, middleware.After) 851} 852 853func addOpRespondActivityTaskCanceledValidationMiddleware(stack *middleware.Stack) error { 854 return stack.Initialize.Add(&validateOpRespondActivityTaskCanceled{}, middleware.After) 855} 856 857func addOpRespondActivityTaskCompletedValidationMiddleware(stack *middleware.Stack) error { 858 return stack.Initialize.Add(&validateOpRespondActivityTaskCompleted{}, middleware.After) 859} 860 861func addOpRespondActivityTaskFailedValidationMiddleware(stack *middleware.Stack) error { 862 return stack.Initialize.Add(&validateOpRespondActivityTaskFailed{}, middleware.After) 863} 864 865func addOpRespondDecisionTaskCompletedValidationMiddleware(stack *middleware.Stack) error { 866 return stack.Initialize.Add(&validateOpRespondDecisionTaskCompleted{}, middleware.After) 867} 868 869func addOpSignalWorkflowExecutionValidationMiddleware(stack *middleware.Stack) error { 870 return stack.Initialize.Add(&validateOpSignalWorkflowExecution{}, middleware.After) 871} 872 873func addOpStartWorkflowExecutionValidationMiddleware(stack *middleware.Stack) error { 874 return stack.Initialize.Add(&validateOpStartWorkflowExecution{}, middleware.After) 875} 876 877func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 878 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 879} 880 881func addOpTerminateWorkflowExecutionValidationMiddleware(stack *middleware.Stack) error { 882 return stack.Initialize.Add(&validateOpTerminateWorkflowExecution{}, middleware.After) 883} 884 885func addOpUndeprecateActivityTypeValidationMiddleware(stack *middleware.Stack) error { 886 return stack.Initialize.Add(&validateOpUndeprecateActivityType{}, middleware.After) 887} 888 889func addOpUndeprecateDomainValidationMiddleware(stack *middleware.Stack) error { 890 return stack.Initialize.Add(&validateOpUndeprecateDomain{}, middleware.After) 891} 892 893func addOpUndeprecateWorkflowTypeValidationMiddleware(stack *middleware.Stack) error { 894 return stack.Initialize.Add(&validateOpUndeprecateWorkflowType{}, middleware.After) 895} 896 897func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 898 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 899} 900 901func validateActivityType(v *types.ActivityType) error { 902 if v == nil { 903 return nil 904 } 905 invalidParams := smithy.InvalidParamsError{Context: "ActivityType"} 906 if v.Name == nil { 907 invalidParams.Add(smithy.NewErrParamRequired("Name")) 908 } 909 if v.Version == nil { 910 invalidParams.Add(smithy.NewErrParamRequired("Version")) 911 } 912 if invalidParams.Len() > 0 { 913 return invalidParams 914 } else { 915 return nil 916 } 917} 918 919func validateCancelTimerDecisionAttributes(v *types.CancelTimerDecisionAttributes) error { 920 if v == nil { 921 return nil 922 } 923 invalidParams := smithy.InvalidParamsError{Context: "CancelTimerDecisionAttributes"} 924 if v.TimerId == nil { 925 invalidParams.Add(smithy.NewErrParamRequired("TimerId")) 926 } 927 if invalidParams.Len() > 0 { 928 return invalidParams 929 } else { 930 return nil 931 } 932} 933 934func validateCloseStatusFilter(v *types.CloseStatusFilter) error { 935 if v == nil { 936 return nil 937 } 938 invalidParams := smithy.InvalidParamsError{Context: "CloseStatusFilter"} 939 if len(v.Status) == 0 { 940 invalidParams.Add(smithy.NewErrParamRequired("Status")) 941 } 942 if invalidParams.Len() > 0 { 943 return invalidParams 944 } else { 945 return nil 946 } 947} 948 949func validateContinueAsNewWorkflowExecutionDecisionAttributes(v *types.ContinueAsNewWorkflowExecutionDecisionAttributes) error { 950 if v == nil { 951 return nil 952 } 953 invalidParams := smithy.InvalidParamsError{Context: "ContinueAsNewWorkflowExecutionDecisionAttributes"} 954 if v.TaskList != nil { 955 if err := validateTaskList(v.TaskList); err != nil { 956 invalidParams.AddNested("TaskList", err.(smithy.InvalidParamsError)) 957 } 958 } 959 if invalidParams.Len() > 0 { 960 return invalidParams 961 } else { 962 return nil 963 } 964} 965 966func validateDecision(v *types.Decision) error { 967 if v == nil { 968 return nil 969 } 970 invalidParams := smithy.InvalidParamsError{Context: "Decision"} 971 if len(v.DecisionType) == 0 { 972 invalidParams.Add(smithy.NewErrParamRequired("DecisionType")) 973 } 974 if v.ScheduleActivityTaskDecisionAttributes != nil { 975 if err := validateScheduleActivityTaskDecisionAttributes(v.ScheduleActivityTaskDecisionAttributes); err != nil { 976 invalidParams.AddNested("ScheduleActivityTaskDecisionAttributes", err.(smithy.InvalidParamsError)) 977 } 978 } 979 if v.RequestCancelActivityTaskDecisionAttributes != nil { 980 if err := validateRequestCancelActivityTaskDecisionAttributes(v.RequestCancelActivityTaskDecisionAttributes); err != nil { 981 invalidParams.AddNested("RequestCancelActivityTaskDecisionAttributes", err.(smithy.InvalidParamsError)) 982 } 983 } 984 if v.ContinueAsNewWorkflowExecutionDecisionAttributes != nil { 985 if err := validateContinueAsNewWorkflowExecutionDecisionAttributes(v.ContinueAsNewWorkflowExecutionDecisionAttributes); err != nil { 986 invalidParams.AddNested("ContinueAsNewWorkflowExecutionDecisionAttributes", err.(smithy.InvalidParamsError)) 987 } 988 } 989 if v.RecordMarkerDecisionAttributes != nil { 990 if err := validateRecordMarkerDecisionAttributes(v.RecordMarkerDecisionAttributes); err != nil { 991 invalidParams.AddNested("RecordMarkerDecisionAttributes", err.(smithy.InvalidParamsError)) 992 } 993 } 994 if v.StartTimerDecisionAttributes != nil { 995 if err := validateStartTimerDecisionAttributes(v.StartTimerDecisionAttributes); err != nil { 996 invalidParams.AddNested("StartTimerDecisionAttributes", err.(smithy.InvalidParamsError)) 997 } 998 } 999 if v.CancelTimerDecisionAttributes != nil { 1000 if err := validateCancelTimerDecisionAttributes(v.CancelTimerDecisionAttributes); err != nil { 1001 invalidParams.AddNested("CancelTimerDecisionAttributes", err.(smithy.InvalidParamsError)) 1002 } 1003 } 1004 if v.SignalExternalWorkflowExecutionDecisionAttributes != nil { 1005 if err := validateSignalExternalWorkflowExecutionDecisionAttributes(v.SignalExternalWorkflowExecutionDecisionAttributes); err != nil { 1006 invalidParams.AddNested("SignalExternalWorkflowExecutionDecisionAttributes", err.(smithy.InvalidParamsError)) 1007 } 1008 } 1009 if v.RequestCancelExternalWorkflowExecutionDecisionAttributes != nil { 1010 if err := validateRequestCancelExternalWorkflowExecutionDecisionAttributes(v.RequestCancelExternalWorkflowExecutionDecisionAttributes); err != nil { 1011 invalidParams.AddNested("RequestCancelExternalWorkflowExecutionDecisionAttributes", err.(smithy.InvalidParamsError)) 1012 } 1013 } 1014 if v.StartChildWorkflowExecutionDecisionAttributes != nil { 1015 if err := validateStartChildWorkflowExecutionDecisionAttributes(v.StartChildWorkflowExecutionDecisionAttributes); err != nil { 1016 invalidParams.AddNested("StartChildWorkflowExecutionDecisionAttributes", err.(smithy.InvalidParamsError)) 1017 } 1018 } 1019 if v.ScheduleLambdaFunctionDecisionAttributes != nil { 1020 if err := validateScheduleLambdaFunctionDecisionAttributes(v.ScheduleLambdaFunctionDecisionAttributes); err != nil { 1021 invalidParams.AddNested("ScheduleLambdaFunctionDecisionAttributes", err.(smithy.InvalidParamsError)) 1022 } 1023 } 1024 if invalidParams.Len() > 0 { 1025 return invalidParams 1026 } else { 1027 return nil 1028 } 1029} 1030 1031func validateDecisionList(v []types.Decision) error { 1032 if v == nil { 1033 return nil 1034 } 1035 invalidParams := smithy.InvalidParamsError{Context: "DecisionList"} 1036 for i := range v { 1037 if err := validateDecision(&v[i]); err != nil { 1038 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1039 } 1040 } 1041 if invalidParams.Len() > 0 { 1042 return invalidParams 1043 } else { 1044 return nil 1045 } 1046} 1047 1048func validateExecutionTimeFilter(v *types.ExecutionTimeFilter) error { 1049 if v == nil { 1050 return nil 1051 } 1052 invalidParams := smithy.InvalidParamsError{Context: "ExecutionTimeFilter"} 1053 if v.OldestDate == nil { 1054 invalidParams.Add(smithy.NewErrParamRequired("OldestDate")) 1055 } 1056 if invalidParams.Len() > 0 { 1057 return invalidParams 1058 } else { 1059 return nil 1060 } 1061} 1062 1063func validateRecordMarkerDecisionAttributes(v *types.RecordMarkerDecisionAttributes) error { 1064 if v == nil { 1065 return nil 1066 } 1067 invalidParams := smithy.InvalidParamsError{Context: "RecordMarkerDecisionAttributes"} 1068 if v.MarkerName == nil { 1069 invalidParams.Add(smithy.NewErrParamRequired("MarkerName")) 1070 } 1071 if invalidParams.Len() > 0 { 1072 return invalidParams 1073 } else { 1074 return nil 1075 } 1076} 1077 1078func validateRequestCancelActivityTaskDecisionAttributes(v *types.RequestCancelActivityTaskDecisionAttributes) error { 1079 if v == nil { 1080 return nil 1081 } 1082 invalidParams := smithy.InvalidParamsError{Context: "RequestCancelActivityTaskDecisionAttributes"} 1083 if v.ActivityId == nil { 1084 invalidParams.Add(smithy.NewErrParamRequired("ActivityId")) 1085 } 1086 if invalidParams.Len() > 0 { 1087 return invalidParams 1088 } else { 1089 return nil 1090 } 1091} 1092 1093func validateRequestCancelExternalWorkflowExecutionDecisionAttributes(v *types.RequestCancelExternalWorkflowExecutionDecisionAttributes) error { 1094 if v == nil { 1095 return nil 1096 } 1097 invalidParams := smithy.InvalidParamsError{Context: "RequestCancelExternalWorkflowExecutionDecisionAttributes"} 1098 if v.WorkflowId == nil { 1099 invalidParams.Add(smithy.NewErrParamRequired("WorkflowId")) 1100 } 1101 if invalidParams.Len() > 0 { 1102 return invalidParams 1103 } else { 1104 return nil 1105 } 1106} 1107 1108func validateResourceTag(v *types.ResourceTag) error { 1109 if v == nil { 1110 return nil 1111 } 1112 invalidParams := smithy.InvalidParamsError{Context: "ResourceTag"} 1113 if v.Key == nil { 1114 invalidParams.Add(smithy.NewErrParamRequired("Key")) 1115 } 1116 if invalidParams.Len() > 0 { 1117 return invalidParams 1118 } else { 1119 return nil 1120 } 1121} 1122 1123func validateResourceTagList(v []types.ResourceTag) error { 1124 if v == nil { 1125 return nil 1126 } 1127 invalidParams := smithy.InvalidParamsError{Context: "ResourceTagList"} 1128 for i := range v { 1129 if err := validateResourceTag(&v[i]); err != nil { 1130 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1131 } 1132 } 1133 if invalidParams.Len() > 0 { 1134 return invalidParams 1135 } else { 1136 return nil 1137 } 1138} 1139 1140func validateScheduleActivityTaskDecisionAttributes(v *types.ScheduleActivityTaskDecisionAttributes) error { 1141 if v == nil { 1142 return nil 1143 } 1144 invalidParams := smithy.InvalidParamsError{Context: "ScheduleActivityTaskDecisionAttributes"} 1145 if v.ActivityType == nil { 1146 invalidParams.Add(smithy.NewErrParamRequired("ActivityType")) 1147 } else if v.ActivityType != nil { 1148 if err := validateActivityType(v.ActivityType); err != nil { 1149 invalidParams.AddNested("ActivityType", err.(smithy.InvalidParamsError)) 1150 } 1151 } 1152 if v.ActivityId == nil { 1153 invalidParams.Add(smithy.NewErrParamRequired("ActivityId")) 1154 } 1155 if v.TaskList != nil { 1156 if err := validateTaskList(v.TaskList); err != nil { 1157 invalidParams.AddNested("TaskList", err.(smithy.InvalidParamsError)) 1158 } 1159 } 1160 if invalidParams.Len() > 0 { 1161 return invalidParams 1162 } else { 1163 return nil 1164 } 1165} 1166 1167func validateScheduleLambdaFunctionDecisionAttributes(v *types.ScheduleLambdaFunctionDecisionAttributes) error { 1168 if v == nil { 1169 return nil 1170 } 1171 invalidParams := smithy.InvalidParamsError{Context: "ScheduleLambdaFunctionDecisionAttributes"} 1172 if v.Id == nil { 1173 invalidParams.Add(smithy.NewErrParamRequired("Id")) 1174 } 1175 if v.Name == nil { 1176 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1177 } 1178 if invalidParams.Len() > 0 { 1179 return invalidParams 1180 } else { 1181 return nil 1182 } 1183} 1184 1185func validateSignalExternalWorkflowExecutionDecisionAttributes(v *types.SignalExternalWorkflowExecutionDecisionAttributes) error { 1186 if v == nil { 1187 return nil 1188 } 1189 invalidParams := smithy.InvalidParamsError{Context: "SignalExternalWorkflowExecutionDecisionAttributes"} 1190 if v.WorkflowId == nil { 1191 invalidParams.Add(smithy.NewErrParamRequired("WorkflowId")) 1192 } 1193 if v.SignalName == nil { 1194 invalidParams.Add(smithy.NewErrParamRequired("SignalName")) 1195 } 1196 if invalidParams.Len() > 0 { 1197 return invalidParams 1198 } else { 1199 return nil 1200 } 1201} 1202 1203func validateStartChildWorkflowExecutionDecisionAttributes(v *types.StartChildWorkflowExecutionDecisionAttributes) error { 1204 if v == nil { 1205 return nil 1206 } 1207 invalidParams := smithy.InvalidParamsError{Context: "StartChildWorkflowExecutionDecisionAttributes"} 1208 if v.WorkflowType == nil { 1209 invalidParams.Add(smithy.NewErrParamRequired("WorkflowType")) 1210 } else if v.WorkflowType != nil { 1211 if err := validateWorkflowType(v.WorkflowType); err != nil { 1212 invalidParams.AddNested("WorkflowType", err.(smithy.InvalidParamsError)) 1213 } 1214 } 1215 if v.WorkflowId == nil { 1216 invalidParams.Add(smithy.NewErrParamRequired("WorkflowId")) 1217 } 1218 if v.TaskList != nil { 1219 if err := validateTaskList(v.TaskList); err != nil { 1220 invalidParams.AddNested("TaskList", err.(smithy.InvalidParamsError)) 1221 } 1222 } 1223 if invalidParams.Len() > 0 { 1224 return invalidParams 1225 } else { 1226 return nil 1227 } 1228} 1229 1230func validateStartTimerDecisionAttributes(v *types.StartTimerDecisionAttributes) error { 1231 if v == nil { 1232 return nil 1233 } 1234 invalidParams := smithy.InvalidParamsError{Context: "StartTimerDecisionAttributes"} 1235 if v.TimerId == nil { 1236 invalidParams.Add(smithy.NewErrParamRequired("TimerId")) 1237 } 1238 if v.StartToFireTimeout == nil { 1239 invalidParams.Add(smithy.NewErrParamRequired("StartToFireTimeout")) 1240 } 1241 if invalidParams.Len() > 0 { 1242 return invalidParams 1243 } else { 1244 return nil 1245 } 1246} 1247 1248func validateTagFilter(v *types.TagFilter) error { 1249 if v == nil { 1250 return nil 1251 } 1252 invalidParams := smithy.InvalidParamsError{Context: "TagFilter"} 1253 if v.Tag == nil { 1254 invalidParams.Add(smithy.NewErrParamRequired("Tag")) 1255 } 1256 if invalidParams.Len() > 0 { 1257 return invalidParams 1258 } else { 1259 return nil 1260 } 1261} 1262 1263func validateTaskList(v *types.TaskList) error { 1264 if v == nil { 1265 return nil 1266 } 1267 invalidParams := smithy.InvalidParamsError{Context: "TaskList"} 1268 if v.Name == nil { 1269 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1270 } 1271 if invalidParams.Len() > 0 { 1272 return invalidParams 1273 } else { 1274 return nil 1275 } 1276} 1277 1278func validateWorkflowExecution(v *types.WorkflowExecution) error { 1279 if v == nil { 1280 return nil 1281 } 1282 invalidParams := smithy.InvalidParamsError{Context: "WorkflowExecution"} 1283 if v.WorkflowId == nil { 1284 invalidParams.Add(smithy.NewErrParamRequired("WorkflowId")) 1285 } 1286 if v.RunId == nil { 1287 invalidParams.Add(smithy.NewErrParamRequired("RunId")) 1288 } 1289 if invalidParams.Len() > 0 { 1290 return invalidParams 1291 } else { 1292 return nil 1293 } 1294} 1295 1296func validateWorkflowExecutionFilter(v *types.WorkflowExecutionFilter) error { 1297 if v == nil { 1298 return nil 1299 } 1300 invalidParams := smithy.InvalidParamsError{Context: "WorkflowExecutionFilter"} 1301 if v.WorkflowId == nil { 1302 invalidParams.Add(smithy.NewErrParamRequired("WorkflowId")) 1303 } 1304 if invalidParams.Len() > 0 { 1305 return invalidParams 1306 } else { 1307 return nil 1308 } 1309} 1310 1311func validateWorkflowType(v *types.WorkflowType) error { 1312 if v == nil { 1313 return nil 1314 } 1315 invalidParams := smithy.InvalidParamsError{Context: "WorkflowType"} 1316 if v.Name == nil { 1317 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1318 } 1319 if v.Version == nil { 1320 invalidParams.Add(smithy.NewErrParamRequired("Version")) 1321 } 1322 if invalidParams.Len() > 0 { 1323 return invalidParams 1324 } else { 1325 return nil 1326 } 1327} 1328 1329func validateWorkflowTypeFilter(v *types.WorkflowTypeFilter) error { 1330 if v == nil { 1331 return nil 1332 } 1333 invalidParams := smithy.InvalidParamsError{Context: "WorkflowTypeFilter"} 1334 if v.Name == nil { 1335 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1336 } 1337 if invalidParams.Len() > 0 { 1338 return invalidParams 1339 } else { 1340 return nil 1341 } 1342} 1343 1344func validateOpCountClosedWorkflowExecutionsInput(v *CountClosedWorkflowExecutionsInput) error { 1345 if v == nil { 1346 return nil 1347 } 1348 invalidParams := smithy.InvalidParamsError{Context: "CountClosedWorkflowExecutionsInput"} 1349 if v.Domain == nil { 1350 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 1351 } 1352 if v.StartTimeFilter != nil { 1353 if err := validateExecutionTimeFilter(v.StartTimeFilter); err != nil { 1354 invalidParams.AddNested("StartTimeFilter", err.(smithy.InvalidParamsError)) 1355 } 1356 } 1357 if v.CloseTimeFilter != nil { 1358 if err := validateExecutionTimeFilter(v.CloseTimeFilter); err != nil { 1359 invalidParams.AddNested("CloseTimeFilter", err.(smithy.InvalidParamsError)) 1360 } 1361 } 1362 if v.ExecutionFilter != nil { 1363 if err := validateWorkflowExecutionFilter(v.ExecutionFilter); err != nil { 1364 invalidParams.AddNested("ExecutionFilter", err.(smithy.InvalidParamsError)) 1365 } 1366 } 1367 if v.TypeFilter != nil { 1368 if err := validateWorkflowTypeFilter(v.TypeFilter); err != nil { 1369 invalidParams.AddNested("TypeFilter", err.(smithy.InvalidParamsError)) 1370 } 1371 } 1372 if v.TagFilter != nil { 1373 if err := validateTagFilter(v.TagFilter); err != nil { 1374 invalidParams.AddNested("TagFilter", err.(smithy.InvalidParamsError)) 1375 } 1376 } 1377 if v.CloseStatusFilter != nil { 1378 if err := validateCloseStatusFilter(v.CloseStatusFilter); err != nil { 1379 invalidParams.AddNested("CloseStatusFilter", err.(smithy.InvalidParamsError)) 1380 } 1381 } 1382 if invalidParams.Len() > 0 { 1383 return invalidParams 1384 } else { 1385 return nil 1386 } 1387} 1388 1389func validateOpCountOpenWorkflowExecutionsInput(v *CountOpenWorkflowExecutionsInput) error { 1390 if v == nil { 1391 return nil 1392 } 1393 invalidParams := smithy.InvalidParamsError{Context: "CountOpenWorkflowExecutionsInput"} 1394 if v.Domain == nil { 1395 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 1396 } 1397 if v.StartTimeFilter == nil { 1398 invalidParams.Add(smithy.NewErrParamRequired("StartTimeFilter")) 1399 } else if v.StartTimeFilter != nil { 1400 if err := validateExecutionTimeFilter(v.StartTimeFilter); err != nil { 1401 invalidParams.AddNested("StartTimeFilter", err.(smithy.InvalidParamsError)) 1402 } 1403 } 1404 if v.TypeFilter != nil { 1405 if err := validateWorkflowTypeFilter(v.TypeFilter); err != nil { 1406 invalidParams.AddNested("TypeFilter", err.(smithy.InvalidParamsError)) 1407 } 1408 } 1409 if v.TagFilter != nil { 1410 if err := validateTagFilter(v.TagFilter); err != nil { 1411 invalidParams.AddNested("TagFilter", err.(smithy.InvalidParamsError)) 1412 } 1413 } 1414 if v.ExecutionFilter != nil { 1415 if err := validateWorkflowExecutionFilter(v.ExecutionFilter); err != nil { 1416 invalidParams.AddNested("ExecutionFilter", err.(smithy.InvalidParamsError)) 1417 } 1418 } 1419 if invalidParams.Len() > 0 { 1420 return invalidParams 1421 } else { 1422 return nil 1423 } 1424} 1425 1426func validateOpCountPendingActivityTasksInput(v *CountPendingActivityTasksInput) error { 1427 if v == nil { 1428 return nil 1429 } 1430 invalidParams := smithy.InvalidParamsError{Context: "CountPendingActivityTasksInput"} 1431 if v.Domain == nil { 1432 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 1433 } 1434 if v.TaskList == nil { 1435 invalidParams.Add(smithy.NewErrParamRequired("TaskList")) 1436 } else if v.TaskList != nil { 1437 if err := validateTaskList(v.TaskList); err != nil { 1438 invalidParams.AddNested("TaskList", err.(smithy.InvalidParamsError)) 1439 } 1440 } 1441 if invalidParams.Len() > 0 { 1442 return invalidParams 1443 } else { 1444 return nil 1445 } 1446} 1447 1448func validateOpCountPendingDecisionTasksInput(v *CountPendingDecisionTasksInput) error { 1449 if v == nil { 1450 return nil 1451 } 1452 invalidParams := smithy.InvalidParamsError{Context: "CountPendingDecisionTasksInput"} 1453 if v.Domain == nil { 1454 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 1455 } 1456 if v.TaskList == nil { 1457 invalidParams.Add(smithy.NewErrParamRequired("TaskList")) 1458 } else if v.TaskList != nil { 1459 if err := validateTaskList(v.TaskList); err != nil { 1460 invalidParams.AddNested("TaskList", err.(smithy.InvalidParamsError)) 1461 } 1462 } 1463 if invalidParams.Len() > 0 { 1464 return invalidParams 1465 } else { 1466 return nil 1467 } 1468} 1469 1470func validateOpDeprecateActivityTypeInput(v *DeprecateActivityTypeInput) error { 1471 if v == nil { 1472 return nil 1473 } 1474 invalidParams := smithy.InvalidParamsError{Context: "DeprecateActivityTypeInput"} 1475 if v.Domain == nil { 1476 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 1477 } 1478 if v.ActivityType == nil { 1479 invalidParams.Add(smithy.NewErrParamRequired("ActivityType")) 1480 } else if v.ActivityType != nil { 1481 if err := validateActivityType(v.ActivityType); err != nil { 1482 invalidParams.AddNested("ActivityType", err.(smithy.InvalidParamsError)) 1483 } 1484 } 1485 if invalidParams.Len() > 0 { 1486 return invalidParams 1487 } else { 1488 return nil 1489 } 1490} 1491 1492func validateOpDeprecateDomainInput(v *DeprecateDomainInput) error { 1493 if v == nil { 1494 return nil 1495 } 1496 invalidParams := smithy.InvalidParamsError{Context: "DeprecateDomainInput"} 1497 if v.Name == nil { 1498 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1499 } 1500 if invalidParams.Len() > 0 { 1501 return invalidParams 1502 } else { 1503 return nil 1504 } 1505} 1506 1507func validateOpDeprecateWorkflowTypeInput(v *DeprecateWorkflowTypeInput) error { 1508 if v == nil { 1509 return nil 1510 } 1511 invalidParams := smithy.InvalidParamsError{Context: "DeprecateWorkflowTypeInput"} 1512 if v.Domain == nil { 1513 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 1514 } 1515 if v.WorkflowType == nil { 1516 invalidParams.Add(smithy.NewErrParamRequired("WorkflowType")) 1517 } else if v.WorkflowType != nil { 1518 if err := validateWorkflowType(v.WorkflowType); err != nil { 1519 invalidParams.AddNested("WorkflowType", err.(smithy.InvalidParamsError)) 1520 } 1521 } 1522 if invalidParams.Len() > 0 { 1523 return invalidParams 1524 } else { 1525 return nil 1526 } 1527} 1528 1529func validateOpDescribeActivityTypeInput(v *DescribeActivityTypeInput) error { 1530 if v == nil { 1531 return nil 1532 } 1533 invalidParams := smithy.InvalidParamsError{Context: "DescribeActivityTypeInput"} 1534 if v.Domain == nil { 1535 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 1536 } 1537 if v.ActivityType == nil { 1538 invalidParams.Add(smithy.NewErrParamRequired("ActivityType")) 1539 } else if v.ActivityType != nil { 1540 if err := validateActivityType(v.ActivityType); err != nil { 1541 invalidParams.AddNested("ActivityType", err.(smithy.InvalidParamsError)) 1542 } 1543 } 1544 if invalidParams.Len() > 0 { 1545 return invalidParams 1546 } else { 1547 return nil 1548 } 1549} 1550 1551func validateOpDescribeDomainInput(v *DescribeDomainInput) error { 1552 if v == nil { 1553 return nil 1554 } 1555 invalidParams := smithy.InvalidParamsError{Context: "DescribeDomainInput"} 1556 if v.Name == nil { 1557 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1558 } 1559 if invalidParams.Len() > 0 { 1560 return invalidParams 1561 } else { 1562 return nil 1563 } 1564} 1565 1566func validateOpDescribeWorkflowExecutionInput(v *DescribeWorkflowExecutionInput) error { 1567 if v == nil { 1568 return nil 1569 } 1570 invalidParams := smithy.InvalidParamsError{Context: "DescribeWorkflowExecutionInput"} 1571 if v.Domain == nil { 1572 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 1573 } 1574 if v.Execution == nil { 1575 invalidParams.Add(smithy.NewErrParamRequired("Execution")) 1576 } else if v.Execution != nil { 1577 if err := validateWorkflowExecution(v.Execution); err != nil { 1578 invalidParams.AddNested("Execution", err.(smithy.InvalidParamsError)) 1579 } 1580 } 1581 if invalidParams.Len() > 0 { 1582 return invalidParams 1583 } else { 1584 return nil 1585 } 1586} 1587 1588func validateOpDescribeWorkflowTypeInput(v *DescribeWorkflowTypeInput) error { 1589 if v == nil { 1590 return nil 1591 } 1592 invalidParams := smithy.InvalidParamsError{Context: "DescribeWorkflowTypeInput"} 1593 if v.Domain == nil { 1594 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 1595 } 1596 if v.WorkflowType == nil { 1597 invalidParams.Add(smithy.NewErrParamRequired("WorkflowType")) 1598 } else if v.WorkflowType != nil { 1599 if err := validateWorkflowType(v.WorkflowType); err != nil { 1600 invalidParams.AddNested("WorkflowType", err.(smithy.InvalidParamsError)) 1601 } 1602 } 1603 if invalidParams.Len() > 0 { 1604 return invalidParams 1605 } else { 1606 return nil 1607 } 1608} 1609 1610func validateOpGetWorkflowExecutionHistoryInput(v *GetWorkflowExecutionHistoryInput) error { 1611 if v == nil { 1612 return nil 1613 } 1614 invalidParams := smithy.InvalidParamsError{Context: "GetWorkflowExecutionHistoryInput"} 1615 if v.Domain == nil { 1616 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 1617 } 1618 if v.Execution == nil { 1619 invalidParams.Add(smithy.NewErrParamRequired("Execution")) 1620 } else if v.Execution != nil { 1621 if err := validateWorkflowExecution(v.Execution); err != nil { 1622 invalidParams.AddNested("Execution", err.(smithy.InvalidParamsError)) 1623 } 1624 } 1625 if invalidParams.Len() > 0 { 1626 return invalidParams 1627 } else { 1628 return nil 1629 } 1630} 1631 1632func validateOpListActivityTypesInput(v *ListActivityTypesInput) error { 1633 if v == nil { 1634 return nil 1635 } 1636 invalidParams := smithy.InvalidParamsError{Context: "ListActivityTypesInput"} 1637 if v.Domain == nil { 1638 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 1639 } 1640 if len(v.RegistrationStatus) == 0 { 1641 invalidParams.Add(smithy.NewErrParamRequired("RegistrationStatus")) 1642 } 1643 if invalidParams.Len() > 0 { 1644 return invalidParams 1645 } else { 1646 return nil 1647 } 1648} 1649 1650func validateOpListClosedWorkflowExecutionsInput(v *ListClosedWorkflowExecutionsInput) error { 1651 if v == nil { 1652 return nil 1653 } 1654 invalidParams := smithy.InvalidParamsError{Context: "ListClosedWorkflowExecutionsInput"} 1655 if v.Domain == nil { 1656 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 1657 } 1658 if v.StartTimeFilter != nil { 1659 if err := validateExecutionTimeFilter(v.StartTimeFilter); err != nil { 1660 invalidParams.AddNested("StartTimeFilter", err.(smithy.InvalidParamsError)) 1661 } 1662 } 1663 if v.CloseTimeFilter != nil { 1664 if err := validateExecutionTimeFilter(v.CloseTimeFilter); err != nil { 1665 invalidParams.AddNested("CloseTimeFilter", err.(smithy.InvalidParamsError)) 1666 } 1667 } 1668 if v.ExecutionFilter != nil { 1669 if err := validateWorkflowExecutionFilter(v.ExecutionFilter); err != nil { 1670 invalidParams.AddNested("ExecutionFilter", err.(smithy.InvalidParamsError)) 1671 } 1672 } 1673 if v.CloseStatusFilter != nil { 1674 if err := validateCloseStatusFilter(v.CloseStatusFilter); err != nil { 1675 invalidParams.AddNested("CloseStatusFilter", err.(smithy.InvalidParamsError)) 1676 } 1677 } 1678 if v.TypeFilter != nil { 1679 if err := validateWorkflowTypeFilter(v.TypeFilter); err != nil { 1680 invalidParams.AddNested("TypeFilter", err.(smithy.InvalidParamsError)) 1681 } 1682 } 1683 if v.TagFilter != nil { 1684 if err := validateTagFilter(v.TagFilter); err != nil { 1685 invalidParams.AddNested("TagFilter", err.(smithy.InvalidParamsError)) 1686 } 1687 } 1688 if invalidParams.Len() > 0 { 1689 return invalidParams 1690 } else { 1691 return nil 1692 } 1693} 1694 1695func validateOpListDomainsInput(v *ListDomainsInput) error { 1696 if v == nil { 1697 return nil 1698 } 1699 invalidParams := smithy.InvalidParamsError{Context: "ListDomainsInput"} 1700 if len(v.RegistrationStatus) == 0 { 1701 invalidParams.Add(smithy.NewErrParamRequired("RegistrationStatus")) 1702 } 1703 if invalidParams.Len() > 0 { 1704 return invalidParams 1705 } else { 1706 return nil 1707 } 1708} 1709 1710func validateOpListOpenWorkflowExecutionsInput(v *ListOpenWorkflowExecutionsInput) error { 1711 if v == nil { 1712 return nil 1713 } 1714 invalidParams := smithy.InvalidParamsError{Context: "ListOpenWorkflowExecutionsInput"} 1715 if v.Domain == nil { 1716 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 1717 } 1718 if v.StartTimeFilter == nil { 1719 invalidParams.Add(smithy.NewErrParamRequired("StartTimeFilter")) 1720 } else if v.StartTimeFilter != nil { 1721 if err := validateExecutionTimeFilter(v.StartTimeFilter); err != nil { 1722 invalidParams.AddNested("StartTimeFilter", err.(smithy.InvalidParamsError)) 1723 } 1724 } 1725 if v.TypeFilter != nil { 1726 if err := validateWorkflowTypeFilter(v.TypeFilter); err != nil { 1727 invalidParams.AddNested("TypeFilter", err.(smithy.InvalidParamsError)) 1728 } 1729 } 1730 if v.TagFilter != nil { 1731 if err := validateTagFilter(v.TagFilter); err != nil { 1732 invalidParams.AddNested("TagFilter", err.(smithy.InvalidParamsError)) 1733 } 1734 } 1735 if v.ExecutionFilter != nil { 1736 if err := validateWorkflowExecutionFilter(v.ExecutionFilter); err != nil { 1737 invalidParams.AddNested("ExecutionFilter", err.(smithy.InvalidParamsError)) 1738 } 1739 } 1740 if invalidParams.Len() > 0 { 1741 return invalidParams 1742 } else { 1743 return nil 1744 } 1745} 1746 1747func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 1748 if v == nil { 1749 return nil 1750 } 1751 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 1752 if v.ResourceArn == nil { 1753 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1754 } 1755 if invalidParams.Len() > 0 { 1756 return invalidParams 1757 } else { 1758 return nil 1759 } 1760} 1761 1762func validateOpListWorkflowTypesInput(v *ListWorkflowTypesInput) error { 1763 if v == nil { 1764 return nil 1765 } 1766 invalidParams := smithy.InvalidParamsError{Context: "ListWorkflowTypesInput"} 1767 if v.Domain == nil { 1768 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 1769 } 1770 if len(v.RegistrationStatus) == 0 { 1771 invalidParams.Add(smithy.NewErrParamRequired("RegistrationStatus")) 1772 } 1773 if invalidParams.Len() > 0 { 1774 return invalidParams 1775 } else { 1776 return nil 1777 } 1778} 1779 1780func validateOpPollForActivityTaskInput(v *PollForActivityTaskInput) error { 1781 if v == nil { 1782 return nil 1783 } 1784 invalidParams := smithy.InvalidParamsError{Context: "PollForActivityTaskInput"} 1785 if v.Domain == nil { 1786 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 1787 } 1788 if v.TaskList == nil { 1789 invalidParams.Add(smithy.NewErrParamRequired("TaskList")) 1790 } else if v.TaskList != nil { 1791 if err := validateTaskList(v.TaskList); err != nil { 1792 invalidParams.AddNested("TaskList", err.(smithy.InvalidParamsError)) 1793 } 1794 } 1795 if invalidParams.Len() > 0 { 1796 return invalidParams 1797 } else { 1798 return nil 1799 } 1800} 1801 1802func validateOpPollForDecisionTaskInput(v *PollForDecisionTaskInput) error { 1803 if v == nil { 1804 return nil 1805 } 1806 invalidParams := smithy.InvalidParamsError{Context: "PollForDecisionTaskInput"} 1807 if v.Domain == nil { 1808 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 1809 } 1810 if v.TaskList == nil { 1811 invalidParams.Add(smithy.NewErrParamRequired("TaskList")) 1812 } else if v.TaskList != nil { 1813 if err := validateTaskList(v.TaskList); err != nil { 1814 invalidParams.AddNested("TaskList", err.(smithy.InvalidParamsError)) 1815 } 1816 } 1817 if invalidParams.Len() > 0 { 1818 return invalidParams 1819 } else { 1820 return nil 1821 } 1822} 1823 1824func validateOpRecordActivityTaskHeartbeatInput(v *RecordActivityTaskHeartbeatInput) error { 1825 if v == nil { 1826 return nil 1827 } 1828 invalidParams := smithy.InvalidParamsError{Context: "RecordActivityTaskHeartbeatInput"} 1829 if v.TaskToken == nil { 1830 invalidParams.Add(smithy.NewErrParamRequired("TaskToken")) 1831 } 1832 if invalidParams.Len() > 0 { 1833 return invalidParams 1834 } else { 1835 return nil 1836 } 1837} 1838 1839func validateOpRegisterActivityTypeInput(v *RegisterActivityTypeInput) error { 1840 if v == nil { 1841 return nil 1842 } 1843 invalidParams := smithy.InvalidParamsError{Context: "RegisterActivityTypeInput"} 1844 if v.Domain == nil { 1845 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 1846 } 1847 if v.Name == nil { 1848 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1849 } 1850 if v.Version == nil { 1851 invalidParams.Add(smithy.NewErrParamRequired("Version")) 1852 } 1853 if v.DefaultTaskList != nil { 1854 if err := validateTaskList(v.DefaultTaskList); err != nil { 1855 invalidParams.AddNested("DefaultTaskList", err.(smithy.InvalidParamsError)) 1856 } 1857 } 1858 if invalidParams.Len() > 0 { 1859 return invalidParams 1860 } else { 1861 return nil 1862 } 1863} 1864 1865func validateOpRegisterDomainInput(v *RegisterDomainInput) error { 1866 if v == nil { 1867 return nil 1868 } 1869 invalidParams := smithy.InvalidParamsError{Context: "RegisterDomainInput"} 1870 if v.Name == nil { 1871 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1872 } 1873 if v.WorkflowExecutionRetentionPeriodInDays == nil { 1874 invalidParams.Add(smithy.NewErrParamRequired("WorkflowExecutionRetentionPeriodInDays")) 1875 } 1876 if v.Tags != nil { 1877 if err := validateResourceTagList(v.Tags); err != nil { 1878 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1879 } 1880 } 1881 if invalidParams.Len() > 0 { 1882 return invalidParams 1883 } else { 1884 return nil 1885 } 1886} 1887 1888func validateOpRegisterWorkflowTypeInput(v *RegisterWorkflowTypeInput) error { 1889 if v == nil { 1890 return nil 1891 } 1892 invalidParams := smithy.InvalidParamsError{Context: "RegisterWorkflowTypeInput"} 1893 if v.Domain == nil { 1894 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 1895 } 1896 if v.Name == nil { 1897 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1898 } 1899 if v.Version == nil { 1900 invalidParams.Add(smithy.NewErrParamRequired("Version")) 1901 } 1902 if v.DefaultTaskList != nil { 1903 if err := validateTaskList(v.DefaultTaskList); err != nil { 1904 invalidParams.AddNested("DefaultTaskList", err.(smithy.InvalidParamsError)) 1905 } 1906 } 1907 if invalidParams.Len() > 0 { 1908 return invalidParams 1909 } else { 1910 return nil 1911 } 1912} 1913 1914func validateOpRequestCancelWorkflowExecutionInput(v *RequestCancelWorkflowExecutionInput) error { 1915 if v == nil { 1916 return nil 1917 } 1918 invalidParams := smithy.InvalidParamsError{Context: "RequestCancelWorkflowExecutionInput"} 1919 if v.Domain == nil { 1920 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 1921 } 1922 if v.WorkflowId == nil { 1923 invalidParams.Add(smithy.NewErrParamRequired("WorkflowId")) 1924 } 1925 if invalidParams.Len() > 0 { 1926 return invalidParams 1927 } else { 1928 return nil 1929 } 1930} 1931 1932func validateOpRespondActivityTaskCanceledInput(v *RespondActivityTaskCanceledInput) error { 1933 if v == nil { 1934 return nil 1935 } 1936 invalidParams := smithy.InvalidParamsError{Context: "RespondActivityTaskCanceledInput"} 1937 if v.TaskToken == nil { 1938 invalidParams.Add(smithy.NewErrParamRequired("TaskToken")) 1939 } 1940 if invalidParams.Len() > 0 { 1941 return invalidParams 1942 } else { 1943 return nil 1944 } 1945} 1946 1947func validateOpRespondActivityTaskCompletedInput(v *RespondActivityTaskCompletedInput) error { 1948 if v == nil { 1949 return nil 1950 } 1951 invalidParams := smithy.InvalidParamsError{Context: "RespondActivityTaskCompletedInput"} 1952 if v.TaskToken == nil { 1953 invalidParams.Add(smithy.NewErrParamRequired("TaskToken")) 1954 } 1955 if invalidParams.Len() > 0 { 1956 return invalidParams 1957 } else { 1958 return nil 1959 } 1960} 1961 1962func validateOpRespondActivityTaskFailedInput(v *RespondActivityTaskFailedInput) error { 1963 if v == nil { 1964 return nil 1965 } 1966 invalidParams := smithy.InvalidParamsError{Context: "RespondActivityTaskFailedInput"} 1967 if v.TaskToken == nil { 1968 invalidParams.Add(smithy.NewErrParamRequired("TaskToken")) 1969 } 1970 if invalidParams.Len() > 0 { 1971 return invalidParams 1972 } else { 1973 return nil 1974 } 1975} 1976 1977func validateOpRespondDecisionTaskCompletedInput(v *RespondDecisionTaskCompletedInput) error { 1978 if v == nil { 1979 return nil 1980 } 1981 invalidParams := smithy.InvalidParamsError{Context: "RespondDecisionTaskCompletedInput"} 1982 if v.TaskToken == nil { 1983 invalidParams.Add(smithy.NewErrParamRequired("TaskToken")) 1984 } 1985 if v.Decisions != nil { 1986 if err := validateDecisionList(v.Decisions); err != nil { 1987 invalidParams.AddNested("Decisions", err.(smithy.InvalidParamsError)) 1988 } 1989 } 1990 if invalidParams.Len() > 0 { 1991 return invalidParams 1992 } else { 1993 return nil 1994 } 1995} 1996 1997func validateOpSignalWorkflowExecutionInput(v *SignalWorkflowExecutionInput) error { 1998 if v == nil { 1999 return nil 2000 } 2001 invalidParams := smithy.InvalidParamsError{Context: "SignalWorkflowExecutionInput"} 2002 if v.Domain == nil { 2003 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 2004 } 2005 if v.WorkflowId == nil { 2006 invalidParams.Add(smithy.NewErrParamRequired("WorkflowId")) 2007 } 2008 if v.SignalName == nil { 2009 invalidParams.Add(smithy.NewErrParamRequired("SignalName")) 2010 } 2011 if invalidParams.Len() > 0 { 2012 return invalidParams 2013 } else { 2014 return nil 2015 } 2016} 2017 2018func validateOpStartWorkflowExecutionInput(v *StartWorkflowExecutionInput) error { 2019 if v == nil { 2020 return nil 2021 } 2022 invalidParams := smithy.InvalidParamsError{Context: "StartWorkflowExecutionInput"} 2023 if v.Domain == nil { 2024 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 2025 } 2026 if v.WorkflowId == nil { 2027 invalidParams.Add(smithy.NewErrParamRequired("WorkflowId")) 2028 } 2029 if v.WorkflowType == nil { 2030 invalidParams.Add(smithy.NewErrParamRequired("WorkflowType")) 2031 } else if v.WorkflowType != nil { 2032 if err := validateWorkflowType(v.WorkflowType); err != nil { 2033 invalidParams.AddNested("WorkflowType", err.(smithy.InvalidParamsError)) 2034 } 2035 } 2036 if v.TaskList != nil { 2037 if err := validateTaskList(v.TaskList); err != nil { 2038 invalidParams.AddNested("TaskList", err.(smithy.InvalidParamsError)) 2039 } 2040 } 2041 if invalidParams.Len() > 0 { 2042 return invalidParams 2043 } else { 2044 return nil 2045 } 2046} 2047 2048func validateOpTagResourceInput(v *TagResourceInput) error { 2049 if v == nil { 2050 return nil 2051 } 2052 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 2053 if v.ResourceArn == nil { 2054 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 2055 } 2056 if v.Tags == nil { 2057 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 2058 } else if v.Tags != nil { 2059 if err := validateResourceTagList(v.Tags); err != nil { 2060 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 2061 } 2062 } 2063 if invalidParams.Len() > 0 { 2064 return invalidParams 2065 } else { 2066 return nil 2067 } 2068} 2069 2070func validateOpTerminateWorkflowExecutionInput(v *TerminateWorkflowExecutionInput) error { 2071 if v == nil { 2072 return nil 2073 } 2074 invalidParams := smithy.InvalidParamsError{Context: "TerminateWorkflowExecutionInput"} 2075 if v.Domain == nil { 2076 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 2077 } 2078 if v.WorkflowId == nil { 2079 invalidParams.Add(smithy.NewErrParamRequired("WorkflowId")) 2080 } 2081 if invalidParams.Len() > 0 { 2082 return invalidParams 2083 } else { 2084 return nil 2085 } 2086} 2087 2088func validateOpUndeprecateActivityTypeInput(v *UndeprecateActivityTypeInput) error { 2089 if v == nil { 2090 return nil 2091 } 2092 invalidParams := smithy.InvalidParamsError{Context: "UndeprecateActivityTypeInput"} 2093 if v.Domain == nil { 2094 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 2095 } 2096 if v.ActivityType == nil { 2097 invalidParams.Add(smithy.NewErrParamRequired("ActivityType")) 2098 } else if v.ActivityType != nil { 2099 if err := validateActivityType(v.ActivityType); err != nil { 2100 invalidParams.AddNested("ActivityType", err.(smithy.InvalidParamsError)) 2101 } 2102 } 2103 if invalidParams.Len() > 0 { 2104 return invalidParams 2105 } else { 2106 return nil 2107 } 2108} 2109 2110func validateOpUndeprecateDomainInput(v *UndeprecateDomainInput) error { 2111 if v == nil { 2112 return nil 2113 } 2114 invalidParams := smithy.InvalidParamsError{Context: "UndeprecateDomainInput"} 2115 if v.Name == nil { 2116 invalidParams.Add(smithy.NewErrParamRequired("Name")) 2117 } 2118 if invalidParams.Len() > 0 { 2119 return invalidParams 2120 } else { 2121 return nil 2122 } 2123} 2124 2125func validateOpUndeprecateWorkflowTypeInput(v *UndeprecateWorkflowTypeInput) error { 2126 if v == nil { 2127 return nil 2128 } 2129 invalidParams := smithy.InvalidParamsError{Context: "UndeprecateWorkflowTypeInput"} 2130 if v.Domain == nil { 2131 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 2132 } 2133 if v.WorkflowType == nil { 2134 invalidParams.Add(smithy.NewErrParamRequired("WorkflowType")) 2135 } else if v.WorkflowType != nil { 2136 if err := validateWorkflowType(v.WorkflowType); err != nil { 2137 invalidParams.AddNested("WorkflowType", err.(smithy.InvalidParamsError)) 2138 } 2139 } 2140 if invalidParams.Len() > 0 { 2141 return invalidParams 2142 } else { 2143 return nil 2144 } 2145} 2146 2147func validateOpUntagResourceInput(v *UntagResourceInput) error { 2148 if v == nil { 2149 return nil 2150 } 2151 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 2152 if v.ResourceArn == nil { 2153 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 2154 } 2155 if v.TagKeys == nil { 2156 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 2157 } 2158 if invalidParams.Len() > 0 { 2159 return invalidParams 2160 } else { 2161 return nil 2162 } 2163} 2164