1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package frauddetector 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/frauddetector/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpBatchCreateVariable struct { 14} 15 16func (*validateOpBatchCreateVariable) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpBatchCreateVariable) 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.(*BatchCreateVariableInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpBatchCreateVariableInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpBatchGetVariable struct { 34} 35 36func (*validateOpBatchGetVariable) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpBatchGetVariable) 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.(*BatchGetVariableInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpBatchGetVariableInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpCreateDetectorVersion struct { 54} 55 56func (*validateOpCreateDetectorVersion) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpCreateDetectorVersion) 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.(*CreateDetectorVersionInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpCreateDetectorVersionInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpCreateModel struct { 74} 75 76func (*validateOpCreateModel) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpCreateModel) 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.(*CreateModelInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpCreateModelInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpCreateModelVersion struct { 94} 95 96func (*validateOpCreateModelVersion) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpCreateModelVersion) 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.(*CreateModelVersionInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpCreateModelVersionInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpCreateRule struct { 114} 115 116func (*validateOpCreateRule) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpCreateRule) 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.(*CreateRuleInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpCreateRuleInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpCreateVariable struct { 134} 135 136func (*validateOpCreateVariable) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpCreateVariable) 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.(*CreateVariableInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpCreateVariableInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpDeleteDetector struct { 154} 155 156func (*validateOpDeleteDetector) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpDeleteDetector) 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.(*DeleteDetectorInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpDeleteDetectorInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpDeleteDetectorVersion struct { 174} 175 176func (*validateOpDeleteDetectorVersion) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpDeleteDetectorVersion) 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.(*DeleteDetectorVersionInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpDeleteDetectorVersionInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpDeleteEntityType struct { 194} 195 196func (*validateOpDeleteEntityType) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpDeleteEntityType) 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.(*DeleteEntityTypeInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpDeleteEntityTypeInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpDeleteEvent struct { 214} 215 216func (*validateOpDeleteEvent) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpDeleteEvent) 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.(*DeleteEventInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpDeleteEventInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpDeleteEventType struct { 234} 235 236func (*validateOpDeleteEventType) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpDeleteEventType) 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.(*DeleteEventTypeInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpDeleteEventTypeInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpDeleteExternalModel struct { 254} 255 256func (*validateOpDeleteExternalModel) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpDeleteExternalModel) 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.(*DeleteExternalModelInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpDeleteExternalModelInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpDeleteLabel struct { 274} 275 276func (*validateOpDeleteLabel) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpDeleteLabel) 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.(*DeleteLabelInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpDeleteLabelInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpDeleteModel struct { 294} 295 296func (*validateOpDeleteModel) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpDeleteModel) 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.(*DeleteModelInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpDeleteModelInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpDeleteModelVersion struct { 314} 315 316func (*validateOpDeleteModelVersion) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpDeleteModelVersion) 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.(*DeleteModelVersionInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpDeleteModelVersionInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpDeleteOutcome struct { 334} 335 336func (*validateOpDeleteOutcome) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpDeleteOutcome) 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.(*DeleteOutcomeInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpDeleteOutcomeInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpDeleteRule struct { 354} 355 356func (*validateOpDeleteRule) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpDeleteRule) 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.(*DeleteRuleInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpDeleteRuleInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpDeleteVariable struct { 374} 375 376func (*validateOpDeleteVariable) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpDeleteVariable) 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.(*DeleteVariableInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpDeleteVariableInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpDescribeDetector struct { 394} 395 396func (*validateOpDescribeDetector) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpDescribeDetector) 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.(*DescribeDetectorInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpDescribeDetectorInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpGetDetectorVersion struct { 414} 415 416func (*validateOpGetDetectorVersion) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpGetDetectorVersion) 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.(*GetDetectorVersionInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpGetDetectorVersionInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpGetEventPrediction struct { 434} 435 436func (*validateOpGetEventPrediction) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpGetEventPrediction) 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.(*GetEventPredictionInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpGetEventPredictionInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpGetModelVersion struct { 454} 455 456func (*validateOpGetModelVersion) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpGetModelVersion) 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.(*GetModelVersionInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpGetModelVersionInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473type validateOpGetRules struct { 474} 475 476func (*validateOpGetRules) ID() string { 477 return "OperationInputValidation" 478} 479 480func (m *validateOpGetRules) 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.(*GetRulesInput) 484 if !ok { 485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 486 } 487 if err := validateOpGetRulesInput(input); err != nil { 488 return out, metadata, err 489 } 490 return next.HandleInitialize(ctx, in) 491} 492 493type validateOpListTagsForResource struct { 494} 495 496func (*validateOpListTagsForResource) ID() string { 497 return "OperationInputValidation" 498} 499 500func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput) 504 if !ok { 505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 506 } 507 if err := validateOpListTagsForResourceInput(input); err != nil { 508 return out, metadata, err 509 } 510 return next.HandleInitialize(ctx, in) 511} 512 513type validateOpPutDetector struct { 514} 515 516func (*validateOpPutDetector) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpPutDetector) 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.(*PutDetectorInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpPutDetectorInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533type validateOpPutEntityType struct { 534} 535 536func (*validateOpPutEntityType) ID() string { 537 return "OperationInputValidation" 538} 539 540func (m *validateOpPutEntityType) 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.(*PutEntityTypeInput) 544 if !ok { 545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 546 } 547 if err := validateOpPutEntityTypeInput(input); err != nil { 548 return out, metadata, err 549 } 550 return next.HandleInitialize(ctx, in) 551} 552 553type validateOpPutEventType struct { 554} 555 556func (*validateOpPutEventType) ID() string { 557 return "OperationInputValidation" 558} 559 560func (m *validateOpPutEventType) 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.(*PutEventTypeInput) 564 if !ok { 565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 566 } 567 if err := validateOpPutEventTypeInput(input); err != nil { 568 return out, metadata, err 569 } 570 return next.HandleInitialize(ctx, in) 571} 572 573type validateOpPutExternalModel struct { 574} 575 576func (*validateOpPutExternalModel) ID() string { 577 return "OperationInputValidation" 578} 579 580func (m *validateOpPutExternalModel) 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.(*PutExternalModelInput) 584 if !ok { 585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 586 } 587 if err := validateOpPutExternalModelInput(input); err != nil { 588 return out, metadata, err 589 } 590 return next.HandleInitialize(ctx, in) 591} 592 593type validateOpPutKMSEncryptionKey struct { 594} 595 596func (*validateOpPutKMSEncryptionKey) ID() string { 597 return "OperationInputValidation" 598} 599 600func (m *validateOpPutKMSEncryptionKey) 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.(*PutKMSEncryptionKeyInput) 604 if !ok { 605 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 606 } 607 if err := validateOpPutKMSEncryptionKeyInput(input); err != nil { 608 return out, metadata, err 609 } 610 return next.HandleInitialize(ctx, in) 611} 612 613type validateOpPutLabel struct { 614} 615 616func (*validateOpPutLabel) ID() string { 617 return "OperationInputValidation" 618} 619 620func (m *validateOpPutLabel) 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.(*PutLabelInput) 624 if !ok { 625 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 626 } 627 if err := validateOpPutLabelInput(input); err != nil { 628 return out, metadata, err 629 } 630 return next.HandleInitialize(ctx, in) 631} 632 633type validateOpPutOutcome struct { 634} 635 636func (*validateOpPutOutcome) ID() string { 637 return "OperationInputValidation" 638} 639 640func (m *validateOpPutOutcome) 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.(*PutOutcomeInput) 644 if !ok { 645 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 646 } 647 if err := validateOpPutOutcomeInput(input); err != nil { 648 return out, metadata, err 649 } 650 return next.HandleInitialize(ctx, in) 651} 652 653type validateOpTagResource struct { 654} 655 656func (*validateOpTagResource) ID() string { 657 return "OperationInputValidation" 658} 659 660func (m *validateOpTagResource) 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.(*TagResourceInput) 664 if !ok { 665 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 666 } 667 if err := validateOpTagResourceInput(input); err != nil { 668 return out, metadata, err 669 } 670 return next.HandleInitialize(ctx, in) 671} 672 673type validateOpUntagResource struct { 674} 675 676func (*validateOpUntagResource) ID() string { 677 return "OperationInputValidation" 678} 679 680func (m *validateOpUntagResource) 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.(*UntagResourceInput) 684 if !ok { 685 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 686 } 687 if err := validateOpUntagResourceInput(input); err != nil { 688 return out, metadata, err 689 } 690 return next.HandleInitialize(ctx, in) 691} 692 693type validateOpUpdateDetectorVersion struct { 694} 695 696func (*validateOpUpdateDetectorVersion) ID() string { 697 return "OperationInputValidation" 698} 699 700func (m *validateOpUpdateDetectorVersion) 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.(*UpdateDetectorVersionInput) 704 if !ok { 705 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 706 } 707 if err := validateOpUpdateDetectorVersionInput(input); err != nil { 708 return out, metadata, err 709 } 710 return next.HandleInitialize(ctx, in) 711} 712 713type validateOpUpdateDetectorVersionMetadata struct { 714} 715 716func (*validateOpUpdateDetectorVersionMetadata) ID() string { 717 return "OperationInputValidation" 718} 719 720func (m *validateOpUpdateDetectorVersionMetadata) 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.(*UpdateDetectorVersionMetadataInput) 724 if !ok { 725 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 726 } 727 if err := validateOpUpdateDetectorVersionMetadataInput(input); err != nil { 728 return out, metadata, err 729 } 730 return next.HandleInitialize(ctx, in) 731} 732 733type validateOpUpdateDetectorVersionStatus struct { 734} 735 736func (*validateOpUpdateDetectorVersionStatus) ID() string { 737 return "OperationInputValidation" 738} 739 740func (m *validateOpUpdateDetectorVersionStatus) 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.(*UpdateDetectorVersionStatusInput) 744 if !ok { 745 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 746 } 747 if err := validateOpUpdateDetectorVersionStatusInput(input); err != nil { 748 return out, metadata, err 749 } 750 return next.HandleInitialize(ctx, in) 751} 752 753type validateOpUpdateModel struct { 754} 755 756func (*validateOpUpdateModel) ID() string { 757 return "OperationInputValidation" 758} 759 760func (m *validateOpUpdateModel) 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.(*UpdateModelInput) 764 if !ok { 765 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 766 } 767 if err := validateOpUpdateModelInput(input); err != nil { 768 return out, metadata, err 769 } 770 return next.HandleInitialize(ctx, in) 771} 772 773type validateOpUpdateModelVersion struct { 774} 775 776func (*validateOpUpdateModelVersion) ID() string { 777 return "OperationInputValidation" 778} 779 780func (m *validateOpUpdateModelVersion) 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.(*UpdateModelVersionInput) 784 if !ok { 785 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 786 } 787 if err := validateOpUpdateModelVersionInput(input); err != nil { 788 return out, metadata, err 789 } 790 return next.HandleInitialize(ctx, in) 791} 792 793type validateOpUpdateModelVersionStatus struct { 794} 795 796func (*validateOpUpdateModelVersionStatus) ID() string { 797 return "OperationInputValidation" 798} 799 800func (m *validateOpUpdateModelVersionStatus) 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.(*UpdateModelVersionStatusInput) 804 if !ok { 805 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 806 } 807 if err := validateOpUpdateModelVersionStatusInput(input); err != nil { 808 return out, metadata, err 809 } 810 return next.HandleInitialize(ctx, in) 811} 812 813type validateOpUpdateRuleMetadata struct { 814} 815 816func (*validateOpUpdateRuleMetadata) ID() string { 817 return "OperationInputValidation" 818} 819 820func (m *validateOpUpdateRuleMetadata) 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.(*UpdateRuleMetadataInput) 824 if !ok { 825 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 826 } 827 if err := validateOpUpdateRuleMetadataInput(input); err != nil { 828 return out, metadata, err 829 } 830 return next.HandleInitialize(ctx, in) 831} 832 833type validateOpUpdateRuleVersion struct { 834} 835 836func (*validateOpUpdateRuleVersion) ID() string { 837 return "OperationInputValidation" 838} 839 840func (m *validateOpUpdateRuleVersion) 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.(*UpdateRuleVersionInput) 844 if !ok { 845 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 846 } 847 if err := validateOpUpdateRuleVersionInput(input); err != nil { 848 return out, metadata, err 849 } 850 return next.HandleInitialize(ctx, in) 851} 852 853type validateOpUpdateVariable struct { 854} 855 856func (*validateOpUpdateVariable) ID() string { 857 return "OperationInputValidation" 858} 859 860func (m *validateOpUpdateVariable) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 861 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 862) { 863 input, ok := in.Parameters.(*UpdateVariableInput) 864 if !ok { 865 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 866 } 867 if err := validateOpUpdateVariableInput(input); err != nil { 868 return out, metadata, err 869 } 870 return next.HandleInitialize(ctx, in) 871} 872 873func addOpBatchCreateVariableValidationMiddleware(stack *middleware.Stack) error { 874 return stack.Initialize.Add(&validateOpBatchCreateVariable{}, middleware.After) 875} 876 877func addOpBatchGetVariableValidationMiddleware(stack *middleware.Stack) error { 878 return stack.Initialize.Add(&validateOpBatchGetVariable{}, middleware.After) 879} 880 881func addOpCreateDetectorVersionValidationMiddleware(stack *middleware.Stack) error { 882 return stack.Initialize.Add(&validateOpCreateDetectorVersion{}, middleware.After) 883} 884 885func addOpCreateModelValidationMiddleware(stack *middleware.Stack) error { 886 return stack.Initialize.Add(&validateOpCreateModel{}, middleware.After) 887} 888 889func addOpCreateModelVersionValidationMiddleware(stack *middleware.Stack) error { 890 return stack.Initialize.Add(&validateOpCreateModelVersion{}, middleware.After) 891} 892 893func addOpCreateRuleValidationMiddleware(stack *middleware.Stack) error { 894 return stack.Initialize.Add(&validateOpCreateRule{}, middleware.After) 895} 896 897func addOpCreateVariableValidationMiddleware(stack *middleware.Stack) error { 898 return stack.Initialize.Add(&validateOpCreateVariable{}, middleware.After) 899} 900 901func addOpDeleteDetectorValidationMiddleware(stack *middleware.Stack) error { 902 return stack.Initialize.Add(&validateOpDeleteDetector{}, middleware.After) 903} 904 905func addOpDeleteDetectorVersionValidationMiddleware(stack *middleware.Stack) error { 906 return stack.Initialize.Add(&validateOpDeleteDetectorVersion{}, middleware.After) 907} 908 909func addOpDeleteEntityTypeValidationMiddleware(stack *middleware.Stack) error { 910 return stack.Initialize.Add(&validateOpDeleteEntityType{}, middleware.After) 911} 912 913func addOpDeleteEventValidationMiddleware(stack *middleware.Stack) error { 914 return stack.Initialize.Add(&validateOpDeleteEvent{}, middleware.After) 915} 916 917func addOpDeleteEventTypeValidationMiddleware(stack *middleware.Stack) error { 918 return stack.Initialize.Add(&validateOpDeleteEventType{}, middleware.After) 919} 920 921func addOpDeleteExternalModelValidationMiddleware(stack *middleware.Stack) error { 922 return stack.Initialize.Add(&validateOpDeleteExternalModel{}, middleware.After) 923} 924 925func addOpDeleteLabelValidationMiddleware(stack *middleware.Stack) error { 926 return stack.Initialize.Add(&validateOpDeleteLabel{}, middleware.After) 927} 928 929func addOpDeleteModelValidationMiddleware(stack *middleware.Stack) error { 930 return stack.Initialize.Add(&validateOpDeleteModel{}, middleware.After) 931} 932 933func addOpDeleteModelVersionValidationMiddleware(stack *middleware.Stack) error { 934 return stack.Initialize.Add(&validateOpDeleteModelVersion{}, middleware.After) 935} 936 937func addOpDeleteOutcomeValidationMiddleware(stack *middleware.Stack) error { 938 return stack.Initialize.Add(&validateOpDeleteOutcome{}, middleware.After) 939} 940 941func addOpDeleteRuleValidationMiddleware(stack *middleware.Stack) error { 942 return stack.Initialize.Add(&validateOpDeleteRule{}, middleware.After) 943} 944 945func addOpDeleteVariableValidationMiddleware(stack *middleware.Stack) error { 946 return stack.Initialize.Add(&validateOpDeleteVariable{}, middleware.After) 947} 948 949func addOpDescribeDetectorValidationMiddleware(stack *middleware.Stack) error { 950 return stack.Initialize.Add(&validateOpDescribeDetector{}, middleware.After) 951} 952 953func addOpGetDetectorVersionValidationMiddleware(stack *middleware.Stack) error { 954 return stack.Initialize.Add(&validateOpGetDetectorVersion{}, middleware.After) 955} 956 957func addOpGetEventPredictionValidationMiddleware(stack *middleware.Stack) error { 958 return stack.Initialize.Add(&validateOpGetEventPrediction{}, middleware.After) 959} 960 961func addOpGetModelVersionValidationMiddleware(stack *middleware.Stack) error { 962 return stack.Initialize.Add(&validateOpGetModelVersion{}, middleware.After) 963} 964 965func addOpGetRulesValidationMiddleware(stack *middleware.Stack) error { 966 return stack.Initialize.Add(&validateOpGetRules{}, middleware.After) 967} 968 969func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 970 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 971} 972 973func addOpPutDetectorValidationMiddleware(stack *middleware.Stack) error { 974 return stack.Initialize.Add(&validateOpPutDetector{}, middleware.After) 975} 976 977func addOpPutEntityTypeValidationMiddleware(stack *middleware.Stack) error { 978 return stack.Initialize.Add(&validateOpPutEntityType{}, middleware.After) 979} 980 981func addOpPutEventTypeValidationMiddleware(stack *middleware.Stack) error { 982 return stack.Initialize.Add(&validateOpPutEventType{}, middleware.After) 983} 984 985func addOpPutExternalModelValidationMiddleware(stack *middleware.Stack) error { 986 return stack.Initialize.Add(&validateOpPutExternalModel{}, middleware.After) 987} 988 989func addOpPutKMSEncryptionKeyValidationMiddleware(stack *middleware.Stack) error { 990 return stack.Initialize.Add(&validateOpPutKMSEncryptionKey{}, middleware.After) 991} 992 993func addOpPutLabelValidationMiddleware(stack *middleware.Stack) error { 994 return stack.Initialize.Add(&validateOpPutLabel{}, middleware.After) 995} 996 997func addOpPutOutcomeValidationMiddleware(stack *middleware.Stack) error { 998 return stack.Initialize.Add(&validateOpPutOutcome{}, middleware.After) 999} 1000 1001func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 1002 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 1003} 1004 1005func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 1006 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 1007} 1008 1009func addOpUpdateDetectorVersionValidationMiddleware(stack *middleware.Stack) error { 1010 return stack.Initialize.Add(&validateOpUpdateDetectorVersion{}, middleware.After) 1011} 1012 1013func addOpUpdateDetectorVersionMetadataValidationMiddleware(stack *middleware.Stack) error { 1014 return stack.Initialize.Add(&validateOpUpdateDetectorVersionMetadata{}, middleware.After) 1015} 1016 1017func addOpUpdateDetectorVersionStatusValidationMiddleware(stack *middleware.Stack) error { 1018 return stack.Initialize.Add(&validateOpUpdateDetectorVersionStatus{}, middleware.After) 1019} 1020 1021func addOpUpdateModelValidationMiddleware(stack *middleware.Stack) error { 1022 return stack.Initialize.Add(&validateOpUpdateModel{}, middleware.After) 1023} 1024 1025func addOpUpdateModelVersionValidationMiddleware(stack *middleware.Stack) error { 1026 return stack.Initialize.Add(&validateOpUpdateModelVersion{}, middleware.After) 1027} 1028 1029func addOpUpdateModelVersionStatusValidationMiddleware(stack *middleware.Stack) error { 1030 return stack.Initialize.Add(&validateOpUpdateModelVersionStatus{}, middleware.After) 1031} 1032 1033func addOpUpdateRuleMetadataValidationMiddleware(stack *middleware.Stack) error { 1034 return stack.Initialize.Add(&validateOpUpdateRuleMetadata{}, middleware.After) 1035} 1036 1037func addOpUpdateRuleVersionValidationMiddleware(stack *middleware.Stack) error { 1038 return stack.Initialize.Add(&validateOpUpdateRuleVersion{}, middleware.After) 1039} 1040 1041func addOpUpdateVariableValidationMiddleware(stack *middleware.Stack) error { 1042 return stack.Initialize.Add(&validateOpUpdateVariable{}, middleware.After) 1043} 1044 1045func validateEntity(v *types.Entity) error { 1046 if v == nil { 1047 return nil 1048 } 1049 invalidParams := smithy.InvalidParamsError{Context: "Entity"} 1050 if v.EntityType == nil { 1051 invalidParams.Add(smithy.NewErrParamRequired("EntityType")) 1052 } 1053 if v.EntityId == nil { 1054 invalidParams.Add(smithy.NewErrParamRequired("EntityId")) 1055 } 1056 if invalidParams.Len() > 0 { 1057 return invalidParams 1058 } else { 1059 return nil 1060 } 1061} 1062 1063func validateExternalEventsDetail(v *types.ExternalEventsDetail) error { 1064 if v == nil { 1065 return nil 1066 } 1067 invalidParams := smithy.InvalidParamsError{Context: "ExternalEventsDetail"} 1068 if v.DataLocation == nil { 1069 invalidParams.Add(smithy.NewErrParamRequired("DataLocation")) 1070 } 1071 if v.DataAccessRoleArn == nil { 1072 invalidParams.Add(smithy.NewErrParamRequired("DataAccessRoleArn")) 1073 } 1074 if invalidParams.Len() > 0 { 1075 return invalidParams 1076 } else { 1077 return nil 1078 } 1079} 1080 1081func validateLabelSchema(v *types.LabelSchema) error { 1082 if v == nil { 1083 return nil 1084 } 1085 invalidParams := smithy.InvalidParamsError{Context: "LabelSchema"} 1086 if v.LabelMapper == nil { 1087 invalidParams.Add(smithy.NewErrParamRequired("LabelMapper")) 1088 } 1089 if invalidParams.Len() > 0 { 1090 return invalidParams 1091 } else { 1092 return nil 1093 } 1094} 1095 1096func validateListOfEntities(v []types.Entity) error { 1097 if v == nil { 1098 return nil 1099 } 1100 invalidParams := smithy.InvalidParamsError{Context: "ListOfEntities"} 1101 for i := range v { 1102 if err := validateEntity(&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 validateListOfModelVersions(v []types.ModelVersion) error { 1114 if v == nil { 1115 return nil 1116 } 1117 invalidParams := smithy.InvalidParamsError{Context: "ListOfModelVersions"} 1118 for i := range v { 1119 if err := validateModelVersion(&v[i]); err != nil { 1120 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1121 } 1122 } 1123 if invalidParams.Len() > 0 { 1124 return invalidParams 1125 } else { 1126 return nil 1127 } 1128} 1129 1130func validateModelInputConfiguration(v *types.ModelInputConfiguration) error { 1131 if v == nil { 1132 return nil 1133 } 1134 invalidParams := smithy.InvalidParamsError{Context: "ModelInputConfiguration"} 1135 if v.UseEventVariables == nil { 1136 invalidParams.Add(smithy.NewErrParamRequired("UseEventVariables")) 1137 } 1138 if invalidParams.Len() > 0 { 1139 return invalidParams 1140 } else { 1141 return nil 1142 } 1143} 1144 1145func validateModelOutputConfiguration(v *types.ModelOutputConfiguration) error { 1146 if v == nil { 1147 return nil 1148 } 1149 invalidParams := smithy.InvalidParamsError{Context: "ModelOutputConfiguration"} 1150 if len(v.Format) == 0 { 1151 invalidParams.Add(smithy.NewErrParamRequired("Format")) 1152 } 1153 if invalidParams.Len() > 0 { 1154 return invalidParams 1155 } else { 1156 return nil 1157 } 1158} 1159 1160func validateModelVersion(v *types.ModelVersion) error { 1161 if v == nil { 1162 return nil 1163 } 1164 invalidParams := smithy.InvalidParamsError{Context: "ModelVersion"} 1165 if v.ModelId == nil { 1166 invalidParams.Add(smithy.NewErrParamRequired("ModelId")) 1167 } 1168 if len(v.ModelType) == 0 { 1169 invalidParams.Add(smithy.NewErrParamRequired("ModelType")) 1170 } 1171 if v.ModelVersionNumber == nil { 1172 invalidParams.Add(smithy.NewErrParamRequired("ModelVersionNumber")) 1173 } 1174 if invalidParams.Len() > 0 { 1175 return invalidParams 1176 } else { 1177 return nil 1178 } 1179} 1180 1181func validateRule(v *types.Rule) error { 1182 if v == nil { 1183 return nil 1184 } 1185 invalidParams := smithy.InvalidParamsError{Context: "Rule"} 1186 if v.DetectorId == nil { 1187 invalidParams.Add(smithy.NewErrParamRequired("DetectorId")) 1188 } 1189 if v.RuleId == nil { 1190 invalidParams.Add(smithy.NewErrParamRequired("RuleId")) 1191 } 1192 if v.RuleVersion == nil { 1193 invalidParams.Add(smithy.NewErrParamRequired("RuleVersion")) 1194 } 1195 if invalidParams.Len() > 0 { 1196 return invalidParams 1197 } else { 1198 return nil 1199 } 1200} 1201 1202func validateRuleList(v []types.Rule) error { 1203 if v == nil { 1204 return nil 1205 } 1206 invalidParams := smithy.InvalidParamsError{Context: "RuleList"} 1207 for i := range v { 1208 if err := validateRule(&v[i]); err != nil { 1209 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1210 } 1211 } 1212 if invalidParams.Len() > 0 { 1213 return invalidParams 1214 } else { 1215 return nil 1216 } 1217} 1218 1219func validateTag(v *types.Tag) error { 1220 if v == nil { 1221 return nil 1222 } 1223 invalidParams := smithy.InvalidParamsError{Context: "Tag"} 1224 if v.Key == nil { 1225 invalidParams.Add(smithy.NewErrParamRequired("Key")) 1226 } 1227 if v.Value == nil { 1228 invalidParams.Add(smithy.NewErrParamRequired("Value")) 1229 } 1230 if invalidParams.Len() > 0 { 1231 return invalidParams 1232 } else { 1233 return nil 1234 } 1235} 1236 1237func validateTagList(v []types.Tag) error { 1238 if v == nil { 1239 return nil 1240 } 1241 invalidParams := smithy.InvalidParamsError{Context: "TagList"} 1242 for i := range v { 1243 if err := validateTag(&v[i]); err != nil { 1244 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1245 } 1246 } 1247 if invalidParams.Len() > 0 { 1248 return invalidParams 1249 } else { 1250 return nil 1251 } 1252} 1253 1254func validateTrainingDataSchema(v *types.TrainingDataSchema) error { 1255 if v == nil { 1256 return nil 1257 } 1258 invalidParams := smithy.InvalidParamsError{Context: "TrainingDataSchema"} 1259 if v.ModelVariables == nil { 1260 invalidParams.Add(smithy.NewErrParamRequired("ModelVariables")) 1261 } 1262 if v.LabelSchema == nil { 1263 invalidParams.Add(smithy.NewErrParamRequired("LabelSchema")) 1264 } else if v.LabelSchema != nil { 1265 if err := validateLabelSchema(v.LabelSchema); err != nil { 1266 invalidParams.AddNested("LabelSchema", err.(smithy.InvalidParamsError)) 1267 } 1268 } 1269 if invalidParams.Len() > 0 { 1270 return invalidParams 1271 } else { 1272 return nil 1273 } 1274} 1275 1276func validateOpBatchCreateVariableInput(v *BatchCreateVariableInput) error { 1277 if v == nil { 1278 return nil 1279 } 1280 invalidParams := smithy.InvalidParamsError{Context: "BatchCreateVariableInput"} 1281 if v.VariableEntries == nil { 1282 invalidParams.Add(smithy.NewErrParamRequired("VariableEntries")) 1283 } 1284 if v.Tags != nil { 1285 if err := validateTagList(v.Tags); err != nil { 1286 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1287 } 1288 } 1289 if invalidParams.Len() > 0 { 1290 return invalidParams 1291 } else { 1292 return nil 1293 } 1294} 1295 1296func validateOpBatchGetVariableInput(v *BatchGetVariableInput) error { 1297 if v == nil { 1298 return nil 1299 } 1300 invalidParams := smithy.InvalidParamsError{Context: "BatchGetVariableInput"} 1301 if v.Names == nil { 1302 invalidParams.Add(smithy.NewErrParamRequired("Names")) 1303 } 1304 if invalidParams.Len() > 0 { 1305 return invalidParams 1306 } else { 1307 return nil 1308 } 1309} 1310 1311func validateOpCreateDetectorVersionInput(v *CreateDetectorVersionInput) error { 1312 if v == nil { 1313 return nil 1314 } 1315 invalidParams := smithy.InvalidParamsError{Context: "CreateDetectorVersionInput"} 1316 if v.DetectorId == nil { 1317 invalidParams.Add(smithy.NewErrParamRequired("DetectorId")) 1318 } 1319 if v.Rules == nil { 1320 invalidParams.Add(smithy.NewErrParamRequired("Rules")) 1321 } else if v.Rules != nil { 1322 if err := validateRuleList(v.Rules); err != nil { 1323 invalidParams.AddNested("Rules", err.(smithy.InvalidParamsError)) 1324 } 1325 } 1326 if v.ModelVersions != nil { 1327 if err := validateListOfModelVersions(v.ModelVersions); err != nil { 1328 invalidParams.AddNested("ModelVersions", err.(smithy.InvalidParamsError)) 1329 } 1330 } 1331 if v.Tags != nil { 1332 if err := validateTagList(v.Tags); err != nil { 1333 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1334 } 1335 } 1336 if invalidParams.Len() > 0 { 1337 return invalidParams 1338 } else { 1339 return nil 1340 } 1341} 1342 1343func validateOpCreateModelInput(v *CreateModelInput) error { 1344 if v == nil { 1345 return nil 1346 } 1347 invalidParams := smithy.InvalidParamsError{Context: "CreateModelInput"} 1348 if v.ModelId == nil { 1349 invalidParams.Add(smithy.NewErrParamRequired("ModelId")) 1350 } 1351 if len(v.ModelType) == 0 { 1352 invalidParams.Add(smithy.NewErrParamRequired("ModelType")) 1353 } 1354 if v.EventTypeName == nil { 1355 invalidParams.Add(smithy.NewErrParamRequired("EventTypeName")) 1356 } 1357 if v.Tags != nil { 1358 if err := validateTagList(v.Tags); err != nil { 1359 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1360 } 1361 } 1362 if invalidParams.Len() > 0 { 1363 return invalidParams 1364 } else { 1365 return nil 1366 } 1367} 1368 1369func validateOpCreateModelVersionInput(v *CreateModelVersionInput) error { 1370 if v == nil { 1371 return nil 1372 } 1373 invalidParams := smithy.InvalidParamsError{Context: "CreateModelVersionInput"} 1374 if v.ModelId == nil { 1375 invalidParams.Add(smithy.NewErrParamRequired("ModelId")) 1376 } 1377 if len(v.ModelType) == 0 { 1378 invalidParams.Add(smithy.NewErrParamRequired("ModelType")) 1379 } 1380 if len(v.TrainingDataSource) == 0 { 1381 invalidParams.Add(smithy.NewErrParamRequired("TrainingDataSource")) 1382 } 1383 if v.TrainingDataSchema == nil { 1384 invalidParams.Add(smithy.NewErrParamRequired("TrainingDataSchema")) 1385 } else if v.TrainingDataSchema != nil { 1386 if err := validateTrainingDataSchema(v.TrainingDataSchema); err != nil { 1387 invalidParams.AddNested("TrainingDataSchema", err.(smithy.InvalidParamsError)) 1388 } 1389 } 1390 if v.ExternalEventsDetail != nil { 1391 if err := validateExternalEventsDetail(v.ExternalEventsDetail); err != nil { 1392 invalidParams.AddNested("ExternalEventsDetail", err.(smithy.InvalidParamsError)) 1393 } 1394 } 1395 if v.Tags != nil { 1396 if err := validateTagList(v.Tags); err != nil { 1397 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1398 } 1399 } 1400 if invalidParams.Len() > 0 { 1401 return invalidParams 1402 } else { 1403 return nil 1404 } 1405} 1406 1407func validateOpCreateRuleInput(v *CreateRuleInput) error { 1408 if v == nil { 1409 return nil 1410 } 1411 invalidParams := smithy.InvalidParamsError{Context: "CreateRuleInput"} 1412 if v.RuleId == nil { 1413 invalidParams.Add(smithy.NewErrParamRequired("RuleId")) 1414 } 1415 if v.DetectorId == nil { 1416 invalidParams.Add(smithy.NewErrParamRequired("DetectorId")) 1417 } 1418 if v.Expression == nil { 1419 invalidParams.Add(smithy.NewErrParamRequired("Expression")) 1420 } 1421 if len(v.Language) == 0 { 1422 invalidParams.Add(smithy.NewErrParamRequired("Language")) 1423 } 1424 if v.Outcomes == nil { 1425 invalidParams.Add(smithy.NewErrParamRequired("Outcomes")) 1426 } 1427 if v.Tags != nil { 1428 if err := validateTagList(v.Tags); err != nil { 1429 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1430 } 1431 } 1432 if invalidParams.Len() > 0 { 1433 return invalidParams 1434 } else { 1435 return nil 1436 } 1437} 1438 1439func validateOpCreateVariableInput(v *CreateVariableInput) error { 1440 if v == nil { 1441 return nil 1442 } 1443 invalidParams := smithy.InvalidParamsError{Context: "CreateVariableInput"} 1444 if v.Name == nil { 1445 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1446 } 1447 if len(v.DataType) == 0 { 1448 invalidParams.Add(smithy.NewErrParamRequired("DataType")) 1449 } 1450 if len(v.DataSource) == 0 { 1451 invalidParams.Add(smithy.NewErrParamRequired("DataSource")) 1452 } 1453 if v.DefaultValue == nil { 1454 invalidParams.Add(smithy.NewErrParamRequired("DefaultValue")) 1455 } 1456 if v.Tags != nil { 1457 if err := validateTagList(v.Tags); err != nil { 1458 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1459 } 1460 } 1461 if invalidParams.Len() > 0 { 1462 return invalidParams 1463 } else { 1464 return nil 1465 } 1466} 1467 1468func validateOpDeleteDetectorInput(v *DeleteDetectorInput) error { 1469 if v == nil { 1470 return nil 1471 } 1472 invalidParams := smithy.InvalidParamsError{Context: "DeleteDetectorInput"} 1473 if v.DetectorId == nil { 1474 invalidParams.Add(smithy.NewErrParamRequired("DetectorId")) 1475 } 1476 if invalidParams.Len() > 0 { 1477 return invalidParams 1478 } else { 1479 return nil 1480 } 1481} 1482 1483func validateOpDeleteDetectorVersionInput(v *DeleteDetectorVersionInput) error { 1484 if v == nil { 1485 return nil 1486 } 1487 invalidParams := smithy.InvalidParamsError{Context: "DeleteDetectorVersionInput"} 1488 if v.DetectorId == nil { 1489 invalidParams.Add(smithy.NewErrParamRequired("DetectorId")) 1490 } 1491 if v.DetectorVersionId == nil { 1492 invalidParams.Add(smithy.NewErrParamRequired("DetectorVersionId")) 1493 } 1494 if invalidParams.Len() > 0 { 1495 return invalidParams 1496 } else { 1497 return nil 1498 } 1499} 1500 1501func validateOpDeleteEntityTypeInput(v *DeleteEntityTypeInput) error { 1502 if v == nil { 1503 return nil 1504 } 1505 invalidParams := smithy.InvalidParamsError{Context: "DeleteEntityTypeInput"} 1506 if v.Name == nil { 1507 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1508 } 1509 if invalidParams.Len() > 0 { 1510 return invalidParams 1511 } else { 1512 return nil 1513 } 1514} 1515 1516func validateOpDeleteEventInput(v *DeleteEventInput) error { 1517 if v == nil { 1518 return nil 1519 } 1520 invalidParams := smithy.InvalidParamsError{Context: "DeleteEventInput"} 1521 if v.EventId == nil { 1522 invalidParams.Add(smithy.NewErrParamRequired("EventId")) 1523 } 1524 if v.EventTypeName == nil { 1525 invalidParams.Add(smithy.NewErrParamRequired("EventTypeName")) 1526 } 1527 if invalidParams.Len() > 0 { 1528 return invalidParams 1529 } else { 1530 return nil 1531 } 1532} 1533 1534func validateOpDeleteEventTypeInput(v *DeleteEventTypeInput) error { 1535 if v == nil { 1536 return nil 1537 } 1538 invalidParams := smithy.InvalidParamsError{Context: "DeleteEventTypeInput"} 1539 if v.Name == nil { 1540 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1541 } 1542 if invalidParams.Len() > 0 { 1543 return invalidParams 1544 } else { 1545 return nil 1546 } 1547} 1548 1549func validateOpDeleteExternalModelInput(v *DeleteExternalModelInput) error { 1550 if v == nil { 1551 return nil 1552 } 1553 invalidParams := smithy.InvalidParamsError{Context: "DeleteExternalModelInput"} 1554 if v.ModelEndpoint == nil { 1555 invalidParams.Add(smithy.NewErrParamRequired("ModelEndpoint")) 1556 } 1557 if invalidParams.Len() > 0 { 1558 return invalidParams 1559 } else { 1560 return nil 1561 } 1562} 1563 1564func validateOpDeleteLabelInput(v *DeleteLabelInput) error { 1565 if v == nil { 1566 return nil 1567 } 1568 invalidParams := smithy.InvalidParamsError{Context: "DeleteLabelInput"} 1569 if v.Name == nil { 1570 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1571 } 1572 if invalidParams.Len() > 0 { 1573 return invalidParams 1574 } else { 1575 return nil 1576 } 1577} 1578 1579func validateOpDeleteModelInput(v *DeleteModelInput) error { 1580 if v == nil { 1581 return nil 1582 } 1583 invalidParams := smithy.InvalidParamsError{Context: "DeleteModelInput"} 1584 if v.ModelId == nil { 1585 invalidParams.Add(smithy.NewErrParamRequired("ModelId")) 1586 } 1587 if len(v.ModelType) == 0 { 1588 invalidParams.Add(smithy.NewErrParamRequired("ModelType")) 1589 } 1590 if invalidParams.Len() > 0 { 1591 return invalidParams 1592 } else { 1593 return nil 1594 } 1595} 1596 1597func validateOpDeleteModelVersionInput(v *DeleteModelVersionInput) error { 1598 if v == nil { 1599 return nil 1600 } 1601 invalidParams := smithy.InvalidParamsError{Context: "DeleteModelVersionInput"} 1602 if v.ModelId == nil { 1603 invalidParams.Add(smithy.NewErrParamRequired("ModelId")) 1604 } 1605 if len(v.ModelType) == 0 { 1606 invalidParams.Add(smithy.NewErrParamRequired("ModelType")) 1607 } 1608 if v.ModelVersionNumber == nil { 1609 invalidParams.Add(smithy.NewErrParamRequired("ModelVersionNumber")) 1610 } 1611 if invalidParams.Len() > 0 { 1612 return invalidParams 1613 } else { 1614 return nil 1615 } 1616} 1617 1618func validateOpDeleteOutcomeInput(v *DeleteOutcomeInput) error { 1619 if v == nil { 1620 return nil 1621 } 1622 invalidParams := smithy.InvalidParamsError{Context: "DeleteOutcomeInput"} 1623 if v.Name == nil { 1624 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1625 } 1626 if invalidParams.Len() > 0 { 1627 return invalidParams 1628 } else { 1629 return nil 1630 } 1631} 1632 1633func validateOpDeleteRuleInput(v *DeleteRuleInput) error { 1634 if v == nil { 1635 return nil 1636 } 1637 invalidParams := smithy.InvalidParamsError{Context: "DeleteRuleInput"} 1638 if v.Rule == nil { 1639 invalidParams.Add(smithy.NewErrParamRequired("Rule")) 1640 } else if v.Rule != nil { 1641 if err := validateRule(v.Rule); err != nil { 1642 invalidParams.AddNested("Rule", err.(smithy.InvalidParamsError)) 1643 } 1644 } 1645 if invalidParams.Len() > 0 { 1646 return invalidParams 1647 } else { 1648 return nil 1649 } 1650} 1651 1652func validateOpDeleteVariableInput(v *DeleteVariableInput) error { 1653 if v == nil { 1654 return nil 1655 } 1656 invalidParams := smithy.InvalidParamsError{Context: "DeleteVariableInput"} 1657 if v.Name == nil { 1658 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1659 } 1660 if invalidParams.Len() > 0 { 1661 return invalidParams 1662 } else { 1663 return nil 1664 } 1665} 1666 1667func validateOpDescribeDetectorInput(v *DescribeDetectorInput) error { 1668 if v == nil { 1669 return nil 1670 } 1671 invalidParams := smithy.InvalidParamsError{Context: "DescribeDetectorInput"} 1672 if v.DetectorId == nil { 1673 invalidParams.Add(smithy.NewErrParamRequired("DetectorId")) 1674 } 1675 if invalidParams.Len() > 0 { 1676 return invalidParams 1677 } else { 1678 return nil 1679 } 1680} 1681 1682func validateOpGetDetectorVersionInput(v *GetDetectorVersionInput) error { 1683 if v == nil { 1684 return nil 1685 } 1686 invalidParams := smithy.InvalidParamsError{Context: "GetDetectorVersionInput"} 1687 if v.DetectorId == nil { 1688 invalidParams.Add(smithy.NewErrParamRequired("DetectorId")) 1689 } 1690 if v.DetectorVersionId == nil { 1691 invalidParams.Add(smithy.NewErrParamRequired("DetectorVersionId")) 1692 } 1693 if invalidParams.Len() > 0 { 1694 return invalidParams 1695 } else { 1696 return nil 1697 } 1698} 1699 1700func validateOpGetEventPredictionInput(v *GetEventPredictionInput) error { 1701 if v == nil { 1702 return nil 1703 } 1704 invalidParams := smithy.InvalidParamsError{Context: "GetEventPredictionInput"} 1705 if v.DetectorId == nil { 1706 invalidParams.Add(smithy.NewErrParamRequired("DetectorId")) 1707 } 1708 if v.EventId == nil { 1709 invalidParams.Add(smithy.NewErrParamRequired("EventId")) 1710 } 1711 if v.EventTypeName == nil { 1712 invalidParams.Add(smithy.NewErrParamRequired("EventTypeName")) 1713 } 1714 if v.Entities == nil { 1715 invalidParams.Add(smithy.NewErrParamRequired("Entities")) 1716 } else if v.Entities != nil { 1717 if err := validateListOfEntities(v.Entities); err != nil { 1718 invalidParams.AddNested("Entities", err.(smithy.InvalidParamsError)) 1719 } 1720 } 1721 if v.EventTimestamp == nil { 1722 invalidParams.Add(smithy.NewErrParamRequired("EventTimestamp")) 1723 } 1724 if v.EventVariables == nil { 1725 invalidParams.Add(smithy.NewErrParamRequired("EventVariables")) 1726 } 1727 if invalidParams.Len() > 0 { 1728 return invalidParams 1729 } else { 1730 return nil 1731 } 1732} 1733 1734func validateOpGetModelVersionInput(v *GetModelVersionInput) error { 1735 if v == nil { 1736 return nil 1737 } 1738 invalidParams := smithy.InvalidParamsError{Context: "GetModelVersionInput"} 1739 if v.ModelId == nil { 1740 invalidParams.Add(smithy.NewErrParamRequired("ModelId")) 1741 } 1742 if len(v.ModelType) == 0 { 1743 invalidParams.Add(smithy.NewErrParamRequired("ModelType")) 1744 } 1745 if v.ModelVersionNumber == nil { 1746 invalidParams.Add(smithy.NewErrParamRequired("ModelVersionNumber")) 1747 } 1748 if invalidParams.Len() > 0 { 1749 return invalidParams 1750 } else { 1751 return nil 1752 } 1753} 1754 1755func validateOpGetRulesInput(v *GetRulesInput) error { 1756 if v == nil { 1757 return nil 1758 } 1759 invalidParams := smithy.InvalidParamsError{Context: "GetRulesInput"} 1760 if v.DetectorId == nil { 1761 invalidParams.Add(smithy.NewErrParamRequired("DetectorId")) 1762 } 1763 if invalidParams.Len() > 0 { 1764 return invalidParams 1765 } else { 1766 return nil 1767 } 1768} 1769 1770func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 1771 if v == nil { 1772 return nil 1773 } 1774 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 1775 if v.ResourceARN == nil { 1776 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 1777 } 1778 if invalidParams.Len() > 0 { 1779 return invalidParams 1780 } else { 1781 return nil 1782 } 1783} 1784 1785func validateOpPutDetectorInput(v *PutDetectorInput) error { 1786 if v == nil { 1787 return nil 1788 } 1789 invalidParams := smithy.InvalidParamsError{Context: "PutDetectorInput"} 1790 if v.DetectorId == nil { 1791 invalidParams.Add(smithy.NewErrParamRequired("DetectorId")) 1792 } 1793 if v.EventTypeName == nil { 1794 invalidParams.Add(smithy.NewErrParamRequired("EventTypeName")) 1795 } 1796 if v.Tags != nil { 1797 if err := validateTagList(v.Tags); err != nil { 1798 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1799 } 1800 } 1801 if invalidParams.Len() > 0 { 1802 return invalidParams 1803 } else { 1804 return nil 1805 } 1806} 1807 1808func validateOpPutEntityTypeInput(v *PutEntityTypeInput) error { 1809 if v == nil { 1810 return nil 1811 } 1812 invalidParams := smithy.InvalidParamsError{Context: "PutEntityTypeInput"} 1813 if v.Name == nil { 1814 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1815 } 1816 if v.Tags != nil { 1817 if err := validateTagList(v.Tags); err != nil { 1818 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1819 } 1820 } 1821 if invalidParams.Len() > 0 { 1822 return invalidParams 1823 } else { 1824 return nil 1825 } 1826} 1827 1828func validateOpPutEventTypeInput(v *PutEventTypeInput) error { 1829 if v == nil { 1830 return nil 1831 } 1832 invalidParams := smithy.InvalidParamsError{Context: "PutEventTypeInput"} 1833 if v.Name == nil { 1834 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1835 } 1836 if v.EventVariables == nil { 1837 invalidParams.Add(smithy.NewErrParamRequired("EventVariables")) 1838 } 1839 if v.EntityTypes == nil { 1840 invalidParams.Add(smithy.NewErrParamRequired("EntityTypes")) 1841 } 1842 if v.Tags != nil { 1843 if err := validateTagList(v.Tags); err != nil { 1844 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1845 } 1846 } 1847 if invalidParams.Len() > 0 { 1848 return invalidParams 1849 } else { 1850 return nil 1851 } 1852} 1853 1854func validateOpPutExternalModelInput(v *PutExternalModelInput) error { 1855 if v == nil { 1856 return nil 1857 } 1858 invalidParams := smithy.InvalidParamsError{Context: "PutExternalModelInput"} 1859 if v.ModelEndpoint == nil { 1860 invalidParams.Add(smithy.NewErrParamRequired("ModelEndpoint")) 1861 } 1862 if len(v.ModelSource) == 0 { 1863 invalidParams.Add(smithy.NewErrParamRequired("ModelSource")) 1864 } 1865 if v.InvokeModelEndpointRoleArn == nil { 1866 invalidParams.Add(smithy.NewErrParamRequired("InvokeModelEndpointRoleArn")) 1867 } 1868 if v.InputConfiguration == nil { 1869 invalidParams.Add(smithy.NewErrParamRequired("InputConfiguration")) 1870 } else if v.InputConfiguration != nil { 1871 if err := validateModelInputConfiguration(v.InputConfiguration); err != nil { 1872 invalidParams.AddNested("InputConfiguration", err.(smithy.InvalidParamsError)) 1873 } 1874 } 1875 if v.OutputConfiguration == nil { 1876 invalidParams.Add(smithy.NewErrParamRequired("OutputConfiguration")) 1877 } else if v.OutputConfiguration != nil { 1878 if err := validateModelOutputConfiguration(v.OutputConfiguration); err != nil { 1879 invalidParams.AddNested("OutputConfiguration", err.(smithy.InvalidParamsError)) 1880 } 1881 } 1882 if len(v.ModelEndpointStatus) == 0 { 1883 invalidParams.Add(smithy.NewErrParamRequired("ModelEndpointStatus")) 1884 } 1885 if v.Tags != nil { 1886 if err := validateTagList(v.Tags); err != nil { 1887 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1888 } 1889 } 1890 if invalidParams.Len() > 0 { 1891 return invalidParams 1892 } else { 1893 return nil 1894 } 1895} 1896 1897func validateOpPutKMSEncryptionKeyInput(v *PutKMSEncryptionKeyInput) error { 1898 if v == nil { 1899 return nil 1900 } 1901 invalidParams := smithy.InvalidParamsError{Context: "PutKMSEncryptionKeyInput"} 1902 if v.KmsEncryptionKeyArn == nil { 1903 invalidParams.Add(smithy.NewErrParamRequired("KmsEncryptionKeyArn")) 1904 } 1905 if invalidParams.Len() > 0 { 1906 return invalidParams 1907 } else { 1908 return nil 1909 } 1910} 1911 1912func validateOpPutLabelInput(v *PutLabelInput) error { 1913 if v == nil { 1914 return nil 1915 } 1916 invalidParams := smithy.InvalidParamsError{Context: "PutLabelInput"} 1917 if v.Name == nil { 1918 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1919 } 1920 if v.Tags != nil { 1921 if err := validateTagList(v.Tags); err != nil { 1922 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1923 } 1924 } 1925 if invalidParams.Len() > 0 { 1926 return invalidParams 1927 } else { 1928 return nil 1929 } 1930} 1931 1932func validateOpPutOutcomeInput(v *PutOutcomeInput) error { 1933 if v == nil { 1934 return nil 1935 } 1936 invalidParams := smithy.InvalidParamsError{Context: "PutOutcomeInput"} 1937 if v.Name == nil { 1938 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1939 } 1940 if v.Tags != nil { 1941 if err := validateTagList(v.Tags); err != nil { 1942 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1943 } 1944 } 1945 if invalidParams.Len() > 0 { 1946 return invalidParams 1947 } else { 1948 return nil 1949 } 1950} 1951 1952func validateOpTagResourceInput(v *TagResourceInput) error { 1953 if v == nil { 1954 return nil 1955 } 1956 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 1957 if v.ResourceARN == nil { 1958 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 1959 } 1960 if v.Tags == nil { 1961 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 1962 } else if v.Tags != nil { 1963 if err := validateTagList(v.Tags); err != nil { 1964 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1965 } 1966 } 1967 if invalidParams.Len() > 0 { 1968 return invalidParams 1969 } else { 1970 return nil 1971 } 1972} 1973 1974func validateOpUntagResourceInput(v *UntagResourceInput) error { 1975 if v == nil { 1976 return nil 1977 } 1978 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 1979 if v.ResourceARN == nil { 1980 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 1981 } 1982 if v.TagKeys == nil { 1983 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 1984 } 1985 if invalidParams.Len() > 0 { 1986 return invalidParams 1987 } else { 1988 return nil 1989 } 1990} 1991 1992func validateOpUpdateDetectorVersionInput(v *UpdateDetectorVersionInput) error { 1993 if v == nil { 1994 return nil 1995 } 1996 invalidParams := smithy.InvalidParamsError{Context: "UpdateDetectorVersionInput"} 1997 if v.DetectorId == nil { 1998 invalidParams.Add(smithy.NewErrParamRequired("DetectorId")) 1999 } 2000 if v.DetectorVersionId == nil { 2001 invalidParams.Add(smithy.NewErrParamRequired("DetectorVersionId")) 2002 } 2003 if v.ExternalModelEndpoints == nil { 2004 invalidParams.Add(smithy.NewErrParamRequired("ExternalModelEndpoints")) 2005 } 2006 if v.Rules == nil { 2007 invalidParams.Add(smithy.NewErrParamRequired("Rules")) 2008 } else if v.Rules != nil { 2009 if err := validateRuleList(v.Rules); err != nil { 2010 invalidParams.AddNested("Rules", err.(smithy.InvalidParamsError)) 2011 } 2012 } 2013 if v.ModelVersions != nil { 2014 if err := validateListOfModelVersions(v.ModelVersions); err != nil { 2015 invalidParams.AddNested("ModelVersions", err.(smithy.InvalidParamsError)) 2016 } 2017 } 2018 if invalidParams.Len() > 0 { 2019 return invalidParams 2020 } else { 2021 return nil 2022 } 2023} 2024 2025func validateOpUpdateDetectorVersionMetadataInput(v *UpdateDetectorVersionMetadataInput) error { 2026 if v == nil { 2027 return nil 2028 } 2029 invalidParams := smithy.InvalidParamsError{Context: "UpdateDetectorVersionMetadataInput"} 2030 if v.DetectorId == nil { 2031 invalidParams.Add(smithy.NewErrParamRequired("DetectorId")) 2032 } 2033 if v.DetectorVersionId == nil { 2034 invalidParams.Add(smithy.NewErrParamRequired("DetectorVersionId")) 2035 } 2036 if v.Description == nil { 2037 invalidParams.Add(smithy.NewErrParamRequired("Description")) 2038 } 2039 if invalidParams.Len() > 0 { 2040 return invalidParams 2041 } else { 2042 return nil 2043 } 2044} 2045 2046func validateOpUpdateDetectorVersionStatusInput(v *UpdateDetectorVersionStatusInput) error { 2047 if v == nil { 2048 return nil 2049 } 2050 invalidParams := smithy.InvalidParamsError{Context: "UpdateDetectorVersionStatusInput"} 2051 if v.DetectorId == nil { 2052 invalidParams.Add(smithy.NewErrParamRequired("DetectorId")) 2053 } 2054 if v.DetectorVersionId == nil { 2055 invalidParams.Add(smithy.NewErrParamRequired("DetectorVersionId")) 2056 } 2057 if len(v.Status) == 0 { 2058 invalidParams.Add(smithy.NewErrParamRequired("Status")) 2059 } 2060 if invalidParams.Len() > 0 { 2061 return invalidParams 2062 } else { 2063 return nil 2064 } 2065} 2066 2067func validateOpUpdateModelInput(v *UpdateModelInput) error { 2068 if v == nil { 2069 return nil 2070 } 2071 invalidParams := smithy.InvalidParamsError{Context: "UpdateModelInput"} 2072 if v.ModelId == nil { 2073 invalidParams.Add(smithy.NewErrParamRequired("ModelId")) 2074 } 2075 if len(v.ModelType) == 0 { 2076 invalidParams.Add(smithy.NewErrParamRequired("ModelType")) 2077 } 2078 if invalidParams.Len() > 0 { 2079 return invalidParams 2080 } else { 2081 return nil 2082 } 2083} 2084 2085func validateOpUpdateModelVersionInput(v *UpdateModelVersionInput) error { 2086 if v == nil { 2087 return nil 2088 } 2089 invalidParams := smithy.InvalidParamsError{Context: "UpdateModelVersionInput"} 2090 if v.ModelId == nil { 2091 invalidParams.Add(smithy.NewErrParamRequired("ModelId")) 2092 } 2093 if len(v.ModelType) == 0 { 2094 invalidParams.Add(smithy.NewErrParamRequired("ModelType")) 2095 } 2096 if v.MajorVersionNumber == nil { 2097 invalidParams.Add(smithy.NewErrParamRequired("MajorVersionNumber")) 2098 } 2099 if v.ExternalEventsDetail != nil { 2100 if err := validateExternalEventsDetail(v.ExternalEventsDetail); err != nil { 2101 invalidParams.AddNested("ExternalEventsDetail", err.(smithy.InvalidParamsError)) 2102 } 2103 } 2104 if v.Tags != nil { 2105 if err := validateTagList(v.Tags); err != nil { 2106 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 2107 } 2108 } 2109 if invalidParams.Len() > 0 { 2110 return invalidParams 2111 } else { 2112 return nil 2113 } 2114} 2115 2116func validateOpUpdateModelVersionStatusInput(v *UpdateModelVersionStatusInput) error { 2117 if v == nil { 2118 return nil 2119 } 2120 invalidParams := smithy.InvalidParamsError{Context: "UpdateModelVersionStatusInput"} 2121 if v.ModelId == nil { 2122 invalidParams.Add(smithy.NewErrParamRequired("ModelId")) 2123 } 2124 if len(v.ModelType) == 0 { 2125 invalidParams.Add(smithy.NewErrParamRequired("ModelType")) 2126 } 2127 if v.ModelVersionNumber == nil { 2128 invalidParams.Add(smithy.NewErrParamRequired("ModelVersionNumber")) 2129 } 2130 if len(v.Status) == 0 { 2131 invalidParams.Add(smithy.NewErrParamRequired("Status")) 2132 } 2133 if invalidParams.Len() > 0 { 2134 return invalidParams 2135 } else { 2136 return nil 2137 } 2138} 2139 2140func validateOpUpdateRuleMetadataInput(v *UpdateRuleMetadataInput) error { 2141 if v == nil { 2142 return nil 2143 } 2144 invalidParams := smithy.InvalidParamsError{Context: "UpdateRuleMetadataInput"} 2145 if v.Rule == nil { 2146 invalidParams.Add(smithy.NewErrParamRequired("Rule")) 2147 } else if v.Rule != nil { 2148 if err := validateRule(v.Rule); err != nil { 2149 invalidParams.AddNested("Rule", err.(smithy.InvalidParamsError)) 2150 } 2151 } 2152 if v.Description == nil { 2153 invalidParams.Add(smithy.NewErrParamRequired("Description")) 2154 } 2155 if invalidParams.Len() > 0 { 2156 return invalidParams 2157 } else { 2158 return nil 2159 } 2160} 2161 2162func validateOpUpdateRuleVersionInput(v *UpdateRuleVersionInput) error { 2163 if v == nil { 2164 return nil 2165 } 2166 invalidParams := smithy.InvalidParamsError{Context: "UpdateRuleVersionInput"} 2167 if v.Rule == nil { 2168 invalidParams.Add(smithy.NewErrParamRequired("Rule")) 2169 } else if v.Rule != nil { 2170 if err := validateRule(v.Rule); err != nil { 2171 invalidParams.AddNested("Rule", err.(smithy.InvalidParamsError)) 2172 } 2173 } 2174 if v.Expression == nil { 2175 invalidParams.Add(smithy.NewErrParamRequired("Expression")) 2176 } 2177 if len(v.Language) == 0 { 2178 invalidParams.Add(smithy.NewErrParamRequired("Language")) 2179 } 2180 if v.Outcomes == nil { 2181 invalidParams.Add(smithy.NewErrParamRequired("Outcomes")) 2182 } 2183 if v.Tags != nil { 2184 if err := validateTagList(v.Tags); err != nil { 2185 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 2186 } 2187 } 2188 if invalidParams.Len() > 0 { 2189 return invalidParams 2190 } else { 2191 return nil 2192 } 2193} 2194 2195func validateOpUpdateVariableInput(v *UpdateVariableInput) error { 2196 if v == nil { 2197 return nil 2198 } 2199 invalidParams := smithy.InvalidParamsError{Context: "UpdateVariableInput"} 2200 if v.Name == nil { 2201 invalidParams.Add(smithy.NewErrParamRequired("Name")) 2202 } 2203 if invalidParams.Len() > 0 { 2204 return invalidParams 2205 } else { 2206 return nil 2207 } 2208} 2209