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