1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package lookoutmetrics 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/lookoutmetrics/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpActivateAnomalyDetector struct { 14} 15 16func (*validateOpActivateAnomalyDetector) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpActivateAnomalyDetector) 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.(*ActivateAnomalyDetectorInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpActivateAnomalyDetectorInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpBackTestAnomalyDetector struct { 34} 35 36func (*validateOpBackTestAnomalyDetector) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpBackTestAnomalyDetector) 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.(*BackTestAnomalyDetectorInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpBackTestAnomalyDetectorInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpCreateAlert struct { 54} 55 56func (*validateOpCreateAlert) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpCreateAlert) 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.(*CreateAlertInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpCreateAlertInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpCreateAnomalyDetector struct { 74} 75 76func (*validateOpCreateAnomalyDetector) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpCreateAnomalyDetector) 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.(*CreateAnomalyDetectorInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpCreateAnomalyDetectorInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpCreateMetricSet struct { 94} 95 96func (*validateOpCreateMetricSet) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpCreateMetricSet) 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.(*CreateMetricSetInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpCreateMetricSetInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpDeleteAlert struct { 114} 115 116func (*validateOpDeleteAlert) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpDeleteAlert) 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.(*DeleteAlertInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpDeleteAlertInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpDeleteAnomalyDetector struct { 134} 135 136func (*validateOpDeleteAnomalyDetector) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpDeleteAnomalyDetector) 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.(*DeleteAnomalyDetectorInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpDeleteAnomalyDetectorInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpDescribeAlert struct { 154} 155 156func (*validateOpDescribeAlert) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpDescribeAlert) 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.(*DescribeAlertInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpDescribeAlertInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpDescribeAnomalyDetectionExecutions struct { 174} 175 176func (*validateOpDescribeAnomalyDetectionExecutions) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpDescribeAnomalyDetectionExecutions) 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.(*DescribeAnomalyDetectionExecutionsInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpDescribeAnomalyDetectionExecutionsInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpDescribeAnomalyDetector struct { 194} 195 196func (*validateOpDescribeAnomalyDetector) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpDescribeAnomalyDetector) 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.(*DescribeAnomalyDetectorInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpDescribeAnomalyDetectorInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpDescribeMetricSet struct { 214} 215 216func (*validateOpDescribeMetricSet) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpDescribeMetricSet) 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.(*DescribeMetricSetInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpDescribeMetricSetInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpGetAnomalyGroup struct { 234} 235 236func (*validateOpGetAnomalyGroup) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpGetAnomalyGroup) 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.(*GetAnomalyGroupInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpGetAnomalyGroupInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpGetFeedback struct { 254} 255 256func (*validateOpGetFeedback) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpGetFeedback) 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.(*GetFeedbackInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpGetFeedbackInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpGetSampleData struct { 274} 275 276func (*validateOpGetSampleData) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpGetSampleData) 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.(*GetSampleDataInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpGetSampleDataInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpListAnomalyGroupSummaries struct { 294} 295 296func (*validateOpListAnomalyGroupSummaries) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpListAnomalyGroupSummaries) 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.(*ListAnomalyGroupSummariesInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpListAnomalyGroupSummariesInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpListAnomalyGroupTimeSeries struct { 314} 315 316func (*validateOpListAnomalyGroupTimeSeries) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpListAnomalyGroupTimeSeries) 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.(*ListAnomalyGroupTimeSeriesInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpListAnomalyGroupTimeSeriesInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpListTagsForResource struct { 334} 335 336func (*validateOpListTagsForResource) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 341 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 342) { 343 input, ok := in.Parameters.(*ListTagsForResourceInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpListTagsForResourceInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpPutFeedback struct { 354} 355 356func (*validateOpPutFeedback) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpPutFeedback) 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.(*PutFeedbackInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpPutFeedbackInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpTagResource struct { 374} 375 376func (*validateOpTagResource) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpTagResource) 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.(*TagResourceInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpTagResourceInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpUntagResource struct { 394} 395 396func (*validateOpUntagResource) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpUntagResource) 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.(*UntagResourceInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpUntagResourceInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpUpdateAnomalyDetector struct { 414} 415 416func (*validateOpUpdateAnomalyDetector) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpUpdateAnomalyDetector) 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.(*UpdateAnomalyDetectorInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpUpdateAnomalyDetectorInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpUpdateMetricSet struct { 434} 435 436func (*validateOpUpdateMetricSet) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpUpdateMetricSet) 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.(*UpdateMetricSetInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpUpdateMetricSetInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453func addOpActivateAnomalyDetectorValidationMiddleware(stack *middleware.Stack) error { 454 return stack.Initialize.Add(&validateOpActivateAnomalyDetector{}, middleware.After) 455} 456 457func addOpBackTestAnomalyDetectorValidationMiddleware(stack *middleware.Stack) error { 458 return stack.Initialize.Add(&validateOpBackTestAnomalyDetector{}, middleware.After) 459} 460 461func addOpCreateAlertValidationMiddleware(stack *middleware.Stack) error { 462 return stack.Initialize.Add(&validateOpCreateAlert{}, middleware.After) 463} 464 465func addOpCreateAnomalyDetectorValidationMiddleware(stack *middleware.Stack) error { 466 return stack.Initialize.Add(&validateOpCreateAnomalyDetector{}, middleware.After) 467} 468 469func addOpCreateMetricSetValidationMiddleware(stack *middleware.Stack) error { 470 return stack.Initialize.Add(&validateOpCreateMetricSet{}, middleware.After) 471} 472 473func addOpDeleteAlertValidationMiddleware(stack *middleware.Stack) error { 474 return stack.Initialize.Add(&validateOpDeleteAlert{}, middleware.After) 475} 476 477func addOpDeleteAnomalyDetectorValidationMiddleware(stack *middleware.Stack) error { 478 return stack.Initialize.Add(&validateOpDeleteAnomalyDetector{}, middleware.After) 479} 480 481func addOpDescribeAlertValidationMiddleware(stack *middleware.Stack) error { 482 return stack.Initialize.Add(&validateOpDescribeAlert{}, middleware.After) 483} 484 485func addOpDescribeAnomalyDetectionExecutionsValidationMiddleware(stack *middleware.Stack) error { 486 return stack.Initialize.Add(&validateOpDescribeAnomalyDetectionExecutions{}, middleware.After) 487} 488 489func addOpDescribeAnomalyDetectorValidationMiddleware(stack *middleware.Stack) error { 490 return stack.Initialize.Add(&validateOpDescribeAnomalyDetector{}, middleware.After) 491} 492 493func addOpDescribeMetricSetValidationMiddleware(stack *middleware.Stack) error { 494 return stack.Initialize.Add(&validateOpDescribeMetricSet{}, middleware.After) 495} 496 497func addOpGetAnomalyGroupValidationMiddleware(stack *middleware.Stack) error { 498 return stack.Initialize.Add(&validateOpGetAnomalyGroup{}, middleware.After) 499} 500 501func addOpGetFeedbackValidationMiddleware(stack *middleware.Stack) error { 502 return stack.Initialize.Add(&validateOpGetFeedback{}, middleware.After) 503} 504 505func addOpGetSampleDataValidationMiddleware(stack *middleware.Stack) error { 506 return stack.Initialize.Add(&validateOpGetSampleData{}, middleware.After) 507} 508 509func addOpListAnomalyGroupSummariesValidationMiddleware(stack *middleware.Stack) error { 510 return stack.Initialize.Add(&validateOpListAnomalyGroupSummaries{}, middleware.After) 511} 512 513func addOpListAnomalyGroupTimeSeriesValidationMiddleware(stack *middleware.Stack) error { 514 return stack.Initialize.Add(&validateOpListAnomalyGroupTimeSeries{}, middleware.After) 515} 516 517func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 518 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 519} 520 521func addOpPutFeedbackValidationMiddleware(stack *middleware.Stack) error { 522 return stack.Initialize.Add(&validateOpPutFeedback{}, middleware.After) 523} 524 525func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 526 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 527} 528 529func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 530 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 531} 532 533func addOpUpdateAnomalyDetectorValidationMiddleware(stack *middleware.Stack) error { 534 return stack.Initialize.Add(&validateOpUpdateAnomalyDetector{}, middleware.After) 535} 536 537func addOpUpdateMetricSetValidationMiddleware(stack *middleware.Stack) error { 538 return stack.Initialize.Add(&validateOpUpdateMetricSet{}, middleware.After) 539} 540 541func validateAction(v *types.Action) error { 542 if v == nil { 543 return nil 544 } 545 invalidParams := smithy.InvalidParamsError{Context: "Action"} 546 if v.SNSConfiguration != nil { 547 if err := validateSNSConfiguration(v.SNSConfiguration); err != nil { 548 invalidParams.AddNested("SNSConfiguration", err.(smithy.InvalidParamsError)) 549 } 550 } 551 if v.LambdaConfiguration != nil { 552 if err := validateLambdaConfiguration(v.LambdaConfiguration); err != nil { 553 invalidParams.AddNested("LambdaConfiguration", err.(smithy.InvalidParamsError)) 554 } 555 } 556 if invalidParams.Len() > 0 { 557 return invalidParams 558 } else { 559 return nil 560 } 561} 562 563func validateAnomalyGroupTimeSeries(v *types.AnomalyGroupTimeSeries) error { 564 if v == nil { 565 return nil 566 } 567 invalidParams := smithy.InvalidParamsError{Context: "AnomalyGroupTimeSeries"} 568 if v.AnomalyGroupId == nil { 569 invalidParams.Add(smithy.NewErrParamRequired("AnomalyGroupId")) 570 } 571 if invalidParams.Len() > 0 { 572 return invalidParams 573 } else { 574 return nil 575 } 576} 577 578func validateAnomalyGroupTimeSeriesFeedback(v *types.AnomalyGroupTimeSeriesFeedback) error { 579 if v == nil { 580 return nil 581 } 582 invalidParams := smithy.InvalidParamsError{Context: "AnomalyGroupTimeSeriesFeedback"} 583 if v.AnomalyGroupId == nil { 584 invalidParams.Add(smithy.NewErrParamRequired("AnomalyGroupId")) 585 } 586 if v.TimeSeriesId == nil { 587 invalidParams.Add(smithy.NewErrParamRequired("TimeSeriesId")) 588 } 589 if v.IsAnomaly == nil { 590 invalidParams.Add(smithy.NewErrParamRequired("IsAnomaly")) 591 } 592 if invalidParams.Len() > 0 { 593 return invalidParams 594 } else { 595 return nil 596 } 597} 598 599func validateAppFlowConfig(v *types.AppFlowConfig) error { 600 if v == nil { 601 return nil 602 } 603 invalidParams := smithy.InvalidParamsError{Context: "AppFlowConfig"} 604 if v.RoleArn == nil { 605 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 606 } 607 if v.FlowName == nil { 608 invalidParams.Add(smithy.NewErrParamRequired("FlowName")) 609 } 610 if invalidParams.Len() > 0 { 611 return invalidParams 612 } else { 613 return nil 614 } 615} 616 617func validateCloudWatchConfig(v *types.CloudWatchConfig) error { 618 if v == nil { 619 return nil 620 } 621 invalidParams := smithy.InvalidParamsError{Context: "CloudWatchConfig"} 622 if v.RoleArn == nil { 623 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 624 } 625 if invalidParams.Len() > 0 { 626 return invalidParams 627 } else { 628 return nil 629 } 630} 631 632func validateLambdaConfiguration(v *types.LambdaConfiguration) error { 633 if v == nil { 634 return nil 635 } 636 invalidParams := smithy.InvalidParamsError{Context: "LambdaConfiguration"} 637 if v.RoleArn == nil { 638 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 639 } 640 if v.LambdaArn == nil { 641 invalidParams.Add(smithy.NewErrParamRequired("LambdaArn")) 642 } 643 if invalidParams.Len() > 0 { 644 return invalidParams 645 } else { 646 return nil 647 } 648} 649 650func validateMetric(v *types.Metric) error { 651 if v == nil { 652 return nil 653 } 654 invalidParams := smithy.InvalidParamsError{Context: "Metric"} 655 if v.MetricName == nil { 656 invalidParams.Add(smithy.NewErrParamRequired("MetricName")) 657 } 658 if len(v.AggregationFunction) == 0 { 659 invalidParams.Add(smithy.NewErrParamRequired("AggregationFunction")) 660 } 661 if invalidParams.Len() > 0 { 662 return invalidParams 663 } else { 664 return nil 665 } 666} 667 668func validateMetricList(v []types.Metric) error { 669 if v == nil { 670 return nil 671 } 672 invalidParams := smithy.InvalidParamsError{Context: "MetricList"} 673 for i := range v { 674 if err := validateMetric(&v[i]); err != nil { 675 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 676 } 677 } 678 if invalidParams.Len() > 0 { 679 return invalidParams 680 } else { 681 return nil 682 } 683} 684 685func validateMetricSource(v *types.MetricSource) error { 686 if v == nil { 687 return nil 688 } 689 invalidParams := smithy.InvalidParamsError{Context: "MetricSource"} 690 if v.S3SourceConfig != nil { 691 if err := validateS3SourceConfig(v.S3SourceConfig); err != nil { 692 invalidParams.AddNested("S3SourceConfig", err.(smithy.InvalidParamsError)) 693 } 694 } 695 if v.AppFlowConfig != nil { 696 if err := validateAppFlowConfig(v.AppFlowConfig); err != nil { 697 invalidParams.AddNested("AppFlowConfig", err.(smithy.InvalidParamsError)) 698 } 699 } 700 if v.CloudWatchConfig != nil { 701 if err := validateCloudWatchConfig(v.CloudWatchConfig); err != nil { 702 invalidParams.AddNested("CloudWatchConfig", err.(smithy.InvalidParamsError)) 703 } 704 } 705 if v.RDSSourceConfig != nil { 706 if err := validateRDSSourceConfig(v.RDSSourceConfig); err != nil { 707 invalidParams.AddNested("RDSSourceConfig", err.(smithy.InvalidParamsError)) 708 } 709 } 710 if v.RedshiftSourceConfig != nil { 711 if err := validateRedshiftSourceConfig(v.RedshiftSourceConfig); err != nil { 712 invalidParams.AddNested("RedshiftSourceConfig", err.(smithy.InvalidParamsError)) 713 } 714 } 715 if invalidParams.Len() > 0 { 716 return invalidParams 717 } else { 718 return nil 719 } 720} 721 722func validateRDSSourceConfig(v *types.RDSSourceConfig) error { 723 if v == nil { 724 return nil 725 } 726 invalidParams := smithy.InvalidParamsError{Context: "RDSSourceConfig"} 727 if v.DBInstanceIdentifier == nil { 728 invalidParams.Add(smithy.NewErrParamRequired("DBInstanceIdentifier")) 729 } 730 if v.DatabaseHost == nil { 731 invalidParams.Add(smithy.NewErrParamRequired("DatabaseHost")) 732 } 733 if v.SecretManagerArn == nil { 734 invalidParams.Add(smithy.NewErrParamRequired("SecretManagerArn")) 735 } 736 if v.DatabaseName == nil { 737 invalidParams.Add(smithy.NewErrParamRequired("DatabaseName")) 738 } 739 if v.TableName == nil { 740 invalidParams.Add(smithy.NewErrParamRequired("TableName")) 741 } 742 if v.RoleArn == nil { 743 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 744 } 745 if v.VpcConfiguration == nil { 746 invalidParams.Add(smithy.NewErrParamRequired("VpcConfiguration")) 747 } else if v.VpcConfiguration != nil { 748 if err := validateVpcConfiguration(v.VpcConfiguration); err != nil { 749 invalidParams.AddNested("VpcConfiguration", err.(smithy.InvalidParamsError)) 750 } 751 } 752 if invalidParams.Len() > 0 { 753 return invalidParams 754 } else { 755 return nil 756 } 757} 758 759func validateRedshiftSourceConfig(v *types.RedshiftSourceConfig) error { 760 if v == nil { 761 return nil 762 } 763 invalidParams := smithy.InvalidParamsError{Context: "RedshiftSourceConfig"} 764 if v.ClusterIdentifier == nil { 765 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 766 } 767 if v.DatabaseHost == nil { 768 invalidParams.Add(smithy.NewErrParamRequired("DatabaseHost")) 769 } 770 if v.SecretManagerArn == nil { 771 invalidParams.Add(smithy.NewErrParamRequired("SecretManagerArn")) 772 } 773 if v.DatabaseName == nil { 774 invalidParams.Add(smithy.NewErrParamRequired("DatabaseName")) 775 } 776 if v.TableName == nil { 777 invalidParams.Add(smithy.NewErrParamRequired("TableName")) 778 } 779 if v.RoleArn == nil { 780 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 781 } 782 if v.VpcConfiguration == nil { 783 invalidParams.Add(smithy.NewErrParamRequired("VpcConfiguration")) 784 } else if v.VpcConfiguration != nil { 785 if err := validateVpcConfiguration(v.VpcConfiguration); err != nil { 786 invalidParams.AddNested("VpcConfiguration", err.(smithy.InvalidParamsError)) 787 } 788 } 789 if invalidParams.Len() > 0 { 790 return invalidParams 791 } else { 792 return nil 793 } 794} 795 796func validateS3SourceConfig(v *types.S3SourceConfig) error { 797 if v == nil { 798 return nil 799 } 800 invalidParams := smithy.InvalidParamsError{Context: "S3SourceConfig"} 801 if v.RoleArn == nil { 802 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 803 } 804 if invalidParams.Len() > 0 { 805 return invalidParams 806 } else { 807 return nil 808 } 809} 810 811func validateSampleDataS3SourceConfig(v *types.SampleDataS3SourceConfig) error { 812 if v == nil { 813 return nil 814 } 815 invalidParams := smithy.InvalidParamsError{Context: "SampleDataS3SourceConfig"} 816 if v.RoleArn == nil { 817 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 818 } 819 if v.FileFormatDescriptor == nil { 820 invalidParams.Add(smithy.NewErrParamRequired("FileFormatDescriptor")) 821 } 822 if invalidParams.Len() > 0 { 823 return invalidParams 824 } else { 825 return nil 826 } 827} 828 829func validateSNSConfiguration(v *types.SNSConfiguration) error { 830 if v == nil { 831 return nil 832 } 833 invalidParams := smithy.InvalidParamsError{Context: "SNSConfiguration"} 834 if v.RoleArn == nil { 835 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 836 } 837 if v.SnsTopicArn == nil { 838 invalidParams.Add(smithy.NewErrParamRequired("SnsTopicArn")) 839 } 840 if invalidParams.Len() > 0 { 841 return invalidParams 842 } else { 843 return nil 844 } 845} 846 847func validateVpcConfiguration(v *types.VpcConfiguration) error { 848 if v == nil { 849 return nil 850 } 851 invalidParams := smithy.InvalidParamsError{Context: "VpcConfiguration"} 852 if v.SubnetIdList == nil { 853 invalidParams.Add(smithy.NewErrParamRequired("SubnetIdList")) 854 } 855 if v.SecurityGroupIdList == nil { 856 invalidParams.Add(smithy.NewErrParamRequired("SecurityGroupIdList")) 857 } 858 if invalidParams.Len() > 0 { 859 return invalidParams 860 } else { 861 return nil 862 } 863} 864 865func validateOpActivateAnomalyDetectorInput(v *ActivateAnomalyDetectorInput) error { 866 if v == nil { 867 return nil 868 } 869 invalidParams := smithy.InvalidParamsError{Context: "ActivateAnomalyDetectorInput"} 870 if v.AnomalyDetectorArn == nil { 871 invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorArn")) 872 } 873 if invalidParams.Len() > 0 { 874 return invalidParams 875 } else { 876 return nil 877 } 878} 879 880func validateOpBackTestAnomalyDetectorInput(v *BackTestAnomalyDetectorInput) error { 881 if v == nil { 882 return nil 883 } 884 invalidParams := smithy.InvalidParamsError{Context: "BackTestAnomalyDetectorInput"} 885 if v.AnomalyDetectorArn == nil { 886 invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorArn")) 887 } 888 if invalidParams.Len() > 0 { 889 return invalidParams 890 } else { 891 return nil 892 } 893} 894 895func validateOpCreateAlertInput(v *CreateAlertInput) error { 896 if v == nil { 897 return nil 898 } 899 invalidParams := smithy.InvalidParamsError{Context: "CreateAlertInput"} 900 if v.AlertName == nil { 901 invalidParams.Add(smithy.NewErrParamRequired("AlertName")) 902 } 903 if v.AnomalyDetectorArn == nil { 904 invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorArn")) 905 } 906 if v.Action == nil { 907 invalidParams.Add(smithy.NewErrParamRequired("Action")) 908 } else if v.Action != nil { 909 if err := validateAction(v.Action); err != nil { 910 invalidParams.AddNested("Action", err.(smithy.InvalidParamsError)) 911 } 912 } 913 if invalidParams.Len() > 0 { 914 return invalidParams 915 } else { 916 return nil 917 } 918} 919 920func validateOpCreateAnomalyDetectorInput(v *CreateAnomalyDetectorInput) error { 921 if v == nil { 922 return nil 923 } 924 invalidParams := smithy.InvalidParamsError{Context: "CreateAnomalyDetectorInput"} 925 if v.AnomalyDetectorName == nil { 926 invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorName")) 927 } 928 if v.AnomalyDetectorConfig == nil { 929 invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorConfig")) 930 } 931 if invalidParams.Len() > 0 { 932 return invalidParams 933 } else { 934 return nil 935 } 936} 937 938func validateOpCreateMetricSetInput(v *CreateMetricSetInput) error { 939 if v == nil { 940 return nil 941 } 942 invalidParams := smithy.InvalidParamsError{Context: "CreateMetricSetInput"} 943 if v.AnomalyDetectorArn == nil { 944 invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorArn")) 945 } 946 if v.MetricSetName == nil { 947 invalidParams.Add(smithy.NewErrParamRequired("MetricSetName")) 948 } 949 if v.MetricList == nil { 950 invalidParams.Add(smithy.NewErrParamRequired("MetricList")) 951 } else if v.MetricList != nil { 952 if err := validateMetricList(v.MetricList); err != nil { 953 invalidParams.AddNested("MetricList", err.(smithy.InvalidParamsError)) 954 } 955 } 956 if v.MetricSource == nil { 957 invalidParams.Add(smithy.NewErrParamRequired("MetricSource")) 958 } else if v.MetricSource != nil { 959 if err := validateMetricSource(v.MetricSource); err != nil { 960 invalidParams.AddNested("MetricSource", err.(smithy.InvalidParamsError)) 961 } 962 } 963 if invalidParams.Len() > 0 { 964 return invalidParams 965 } else { 966 return nil 967 } 968} 969 970func validateOpDeleteAlertInput(v *DeleteAlertInput) error { 971 if v == nil { 972 return nil 973 } 974 invalidParams := smithy.InvalidParamsError{Context: "DeleteAlertInput"} 975 if v.AlertArn == nil { 976 invalidParams.Add(smithy.NewErrParamRequired("AlertArn")) 977 } 978 if invalidParams.Len() > 0 { 979 return invalidParams 980 } else { 981 return nil 982 } 983} 984 985func validateOpDeleteAnomalyDetectorInput(v *DeleteAnomalyDetectorInput) error { 986 if v == nil { 987 return nil 988 } 989 invalidParams := smithy.InvalidParamsError{Context: "DeleteAnomalyDetectorInput"} 990 if v.AnomalyDetectorArn == nil { 991 invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorArn")) 992 } 993 if invalidParams.Len() > 0 { 994 return invalidParams 995 } else { 996 return nil 997 } 998} 999 1000func validateOpDescribeAlertInput(v *DescribeAlertInput) error { 1001 if v == nil { 1002 return nil 1003 } 1004 invalidParams := smithy.InvalidParamsError{Context: "DescribeAlertInput"} 1005 if v.AlertArn == nil { 1006 invalidParams.Add(smithy.NewErrParamRequired("AlertArn")) 1007 } 1008 if invalidParams.Len() > 0 { 1009 return invalidParams 1010 } else { 1011 return nil 1012 } 1013} 1014 1015func validateOpDescribeAnomalyDetectionExecutionsInput(v *DescribeAnomalyDetectionExecutionsInput) error { 1016 if v == nil { 1017 return nil 1018 } 1019 invalidParams := smithy.InvalidParamsError{Context: "DescribeAnomalyDetectionExecutionsInput"} 1020 if v.AnomalyDetectorArn == nil { 1021 invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorArn")) 1022 } 1023 if invalidParams.Len() > 0 { 1024 return invalidParams 1025 } else { 1026 return nil 1027 } 1028} 1029 1030func validateOpDescribeAnomalyDetectorInput(v *DescribeAnomalyDetectorInput) error { 1031 if v == nil { 1032 return nil 1033 } 1034 invalidParams := smithy.InvalidParamsError{Context: "DescribeAnomalyDetectorInput"} 1035 if v.AnomalyDetectorArn == nil { 1036 invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorArn")) 1037 } 1038 if invalidParams.Len() > 0 { 1039 return invalidParams 1040 } else { 1041 return nil 1042 } 1043} 1044 1045func validateOpDescribeMetricSetInput(v *DescribeMetricSetInput) error { 1046 if v == nil { 1047 return nil 1048 } 1049 invalidParams := smithy.InvalidParamsError{Context: "DescribeMetricSetInput"} 1050 if v.MetricSetArn == nil { 1051 invalidParams.Add(smithy.NewErrParamRequired("MetricSetArn")) 1052 } 1053 if invalidParams.Len() > 0 { 1054 return invalidParams 1055 } else { 1056 return nil 1057 } 1058} 1059 1060func validateOpGetAnomalyGroupInput(v *GetAnomalyGroupInput) error { 1061 if v == nil { 1062 return nil 1063 } 1064 invalidParams := smithy.InvalidParamsError{Context: "GetAnomalyGroupInput"} 1065 if v.AnomalyGroupId == nil { 1066 invalidParams.Add(smithy.NewErrParamRequired("AnomalyGroupId")) 1067 } 1068 if v.AnomalyDetectorArn == nil { 1069 invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorArn")) 1070 } 1071 if invalidParams.Len() > 0 { 1072 return invalidParams 1073 } else { 1074 return nil 1075 } 1076} 1077 1078func validateOpGetFeedbackInput(v *GetFeedbackInput) error { 1079 if v == nil { 1080 return nil 1081 } 1082 invalidParams := smithy.InvalidParamsError{Context: "GetFeedbackInput"} 1083 if v.AnomalyDetectorArn == nil { 1084 invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorArn")) 1085 } 1086 if v.AnomalyGroupTimeSeriesFeedback == nil { 1087 invalidParams.Add(smithy.NewErrParamRequired("AnomalyGroupTimeSeriesFeedback")) 1088 } else if v.AnomalyGroupTimeSeriesFeedback != nil { 1089 if err := validateAnomalyGroupTimeSeries(v.AnomalyGroupTimeSeriesFeedback); err != nil { 1090 invalidParams.AddNested("AnomalyGroupTimeSeriesFeedback", err.(smithy.InvalidParamsError)) 1091 } 1092 } 1093 if invalidParams.Len() > 0 { 1094 return invalidParams 1095 } else { 1096 return nil 1097 } 1098} 1099 1100func validateOpGetSampleDataInput(v *GetSampleDataInput) error { 1101 if v == nil { 1102 return nil 1103 } 1104 invalidParams := smithy.InvalidParamsError{Context: "GetSampleDataInput"} 1105 if v.S3SourceConfig != nil { 1106 if err := validateSampleDataS3SourceConfig(v.S3SourceConfig); err != nil { 1107 invalidParams.AddNested("S3SourceConfig", err.(smithy.InvalidParamsError)) 1108 } 1109 } 1110 if invalidParams.Len() > 0 { 1111 return invalidParams 1112 } else { 1113 return nil 1114 } 1115} 1116 1117func validateOpListAnomalyGroupSummariesInput(v *ListAnomalyGroupSummariesInput) error { 1118 if v == nil { 1119 return nil 1120 } 1121 invalidParams := smithy.InvalidParamsError{Context: "ListAnomalyGroupSummariesInput"} 1122 if v.AnomalyDetectorArn == nil { 1123 invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorArn")) 1124 } 1125 if invalidParams.Len() > 0 { 1126 return invalidParams 1127 } else { 1128 return nil 1129 } 1130} 1131 1132func validateOpListAnomalyGroupTimeSeriesInput(v *ListAnomalyGroupTimeSeriesInput) error { 1133 if v == nil { 1134 return nil 1135 } 1136 invalidParams := smithy.InvalidParamsError{Context: "ListAnomalyGroupTimeSeriesInput"} 1137 if v.AnomalyDetectorArn == nil { 1138 invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorArn")) 1139 } 1140 if v.AnomalyGroupId == nil { 1141 invalidParams.Add(smithy.NewErrParamRequired("AnomalyGroupId")) 1142 } 1143 if v.MetricName == nil { 1144 invalidParams.Add(smithy.NewErrParamRequired("MetricName")) 1145 } 1146 if invalidParams.Len() > 0 { 1147 return invalidParams 1148 } else { 1149 return nil 1150 } 1151} 1152 1153func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 1154 if v == nil { 1155 return nil 1156 } 1157 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 1158 if v.ResourceArn == nil { 1159 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1160 } 1161 if invalidParams.Len() > 0 { 1162 return invalidParams 1163 } else { 1164 return nil 1165 } 1166} 1167 1168func validateOpPutFeedbackInput(v *PutFeedbackInput) error { 1169 if v == nil { 1170 return nil 1171 } 1172 invalidParams := smithy.InvalidParamsError{Context: "PutFeedbackInput"} 1173 if v.AnomalyDetectorArn == nil { 1174 invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorArn")) 1175 } 1176 if v.AnomalyGroupTimeSeriesFeedback == nil { 1177 invalidParams.Add(smithy.NewErrParamRequired("AnomalyGroupTimeSeriesFeedback")) 1178 } else if v.AnomalyGroupTimeSeriesFeedback != nil { 1179 if err := validateAnomalyGroupTimeSeriesFeedback(v.AnomalyGroupTimeSeriesFeedback); err != nil { 1180 invalidParams.AddNested("AnomalyGroupTimeSeriesFeedback", err.(smithy.InvalidParamsError)) 1181 } 1182 } 1183 if invalidParams.Len() > 0 { 1184 return invalidParams 1185 } else { 1186 return nil 1187 } 1188} 1189 1190func validateOpTagResourceInput(v *TagResourceInput) error { 1191 if v == nil { 1192 return nil 1193 } 1194 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 1195 if v.ResourceArn == nil { 1196 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1197 } 1198 if v.Tags == nil { 1199 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 1200 } 1201 if invalidParams.Len() > 0 { 1202 return invalidParams 1203 } else { 1204 return nil 1205 } 1206} 1207 1208func validateOpUntagResourceInput(v *UntagResourceInput) error { 1209 if v == nil { 1210 return nil 1211 } 1212 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 1213 if v.ResourceArn == nil { 1214 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1215 } 1216 if v.TagKeys == nil { 1217 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 1218 } 1219 if invalidParams.Len() > 0 { 1220 return invalidParams 1221 } else { 1222 return nil 1223 } 1224} 1225 1226func validateOpUpdateAnomalyDetectorInput(v *UpdateAnomalyDetectorInput) error { 1227 if v == nil { 1228 return nil 1229 } 1230 invalidParams := smithy.InvalidParamsError{Context: "UpdateAnomalyDetectorInput"} 1231 if v.AnomalyDetectorArn == nil { 1232 invalidParams.Add(smithy.NewErrParamRequired("AnomalyDetectorArn")) 1233 } 1234 if invalidParams.Len() > 0 { 1235 return invalidParams 1236 } else { 1237 return nil 1238 } 1239} 1240 1241func validateOpUpdateMetricSetInput(v *UpdateMetricSetInput) error { 1242 if v == nil { 1243 return nil 1244 } 1245 invalidParams := smithy.InvalidParamsError{Context: "UpdateMetricSetInput"} 1246 if v.MetricSetArn == nil { 1247 invalidParams.Add(smithy.NewErrParamRequired("MetricSetArn")) 1248 } 1249 if v.MetricList != nil { 1250 if err := validateMetricList(v.MetricList); err != nil { 1251 invalidParams.AddNested("MetricList", err.(smithy.InvalidParamsError)) 1252 } 1253 } 1254 if v.MetricSource != nil { 1255 if err := validateMetricSource(v.MetricSource); err != nil { 1256 invalidParams.AddNested("MetricSource", err.(smithy.InvalidParamsError)) 1257 } 1258 } 1259 if invalidParams.Len() > 0 { 1260 return invalidParams 1261 } else { 1262 return nil 1263 } 1264} 1265