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 validateOpCreateApiDestination struct { 54} 55 56func (*validateOpCreateApiDestination) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpCreateApiDestination) 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.(*CreateApiDestinationInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpCreateApiDestinationInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpCreateArchive struct { 74} 75 76func (*validateOpCreateArchive) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpCreateArchive) 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.(*CreateArchiveInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpCreateArchiveInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpCreateConnection struct { 94} 95 96func (*validateOpCreateConnection) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpCreateConnection) 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.(*CreateConnectionInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpCreateConnectionInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpCreateEventBus struct { 114} 115 116func (*validateOpCreateEventBus) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpCreateEventBus) 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.(*CreateEventBusInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpCreateEventBusInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpCreatePartnerEventSource struct { 134} 135 136func (*validateOpCreatePartnerEventSource) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpCreatePartnerEventSource) 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.(*CreatePartnerEventSourceInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpCreatePartnerEventSourceInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpDeactivateEventSource struct { 154} 155 156func (*validateOpDeactivateEventSource) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpDeactivateEventSource) 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.(*DeactivateEventSourceInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpDeactivateEventSourceInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpDeauthorizeConnection struct { 174} 175 176func (*validateOpDeauthorizeConnection) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpDeauthorizeConnection) 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.(*DeauthorizeConnectionInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpDeauthorizeConnectionInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpDeleteApiDestination struct { 194} 195 196func (*validateOpDeleteApiDestination) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpDeleteApiDestination) 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.(*DeleteApiDestinationInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpDeleteApiDestinationInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpDeleteArchive struct { 214} 215 216func (*validateOpDeleteArchive) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpDeleteArchive) 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.(*DeleteArchiveInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpDeleteArchiveInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpDeleteConnection struct { 234} 235 236func (*validateOpDeleteConnection) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpDeleteConnection) 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.(*DeleteConnectionInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpDeleteConnectionInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpDeleteEventBus struct { 254} 255 256func (*validateOpDeleteEventBus) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpDeleteEventBus) 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.(*DeleteEventBusInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpDeleteEventBusInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpDeletePartnerEventSource struct { 274} 275 276func (*validateOpDeletePartnerEventSource) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpDeletePartnerEventSource) 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.(*DeletePartnerEventSourceInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpDeletePartnerEventSourceInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpDeleteRule struct { 294} 295 296func (*validateOpDeleteRule) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpDeleteRule) 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.(*DeleteRuleInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpDeleteRuleInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpDescribeApiDestination struct { 314} 315 316func (*validateOpDescribeApiDestination) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpDescribeApiDestination) 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.(*DescribeApiDestinationInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpDescribeApiDestinationInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpDescribeArchive struct { 334} 335 336func (*validateOpDescribeArchive) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpDescribeArchive) 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.(*DescribeArchiveInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpDescribeArchiveInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpDescribeConnection struct { 354} 355 356func (*validateOpDescribeConnection) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpDescribeConnection) 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.(*DescribeConnectionInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpDescribeConnectionInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpDescribeEventSource struct { 374} 375 376func (*validateOpDescribeEventSource) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpDescribeEventSource) 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.(*DescribeEventSourceInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpDescribeEventSourceInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpDescribePartnerEventSource struct { 394} 395 396func (*validateOpDescribePartnerEventSource) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpDescribePartnerEventSource) 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.(*DescribePartnerEventSourceInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpDescribePartnerEventSourceInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpDescribeReplay struct { 414} 415 416func (*validateOpDescribeReplay) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpDescribeReplay) 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.(*DescribeReplayInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpDescribeReplayInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpDescribeRule struct { 434} 435 436func (*validateOpDescribeRule) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpDescribeRule) 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.(*DescribeRuleInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpDescribeRuleInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpDisableRule struct { 454} 455 456func (*validateOpDisableRule) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpDisableRule) 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.(*DisableRuleInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpDisableRuleInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473type validateOpEnableRule struct { 474} 475 476func (*validateOpEnableRule) ID() string { 477 return "OperationInputValidation" 478} 479 480func (m *validateOpEnableRule) 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.(*EnableRuleInput) 484 if !ok { 485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 486 } 487 if err := validateOpEnableRuleInput(input); err != nil { 488 return out, metadata, err 489 } 490 return next.HandleInitialize(ctx, in) 491} 492 493type validateOpListPartnerEventSourceAccounts struct { 494} 495 496func (*validateOpListPartnerEventSourceAccounts) ID() string { 497 return "OperationInputValidation" 498} 499 500func (m *validateOpListPartnerEventSourceAccounts) 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.(*ListPartnerEventSourceAccountsInput) 504 if !ok { 505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 506 } 507 if err := validateOpListPartnerEventSourceAccountsInput(input); err != nil { 508 return out, metadata, err 509 } 510 return next.HandleInitialize(ctx, in) 511} 512 513type validateOpListPartnerEventSources struct { 514} 515 516func (*validateOpListPartnerEventSources) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpListPartnerEventSources) 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.(*ListPartnerEventSourcesInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpListPartnerEventSourcesInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533type validateOpListRuleNamesByTarget struct { 534} 535 536func (*validateOpListRuleNamesByTarget) ID() string { 537 return "OperationInputValidation" 538} 539 540func (m *validateOpListRuleNamesByTarget) 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.(*ListRuleNamesByTargetInput) 544 if !ok { 545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 546 } 547 if err := validateOpListRuleNamesByTargetInput(input); err != nil { 548 return out, metadata, err 549 } 550 return next.HandleInitialize(ctx, in) 551} 552 553type validateOpListTagsForResource struct { 554} 555 556func (*validateOpListTagsForResource) ID() string { 557 return "OperationInputValidation" 558} 559 560func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput) 564 if !ok { 565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 566 } 567 if err := validateOpListTagsForResourceInput(input); err != nil { 568 return out, metadata, err 569 } 570 return next.HandleInitialize(ctx, in) 571} 572 573type validateOpListTargetsByRule struct { 574} 575 576func (*validateOpListTargetsByRule) ID() string { 577 return "OperationInputValidation" 578} 579 580func (m *validateOpListTargetsByRule) 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.(*ListTargetsByRuleInput) 584 if !ok { 585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 586 } 587 if err := validateOpListTargetsByRuleInput(input); err != nil { 588 return out, metadata, err 589 } 590 return next.HandleInitialize(ctx, in) 591} 592 593type validateOpPutEvents struct { 594} 595 596func (*validateOpPutEvents) ID() string { 597 return "OperationInputValidation" 598} 599 600func (m *validateOpPutEvents) 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.(*PutEventsInput) 604 if !ok { 605 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 606 } 607 if err := validateOpPutEventsInput(input); err != nil { 608 return out, metadata, err 609 } 610 return next.HandleInitialize(ctx, in) 611} 612 613type validateOpPutPartnerEvents struct { 614} 615 616func (*validateOpPutPartnerEvents) ID() string { 617 return "OperationInputValidation" 618} 619 620func (m *validateOpPutPartnerEvents) 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.(*PutPartnerEventsInput) 624 if !ok { 625 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 626 } 627 if err := validateOpPutPartnerEventsInput(input); err != nil { 628 return out, metadata, err 629 } 630 return next.HandleInitialize(ctx, in) 631} 632 633type validateOpPutPermission struct { 634} 635 636func (*validateOpPutPermission) ID() string { 637 return "OperationInputValidation" 638} 639 640func (m *validateOpPutPermission) 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.(*PutPermissionInput) 644 if !ok { 645 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 646 } 647 if err := validateOpPutPermissionInput(input); err != nil { 648 return out, metadata, err 649 } 650 return next.HandleInitialize(ctx, in) 651} 652 653type validateOpPutRule struct { 654} 655 656func (*validateOpPutRule) ID() string { 657 return "OperationInputValidation" 658} 659 660func (m *validateOpPutRule) 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.(*PutRuleInput) 664 if !ok { 665 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 666 } 667 if err := validateOpPutRuleInput(input); err != nil { 668 return out, metadata, err 669 } 670 return next.HandleInitialize(ctx, in) 671} 672 673type validateOpPutTargets struct { 674} 675 676func (*validateOpPutTargets) ID() string { 677 return "OperationInputValidation" 678} 679 680func (m *validateOpPutTargets) 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.(*PutTargetsInput) 684 if !ok { 685 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 686 } 687 if err := validateOpPutTargetsInput(input); err != nil { 688 return out, metadata, err 689 } 690 return next.HandleInitialize(ctx, in) 691} 692 693type validateOpRemoveTargets struct { 694} 695 696func (*validateOpRemoveTargets) ID() string { 697 return "OperationInputValidation" 698} 699 700func (m *validateOpRemoveTargets) 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.(*RemoveTargetsInput) 704 if !ok { 705 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 706 } 707 if err := validateOpRemoveTargetsInput(input); err != nil { 708 return out, metadata, err 709 } 710 return next.HandleInitialize(ctx, in) 711} 712 713type validateOpStartReplay struct { 714} 715 716func (*validateOpStartReplay) ID() string { 717 return "OperationInputValidation" 718} 719 720func (m *validateOpStartReplay) 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.(*StartReplayInput) 724 if !ok { 725 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 726 } 727 if err := validateOpStartReplayInput(input); err != nil { 728 return out, metadata, err 729 } 730 return next.HandleInitialize(ctx, in) 731} 732 733type validateOpTagResource struct { 734} 735 736func (*validateOpTagResource) ID() string { 737 return "OperationInputValidation" 738} 739 740func (m *validateOpTagResource) 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.(*TagResourceInput) 744 if !ok { 745 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 746 } 747 if err := validateOpTagResourceInput(input); err != nil { 748 return out, metadata, err 749 } 750 return next.HandleInitialize(ctx, in) 751} 752 753type validateOpTestEventPattern struct { 754} 755 756func (*validateOpTestEventPattern) ID() string { 757 return "OperationInputValidation" 758} 759 760func (m *validateOpTestEventPattern) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 761 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 762) { 763 input, ok := in.Parameters.(*TestEventPatternInput) 764 if !ok { 765 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 766 } 767 if err := validateOpTestEventPatternInput(input); err != nil { 768 return out, metadata, err 769 } 770 return next.HandleInitialize(ctx, in) 771} 772 773type validateOpUntagResource struct { 774} 775 776func (*validateOpUntagResource) ID() string { 777 return "OperationInputValidation" 778} 779 780func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 781 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 782) { 783 input, ok := in.Parameters.(*UntagResourceInput) 784 if !ok { 785 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 786 } 787 if err := validateOpUntagResourceInput(input); err != nil { 788 return out, metadata, err 789 } 790 return next.HandleInitialize(ctx, in) 791} 792 793type validateOpUpdateApiDestination struct { 794} 795 796func (*validateOpUpdateApiDestination) ID() string { 797 return "OperationInputValidation" 798} 799 800func (m *validateOpUpdateApiDestination) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 801 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 802) { 803 input, ok := in.Parameters.(*UpdateApiDestinationInput) 804 if !ok { 805 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 806 } 807 if err := validateOpUpdateApiDestinationInput(input); err != nil { 808 return out, metadata, err 809 } 810 return next.HandleInitialize(ctx, in) 811} 812 813type validateOpUpdateArchive struct { 814} 815 816func (*validateOpUpdateArchive) ID() string { 817 return "OperationInputValidation" 818} 819 820func (m *validateOpUpdateArchive) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 821 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 822) { 823 input, ok := in.Parameters.(*UpdateArchiveInput) 824 if !ok { 825 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 826 } 827 if err := validateOpUpdateArchiveInput(input); err != nil { 828 return out, metadata, err 829 } 830 return next.HandleInitialize(ctx, in) 831} 832 833type validateOpUpdateConnection struct { 834} 835 836func (*validateOpUpdateConnection) ID() string { 837 return "OperationInputValidation" 838} 839 840func (m *validateOpUpdateConnection) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 841 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 842) { 843 input, ok := in.Parameters.(*UpdateConnectionInput) 844 if !ok { 845 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 846 } 847 if err := validateOpUpdateConnectionInput(input); err != nil { 848 return out, metadata, err 849 } 850 return next.HandleInitialize(ctx, in) 851} 852 853func addOpActivateEventSourceValidationMiddleware(stack *middleware.Stack) error { 854 return stack.Initialize.Add(&validateOpActivateEventSource{}, middleware.After) 855} 856 857func addOpCancelReplayValidationMiddleware(stack *middleware.Stack) error { 858 return stack.Initialize.Add(&validateOpCancelReplay{}, middleware.After) 859} 860 861func addOpCreateApiDestinationValidationMiddleware(stack *middleware.Stack) error { 862 return stack.Initialize.Add(&validateOpCreateApiDestination{}, middleware.After) 863} 864 865func addOpCreateArchiveValidationMiddleware(stack *middleware.Stack) error { 866 return stack.Initialize.Add(&validateOpCreateArchive{}, middleware.After) 867} 868 869func addOpCreateConnectionValidationMiddleware(stack *middleware.Stack) error { 870 return stack.Initialize.Add(&validateOpCreateConnection{}, middleware.After) 871} 872 873func addOpCreateEventBusValidationMiddleware(stack *middleware.Stack) error { 874 return stack.Initialize.Add(&validateOpCreateEventBus{}, middleware.After) 875} 876 877func addOpCreatePartnerEventSourceValidationMiddleware(stack *middleware.Stack) error { 878 return stack.Initialize.Add(&validateOpCreatePartnerEventSource{}, middleware.After) 879} 880 881func addOpDeactivateEventSourceValidationMiddleware(stack *middleware.Stack) error { 882 return stack.Initialize.Add(&validateOpDeactivateEventSource{}, middleware.After) 883} 884 885func addOpDeauthorizeConnectionValidationMiddleware(stack *middleware.Stack) error { 886 return stack.Initialize.Add(&validateOpDeauthorizeConnection{}, middleware.After) 887} 888 889func addOpDeleteApiDestinationValidationMiddleware(stack *middleware.Stack) error { 890 return stack.Initialize.Add(&validateOpDeleteApiDestination{}, middleware.After) 891} 892 893func addOpDeleteArchiveValidationMiddleware(stack *middleware.Stack) error { 894 return stack.Initialize.Add(&validateOpDeleteArchive{}, middleware.After) 895} 896 897func addOpDeleteConnectionValidationMiddleware(stack *middleware.Stack) error { 898 return stack.Initialize.Add(&validateOpDeleteConnection{}, middleware.After) 899} 900 901func addOpDeleteEventBusValidationMiddleware(stack *middleware.Stack) error { 902 return stack.Initialize.Add(&validateOpDeleteEventBus{}, middleware.After) 903} 904 905func addOpDeletePartnerEventSourceValidationMiddleware(stack *middleware.Stack) error { 906 return stack.Initialize.Add(&validateOpDeletePartnerEventSource{}, middleware.After) 907} 908 909func addOpDeleteRuleValidationMiddleware(stack *middleware.Stack) error { 910 return stack.Initialize.Add(&validateOpDeleteRule{}, middleware.After) 911} 912 913func addOpDescribeApiDestinationValidationMiddleware(stack *middleware.Stack) error { 914 return stack.Initialize.Add(&validateOpDescribeApiDestination{}, middleware.After) 915} 916 917func addOpDescribeArchiveValidationMiddleware(stack *middleware.Stack) error { 918 return stack.Initialize.Add(&validateOpDescribeArchive{}, middleware.After) 919} 920 921func addOpDescribeConnectionValidationMiddleware(stack *middleware.Stack) error { 922 return stack.Initialize.Add(&validateOpDescribeConnection{}, middleware.After) 923} 924 925func addOpDescribeEventSourceValidationMiddleware(stack *middleware.Stack) error { 926 return stack.Initialize.Add(&validateOpDescribeEventSource{}, middleware.After) 927} 928 929func addOpDescribePartnerEventSourceValidationMiddleware(stack *middleware.Stack) error { 930 return stack.Initialize.Add(&validateOpDescribePartnerEventSource{}, middleware.After) 931} 932 933func addOpDescribeReplayValidationMiddleware(stack *middleware.Stack) error { 934 return stack.Initialize.Add(&validateOpDescribeReplay{}, middleware.After) 935} 936 937func addOpDescribeRuleValidationMiddleware(stack *middleware.Stack) error { 938 return stack.Initialize.Add(&validateOpDescribeRule{}, middleware.After) 939} 940 941func addOpDisableRuleValidationMiddleware(stack *middleware.Stack) error { 942 return stack.Initialize.Add(&validateOpDisableRule{}, middleware.After) 943} 944 945func addOpEnableRuleValidationMiddleware(stack *middleware.Stack) error { 946 return stack.Initialize.Add(&validateOpEnableRule{}, middleware.After) 947} 948 949func addOpListPartnerEventSourceAccountsValidationMiddleware(stack *middleware.Stack) error { 950 return stack.Initialize.Add(&validateOpListPartnerEventSourceAccounts{}, middleware.After) 951} 952 953func addOpListPartnerEventSourcesValidationMiddleware(stack *middleware.Stack) error { 954 return stack.Initialize.Add(&validateOpListPartnerEventSources{}, middleware.After) 955} 956 957func addOpListRuleNamesByTargetValidationMiddleware(stack *middleware.Stack) error { 958 return stack.Initialize.Add(&validateOpListRuleNamesByTarget{}, middleware.After) 959} 960 961func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 962 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 963} 964 965func addOpListTargetsByRuleValidationMiddleware(stack *middleware.Stack) error { 966 return stack.Initialize.Add(&validateOpListTargetsByRule{}, middleware.After) 967} 968 969func addOpPutEventsValidationMiddleware(stack *middleware.Stack) error { 970 return stack.Initialize.Add(&validateOpPutEvents{}, middleware.After) 971} 972 973func addOpPutPartnerEventsValidationMiddleware(stack *middleware.Stack) error { 974 return stack.Initialize.Add(&validateOpPutPartnerEvents{}, middleware.After) 975} 976 977func addOpPutPermissionValidationMiddleware(stack *middleware.Stack) error { 978 return stack.Initialize.Add(&validateOpPutPermission{}, middleware.After) 979} 980 981func addOpPutRuleValidationMiddleware(stack *middleware.Stack) error { 982 return stack.Initialize.Add(&validateOpPutRule{}, middleware.After) 983} 984 985func addOpPutTargetsValidationMiddleware(stack *middleware.Stack) error { 986 return stack.Initialize.Add(&validateOpPutTargets{}, middleware.After) 987} 988 989func addOpRemoveTargetsValidationMiddleware(stack *middleware.Stack) error { 990 return stack.Initialize.Add(&validateOpRemoveTargets{}, middleware.After) 991} 992 993func addOpStartReplayValidationMiddleware(stack *middleware.Stack) error { 994 return stack.Initialize.Add(&validateOpStartReplay{}, middleware.After) 995} 996 997func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 998 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 999} 1000 1001func addOpTestEventPatternValidationMiddleware(stack *middleware.Stack) error { 1002 return stack.Initialize.Add(&validateOpTestEventPattern{}, middleware.After) 1003} 1004 1005func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 1006 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 1007} 1008 1009func addOpUpdateApiDestinationValidationMiddleware(stack *middleware.Stack) error { 1010 return stack.Initialize.Add(&validateOpUpdateApiDestination{}, middleware.After) 1011} 1012 1013func addOpUpdateArchiveValidationMiddleware(stack *middleware.Stack) error { 1014 return stack.Initialize.Add(&validateOpUpdateArchive{}, middleware.After) 1015} 1016 1017func addOpUpdateConnectionValidationMiddleware(stack *middleware.Stack) error { 1018 return stack.Initialize.Add(&validateOpUpdateConnection{}, middleware.After) 1019} 1020 1021func validateAwsVpcConfiguration(v *types.AwsVpcConfiguration) error { 1022 if v == nil { 1023 return nil 1024 } 1025 invalidParams := smithy.InvalidParamsError{Context: "AwsVpcConfiguration"} 1026 if v.Subnets == nil { 1027 invalidParams.Add(smithy.NewErrParamRequired("Subnets")) 1028 } 1029 if invalidParams.Len() > 0 { 1030 return invalidParams 1031 } else { 1032 return nil 1033 } 1034} 1035 1036func validateBatchParameters(v *types.BatchParameters) error { 1037 if v == nil { 1038 return nil 1039 } 1040 invalidParams := smithy.InvalidParamsError{Context: "BatchParameters"} 1041 if v.JobDefinition == nil { 1042 invalidParams.Add(smithy.NewErrParamRequired("JobDefinition")) 1043 } 1044 if v.JobName == nil { 1045 invalidParams.Add(smithy.NewErrParamRequired("JobName")) 1046 } 1047 if invalidParams.Len() > 0 { 1048 return invalidParams 1049 } else { 1050 return nil 1051 } 1052} 1053 1054func validateCondition(v *types.Condition) error { 1055 if v == nil { 1056 return nil 1057 } 1058 invalidParams := smithy.InvalidParamsError{Context: "Condition"} 1059 if v.Type == nil { 1060 invalidParams.Add(smithy.NewErrParamRequired("Type")) 1061 } 1062 if v.Key == nil { 1063 invalidParams.Add(smithy.NewErrParamRequired("Key")) 1064 } 1065 if v.Value == nil { 1066 invalidParams.Add(smithy.NewErrParamRequired("Value")) 1067 } 1068 if invalidParams.Len() > 0 { 1069 return invalidParams 1070 } else { 1071 return nil 1072 } 1073} 1074 1075func validateCreateConnectionApiKeyAuthRequestParameters(v *types.CreateConnectionApiKeyAuthRequestParameters) error { 1076 if v == nil { 1077 return nil 1078 } 1079 invalidParams := smithy.InvalidParamsError{Context: "CreateConnectionApiKeyAuthRequestParameters"} 1080 if v.ApiKeyName == nil { 1081 invalidParams.Add(smithy.NewErrParamRequired("ApiKeyName")) 1082 } 1083 if v.ApiKeyValue == nil { 1084 invalidParams.Add(smithy.NewErrParamRequired("ApiKeyValue")) 1085 } 1086 if invalidParams.Len() > 0 { 1087 return invalidParams 1088 } else { 1089 return nil 1090 } 1091} 1092 1093func validateCreateConnectionAuthRequestParameters(v *types.CreateConnectionAuthRequestParameters) error { 1094 if v == nil { 1095 return nil 1096 } 1097 invalidParams := smithy.InvalidParamsError{Context: "CreateConnectionAuthRequestParameters"} 1098 if v.BasicAuthParameters != nil { 1099 if err := validateCreateConnectionBasicAuthRequestParameters(v.BasicAuthParameters); err != nil { 1100 invalidParams.AddNested("BasicAuthParameters", err.(smithy.InvalidParamsError)) 1101 } 1102 } 1103 if v.OAuthParameters != nil { 1104 if err := validateCreateConnectionOAuthRequestParameters(v.OAuthParameters); err != nil { 1105 invalidParams.AddNested("OAuthParameters", err.(smithy.InvalidParamsError)) 1106 } 1107 } 1108 if v.ApiKeyAuthParameters != nil { 1109 if err := validateCreateConnectionApiKeyAuthRequestParameters(v.ApiKeyAuthParameters); err != nil { 1110 invalidParams.AddNested("ApiKeyAuthParameters", err.(smithy.InvalidParamsError)) 1111 } 1112 } 1113 if invalidParams.Len() > 0 { 1114 return invalidParams 1115 } else { 1116 return nil 1117 } 1118} 1119 1120func validateCreateConnectionBasicAuthRequestParameters(v *types.CreateConnectionBasicAuthRequestParameters) error { 1121 if v == nil { 1122 return nil 1123 } 1124 invalidParams := smithy.InvalidParamsError{Context: "CreateConnectionBasicAuthRequestParameters"} 1125 if v.Username == nil { 1126 invalidParams.Add(smithy.NewErrParamRequired("Username")) 1127 } 1128 if v.Password == nil { 1129 invalidParams.Add(smithy.NewErrParamRequired("Password")) 1130 } 1131 if invalidParams.Len() > 0 { 1132 return invalidParams 1133 } else { 1134 return nil 1135 } 1136} 1137 1138func validateCreateConnectionOAuthClientRequestParameters(v *types.CreateConnectionOAuthClientRequestParameters) error { 1139 if v == nil { 1140 return nil 1141 } 1142 invalidParams := smithy.InvalidParamsError{Context: "CreateConnectionOAuthClientRequestParameters"} 1143 if v.ClientID == nil { 1144 invalidParams.Add(smithy.NewErrParamRequired("ClientID")) 1145 } 1146 if v.ClientSecret == nil { 1147 invalidParams.Add(smithy.NewErrParamRequired("ClientSecret")) 1148 } 1149 if invalidParams.Len() > 0 { 1150 return invalidParams 1151 } else { 1152 return nil 1153 } 1154} 1155 1156func validateCreateConnectionOAuthRequestParameters(v *types.CreateConnectionOAuthRequestParameters) error { 1157 if v == nil { 1158 return nil 1159 } 1160 invalidParams := smithy.InvalidParamsError{Context: "CreateConnectionOAuthRequestParameters"} 1161 if v.ClientParameters == nil { 1162 invalidParams.Add(smithy.NewErrParamRequired("ClientParameters")) 1163 } else if v.ClientParameters != nil { 1164 if err := validateCreateConnectionOAuthClientRequestParameters(v.ClientParameters); err != nil { 1165 invalidParams.AddNested("ClientParameters", err.(smithy.InvalidParamsError)) 1166 } 1167 } 1168 if v.AuthorizationEndpoint == nil { 1169 invalidParams.Add(smithy.NewErrParamRequired("AuthorizationEndpoint")) 1170 } 1171 if len(v.HttpMethod) == 0 { 1172 invalidParams.Add(smithy.NewErrParamRequired("HttpMethod")) 1173 } 1174 if invalidParams.Len() > 0 { 1175 return invalidParams 1176 } else { 1177 return nil 1178 } 1179} 1180 1181func validateEcsParameters(v *types.EcsParameters) error { 1182 if v == nil { 1183 return nil 1184 } 1185 invalidParams := smithy.InvalidParamsError{Context: "EcsParameters"} 1186 if v.TaskDefinitionArn == nil { 1187 invalidParams.Add(smithy.NewErrParamRequired("TaskDefinitionArn")) 1188 } 1189 if v.NetworkConfiguration != nil { 1190 if err := validateNetworkConfiguration(v.NetworkConfiguration); err != nil { 1191 invalidParams.AddNested("NetworkConfiguration", err.(smithy.InvalidParamsError)) 1192 } 1193 } 1194 if invalidParams.Len() > 0 { 1195 return invalidParams 1196 } else { 1197 return nil 1198 } 1199} 1200 1201func validateInputTransformer(v *types.InputTransformer) error { 1202 if v == nil { 1203 return nil 1204 } 1205 invalidParams := smithy.InvalidParamsError{Context: "InputTransformer"} 1206 if v.InputTemplate == nil { 1207 invalidParams.Add(smithy.NewErrParamRequired("InputTemplate")) 1208 } 1209 if invalidParams.Len() > 0 { 1210 return invalidParams 1211 } else { 1212 return nil 1213 } 1214} 1215 1216func validateKinesisParameters(v *types.KinesisParameters) error { 1217 if v == nil { 1218 return nil 1219 } 1220 invalidParams := smithy.InvalidParamsError{Context: "KinesisParameters"} 1221 if v.PartitionKeyPath == nil { 1222 invalidParams.Add(smithy.NewErrParamRequired("PartitionKeyPath")) 1223 } 1224 if invalidParams.Len() > 0 { 1225 return invalidParams 1226 } else { 1227 return nil 1228 } 1229} 1230 1231func validateNetworkConfiguration(v *types.NetworkConfiguration) error { 1232 if v == nil { 1233 return nil 1234 } 1235 invalidParams := smithy.InvalidParamsError{Context: "NetworkConfiguration"} 1236 if v.AwsvpcConfiguration != nil { 1237 if err := validateAwsVpcConfiguration(v.AwsvpcConfiguration); err != nil { 1238 invalidParams.AddNested("AwsvpcConfiguration", err.(smithy.InvalidParamsError)) 1239 } 1240 } 1241 if invalidParams.Len() > 0 { 1242 return invalidParams 1243 } else { 1244 return nil 1245 } 1246} 1247 1248func validateRedshiftDataParameters(v *types.RedshiftDataParameters) error { 1249 if v == nil { 1250 return nil 1251 } 1252 invalidParams := smithy.InvalidParamsError{Context: "RedshiftDataParameters"} 1253 if v.Database == nil { 1254 invalidParams.Add(smithy.NewErrParamRequired("Database")) 1255 } 1256 if v.Sql == nil { 1257 invalidParams.Add(smithy.NewErrParamRequired("Sql")) 1258 } 1259 if invalidParams.Len() > 0 { 1260 return invalidParams 1261 } else { 1262 return nil 1263 } 1264} 1265 1266func validateReplayDestination(v *types.ReplayDestination) error { 1267 if v == nil { 1268 return nil 1269 } 1270 invalidParams := smithy.InvalidParamsError{Context: "ReplayDestination"} 1271 if v.Arn == nil { 1272 invalidParams.Add(smithy.NewErrParamRequired("Arn")) 1273 } 1274 if invalidParams.Len() > 0 { 1275 return invalidParams 1276 } else { 1277 return nil 1278 } 1279} 1280 1281func validateRunCommandParameters(v *types.RunCommandParameters) error { 1282 if v == nil { 1283 return nil 1284 } 1285 invalidParams := smithy.InvalidParamsError{Context: "RunCommandParameters"} 1286 if v.RunCommandTargets == nil { 1287 invalidParams.Add(smithy.NewErrParamRequired("RunCommandTargets")) 1288 } else if v.RunCommandTargets != nil { 1289 if err := validateRunCommandTargets(v.RunCommandTargets); err != nil { 1290 invalidParams.AddNested("RunCommandTargets", err.(smithy.InvalidParamsError)) 1291 } 1292 } 1293 if invalidParams.Len() > 0 { 1294 return invalidParams 1295 } else { 1296 return nil 1297 } 1298} 1299 1300func validateRunCommandTarget(v *types.RunCommandTarget) error { 1301 if v == nil { 1302 return nil 1303 } 1304 invalidParams := smithy.InvalidParamsError{Context: "RunCommandTarget"} 1305 if v.Key == nil { 1306 invalidParams.Add(smithy.NewErrParamRequired("Key")) 1307 } 1308 if v.Values == nil { 1309 invalidParams.Add(smithy.NewErrParamRequired("Values")) 1310 } 1311 if invalidParams.Len() > 0 { 1312 return invalidParams 1313 } else { 1314 return nil 1315 } 1316} 1317 1318func validateRunCommandTargets(v []types.RunCommandTarget) error { 1319 if v == nil { 1320 return nil 1321 } 1322 invalidParams := smithy.InvalidParamsError{Context: "RunCommandTargets"} 1323 for i := range v { 1324 if err := validateRunCommandTarget(&v[i]); err != nil { 1325 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1326 } 1327 } 1328 if invalidParams.Len() > 0 { 1329 return invalidParams 1330 } else { 1331 return nil 1332 } 1333} 1334 1335func validateSageMakerPipelineParameter(v *types.SageMakerPipelineParameter) error { 1336 if v == nil { 1337 return nil 1338 } 1339 invalidParams := smithy.InvalidParamsError{Context: "SageMakerPipelineParameter"} 1340 if v.Name == nil { 1341 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1342 } 1343 if v.Value == nil { 1344 invalidParams.Add(smithy.NewErrParamRequired("Value")) 1345 } 1346 if invalidParams.Len() > 0 { 1347 return invalidParams 1348 } else { 1349 return nil 1350 } 1351} 1352 1353func validateSageMakerPipelineParameterList(v []types.SageMakerPipelineParameter) error { 1354 if v == nil { 1355 return nil 1356 } 1357 invalidParams := smithy.InvalidParamsError{Context: "SageMakerPipelineParameterList"} 1358 for i := range v { 1359 if err := validateSageMakerPipelineParameter(&v[i]); err != nil { 1360 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1361 } 1362 } 1363 if invalidParams.Len() > 0 { 1364 return invalidParams 1365 } else { 1366 return nil 1367 } 1368} 1369 1370func validateSageMakerPipelineParameters(v *types.SageMakerPipelineParameters) error { 1371 if v == nil { 1372 return nil 1373 } 1374 invalidParams := smithy.InvalidParamsError{Context: "SageMakerPipelineParameters"} 1375 if v.PipelineParameterList != nil { 1376 if err := validateSageMakerPipelineParameterList(v.PipelineParameterList); err != nil { 1377 invalidParams.AddNested("PipelineParameterList", err.(smithy.InvalidParamsError)) 1378 } 1379 } 1380 if invalidParams.Len() > 0 { 1381 return invalidParams 1382 } else { 1383 return nil 1384 } 1385} 1386 1387func validateTag(v *types.Tag) error { 1388 if v == nil { 1389 return nil 1390 } 1391 invalidParams := smithy.InvalidParamsError{Context: "Tag"} 1392 if v.Key == nil { 1393 invalidParams.Add(smithy.NewErrParamRequired("Key")) 1394 } 1395 if v.Value == nil { 1396 invalidParams.Add(smithy.NewErrParamRequired("Value")) 1397 } 1398 if invalidParams.Len() > 0 { 1399 return invalidParams 1400 } else { 1401 return nil 1402 } 1403} 1404 1405func validateTagList(v []types.Tag) error { 1406 if v == nil { 1407 return nil 1408 } 1409 invalidParams := smithy.InvalidParamsError{Context: "TagList"} 1410 for i := range v { 1411 if err := validateTag(&v[i]); err != nil { 1412 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1413 } 1414 } 1415 if invalidParams.Len() > 0 { 1416 return invalidParams 1417 } else { 1418 return nil 1419 } 1420} 1421 1422func validateTarget(v *types.Target) error { 1423 if v == nil { 1424 return nil 1425 } 1426 invalidParams := smithy.InvalidParamsError{Context: "Target"} 1427 if v.Id == nil { 1428 invalidParams.Add(smithy.NewErrParamRequired("Id")) 1429 } 1430 if v.Arn == nil { 1431 invalidParams.Add(smithy.NewErrParamRequired("Arn")) 1432 } 1433 if v.InputTransformer != nil { 1434 if err := validateInputTransformer(v.InputTransformer); err != nil { 1435 invalidParams.AddNested("InputTransformer", err.(smithy.InvalidParamsError)) 1436 } 1437 } 1438 if v.KinesisParameters != nil { 1439 if err := validateKinesisParameters(v.KinesisParameters); err != nil { 1440 invalidParams.AddNested("KinesisParameters", err.(smithy.InvalidParamsError)) 1441 } 1442 } 1443 if v.RunCommandParameters != nil { 1444 if err := validateRunCommandParameters(v.RunCommandParameters); err != nil { 1445 invalidParams.AddNested("RunCommandParameters", err.(smithy.InvalidParamsError)) 1446 } 1447 } 1448 if v.EcsParameters != nil { 1449 if err := validateEcsParameters(v.EcsParameters); err != nil { 1450 invalidParams.AddNested("EcsParameters", err.(smithy.InvalidParamsError)) 1451 } 1452 } 1453 if v.BatchParameters != nil { 1454 if err := validateBatchParameters(v.BatchParameters); err != nil { 1455 invalidParams.AddNested("BatchParameters", err.(smithy.InvalidParamsError)) 1456 } 1457 } 1458 if v.RedshiftDataParameters != nil { 1459 if err := validateRedshiftDataParameters(v.RedshiftDataParameters); err != nil { 1460 invalidParams.AddNested("RedshiftDataParameters", err.(smithy.InvalidParamsError)) 1461 } 1462 } 1463 if v.SageMakerPipelineParameters != nil { 1464 if err := validateSageMakerPipelineParameters(v.SageMakerPipelineParameters); err != nil { 1465 invalidParams.AddNested("SageMakerPipelineParameters", err.(smithy.InvalidParamsError)) 1466 } 1467 } 1468 if invalidParams.Len() > 0 { 1469 return invalidParams 1470 } else { 1471 return nil 1472 } 1473} 1474 1475func validateTargetList(v []types.Target) error { 1476 if v == nil { 1477 return nil 1478 } 1479 invalidParams := smithy.InvalidParamsError{Context: "TargetList"} 1480 for i := range v { 1481 if err := validateTarget(&v[i]); err != nil { 1482 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1483 } 1484 } 1485 if invalidParams.Len() > 0 { 1486 return invalidParams 1487 } else { 1488 return nil 1489 } 1490} 1491 1492func validateOpActivateEventSourceInput(v *ActivateEventSourceInput) error { 1493 if v == nil { 1494 return nil 1495 } 1496 invalidParams := smithy.InvalidParamsError{Context: "ActivateEventSourceInput"} 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 validateOpCancelReplayInput(v *CancelReplayInput) error { 1508 if v == nil { 1509 return nil 1510 } 1511 invalidParams := smithy.InvalidParamsError{Context: "CancelReplayInput"} 1512 if v.ReplayName == nil { 1513 invalidParams.Add(smithy.NewErrParamRequired("ReplayName")) 1514 } 1515 if invalidParams.Len() > 0 { 1516 return invalidParams 1517 } else { 1518 return nil 1519 } 1520} 1521 1522func validateOpCreateApiDestinationInput(v *CreateApiDestinationInput) error { 1523 if v == nil { 1524 return nil 1525 } 1526 invalidParams := smithy.InvalidParamsError{Context: "CreateApiDestinationInput"} 1527 if v.Name == nil { 1528 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1529 } 1530 if v.ConnectionArn == nil { 1531 invalidParams.Add(smithy.NewErrParamRequired("ConnectionArn")) 1532 } 1533 if v.InvocationEndpoint == nil { 1534 invalidParams.Add(smithy.NewErrParamRequired("InvocationEndpoint")) 1535 } 1536 if len(v.HttpMethod) == 0 { 1537 invalidParams.Add(smithy.NewErrParamRequired("HttpMethod")) 1538 } 1539 if invalidParams.Len() > 0 { 1540 return invalidParams 1541 } else { 1542 return nil 1543 } 1544} 1545 1546func validateOpCreateArchiveInput(v *CreateArchiveInput) error { 1547 if v == nil { 1548 return nil 1549 } 1550 invalidParams := smithy.InvalidParamsError{Context: "CreateArchiveInput"} 1551 if v.ArchiveName == nil { 1552 invalidParams.Add(smithy.NewErrParamRequired("ArchiveName")) 1553 } 1554 if v.EventSourceArn == nil { 1555 invalidParams.Add(smithy.NewErrParamRequired("EventSourceArn")) 1556 } 1557 if invalidParams.Len() > 0 { 1558 return invalidParams 1559 } else { 1560 return nil 1561 } 1562} 1563 1564func validateOpCreateConnectionInput(v *CreateConnectionInput) error { 1565 if v == nil { 1566 return nil 1567 } 1568 invalidParams := smithy.InvalidParamsError{Context: "CreateConnectionInput"} 1569 if v.Name == nil { 1570 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1571 } 1572 if len(v.AuthorizationType) == 0 { 1573 invalidParams.Add(smithy.NewErrParamRequired("AuthorizationType")) 1574 } 1575 if v.AuthParameters == nil { 1576 invalidParams.Add(smithy.NewErrParamRequired("AuthParameters")) 1577 } else if v.AuthParameters != nil { 1578 if err := validateCreateConnectionAuthRequestParameters(v.AuthParameters); err != nil { 1579 invalidParams.AddNested("AuthParameters", err.(smithy.InvalidParamsError)) 1580 } 1581 } 1582 if invalidParams.Len() > 0 { 1583 return invalidParams 1584 } else { 1585 return nil 1586 } 1587} 1588 1589func validateOpCreateEventBusInput(v *CreateEventBusInput) error { 1590 if v == nil { 1591 return nil 1592 } 1593 invalidParams := smithy.InvalidParamsError{Context: "CreateEventBusInput"} 1594 if v.Name == nil { 1595 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1596 } 1597 if v.Tags != nil { 1598 if err := validateTagList(v.Tags); err != nil { 1599 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1600 } 1601 } 1602 if invalidParams.Len() > 0 { 1603 return invalidParams 1604 } else { 1605 return nil 1606 } 1607} 1608 1609func validateOpCreatePartnerEventSourceInput(v *CreatePartnerEventSourceInput) error { 1610 if v == nil { 1611 return nil 1612 } 1613 invalidParams := smithy.InvalidParamsError{Context: "CreatePartnerEventSourceInput"} 1614 if v.Name == nil { 1615 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1616 } 1617 if v.Account == nil { 1618 invalidParams.Add(smithy.NewErrParamRequired("Account")) 1619 } 1620 if invalidParams.Len() > 0 { 1621 return invalidParams 1622 } else { 1623 return nil 1624 } 1625} 1626 1627func validateOpDeactivateEventSourceInput(v *DeactivateEventSourceInput) error { 1628 if v == nil { 1629 return nil 1630 } 1631 invalidParams := smithy.InvalidParamsError{Context: "DeactivateEventSourceInput"} 1632 if v.Name == nil { 1633 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1634 } 1635 if invalidParams.Len() > 0 { 1636 return invalidParams 1637 } else { 1638 return nil 1639 } 1640} 1641 1642func validateOpDeauthorizeConnectionInput(v *DeauthorizeConnectionInput) error { 1643 if v == nil { 1644 return nil 1645 } 1646 invalidParams := smithy.InvalidParamsError{Context: "DeauthorizeConnectionInput"} 1647 if v.Name == nil { 1648 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1649 } 1650 if invalidParams.Len() > 0 { 1651 return invalidParams 1652 } else { 1653 return nil 1654 } 1655} 1656 1657func validateOpDeleteApiDestinationInput(v *DeleteApiDestinationInput) error { 1658 if v == nil { 1659 return nil 1660 } 1661 invalidParams := smithy.InvalidParamsError{Context: "DeleteApiDestinationInput"} 1662 if v.Name == nil { 1663 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1664 } 1665 if invalidParams.Len() > 0 { 1666 return invalidParams 1667 } else { 1668 return nil 1669 } 1670} 1671 1672func validateOpDeleteArchiveInput(v *DeleteArchiveInput) error { 1673 if v == nil { 1674 return nil 1675 } 1676 invalidParams := smithy.InvalidParamsError{Context: "DeleteArchiveInput"} 1677 if v.ArchiveName == nil { 1678 invalidParams.Add(smithy.NewErrParamRequired("ArchiveName")) 1679 } 1680 if invalidParams.Len() > 0 { 1681 return invalidParams 1682 } else { 1683 return nil 1684 } 1685} 1686 1687func validateOpDeleteConnectionInput(v *DeleteConnectionInput) error { 1688 if v == nil { 1689 return nil 1690 } 1691 invalidParams := smithy.InvalidParamsError{Context: "DeleteConnectionInput"} 1692 if v.Name == nil { 1693 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1694 } 1695 if invalidParams.Len() > 0 { 1696 return invalidParams 1697 } else { 1698 return nil 1699 } 1700} 1701 1702func validateOpDeleteEventBusInput(v *DeleteEventBusInput) error { 1703 if v == nil { 1704 return nil 1705 } 1706 invalidParams := smithy.InvalidParamsError{Context: "DeleteEventBusInput"} 1707 if v.Name == nil { 1708 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1709 } 1710 if invalidParams.Len() > 0 { 1711 return invalidParams 1712 } else { 1713 return nil 1714 } 1715} 1716 1717func validateOpDeletePartnerEventSourceInput(v *DeletePartnerEventSourceInput) error { 1718 if v == nil { 1719 return nil 1720 } 1721 invalidParams := smithy.InvalidParamsError{Context: "DeletePartnerEventSourceInput"} 1722 if v.Name == nil { 1723 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1724 } 1725 if v.Account == nil { 1726 invalidParams.Add(smithy.NewErrParamRequired("Account")) 1727 } 1728 if invalidParams.Len() > 0 { 1729 return invalidParams 1730 } else { 1731 return nil 1732 } 1733} 1734 1735func validateOpDeleteRuleInput(v *DeleteRuleInput) error { 1736 if v == nil { 1737 return nil 1738 } 1739 invalidParams := smithy.InvalidParamsError{Context: "DeleteRuleInput"} 1740 if v.Name == nil { 1741 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1742 } 1743 if invalidParams.Len() > 0 { 1744 return invalidParams 1745 } else { 1746 return nil 1747 } 1748} 1749 1750func validateOpDescribeApiDestinationInput(v *DescribeApiDestinationInput) error { 1751 if v == nil { 1752 return nil 1753 } 1754 invalidParams := smithy.InvalidParamsError{Context: "DescribeApiDestinationInput"} 1755 if v.Name == nil { 1756 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1757 } 1758 if invalidParams.Len() > 0 { 1759 return invalidParams 1760 } else { 1761 return nil 1762 } 1763} 1764 1765func validateOpDescribeArchiveInput(v *DescribeArchiveInput) error { 1766 if v == nil { 1767 return nil 1768 } 1769 invalidParams := smithy.InvalidParamsError{Context: "DescribeArchiveInput"} 1770 if v.ArchiveName == nil { 1771 invalidParams.Add(smithy.NewErrParamRequired("ArchiveName")) 1772 } 1773 if invalidParams.Len() > 0 { 1774 return invalidParams 1775 } else { 1776 return nil 1777 } 1778} 1779 1780func validateOpDescribeConnectionInput(v *DescribeConnectionInput) error { 1781 if v == nil { 1782 return nil 1783 } 1784 invalidParams := smithy.InvalidParamsError{Context: "DescribeConnectionInput"} 1785 if v.Name == nil { 1786 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1787 } 1788 if invalidParams.Len() > 0 { 1789 return invalidParams 1790 } else { 1791 return nil 1792 } 1793} 1794 1795func validateOpDescribeEventSourceInput(v *DescribeEventSourceInput) error { 1796 if v == nil { 1797 return nil 1798 } 1799 invalidParams := smithy.InvalidParamsError{Context: "DescribeEventSourceInput"} 1800 if v.Name == nil { 1801 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1802 } 1803 if invalidParams.Len() > 0 { 1804 return invalidParams 1805 } else { 1806 return nil 1807 } 1808} 1809 1810func validateOpDescribePartnerEventSourceInput(v *DescribePartnerEventSourceInput) error { 1811 if v == nil { 1812 return nil 1813 } 1814 invalidParams := smithy.InvalidParamsError{Context: "DescribePartnerEventSourceInput"} 1815 if v.Name == nil { 1816 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1817 } 1818 if invalidParams.Len() > 0 { 1819 return invalidParams 1820 } else { 1821 return nil 1822 } 1823} 1824 1825func validateOpDescribeReplayInput(v *DescribeReplayInput) error { 1826 if v == nil { 1827 return nil 1828 } 1829 invalidParams := smithy.InvalidParamsError{Context: "DescribeReplayInput"} 1830 if v.ReplayName == nil { 1831 invalidParams.Add(smithy.NewErrParamRequired("ReplayName")) 1832 } 1833 if invalidParams.Len() > 0 { 1834 return invalidParams 1835 } else { 1836 return nil 1837 } 1838} 1839 1840func validateOpDescribeRuleInput(v *DescribeRuleInput) error { 1841 if v == nil { 1842 return nil 1843 } 1844 invalidParams := smithy.InvalidParamsError{Context: "DescribeRuleInput"} 1845 if v.Name == nil { 1846 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1847 } 1848 if invalidParams.Len() > 0 { 1849 return invalidParams 1850 } else { 1851 return nil 1852 } 1853} 1854 1855func validateOpDisableRuleInput(v *DisableRuleInput) error { 1856 if v == nil { 1857 return nil 1858 } 1859 invalidParams := smithy.InvalidParamsError{Context: "DisableRuleInput"} 1860 if v.Name == nil { 1861 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1862 } 1863 if invalidParams.Len() > 0 { 1864 return invalidParams 1865 } else { 1866 return nil 1867 } 1868} 1869 1870func validateOpEnableRuleInput(v *EnableRuleInput) error { 1871 if v == nil { 1872 return nil 1873 } 1874 invalidParams := smithy.InvalidParamsError{Context: "EnableRuleInput"} 1875 if v.Name == nil { 1876 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1877 } 1878 if invalidParams.Len() > 0 { 1879 return invalidParams 1880 } else { 1881 return nil 1882 } 1883} 1884 1885func validateOpListPartnerEventSourceAccountsInput(v *ListPartnerEventSourceAccountsInput) error { 1886 if v == nil { 1887 return nil 1888 } 1889 invalidParams := smithy.InvalidParamsError{Context: "ListPartnerEventSourceAccountsInput"} 1890 if v.EventSourceName == nil { 1891 invalidParams.Add(smithy.NewErrParamRequired("EventSourceName")) 1892 } 1893 if invalidParams.Len() > 0 { 1894 return invalidParams 1895 } else { 1896 return nil 1897 } 1898} 1899 1900func validateOpListPartnerEventSourcesInput(v *ListPartnerEventSourcesInput) error { 1901 if v == nil { 1902 return nil 1903 } 1904 invalidParams := smithy.InvalidParamsError{Context: "ListPartnerEventSourcesInput"} 1905 if v.NamePrefix == nil { 1906 invalidParams.Add(smithy.NewErrParamRequired("NamePrefix")) 1907 } 1908 if invalidParams.Len() > 0 { 1909 return invalidParams 1910 } else { 1911 return nil 1912 } 1913} 1914 1915func validateOpListRuleNamesByTargetInput(v *ListRuleNamesByTargetInput) error { 1916 if v == nil { 1917 return nil 1918 } 1919 invalidParams := smithy.InvalidParamsError{Context: "ListRuleNamesByTargetInput"} 1920 if v.TargetArn == nil { 1921 invalidParams.Add(smithy.NewErrParamRequired("TargetArn")) 1922 } 1923 if invalidParams.Len() > 0 { 1924 return invalidParams 1925 } else { 1926 return nil 1927 } 1928} 1929 1930func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 1931 if v == nil { 1932 return nil 1933 } 1934 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 1935 if v.ResourceARN == nil { 1936 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 1937 } 1938 if invalidParams.Len() > 0 { 1939 return invalidParams 1940 } else { 1941 return nil 1942 } 1943} 1944 1945func validateOpListTargetsByRuleInput(v *ListTargetsByRuleInput) error { 1946 if v == nil { 1947 return nil 1948 } 1949 invalidParams := smithy.InvalidParamsError{Context: "ListTargetsByRuleInput"} 1950 if v.Rule == nil { 1951 invalidParams.Add(smithy.NewErrParamRequired("Rule")) 1952 } 1953 if invalidParams.Len() > 0 { 1954 return invalidParams 1955 } else { 1956 return nil 1957 } 1958} 1959 1960func validateOpPutEventsInput(v *PutEventsInput) error { 1961 if v == nil { 1962 return nil 1963 } 1964 invalidParams := smithy.InvalidParamsError{Context: "PutEventsInput"} 1965 if v.Entries == nil { 1966 invalidParams.Add(smithy.NewErrParamRequired("Entries")) 1967 } 1968 if invalidParams.Len() > 0 { 1969 return invalidParams 1970 } else { 1971 return nil 1972 } 1973} 1974 1975func validateOpPutPartnerEventsInput(v *PutPartnerEventsInput) error { 1976 if v == nil { 1977 return nil 1978 } 1979 invalidParams := smithy.InvalidParamsError{Context: "PutPartnerEventsInput"} 1980 if v.Entries == nil { 1981 invalidParams.Add(smithy.NewErrParamRequired("Entries")) 1982 } 1983 if invalidParams.Len() > 0 { 1984 return invalidParams 1985 } else { 1986 return nil 1987 } 1988} 1989 1990func validateOpPutPermissionInput(v *PutPermissionInput) error { 1991 if v == nil { 1992 return nil 1993 } 1994 invalidParams := smithy.InvalidParamsError{Context: "PutPermissionInput"} 1995 if v.Condition != nil { 1996 if err := validateCondition(v.Condition); err != nil { 1997 invalidParams.AddNested("Condition", err.(smithy.InvalidParamsError)) 1998 } 1999 } 2000 if invalidParams.Len() > 0 { 2001 return invalidParams 2002 } else { 2003 return nil 2004 } 2005} 2006 2007func validateOpPutRuleInput(v *PutRuleInput) error { 2008 if v == nil { 2009 return nil 2010 } 2011 invalidParams := smithy.InvalidParamsError{Context: "PutRuleInput"} 2012 if v.Name == nil { 2013 invalidParams.Add(smithy.NewErrParamRequired("Name")) 2014 } 2015 if v.Tags != nil { 2016 if err := validateTagList(v.Tags); err != nil { 2017 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 2018 } 2019 } 2020 if invalidParams.Len() > 0 { 2021 return invalidParams 2022 } else { 2023 return nil 2024 } 2025} 2026 2027func validateOpPutTargetsInput(v *PutTargetsInput) error { 2028 if v == nil { 2029 return nil 2030 } 2031 invalidParams := smithy.InvalidParamsError{Context: "PutTargetsInput"} 2032 if v.Rule == nil { 2033 invalidParams.Add(smithy.NewErrParamRequired("Rule")) 2034 } 2035 if v.Targets == nil { 2036 invalidParams.Add(smithy.NewErrParamRequired("Targets")) 2037 } else if v.Targets != nil { 2038 if err := validateTargetList(v.Targets); err != nil { 2039 invalidParams.AddNested("Targets", err.(smithy.InvalidParamsError)) 2040 } 2041 } 2042 if invalidParams.Len() > 0 { 2043 return invalidParams 2044 } else { 2045 return nil 2046 } 2047} 2048 2049func validateOpRemoveTargetsInput(v *RemoveTargetsInput) error { 2050 if v == nil { 2051 return nil 2052 } 2053 invalidParams := smithy.InvalidParamsError{Context: "RemoveTargetsInput"} 2054 if v.Rule == nil { 2055 invalidParams.Add(smithy.NewErrParamRequired("Rule")) 2056 } 2057 if v.Ids == nil { 2058 invalidParams.Add(smithy.NewErrParamRequired("Ids")) 2059 } 2060 if invalidParams.Len() > 0 { 2061 return invalidParams 2062 } else { 2063 return nil 2064 } 2065} 2066 2067func validateOpStartReplayInput(v *StartReplayInput) error { 2068 if v == nil { 2069 return nil 2070 } 2071 invalidParams := smithy.InvalidParamsError{Context: "StartReplayInput"} 2072 if v.ReplayName == nil { 2073 invalidParams.Add(smithy.NewErrParamRequired("ReplayName")) 2074 } 2075 if v.EventSourceArn == nil { 2076 invalidParams.Add(smithy.NewErrParamRequired("EventSourceArn")) 2077 } 2078 if v.EventStartTime == nil { 2079 invalidParams.Add(smithy.NewErrParamRequired("EventStartTime")) 2080 } 2081 if v.EventEndTime == nil { 2082 invalidParams.Add(smithy.NewErrParamRequired("EventEndTime")) 2083 } 2084 if v.Destination == nil { 2085 invalidParams.Add(smithy.NewErrParamRequired("Destination")) 2086 } else if v.Destination != nil { 2087 if err := validateReplayDestination(v.Destination); err != nil { 2088 invalidParams.AddNested("Destination", err.(smithy.InvalidParamsError)) 2089 } 2090 } 2091 if invalidParams.Len() > 0 { 2092 return invalidParams 2093 } else { 2094 return nil 2095 } 2096} 2097 2098func validateOpTagResourceInput(v *TagResourceInput) error { 2099 if v == nil { 2100 return nil 2101 } 2102 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 2103 if v.ResourceARN == nil { 2104 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 2105 } 2106 if v.Tags == nil { 2107 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 2108 } else if v.Tags != nil { 2109 if err := validateTagList(v.Tags); err != nil { 2110 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 2111 } 2112 } 2113 if invalidParams.Len() > 0 { 2114 return invalidParams 2115 } else { 2116 return nil 2117 } 2118} 2119 2120func validateOpTestEventPatternInput(v *TestEventPatternInput) error { 2121 if v == nil { 2122 return nil 2123 } 2124 invalidParams := smithy.InvalidParamsError{Context: "TestEventPatternInput"} 2125 if v.EventPattern == nil { 2126 invalidParams.Add(smithy.NewErrParamRequired("EventPattern")) 2127 } 2128 if v.Event == nil { 2129 invalidParams.Add(smithy.NewErrParamRequired("Event")) 2130 } 2131 if invalidParams.Len() > 0 { 2132 return invalidParams 2133 } else { 2134 return nil 2135 } 2136} 2137 2138func validateOpUntagResourceInput(v *UntagResourceInput) error { 2139 if v == nil { 2140 return nil 2141 } 2142 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 2143 if v.ResourceARN == nil { 2144 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 2145 } 2146 if v.TagKeys == nil { 2147 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 2148 } 2149 if invalidParams.Len() > 0 { 2150 return invalidParams 2151 } else { 2152 return nil 2153 } 2154} 2155 2156func validateOpUpdateApiDestinationInput(v *UpdateApiDestinationInput) error { 2157 if v == nil { 2158 return nil 2159 } 2160 invalidParams := smithy.InvalidParamsError{Context: "UpdateApiDestinationInput"} 2161 if v.Name == nil { 2162 invalidParams.Add(smithy.NewErrParamRequired("Name")) 2163 } 2164 if invalidParams.Len() > 0 { 2165 return invalidParams 2166 } else { 2167 return nil 2168 } 2169} 2170 2171func validateOpUpdateArchiveInput(v *UpdateArchiveInput) error { 2172 if v == nil { 2173 return nil 2174 } 2175 invalidParams := smithy.InvalidParamsError{Context: "UpdateArchiveInput"} 2176 if v.ArchiveName == nil { 2177 invalidParams.Add(smithy.NewErrParamRequired("ArchiveName")) 2178 } 2179 if invalidParams.Len() > 0 { 2180 return invalidParams 2181 } else { 2182 return nil 2183 } 2184} 2185 2186func validateOpUpdateConnectionInput(v *UpdateConnectionInput) error { 2187 if v == nil { 2188 return nil 2189 } 2190 invalidParams := smithy.InvalidParamsError{Context: "UpdateConnectionInput"} 2191 if v.Name == nil { 2192 invalidParams.Add(smithy.NewErrParamRequired("Name")) 2193 } 2194 if invalidParams.Len() > 0 { 2195 return invalidParams 2196 } else { 2197 return nil 2198 } 2199} 2200