1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package cloudwatchevents 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/cloudwatchevents/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpActivateEventSource struct { 14} 15 16func (*validateOpActivateEventSource) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpActivateEventSource) 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.(*ActivateEventSourceInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpActivateEventSourceInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpCancelReplay struct { 34} 35 36func (*validateOpCancelReplay) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpCancelReplay) 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.(*CancelReplayInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpCancelReplayInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpCreateArchive struct { 54} 55 56func (*validateOpCreateArchive) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpCreateArchive) 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.(*CreateArchiveInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpCreateArchiveInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpCreateEventBus struct { 74} 75 76func (*validateOpCreateEventBus) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpCreateEventBus) 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.(*CreateEventBusInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpCreateEventBusInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpCreatePartnerEventSource struct { 94} 95 96func (*validateOpCreatePartnerEventSource) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpCreatePartnerEventSource) 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.(*CreatePartnerEventSourceInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpCreatePartnerEventSourceInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpDeactivateEventSource struct { 114} 115 116func (*validateOpDeactivateEventSource) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpDeactivateEventSource) 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.(*DeactivateEventSourceInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpDeactivateEventSourceInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpDeleteArchive struct { 134} 135 136func (*validateOpDeleteArchive) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpDeleteArchive) 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.(*DeleteArchiveInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpDeleteArchiveInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpDeleteEventBus struct { 154} 155 156func (*validateOpDeleteEventBus) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpDeleteEventBus) 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.(*DeleteEventBusInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpDeleteEventBusInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpDeletePartnerEventSource struct { 174} 175 176func (*validateOpDeletePartnerEventSource) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpDeletePartnerEventSource) 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.(*DeletePartnerEventSourceInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpDeletePartnerEventSourceInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpDeleteRule struct { 194} 195 196func (*validateOpDeleteRule) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpDeleteRule) 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.(*DeleteRuleInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpDeleteRuleInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpDescribeArchive struct { 214} 215 216func (*validateOpDescribeArchive) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpDescribeArchive) 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.(*DescribeArchiveInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpDescribeArchiveInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpDescribeEventSource struct { 234} 235 236func (*validateOpDescribeEventSource) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpDescribeEventSource) 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.(*DescribeEventSourceInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpDescribeEventSourceInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpDescribePartnerEventSource struct { 254} 255 256func (*validateOpDescribePartnerEventSource) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpDescribePartnerEventSource) 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.(*DescribePartnerEventSourceInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpDescribePartnerEventSourceInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpDescribeReplay struct { 274} 275 276func (*validateOpDescribeReplay) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpDescribeReplay) 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.(*DescribeReplayInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpDescribeReplayInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpDescribeRule struct { 294} 295 296func (*validateOpDescribeRule) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpDescribeRule) 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.(*DescribeRuleInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpDescribeRuleInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpDisableRule struct { 314} 315 316func (*validateOpDisableRule) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpDisableRule) 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.(*DisableRuleInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpDisableRuleInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpEnableRule struct { 334} 335 336func (*validateOpEnableRule) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpEnableRule) 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.(*EnableRuleInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpEnableRuleInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpListPartnerEventSourceAccounts struct { 354} 355 356func (*validateOpListPartnerEventSourceAccounts) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpListPartnerEventSourceAccounts) 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.(*ListPartnerEventSourceAccountsInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpListPartnerEventSourceAccountsInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpListPartnerEventSources struct { 374} 375 376func (*validateOpListPartnerEventSources) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpListPartnerEventSources) 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.(*ListPartnerEventSourcesInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpListPartnerEventSourcesInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpListRuleNamesByTarget struct { 394} 395 396func (*validateOpListRuleNamesByTarget) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpListRuleNamesByTarget) 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.(*ListRuleNamesByTargetInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpListRuleNamesByTargetInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpListTagsForResource struct { 414} 415 416func (*validateOpListTagsForResource) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpListTagsForResourceInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpListTargetsByRule struct { 434} 435 436func (*validateOpListTargetsByRule) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpListTargetsByRule) 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.(*ListTargetsByRuleInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpListTargetsByRuleInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpPutEvents struct { 454} 455 456func (*validateOpPutEvents) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpPutEvents) 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.(*PutEventsInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpPutEventsInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473type validateOpPutPartnerEvents struct { 474} 475 476func (*validateOpPutPartnerEvents) ID() string { 477 return "OperationInputValidation" 478} 479 480func (m *validateOpPutPartnerEvents) 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.(*PutPartnerEventsInput) 484 if !ok { 485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 486 } 487 if err := validateOpPutPartnerEventsInput(input); err != nil { 488 return out, metadata, err 489 } 490 return next.HandleInitialize(ctx, in) 491} 492 493type validateOpPutPermission struct { 494} 495 496func (*validateOpPutPermission) ID() string { 497 return "OperationInputValidation" 498} 499 500func (m *validateOpPutPermission) 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.(*PutPermissionInput) 504 if !ok { 505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 506 } 507 if err := validateOpPutPermissionInput(input); err != nil { 508 return out, metadata, err 509 } 510 return next.HandleInitialize(ctx, in) 511} 512 513type validateOpPutRule struct { 514} 515 516func (*validateOpPutRule) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpPutRule) 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.(*PutRuleInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpPutRuleInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533type validateOpPutTargets struct { 534} 535 536func (*validateOpPutTargets) ID() string { 537 return "OperationInputValidation" 538} 539 540func (m *validateOpPutTargets) 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.(*PutTargetsInput) 544 if !ok { 545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 546 } 547 if err := validateOpPutTargetsInput(input); err != nil { 548 return out, metadata, err 549 } 550 return next.HandleInitialize(ctx, in) 551} 552 553type validateOpRemoveTargets struct { 554} 555 556func (*validateOpRemoveTargets) ID() string { 557 return "OperationInputValidation" 558} 559 560func (m *validateOpRemoveTargets) 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.(*RemoveTargetsInput) 564 if !ok { 565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 566 } 567 if err := validateOpRemoveTargetsInput(input); err != nil { 568 return out, metadata, err 569 } 570 return next.HandleInitialize(ctx, in) 571} 572 573type validateOpStartReplay struct { 574} 575 576func (*validateOpStartReplay) ID() string { 577 return "OperationInputValidation" 578} 579 580func (m *validateOpStartReplay) 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.(*StartReplayInput) 584 if !ok { 585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 586 } 587 if err := validateOpStartReplayInput(input); err != nil { 588 return out, metadata, err 589 } 590 return next.HandleInitialize(ctx, in) 591} 592 593type validateOpTagResource struct { 594} 595 596func (*validateOpTagResource) ID() string { 597 return "OperationInputValidation" 598} 599 600func (m *validateOpTagResource) 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.(*TagResourceInput) 604 if !ok { 605 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 606 } 607 if err := validateOpTagResourceInput(input); err != nil { 608 return out, metadata, err 609 } 610 return next.HandleInitialize(ctx, in) 611} 612 613type validateOpTestEventPattern struct { 614} 615 616func (*validateOpTestEventPattern) ID() string { 617 return "OperationInputValidation" 618} 619 620func (m *validateOpTestEventPattern) 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.(*TestEventPatternInput) 624 if !ok { 625 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 626 } 627 if err := validateOpTestEventPatternInput(input); err != nil { 628 return out, metadata, err 629 } 630 return next.HandleInitialize(ctx, in) 631} 632 633type validateOpUntagResource struct { 634} 635 636func (*validateOpUntagResource) ID() string { 637 return "OperationInputValidation" 638} 639 640func (m *validateOpUntagResource) 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.(*UntagResourceInput) 644 if !ok { 645 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 646 } 647 if err := validateOpUntagResourceInput(input); err != nil { 648 return out, metadata, err 649 } 650 return next.HandleInitialize(ctx, in) 651} 652 653type validateOpUpdateArchive struct { 654} 655 656func (*validateOpUpdateArchive) ID() string { 657 return "OperationInputValidation" 658} 659 660func (m *validateOpUpdateArchive) 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.(*UpdateArchiveInput) 664 if !ok { 665 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 666 } 667 if err := validateOpUpdateArchiveInput(input); err != nil { 668 return out, metadata, err 669 } 670 return next.HandleInitialize(ctx, in) 671} 672 673func addOpActivateEventSourceValidationMiddleware(stack *middleware.Stack) error { 674 return stack.Initialize.Add(&validateOpActivateEventSource{}, middleware.After) 675} 676 677func addOpCancelReplayValidationMiddleware(stack *middleware.Stack) error { 678 return stack.Initialize.Add(&validateOpCancelReplay{}, middleware.After) 679} 680 681func addOpCreateArchiveValidationMiddleware(stack *middleware.Stack) error { 682 return stack.Initialize.Add(&validateOpCreateArchive{}, middleware.After) 683} 684 685func addOpCreateEventBusValidationMiddleware(stack *middleware.Stack) error { 686 return stack.Initialize.Add(&validateOpCreateEventBus{}, middleware.After) 687} 688 689func addOpCreatePartnerEventSourceValidationMiddleware(stack *middleware.Stack) error { 690 return stack.Initialize.Add(&validateOpCreatePartnerEventSource{}, middleware.After) 691} 692 693func addOpDeactivateEventSourceValidationMiddleware(stack *middleware.Stack) error { 694 return stack.Initialize.Add(&validateOpDeactivateEventSource{}, middleware.After) 695} 696 697func addOpDeleteArchiveValidationMiddleware(stack *middleware.Stack) error { 698 return stack.Initialize.Add(&validateOpDeleteArchive{}, middleware.After) 699} 700 701func addOpDeleteEventBusValidationMiddleware(stack *middleware.Stack) error { 702 return stack.Initialize.Add(&validateOpDeleteEventBus{}, middleware.After) 703} 704 705func addOpDeletePartnerEventSourceValidationMiddleware(stack *middleware.Stack) error { 706 return stack.Initialize.Add(&validateOpDeletePartnerEventSource{}, middleware.After) 707} 708 709func addOpDeleteRuleValidationMiddleware(stack *middleware.Stack) error { 710 return stack.Initialize.Add(&validateOpDeleteRule{}, middleware.After) 711} 712 713func addOpDescribeArchiveValidationMiddleware(stack *middleware.Stack) error { 714 return stack.Initialize.Add(&validateOpDescribeArchive{}, middleware.After) 715} 716 717func addOpDescribeEventSourceValidationMiddleware(stack *middleware.Stack) error { 718 return stack.Initialize.Add(&validateOpDescribeEventSource{}, middleware.After) 719} 720 721func addOpDescribePartnerEventSourceValidationMiddleware(stack *middleware.Stack) error { 722 return stack.Initialize.Add(&validateOpDescribePartnerEventSource{}, middleware.After) 723} 724 725func addOpDescribeReplayValidationMiddleware(stack *middleware.Stack) error { 726 return stack.Initialize.Add(&validateOpDescribeReplay{}, middleware.After) 727} 728 729func addOpDescribeRuleValidationMiddleware(stack *middleware.Stack) error { 730 return stack.Initialize.Add(&validateOpDescribeRule{}, middleware.After) 731} 732 733func addOpDisableRuleValidationMiddleware(stack *middleware.Stack) error { 734 return stack.Initialize.Add(&validateOpDisableRule{}, middleware.After) 735} 736 737func addOpEnableRuleValidationMiddleware(stack *middleware.Stack) error { 738 return stack.Initialize.Add(&validateOpEnableRule{}, middleware.After) 739} 740 741func addOpListPartnerEventSourceAccountsValidationMiddleware(stack *middleware.Stack) error { 742 return stack.Initialize.Add(&validateOpListPartnerEventSourceAccounts{}, middleware.After) 743} 744 745func addOpListPartnerEventSourcesValidationMiddleware(stack *middleware.Stack) error { 746 return stack.Initialize.Add(&validateOpListPartnerEventSources{}, middleware.After) 747} 748 749func addOpListRuleNamesByTargetValidationMiddleware(stack *middleware.Stack) error { 750 return stack.Initialize.Add(&validateOpListRuleNamesByTarget{}, middleware.After) 751} 752 753func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 754 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 755} 756 757func addOpListTargetsByRuleValidationMiddleware(stack *middleware.Stack) error { 758 return stack.Initialize.Add(&validateOpListTargetsByRule{}, middleware.After) 759} 760 761func addOpPutEventsValidationMiddleware(stack *middleware.Stack) error { 762 return stack.Initialize.Add(&validateOpPutEvents{}, middleware.After) 763} 764 765func addOpPutPartnerEventsValidationMiddleware(stack *middleware.Stack) error { 766 return stack.Initialize.Add(&validateOpPutPartnerEvents{}, middleware.After) 767} 768 769func addOpPutPermissionValidationMiddleware(stack *middleware.Stack) error { 770 return stack.Initialize.Add(&validateOpPutPermission{}, middleware.After) 771} 772 773func addOpPutRuleValidationMiddleware(stack *middleware.Stack) error { 774 return stack.Initialize.Add(&validateOpPutRule{}, middleware.After) 775} 776 777func addOpPutTargetsValidationMiddleware(stack *middleware.Stack) error { 778 return stack.Initialize.Add(&validateOpPutTargets{}, middleware.After) 779} 780 781func addOpRemoveTargetsValidationMiddleware(stack *middleware.Stack) error { 782 return stack.Initialize.Add(&validateOpRemoveTargets{}, middleware.After) 783} 784 785func addOpStartReplayValidationMiddleware(stack *middleware.Stack) error { 786 return stack.Initialize.Add(&validateOpStartReplay{}, middleware.After) 787} 788 789func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 790 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 791} 792 793func addOpTestEventPatternValidationMiddleware(stack *middleware.Stack) error { 794 return stack.Initialize.Add(&validateOpTestEventPattern{}, middleware.After) 795} 796 797func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 798 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 799} 800 801func addOpUpdateArchiveValidationMiddleware(stack *middleware.Stack) error { 802 return stack.Initialize.Add(&validateOpUpdateArchive{}, middleware.After) 803} 804 805func validateAwsVpcConfiguration(v *types.AwsVpcConfiguration) error { 806 if v == nil { 807 return nil 808 } 809 invalidParams := smithy.InvalidParamsError{Context: "AwsVpcConfiguration"} 810 if v.Subnets == nil { 811 invalidParams.Add(smithy.NewErrParamRequired("Subnets")) 812 } 813 if invalidParams.Len() > 0 { 814 return invalidParams 815 } else { 816 return nil 817 } 818} 819 820func validateBatchParameters(v *types.BatchParameters) error { 821 if v == nil { 822 return nil 823 } 824 invalidParams := smithy.InvalidParamsError{Context: "BatchParameters"} 825 if v.JobDefinition == nil { 826 invalidParams.Add(smithy.NewErrParamRequired("JobDefinition")) 827 } 828 if v.JobName == nil { 829 invalidParams.Add(smithy.NewErrParamRequired("JobName")) 830 } 831 if invalidParams.Len() > 0 { 832 return invalidParams 833 } else { 834 return nil 835 } 836} 837 838func validateCondition(v *types.Condition) error { 839 if v == nil { 840 return nil 841 } 842 invalidParams := smithy.InvalidParamsError{Context: "Condition"} 843 if v.Type == nil { 844 invalidParams.Add(smithy.NewErrParamRequired("Type")) 845 } 846 if v.Key == nil { 847 invalidParams.Add(smithy.NewErrParamRequired("Key")) 848 } 849 if v.Value == nil { 850 invalidParams.Add(smithy.NewErrParamRequired("Value")) 851 } 852 if invalidParams.Len() > 0 { 853 return invalidParams 854 } else { 855 return nil 856 } 857} 858 859func validateEcsParameters(v *types.EcsParameters) error { 860 if v == nil { 861 return nil 862 } 863 invalidParams := smithy.InvalidParamsError{Context: "EcsParameters"} 864 if v.TaskDefinitionArn == nil { 865 invalidParams.Add(smithy.NewErrParamRequired("TaskDefinitionArn")) 866 } 867 if v.NetworkConfiguration != nil { 868 if err := validateNetworkConfiguration(v.NetworkConfiguration); err != nil { 869 invalidParams.AddNested("NetworkConfiguration", err.(smithy.InvalidParamsError)) 870 } 871 } 872 if invalidParams.Len() > 0 { 873 return invalidParams 874 } else { 875 return nil 876 } 877} 878 879func validateInputTransformer(v *types.InputTransformer) error { 880 if v == nil { 881 return nil 882 } 883 invalidParams := smithy.InvalidParamsError{Context: "InputTransformer"} 884 if v.InputTemplate == nil { 885 invalidParams.Add(smithy.NewErrParamRequired("InputTemplate")) 886 } 887 if invalidParams.Len() > 0 { 888 return invalidParams 889 } else { 890 return nil 891 } 892} 893 894func validateKinesisParameters(v *types.KinesisParameters) error { 895 if v == nil { 896 return nil 897 } 898 invalidParams := smithy.InvalidParamsError{Context: "KinesisParameters"} 899 if v.PartitionKeyPath == nil { 900 invalidParams.Add(smithy.NewErrParamRequired("PartitionKeyPath")) 901 } 902 if invalidParams.Len() > 0 { 903 return invalidParams 904 } else { 905 return nil 906 } 907} 908 909func validateNetworkConfiguration(v *types.NetworkConfiguration) error { 910 if v == nil { 911 return nil 912 } 913 invalidParams := smithy.InvalidParamsError{Context: "NetworkConfiguration"} 914 if v.AwsvpcConfiguration != nil { 915 if err := validateAwsVpcConfiguration(v.AwsvpcConfiguration); err != nil { 916 invalidParams.AddNested("AwsvpcConfiguration", err.(smithy.InvalidParamsError)) 917 } 918 } 919 if invalidParams.Len() > 0 { 920 return invalidParams 921 } else { 922 return nil 923 } 924} 925 926func validateRedshiftDataParameters(v *types.RedshiftDataParameters) error { 927 if v == nil { 928 return nil 929 } 930 invalidParams := smithy.InvalidParamsError{Context: "RedshiftDataParameters"} 931 if v.Database == nil { 932 invalidParams.Add(smithy.NewErrParamRequired("Database")) 933 } 934 if v.Sql == nil { 935 invalidParams.Add(smithy.NewErrParamRequired("Sql")) 936 } 937 if invalidParams.Len() > 0 { 938 return invalidParams 939 } else { 940 return nil 941 } 942} 943 944func validateReplayDestination(v *types.ReplayDestination) error { 945 if v == nil { 946 return nil 947 } 948 invalidParams := smithy.InvalidParamsError{Context: "ReplayDestination"} 949 if v.Arn == nil { 950 invalidParams.Add(smithy.NewErrParamRequired("Arn")) 951 } 952 if invalidParams.Len() > 0 { 953 return invalidParams 954 } else { 955 return nil 956 } 957} 958 959func validateRunCommandParameters(v *types.RunCommandParameters) error { 960 if v == nil { 961 return nil 962 } 963 invalidParams := smithy.InvalidParamsError{Context: "RunCommandParameters"} 964 if v.RunCommandTargets == nil { 965 invalidParams.Add(smithy.NewErrParamRequired("RunCommandTargets")) 966 } else if v.RunCommandTargets != nil { 967 if err := validateRunCommandTargets(v.RunCommandTargets); err != nil { 968 invalidParams.AddNested("RunCommandTargets", err.(smithy.InvalidParamsError)) 969 } 970 } 971 if invalidParams.Len() > 0 { 972 return invalidParams 973 } else { 974 return nil 975 } 976} 977 978func validateRunCommandTarget(v *types.RunCommandTarget) error { 979 if v == nil { 980 return nil 981 } 982 invalidParams := smithy.InvalidParamsError{Context: "RunCommandTarget"} 983 if v.Key == nil { 984 invalidParams.Add(smithy.NewErrParamRequired("Key")) 985 } 986 if v.Values == nil { 987 invalidParams.Add(smithy.NewErrParamRequired("Values")) 988 } 989 if invalidParams.Len() > 0 { 990 return invalidParams 991 } else { 992 return nil 993 } 994} 995 996func validateRunCommandTargets(v []types.RunCommandTarget) error { 997 if v == nil { 998 return nil 999 } 1000 invalidParams := smithy.InvalidParamsError{Context: "RunCommandTargets"} 1001 for i := range v { 1002 if err := validateRunCommandTarget(&v[i]); err != nil { 1003 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1004 } 1005 } 1006 if invalidParams.Len() > 0 { 1007 return invalidParams 1008 } else { 1009 return nil 1010 } 1011} 1012 1013func validateTag(v *types.Tag) error { 1014 if v == nil { 1015 return nil 1016 } 1017 invalidParams := smithy.InvalidParamsError{Context: "Tag"} 1018 if v.Key == nil { 1019 invalidParams.Add(smithy.NewErrParamRequired("Key")) 1020 } 1021 if v.Value == nil { 1022 invalidParams.Add(smithy.NewErrParamRequired("Value")) 1023 } 1024 if invalidParams.Len() > 0 { 1025 return invalidParams 1026 } else { 1027 return nil 1028 } 1029} 1030 1031func validateTagList(v []types.Tag) error { 1032 if v == nil { 1033 return nil 1034 } 1035 invalidParams := smithy.InvalidParamsError{Context: "TagList"} 1036 for i := range v { 1037 if err := validateTag(&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 validateTarget(v *types.Target) error { 1049 if v == nil { 1050 return nil 1051 } 1052 invalidParams := smithy.InvalidParamsError{Context: "Target"} 1053 if v.Id == nil { 1054 invalidParams.Add(smithy.NewErrParamRequired("Id")) 1055 } 1056 if v.Arn == nil { 1057 invalidParams.Add(smithy.NewErrParamRequired("Arn")) 1058 } 1059 if v.InputTransformer != nil { 1060 if err := validateInputTransformer(v.InputTransformer); err != nil { 1061 invalidParams.AddNested("InputTransformer", err.(smithy.InvalidParamsError)) 1062 } 1063 } 1064 if v.KinesisParameters != nil { 1065 if err := validateKinesisParameters(v.KinesisParameters); err != nil { 1066 invalidParams.AddNested("KinesisParameters", err.(smithy.InvalidParamsError)) 1067 } 1068 } 1069 if v.RunCommandParameters != nil { 1070 if err := validateRunCommandParameters(v.RunCommandParameters); err != nil { 1071 invalidParams.AddNested("RunCommandParameters", err.(smithy.InvalidParamsError)) 1072 } 1073 } 1074 if v.EcsParameters != nil { 1075 if err := validateEcsParameters(v.EcsParameters); err != nil { 1076 invalidParams.AddNested("EcsParameters", err.(smithy.InvalidParamsError)) 1077 } 1078 } 1079 if v.BatchParameters != nil { 1080 if err := validateBatchParameters(v.BatchParameters); err != nil { 1081 invalidParams.AddNested("BatchParameters", err.(smithy.InvalidParamsError)) 1082 } 1083 } 1084 if v.RedshiftDataParameters != nil { 1085 if err := validateRedshiftDataParameters(v.RedshiftDataParameters); err != nil { 1086 invalidParams.AddNested("RedshiftDataParameters", err.(smithy.InvalidParamsError)) 1087 } 1088 } 1089 if invalidParams.Len() > 0 { 1090 return invalidParams 1091 } else { 1092 return nil 1093 } 1094} 1095 1096func validateTargetList(v []types.Target) error { 1097 if v == nil { 1098 return nil 1099 } 1100 invalidParams := smithy.InvalidParamsError{Context: "TargetList"} 1101 for i := range v { 1102 if err := validateTarget(&v[i]); err != nil { 1103 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1104 } 1105 } 1106 if invalidParams.Len() > 0 { 1107 return invalidParams 1108 } else { 1109 return nil 1110 } 1111} 1112 1113func validateOpActivateEventSourceInput(v *ActivateEventSourceInput) error { 1114 if v == nil { 1115 return nil 1116 } 1117 invalidParams := smithy.InvalidParamsError{Context: "ActivateEventSourceInput"} 1118 if v.Name == nil { 1119 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1120 } 1121 if invalidParams.Len() > 0 { 1122 return invalidParams 1123 } else { 1124 return nil 1125 } 1126} 1127 1128func validateOpCancelReplayInput(v *CancelReplayInput) error { 1129 if v == nil { 1130 return nil 1131 } 1132 invalidParams := smithy.InvalidParamsError{Context: "CancelReplayInput"} 1133 if v.ReplayName == nil { 1134 invalidParams.Add(smithy.NewErrParamRequired("ReplayName")) 1135 } 1136 if invalidParams.Len() > 0 { 1137 return invalidParams 1138 } else { 1139 return nil 1140 } 1141} 1142 1143func validateOpCreateArchiveInput(v *CreateArchiveInput) error { 1144 if v == nil { 1145 return nil 1146 } 1147 invalidParams := smithy.InvalidParamsError{Context: "CreateArchiveInput"} 1148 if v.ArchiveName == nil { 1149 invalidParams.Add(smithy.NewErrParamRequired("ArchiveName")) 1150 } 1151 if v.EventSourceArn == nil { 1152 invalidParams.Add(smithy.NewErrParamRequired("EventSourceArn")) 1153 } 1154 if invalidParams.Len() > 0 { 1155 return invalidParams 1156 } else { 1157 return nil 1158 } 1159} 1160 1161func validateOpCreateEventBusInput(v *CreateEventBusInput) error { 1162 if v == nil { 1163 return nil 1164 } 1165 invalidParams := smithy.InvalidParamsError{Context: "CreateEventBusInput"} 1166 if v.Name == nil { 1167 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1168 } 1169 if v.Tags != nil { 1170 if err := validateTagList(v.Tags); err != nil { 1171 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1172 } 1173 } 1174 if invalidParams.Len() > 0 { 1175 return invalidParams 1176 } else { 1177 return nil 1178 } 1179} 1180 1181func validateOpCreatePartnerEventSourceInput(v *CreatePartnerEventSourceInput) error { 1182 if v == nil { 1183 return nil 1184 } 1185 invalidParams := smithy.InvalidParamsError{Context: "CreatePartnerEventSourceInput"} 1186 if v.Name == nil { 1187 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1188 } 1189 if v.Account == nil { 1190 invalidParams.Add(smithy.NewErrParamRequired("Account")) 1191 } 1192 if invalidParams.Len() > 0 { 1193 return invalidParams 1194 } else { 1195 return nil 1196 } 1197} 1198 1199func validateOpDeactivateEventSourceInput(v *DeactivateEventSourceInput) error { 1200 if v == nil { 1201 return nil 1202 } 1203 invalidParams := smithy.InvalidParamsError{Context: "DeactivateEventSourceInput"} 1204 if v.Name == nil { 1205 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1206 } 1207 if invalidParams.Len() > 0 { 1208 return invalidParams 1209 } else { 1210 return nil 1211 } 1212} 1213 1214func validateOpDeleteArchiveInput(v *DeleteArchiveInput) error { 1215 if v == nil { 1216 return nil 1217 } 1218 invalidParams := smithy.InvalidParamsError{Context: "DeleteArchiveInput"} 1219 if v.ArchiveName == nil { 1220 invalidParams.Add(smithy.NewErrParamRequired("ArchiveName")) 1221 } 1222 if invalidParams.Len() > 0 { 1223 return invalidParams 1224 } else { 1225 return nil 1226 } 1227} 1228 1229func validateOpDeleteEventBusInput(v *DeleteEventBusInput) error { 1230 if v == nil { 1231 return nil 1232 } 1233 invalidParams := smithy.InvalidParamsError{Context: "DeleteEventBusInput"} 1234 if v.Name == nil { 1235 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1236 } 1237 if invalidParams.Len() > 0 { 1238 return invalidParams 1239 } else { 1240 return nil 1241 } 1242} 1243 1244func validateOpDeletePartnerEventSourceInput(v *DeletePartnerEventSourceInput) error { 1245 if v == nil { 1246 return nil 1247 } 1248 invalidParams := smithy.InvalidParamsError{Context: "DeletePartnerEventSourceInput"} 1249 if v.Name == nil { 1250 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1251 } 1252 if v.Account == nil { 1253 invalidParams.Add(smithy.NewErrParamRequired("Account")) 1254 } 1255 if invalidParams.Len() > 0 { 1256 return invalidParams 1257 } else { 1258 return nil 1259 } 1260} 1261 1262func validateOpDeleteRuleInput(v *DeleteRuleInput) error { 1263 if v == nil { 1264 return nil 1265 } 1266 invalidParams := smithy.InvalidParamsError{Context: "DeleteRuleInput"} 1267 if v.Name == nil { 1268 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1269 } 1270 if invalidParams.Len() > 0 { 1271 return invalidParams 1272 } else { 1273 return nil 1274 } 1275} 1276 1277func validateOpDescribeArchiveInput(v *DescribeArchiveInput) error { 1278 if v == nil { 1279 return nil 1280 } 1281 invalidParams := smithy.InvalidParamsError{Context: "DescribeArchiveInput"} 1282 if v.ArchiveName == nil { 1283 invalidParams.Add(smithy.NewErrParamRequired("ArchiveName")) 1284 } 1285 if invalidParams.Len() > 0 { 1286 return invalidParams 1287 } else { 1288 return nil 1289 } 1290} 1291 1292func validateOpDescribeEventSourceInput(v *DescribeEventSourceInput) error { 1293 if v == nil { 1294 return nil 1295 } 1296 invalidParams := smithy.InvalidParamsError{Context: "DescribeEventSourceInput"} 1297 if v.Name == nil { 1298 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1299 } 1300 if invalidParams.Len() > 0 { 1301 return invalidParams 1302 } else { 1303 return nil 1304 } 1305} 1306 1307func validateOpDescribePartnerEventSourceInput(v *DescribePartnerEventSourceInput) error { 1308 if v == nil { 1309 return nil 1310 } 1311 invalidParams := smithy.InvalidParamsError{Context: "DescribePartnerEventSourceInput"} 1312 if v.Name == nil { 1313 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1314 } 1315 if invalidParams.Len() > 0 { 1316 return invalidParams 1317 } else { 1318 return nil 1319 } 1320} 1321 1322func validateOpDescribeReplayInput(v *DescribeReplayInput) error { 1323 if v == nil { 1324 return nil 1325 } 1326 invalidParams := smithy.InvalidParamsError{Context: "DescribeReplayInput"} 1327 if v.ReplayName == nil { 1328 invalidParams.Add(smithy.NewErrParamRequired("ReplayName")) 1329 } 1330 if invalidParams.Len() > 0 { 1331 return invalidParams 1332 } else { 1333 return nil 1334 } 1335} 1336 1337func validateOpDescribeRuleInput(v *DescribeRuleInput) error { 1338 if v == nil { 1339 return nil 1340 } 1341 invalidParams := smithy.InvalidParamsError{Context: "DescribeRuleInput"} 1342 if v.Name == nil { 1343 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1344 } 1345 if invalidParams.Len() > 0 { 1346 return invalidParams 1347 } else { 1348 return nil 1349 } 1350} 1351 1352func validateOpDisableRuleInput(v *DisableRuleInput) error { 1353 if v == nil { 1354 return nil 1355 } 1356 invalidParams := smithy.InvalidParamsError{Context: "DisableRuleInput"} 1357 if v.Name == nil { 1358 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1359 } 1360 if invalidParams.Len() > 0 { 1361 return invalidParams 1362 } else { 1363 return nil 1364 } 1365} 1366 1367func validateOpEnableRuleInput(v *EnableRuleInput) error { 1368 if v == nil { 1369 return nil 1370 } 1371 invalidParams := smithy.InvalidParamsError{Context: "EnableRuleInput"} 1372 if v.Name == nil { 1373 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1374 } 1375 if invalidParams.Len() > 0 { 1376 return invalidParams 1377 } else { 1378 return nil 1379 } 1380} 1381 1382func validateOpListPartnerEventSourceAccountsInput(v *ListPartnerEventSourceAccountsInput) error { 1383 if v == nil { 1384 return nil 1385 } 1386 invalidParams := smithy.InvalidParamsError{Context: "ListPartnerEventSourceAccountsInput"} 1387 if v.EventSourceName == nil { 1388 invalidParams.Add(smithy.NewErrParamRequired("EventSourceName")) 1389 } 1390 if invalidParams.Len() > 0 { 1391 return invalidParams 1392 } else { 1393 return nil 1394 } 1395} 1396 1397func validateOpListPartnerEventSourcesInput(v *ListPartnerEventSourcesInput) error { 1398 if v == nil { 1399 return nil 1400 } 1401 invalidParams := smithy.InvalidParamsError{Context: "ListPartnerEventSourcesInput"} 1402 if v.NamePrefix == nil { 1403 invalidParams.Add(smithy.NewErrParamRequired("NamePrefix")) 1404 } 1405 if invalidParams.Len() > 0 { 1406 return invalidParams 1407 } else { 1408 return nil 1409 } 1410} 1411 1412func validateOpListRuleNamesByTargetInput(v *ListRuleNamesByTargetInput) error { 1413 if v == nil { 1414 return nil 1415 } 1416 invalidParams := smithy.InvalidParamsError{Context: "ListRuleNamesByTargetInput"} 1417 if v.TargetArn == nil { 1418 invalidParams.Add(smithy.NewErrParamRequired("TargetArn")) 1419 } 1420 if invalidParams.Len() > 0 { 1421 return invalidParams 1422 } else { 1423 return nil 1424 } 1425} 1426 1427func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 1428 if v == nil { 1429 return nil 1430 } 1431 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 1432 if v.ResourceARN == nil { 1433 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 1434 } 1435 if invalidParams.Len() > 0 { 1436 return invalidParams 1437 } else { 1438 return nil 1439 } 1440} 1441 1442func validateOpListTargetsByRuleInput(v *ListTargetsByRuleInput) error { 1443 if v == nil { 1444 return nil 1445 } 1446 invalidParams := smithy.InvalidParamsError{Context: "ListTargetsByRuleInput"} 1447 if v.Rule == nil { 1448 invalidParams.Add(smithy.NewErrParamRequired("Rule")) 1449 } 1450 if invalidParams.Len() > 0 { 1451 return invalidParams 1452 } else { 1453 return nil 1454 } 1455} 1456 1457func validateOpPutEventsInput(v *PutEventsInput) error { 1458 if v == nil { 1459 return nil 1460 } 1461 invalidParams := smithy.InvalidParamsError{Context: "PutEventsInput"} 1462 if v.Entries == nil { 1463 invalidParams.Add(smithy.NewErrParamRequired("Entries")) 1464 } 1465 if invalidParams.Len() > 0 { 1466 return invalidParams 1467 } else { 1468 return nil 1469 } 1470} 1471 1472func validateOpPutPartnerEventsInput(v *PutPartnerEventsInput) error { 1473 if v == nil { 1474 return nil 1475 } 1476 invalidParams := smithy.InvalidParamsError{Context: "PutPartnerEventsInput"} 1477 if v.Entries == nil { 1478 invalidParams.Add(smithy.NewErrParamRequired("Entries")) 1479 } 1480 if invalidParams.Len() > 0 { 1481 return invalidParams 1482 } else { 1483 return nil 1484 } 1485} 1486 1487func validateOpPutPermissionInput(v *PutPermissionInput) error { 1488 if v == nil { 1489 return nil 1490 } 1491 invalidParams := smithy.InvalidParamsError{Context: "PutPermissionInput"} 1492 if v.Condition != nil { 1493 if err := validateCondition(v.Condition); err != nil { 1494 invalidParams.AddNested("Condition", err.(smithy.InvalidParamsError)) 1495 } 1496 } 1497 if invalidParams.Len() > 0 { 1498 return invalidParams 1499 } else { 1500 return nil 1501 } 1502} 1503 1504func validateOpPutRuleInput(v *PutRuleInput) error { 1505 if v == nil { 1506 return nil 1507 } 1508 invalidParams := smithy.InvalidParamsError{Context: "PutRuleInput"} 1509 if v.Name == nil { 1510 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1511 } 1512 if v.Tags != nil { 1513 if err := validateTagList(v.Tags); err != nil { 1514 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1515 } 1516 } 1517 if invalidParams.Len() > 0 { 1518 return invalidParams 1519 } else { 1520 return nil 1521 } 1522} 1523 1524func validateOpPutTargetsInput(v *PutTargetsInput) error { 1525 if v == nil { 1526 return nil 1527 } 1528 invalidParams := smithy.InvalidParamsError{Context: "PutTargetsInput"} 1529 if v.Rule == nil { 1530 invalidParams.Add(smithy.NewErrParamRequired("Rule")) 1531 } 1532 if v.Targets == nil { 1533 invalidParams.Add(smithy.NewErrParamRequired("Targets")) 1534 } else if v.Targets != nil { 1535 if err := validateTargetList(v.Targets); err != nil { 1536 invalidParams.AddNested("Targets", err.(smithy.InvalidParamsError)) 1537 } 1538 } 1539 if invalidParams.Len() > 0 { 1540 return invalidParams 1541 } else { 1542 return nil 1543 } 1544} 1545 1546func validateOpRemoveTargetsInput(v *RemoveTargetsInput) error { 1547 if v == nil { 1548 return nil 1549 } 1550 invalidParams := smithy.InvalidParamsError{Context: "RemoveTargetsInput"} 1551 if v.Rule == nil { 1552 invalidParams.Add(smithy.NewErrParamRequired("Rule")) 1553 } 1554 if v.Ids == nil { 1555 invalidParams.Add(smithy.NewErrParamRequired("Ids")) 1556 } 1557 if invalidParams.Len() > 0 { 1558 return invalidParams 1559 } else { 1560 return nil 1561 } 1562} 1563 1564func validateOpStartReplayInput(v *StartReplayInput) error { 1565 if v == nil { 1566 return nil 1567 } 1568 invalidParams := smithy.InvalidParamsError{Context: "StartReplayInput"} 1569 if v.ReplayName == nil { 1570 invalidParams.Add(smithy.NewErrParamRequired("ReplayName")) 1571 } 1572 if v.EventSourceArn == nil { 1573 invalidParams.Add(smithy.NewErrParamRequired("EventSourceArn")) 1574 } 1575 if v.EventStartTime == nil { 1576 invalidParams.Add(smithy.NewErrParamRequired("EventStartTime")) 1577 } 1578 if v.EventEndTime == nil { 1579 invalidParams.Add(smithy.NewErrParamRequired("EventEndTime")) 1580 } 1581 if v.Destination == nil { 1582 invalidParams.Add(smithy.NewErrParamRequired("Destination")) 1583 } else if v.Destination != nil { 1584 if err := validateReplayDestination(v.Destination); err != nil { 1585 invalidParams.AddNested("Destination", err.(smithy.InvalidParamsError)) 1586 } 1587 } 1588 if invalidParams.Len() > 0 { 1589 return invalidParams 1590 } else { 1591 return nil 1592 } 1593} 1594 1595func validateOpTagResourceInput(v *TagResourceInput) error { 1596 if v == nil { 1597 return nil 1598 } 1599 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 1600 if v.ResourceARN == nil { 1601 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 1602 } 1603 if v.Tags == nil { 1604 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 1605 } else if v.Tags != nil { 1606 if err := validateTagList(v.Tags); err != nil { 1607 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1608 } 1609 } 1610 if invalidParams.Len() > 0 { 1611 return invalidParams 1612 } else { 1613 return nil 1614 } 1615} 1616 1617func validateOpTestEventPatternInput(v *TestEventPatternInput) error { 1618 if v == nil { 1619 return nil 1620 } 1621 invalidParams := smithy.InvalidParamsError{Context: "TestEventPatternInput"} 1622 if v.EventPattern == nil { 1623 invalidParams.Add(smithy.NewErrParamRequired("EventPattern")) 1624 } 1625 if v.Event == nil { 1626 invalidParams.Add(smithy.NewErrParamRequired("Event")) 1627 } 1628 if invalidParams.Len() > 0 { 1629 return invalidParams 1630 } else { 1631 return nil 1632 } 1633} 1634 1635func validateOpUntagResourceInput(v *UntagResourceInput) error { 1636 if v == nil { 1637 return nil 1638 } 1639 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 1640 if v.ResourceARN == nil { 1641 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 1642 } 1643 if v.TagKeys == nil { 1644 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 1645 } 1646 if invalidParams.Len() > 0 { 1647 return invalidParams 1648 } else { 1649 return nil 1650 } 1651} 1652 1653func validateOpUpdateArchiveInput(v *UpdateArchiveInput) error { 1654 if v == nil { 1655 return nil 1656 } 1657 invalidParams := smithy.InvalidParamsError{Context: "UpdateArchiveInput"} 1658 if v.ArchiveName == nil { 1659 invalidParams.Add(smithy.NewErrParamRequired("ArchiveName")) 1660 } 1661 if invalidParams.Len() > 0 { 1662 return invalidParams 1663 } else { 1664 return nil 1665 } 1666} 1667