1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package forecast 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/forecast/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpCreateDatasetGroup struct { 14} 15 16func (*validateOpCreateDatasetGroup) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpCreateDatasetGroup) 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.(*CreateDatasetGroupInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpCreateDatasetGroupInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpCreateDatasetImportJob struct { 34} 35 36func (*validateOpCreateDatasetImportJob) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpCreateDatasetImportJob) 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.(*CreateDatasetImportJobInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpCreateDatasetImportJobInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpCreateDataset struct { 54} 55 56func (*validateOpCreateDataset) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpCreateDataset) 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.(*CreateDatasetInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpCreateDatasetInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpCreateForecastExportJob struct { 74} 75 76func (*validateOpCreateForecastExportJob) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpCreateForecastExportJob) 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.(*CreateForecastExportJobInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpCreateForecastExportJobInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpCreateForecast struct { 94} 95 96func (*validateOpCreateForecast) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpCreateForecast) 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.(*CreateForecastInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpCreateForecastInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpCreatePredictorBacktestExportJob struct { 114} 115 116func (*validateOpCreatePredictorBacktestExportJob) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpCreatePredictorBacktestExportJob) 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.(*CreatePredictorBacktestExportJobInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpCreatePredictorBacktestExportJobInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpCreatePredictor struct { 134} 135 136func (*validateOpCreatePredictor) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpCreatePredictor) 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.(*CreatePredictorInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpCreatePredictorInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpDeleteDatasetGroup struct { 154} 155 156func (*validateOpDeleteDatasetGroup) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpDeleteDatasetGroup) 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.(*DeleteDatasetGroupInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpDeleteDatasetGroupInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpDeleteDatasetImportJob struct { 174} 175 176func (*validateOpDeleteDatasetImportJob) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpDeleteDatasetImportJob) 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.(*DeleteDatasetImportJobInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpDeleteDatasetImportJobInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpDeleteDataset struct { 194} 195 196func (*validateOpDeleteDataset) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpDeleteDataset) 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.(*DeleteDatasetInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpDeleteDatasetInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpDeleteForecastExportJob struct { 214} 215 216func (*validateOpDeleteForecastExportJob) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpDeleteForecastExportJob) 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.(*DeleteForecastExportJobInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpDeleteForecastExportJobInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpDeleteForecast struct { 234} 235 236func (*validateOpDeleteForecast) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpDeleteForecast) 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.(*DeleteForecastInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpDeleteForecastInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpDeletePredictorBacktestExportJob struct { 254} 255 256func (*validateOpDeletePredictorBacktestExportJob) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpDeletePredictorBacktestExportJob) 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.(*DeletePredictorBacktestExportJobInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpDeletePredictorBacktestExportJobInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpDeletePredictor struct { 274} 275 276func (*validateOpDeletePredictor) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpDeletePredictor) 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.(*DeletePredictorInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpDeletePredictorInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpDescribeDatasetGroup struct { 294} 295 296func (*validateOpDescribeDatasetGroup) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpDescribeDatasetGroup) 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.(*DescribeDatasetGroupInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpDescribeDatasetGroupInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpDescribeDatasetImportJob struct { 314} 315 316func (*validateOpDescribeDatasetImportJob) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpDescribeDatasetImportJob) 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.(*DescribeDatasetImportJobInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpDescribeDatasetImportJobInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpDescribeDataset struct { 334} 335 336func (*validateOpDescribeDataset) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpDescribeDataset) 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.(*DescribeDatasetInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpDescribeDatasetInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpDescribeForecastExportJob struct { 354} 355 356func (*validateOpDescribeForecastExportJob) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpDescribeForecastExportJob) 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.(*DescribeForecastExportJobInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpDescribeForecastExportJobInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpDescribeForecast struct { 374} 375 376func (*validateOpDescribeForecast) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpDescribeForecast) 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.(*DescribeForecastInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpDescribeForecastInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpDescribePredictorBacktestExportJob struct { 394} 395 396func (*validateOpDescribePredictorBacktestExportJob) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpDescribePredictorBacktestExportJob) 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.(*DescribePredictorBacktestExportJobInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpDescribePredictorBacktestExportJobInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpDescribePredictor struct { 414} 415 416func (*validateOpDescribePredictor) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpDescribePredictor) 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.(*DescribePredictorInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpDescribePredictorInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpGetAccuracyMetrics struct { 434} 435 436func (*validateOpGetAccuracyMetrics) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpGetAccuracyMetrics) 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.(*GetAccuracyMetricsInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpGetAccuracyMetricsInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpListDatasetImportJobs struct { 454} 455 456func (*validateOpListDatasetImportJobs) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpListDatasetImportJobs) 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.(*ListDatasetImportJobsInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpListDatasetImportJobsInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473type validateOpListForecastExportJobs struct { 474} 475 476func (*validateOpListForecastExportJobs) ID() string { 477 return "OperationInputValidation" 478} 479 480func (m *validateOpListForecastExportJobs) 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.(*ListForecastExportJobsInput) 484 if !ok { 485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 486 } 487 if err := validateOpListForecastExportJobsInput(input); err != nil { 488 return out, metadata, err 489 } 490 return next.HandleInitialize(ctx, in) 491} 492 493type validateOpListForecasts struct { 494} 495 496func (*validateOpListForecasts) ID() string { 497 return "OperationInputValidation" 498} 499 500func (m *validateOpListForecasts) 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.(*ListForecastsInput) 504 if !ok { 505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 506 } 507 if err := validateOpListForecastsInput(input); err != nil { 508 return out, metadata, err 509 } 510 return next.HandleInitialize(ctx, in) 511} 512 513type validateOpListPredictorBacktestExportJobs struct { 514} 515 516func (*validateOpListPredictorBacktestExportJobs) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpListPredictorBacktestExportJobs) 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.(*ListPredictorBacktestExportJobsInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpListPredictorBacktestExportJobsInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533type validateOpListPredictors struct { 534} 535 536func (*validateOpListPredictors) ID() string { 537 return "OperationInputValidation" 538} 539 540func (m *validateOpListPredictors) 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.(*ListPredictorsInput) 544 if !ok { 545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 546 } 547 if err := validateOpListPredictorsInput(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 validateOpStopResource struct { 574} 575 576func (*validateOpStopResource) ID() string { 577 return "OperationInputValidation" 578} 579 580func (m *validateOpStopResource) 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.(*StopResourceInput) 584 if !ok { 585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 586 } 587 if err := validateOpStopResourceInput(input); err != nil { 588 return out, metadata, err 589 } 590 return next.HandleInitialize(ctx, in) 591} 592 593type validateOpTagResource struct { 594} 595 596func (*validateOpTagResource) ID() string { 597 return "OperationInputValidation" 598} 599 600func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 601 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 602) { 603 input, ok := in.Parameters.(*TagResourceInput) 604 if !ok { 605 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 606 } 607 if err := validateOpTagResourceInput(input); err != nil { 608 return out, metadata, err 609 } 610 return next.HandleInitialize(ctx, in) 611} 612 613type validateOpUntagResource struct { 614} 615 616func (*validateOpUntagResource) ID() string { 617 return "OperationInputValidation" 618} 619 620func (m *validateOpUntagResource) 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.(*UntagResourceInput) 624 if !ok { 625 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 626 } 627 if err := validateOpUntagResourceInput(input); err != nil { 628 return out, metadata, err 629 } 630 return next.HandleInitialize(ctx, in) 631} 632 633type validateOpUpdateDatasetGroup struct { 634} 635 636func (*validateOpUpdateDatasetGroup) ID() string { 637 return "OperationInputValidation" 638} 639 640func (m *validateOpUpdateDatasetGroup) 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.(*UpdateDatasetGroupInput) 644 if !ok { 645 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 646 } 647 if err := validateOpUpdateDatasetGroupInput(input); err != nil { 648 return out, metadata, err 649 } 650 return next.HandleInitialize(ctx, in) 651} 652 653func addOpCreateDatasetGroupValidationMiddleware(stack *middleware.Stack) error { 654 return stack.Initialize.Add(&validateOpCreateDatasetGroup{}, middleware.After) 655} 656 657func addOpCreateDatasetImportJobValidationMiddleware(stack *middleware.Stack) error { 658 return stack.Initialize.Add(&validateOpCreateDatasetImportJob{}, middleware.After) 659} 660 661func addOpCreateDatasetValidationMiddleware(stack *middleware.Stack) error { 662 return stack.Initialize.Add(&validateOpCreateDataset{}, middleware.After) 663} 664 665func addOpCreateForecastExportJobValidationMiddleware(stack *middleware.Stack) error { 666 return stack.Initialize.Add(&validateOpCreateForecastExportJob{}, middleware.After) 667} 668 669func addOpCreateForecastValidationMiddleware(stack *middleware.Stack) error { 670 return stack.Initialize.Add(&validateOpCreateForecast{}, middleware.After) 671} 672 673func addOpCreatePredictorBacktestExportJobValidationMiddleware(stack *middleware.Stack) error { 674 return stack.Initialize.Add(&validateOpCreatePredictorBacktestExportJob{}, middleware.After) 675} 676 677func addOpCreatePredictorValidationMiddleware(stack *middleware.Stack) error { 678 return stack.Initialize.Add(&validateOpCreatePredictor{}, middleware.After) 679} 680 681func addOpDeleteDatasetGroupValidationMiddleware(stack *middleware.Stack) error { 682 return stack.Initialize.Add(&validateOpDeleteDatasetGroup{}, middleware.After) 683} 684 685func addOpDeleteDatasetImportJobValidationMiddleware(stack *middleware.Stack) error { 686 return stack.Initialize.Add(&validateOpDeleteDatasetImportJob{}, middleware.After) 687} 688 689func addOpDeleteDatasetValidationMiddleware(stack *middleware.Stack) error { 690 return stack.Initialize.Add(&validateOpDeleteDataset{}, middleware.After) 691} 692 693func addOpDeleteForecastExportJobValidationMiddleware(stack *middleware.Stack) error { 694 return stack.Initialize.Add(&validateOpDeleteForecastExportJob{}, middleware.After) 695} 696 697func addOpDeleteForecastValidationMiddleware(stack *middleware.Stack) error { 698 return stack.Initialize.Add(&validateOpDeleteForecast{}, middleware.After) 699} 700 701func addOpDeletePredictorBacktestExportJobValidationMiddleware(stack *middleware.Stack) error { 702 return stack.Initialize.Add(&validateOpDeletePredictorBacktestExportJob{}, middleware.After) 703} 704 705func addOpDeletePredictorValidationMiddleware(stack *middleware.Stack) error { 706 return stack.Initialize.Add(&validateOpDeletePredictor{}, middleware.After) 707} 708 709func addOpDescribeDatasetGroupValidationMiddleware(stack *middleware.Stack) error { 710 return stack.Initialize.Add(&validateOpDescribeDatasetGroup{}, middleware.After) 711} 712 713func addOpDescribeDatasetImportJobValidationMiddleware(stack *middleware.Stack) error { 714 return stack.Initialize.Add(&validateOpDescribeDatasetImportJob{}, middleware.After) 715} 716 717func addOpDescribeDatasetValidationMiddleware(stack *middleware.Stack) error { 718 return stack.Initialize.Add(&validateOpDescribeDataset{}, middleware.After) 719} 720 721func addOpDescribeForecastExportJobValidationMiddleware(stack *middleware.Stack) error { 722 return stack.Initialize.Add(&validateOpDescribeForecastExportJob{}, middleware.After) 723} 724 725func addOpDescribeForecastValidationMiddleware(stack *middleware.Stack) error { 726 return stack.Initialize.Add(&validateOpDescribeForecast{}, middleware.After) 727} 728 729func addOpDescribePredictorBacktestExportJobValidationMiddleware(stack *middleware.Stack) error { 730 return stack.Initialize.Add(&validateOpDescribePredictorBacktestExportJob{}, middleware.After) 731} 732 733func addOpDescribePredictorValidationMiddleware(stack *middleware.Stack) error { 734 return stack.Initialize.Add(&validateOpDescribePredictor{}, middleware.After) 735} 736 737func addOpGetAccuracyMetricsValidationMiddleware(stack *middleware.Stack) error { 738 return stack.Initialize.Add(&validateOpGetAccuracyMetrics{}, middleware.After) 739} 740 741func addOpListDatasetImportJobsValidationMiddleware(stack *middleware.Stack) error { 742 return stack.Initialize.Add(&validateOpListDatasetImportJobs{}, middleware.After) 743} 744 745func addOpListForecastExportJobsValidationMiddleware(stack *middleware.Stack) error { 746 return stack.Initialize.Add(&validateOpListForecastExportJobs{}, middleware.After) 747} 748 749func addOpListForecastsValidationMiddleware(stack *middleware.Stack) error { 750 return stack.Initialize.Add(&validateOpListForecasts{}, middleware.After) 751} 752 753func addOpListPredictorBacktestExportJobsValidationMiddleware(stack *middleware.Stack) error { 754 return stack.Initialize.Add(&validateOpListPredictorBacktestExportJobs{}, middleware.After) 755} 756 757func addOpListPredictorsValidationMiddleware(stack *middleware.Stack) error { 758 return stack.Initialize.Add(&validateOpListPredictors{}, middleware.After) 759} 760 761func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 762 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 763} 764 765func addOpStopResourceValidationMiddleware(stack *middleware.Stack) error { 766 return stack.Initialize.Add(&validateOpStopResource{}, middleware.After) 767} 768 769func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 770 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 771} 772 773func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 774 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 775} 776 777func addOpUpdateDatasetGroupValidationMiddleware(stack *middleware.Stack) error { 778 return stack.Initialize.Add(&validateOpUpdateDatasetGroup{}, middleware.After) 779} 780 781func validateCategoricalParameterRange(v *types.CategoricalParameterRange) error { 782 if v == nil { 783 return nil 784 } 785 invalidParams := smithy.InvalidParamsError{Context: "CategoricalParameterRange"} 786 if v.Name == nil { 787 invalidParams.Add(smithy.NewErrParamRequired("Name")) 788 } 789 if v.Values == nil { 790 invalidParams.Add(smithy.NewErrParamRequired("Values")) 791 } 792 if invalidParams.Len() > 0 { 793 return invalidParams 794 } else { 795 return nil 796 } 797} 798 799func validateCategoricalParameterRanges(v []types.CategoricalParameterRange) error { 800 if v == nil { 801 return nil 802 } 803 invalidParams := smithy.InvalidParamsError{Context: "CategoricalParameterRanges"} 804 for i := range v { 805 if err := validateCategoricalParameterRange(&v[i]); err != nil { 806 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 807 } 808 } 809 if invalidParams.Len() > 0 { 810 return invalidParams 811 } else { 812 return nil 813 } 814} 815 816func validateContinuousParameterRange(v *types.ContinuousParameterRange) error { 817 if v == nil { 818 return nil 819 } 820 invalidParams := smithy.InvalidParamsError{Context: "ContinuousParameterRange"} 821 if v.Name == nil { 822 invalidParams.Add(smithy.NewErrParamRequired("Name")) 823 } 824 if v.MaxValue == nil { 825 invalidParams.Add(smithy.NewErrParamRequired("MaxValue")) 826 } 827 if v.MinValue == nil { 828 invalidParams.Add(smithy.NewErrParamRequired("MinValue")) 829 } 830 if invalidParams.Len() > 0 { 831 return invalidParams 832 } else { 833 return nil 834 } 835} 836 837func validateContinuousParameterRanges(v []types.ContinuousParameterRange) error { 838 if v == nil { 839 return nil 840 } 841 invalidParams := smithy.InvalidParamsError{Context: "ContinuousParameterRanges"} 842 for i := range v { 843 if err := validateContinuousParameterRange(&v[i]); err != nil { 844 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 845 } 846 } 847 if invalidParams.Len() > 0 { 848 return invalidParams 849 } else { 850 return nil 851 } 852} 853 854func validateDataDestination(v *types.DataDestination) error { 855 if v == nil { 856 return nil 857 } 858 invalidParams := smithy.InvalidParamsError{Context: "DataDestination"} 859 if v.S3Config == nil { 860 invalidParams.Add(smithy.NewErrParamRequired("S3Config")) 861 } else if v.S3Config != nil { 862 if err := validateS3Config(v.S3Config); err != nil { 863 invalidParams.AddNested("S3Config", err.(smithy.InvalidParamsError)) 864 } 865 } 866 if invalidParams.Len() > 0 { 867 return invalidParams 868 } else { 869 return nil 870 } 871} 872 873func validateDataSource(v *types.DataSource) error { 874 if v == nil { 875 return nil 876 } 877 invalidParams := smithy.InvalidParamsError{Context: "DataSource"} 878 if v.S3Config == nil { 879 invalidParams.Add(smithy.NewErrParamRequired("S3Config")) 880 } else if v.S3Config != nil { 881 if err := validateS3Config(v.S3Config); err != nil { 882 invalidParams.AddNested("S3Config", err.(smithy.InvalidParamsError)) 883 } 884 } 885 if invalidParams.Len() > 0 { 886 return invalidParams 887 } else { 888 return nil 889 } 890} 891 892func validateEncryptionConfig(v *types.EncryptionConfig) error { 893 if v == nil { 894 return nil 895 } 896 invalidParams := smithy.InvalidParamsError{Context: "EncryptionConfig"} 897 if v.RoleArn == nil { 898 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 899 } 900 if v.KMSKeyArn == nil { 901 invalidParams.Add(smithy.NewErrParamRequired("KMSKeyArn")) 902 } 903 if invalidParams.Len() > 0 { 904 return invalidParams 905 } else { 906 return nil 907 } 908} 909 910func validateFeaturization(v *types.Featurization) error { 911 if v == nil { 912 return nil 913 } 914 invalidParams := smithy.InvalidParamsError{Context: "Featurization"} 915 if v.AttributeName == nil { 916 invalidParams.Add(smithy.NewErrParamRequired("AttributeName")) 917 } 918 if v.FeaturizationPipeline != nil { 919 if err := validateFeaturizationPipeline(v.FeaturizationPipeline); err != nil { 920 invalidParams.AddNested("FeaturizationPipeline", err.(smithy.InvalidParamsError)) 921 } 922 } 923 if invalidParams.Len() > 0 { 924 return invalidParams 925 } else { 926 return nil 927 } 928} 929 930func validateFeaturizationConfig(v *types.FeaturizationConfig) error { 931 if v == nil { 932 return nil 933 } 934 invalidParams := smithy.InvalidParamsError{Context: "FeaturizationConfig"} 935 if v.ForecastFrequency == nil { 936 invalidParams.Add(smithy.NewErrParamRequired("ForecastFrequency")) 937 } 938 if v.Featurizations != nil { 939 if err := validateFeaturizations(v.Featurizations); err != nil { 940 invalidParams.AddNested("Featurizations", err.(smithy.InvalidParamsError)) 941 } 942 } 943 if invalidParams.Len() > 0 { 944 return invalidParams 945 } else { 946 return nil 947 } 948} 949 950func validateFeaturizationMethod(v *types.FeaturizationMethod) error { 951 if v == nil { 952 return nil 953 } 954 invalidParams := smithy.InvalidParamsError{Context: "FeaturizationMethod"} 955 if len(v.FeaturizationMethodName) == 0 { 956 invalidParams.Add(smithy.NewErrParamRequired("FeaturizationMethodName")) 957 } 958 if invalidParams.Len() > 0 { 959 return invalidParams 960 } else { 961 return nil 962 } 963} 964 965func validateFeaturizationPipeline(v []types.FeaturizationMethod) error { 966 if v == nil { 967 return nil 968 } 969 invalidParams := smithy.InvalidParamsError{Context: "FeaturizationPipeline"} 970 for i := range v { 971 if err := validateFeaturizationMethod(&v[i]); err != nil { 972 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 973 } 974 } 975 if invalidParams.Len() > 0 { 976 return invalidParams 977 } else { 978 return nil 979 } 980} 981 982func validateFeaturizations(v []types.Featurization) error { 983 if v == nil { 984 return nil 985 } 986 invalidParams := smithy.InvalidParamsError{Context: "Featurizations"} 987 for i := range v { 988 if err := validateFeaturization(&v[i]); err != nil { 989 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 990 } 991 } 992 if invalidParams.Len() > 0 { 993 return invalidParams 994 } else { 995 return nil 996 } 997} 998 999func validateFilter(v *types.Filter) error { 1000 if v == nil { 1001 return nil 1002 } 1003 invalidParams := smithy.InvalidParamsError{Context: "Filter"} 1004 if v.Key == nil { 1005 invalidParams.Add(smithy.NewErrParamRequired("Key")) 1006 } 1007 if v.Value == nil { 1008 invalidParams.Add(smithy.NewErrParamRequired("Value")) 1009 } 1010 if len(v.Condition) == 0 { 1011 invalidParams.Add(smithy.NewErrParamRequired("Condition")) 1012 } 1013 if invalidParams.Len() > 0 { 1014 return invalidParams 1015 } else { 1016 return nil 1017 } 1018} 1019 1020func validateFilters(v []types.Filter) error { 1021 if v == nil { 1022 return nil 1023 } 1024 invalidParams := smithy.InvalidParamsError{Context: "Filters"} 1025 for i := range v { 1026 if err := validateFilter(&v[i]); err != nil { 1027 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1028 } 1029 } 1030 if invalidParams.Len() > 0 { 1031 return invalidParams 1032 } else { 1033 return nil 1034 } 1035} 1036 1037func validateHyperParameterTuningJobConfig(v *types.HyperParameterTuningJobConfig) error { 1038 if v == nil { 1039 return nil 1040 } 1041 invalidParams := smithy.InvalidParamsError{Context: "HyperParameterTuningJobConfig"} 1042 if v.ParameterRanges != nil { 1043 if err := validateParameterRanges(v.ParameterRanges); err != nil { 1044 invalidParams.AddNested("ParameterRanges", err.(smithy.InvalidParamsError)) 1045 } 1046 } 1047 if invalidParams.Len() > 0 { 1048 return invalidParams 1049 } else { 1050 return nil 1051 } 1052} 1053 1054func validateInputDataConfig(v *types.InputDataConfig) error { 1055 if v == nil { 1056 return nil 1057 } 1058 invalidParams := smithy.InvalidParamsError{Context: "InputDataConfig"} 1059 if v.DatasetGroupArn == nil { 1060 invalidParams.Add(smithy.NewErrParamRequired("DatasetGroupArn")) 1061 } 1062 if v.SupplementaryFeatures != nil { 1063 if err := validateSupplementaryFeatures(v.SupplementaryFeatures); err != nil { 1064 invalidParams.AddNested("SupplementaryFeatures", err.(smithy.InvalidParamsError)) 1065 } 1066 } 1067 if invalidParams.Len() > 0 { 1068 return invalidParams 1069 } else { 1070 return nil 1071 } 1072} 1073 1074func validateIntegerParameterRange(v *types.IntegerParameterRange) error { 1075 if v == nil { 1076 return nil 1077 } 1078 invalidParams := smithy.InvalidParamsError{Context: "IntegerParameterRange"} 1079 if v.Name == nil { 1080 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1081 } 1082 if v.MaxValue == nil { 1083 invalidParams.Add(smithy.NewErrParamRequired("MaxValue")) 1084 } 1085 if v.MinValue == nil { 1086 invalidParams.Add(smithy.NewErrParamRequired("MinValue")) 1087 } 1088 if invalidParams.Len() > 0 { 1089 return invalidParams 1090 } else { 1091 return nil 1092 } 1093} 1094 1095func validateIntegerParameterRanges(v []types.IntegerParameterRange) error { 1096 if v == nil { 1097 return nil 1098 } 1099 invalidParams := smithy.InvalidParamsError{Context: "IntegerParameterRanges"} 1100 for i := range v { 1101 if err := validateIntegerParameterRange(&v[i]); err != nil { 1102 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1103 } 1104 } 1105 if invalidParams.Len() > 0 { 1106 return invalidParams 1107 } else { 1108 return nil 1109 } 1110} 1111 1112func validateParameterRanges(v *types.ParameterRanges) error { 1113 if v == nil { 1114 return nil 1115 } 1116 invalidParams := smithy.InvalidParamsError{Context: "ParameterRanges"} 1117 if v.CategoricalParameterRanges != nil { 1118 if err := validateCategoricalParameterRanges(v.CategoricalParameterRanges); err != nil { 1119 invalidParams.AddNested("CategoricalParameterRanges", err.(smithy.InvalidParamsError)) 1120 } 1121 } 1122 if v.ContinuousParameterRanges != nil { 1123 if err := validateContinuousParameterRanges(v.ContinuousParameterRanges); err != nil { 1124 invalidParams.AddNested("ContinuousParameterRanges", err.(smithy.InvalidParamsError)) 1125 } 1126 } 1127 if v.IntegerParameterRanges != nil { 1128 if err := validateIntegerParameterRanges(v.IntegerParameterRanges); err != nil { 1129 invalidParams.AddNested("IntegerParameterRanges", err.(smithy.InvalidParamsError)) 1130 } 1131 } 1132 if invalidParams.Len() > 0 { 1133 return invalidParams 1134 } else { 1135 return nil 1136 } 1137} 1138 1139func validateS3Config(v *types.S3Config) error { 1140 if v == nil { 1141 return nil 1142 } 1143 invalidParams := smithy.InvalidParamsError{Context: "S3Config"} 1144 if v.Path == nil { 1145 invalidParams.Add(smithy.NewErrParamRequired("Path")) 1146 } 1147 if v.RoleArn == nil { 1148 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 1149 } 1150 if invalidParams.Len() > 0 { 1151 return invalidParams 1152 } else { 1153 return nil 1154 } 1155} 1156 1157func validateSupplementaryFeature(v *types.SupplementaryFeature) error { 1158 if v == nil { 1159 return nil 1160 } 1161 invalidParams := smithy.InvalidParamsError{Context: "SupplementaryFeature"} 1162 if v.Name == nil { 1163 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1164 } 1165 if v.Value == nil { 1166 invalidParams.Add(smithy.NewErrParamRequired("Value")) 1167 } 1168 if invalidParams.Len() > 0 { 1169 return invalidParams 1170 } else { 1171 return nil 1172 } 1173} 1174 1175func validateSupplementaryFeatures(v []types.SupplementaryFeature) error { 1176 if v == nil { 1177 return nil 1178 } 1179 invalidParams := smithy.InvalidParamsError{Context: "SupplementaryFeatures"} 1180 for i := range v { 1181 if err := validateSupplementaryFeature(&v[i]); err != nil { 1182 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1183 } 1184 } 1185 if invalidParams.Len() > 0 { 1186 return invalidParams 1187 } else { 1188 return nil 1189 } 1190} 1191 1192func validateTag(v *types.Tag) error { 1193 if v == nil { 1194 return nil 1195 } 1196 invalidParams := smithy.InvalidParamsError{Context: "Tag"} 1197 if v.Key == nil { 1198 invalidParams.Add(smithy.NewErrParamRequired("Key")) 1199 } 1200 if v.Value == nil { 1201 invalidParams.Add(smithy.NewErrParamRequired("Value")) 1202 } 1203 if invalidParams.Len() > 0 { 1204 return invalidParams 1205 } else { 1206 return nil 1207 } 1208} 1209 1210func validateTags(v []types.Tag) error { 1211 if v == nil { 1212 return nil 1213 } 1214 invalidParams := smithy.InvalidParamsError{Context: "Tags"} 1215 for i := range v { 1216 if err := validateTag(&v[i]); err != nil { 1217 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1218 } 1219 } 1220 if invalidParams.Len() > 0 { 1221 return invalidParams 1222 } else { 1223 return nil 1224 } 1225} 1226 1227func validateOpCreateDatasetGroupInput(v *CreateDatasetGroupInput) error { 1228 if v == nil { 1229 return nil 1230 } 1231 invalidParams := smithy.InvalidParamsError{Context: "CreateDatasetGroupInput"} 1232 if v.DatasetGroupName == nil { 1233 invalidParams.Add(smithy.NewErrParamRequired("DatasetGroupName")) 1234 } 1235 if len(v.Domain) == 0 { 1236 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 1237 } 1238 if v.Tags != nil { 1239 if err := validateTags(v.Tags); err != nil { 1240 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1241 } 1242 } 1243 if invalidParams.Len() > 0 { 1244 return invalidParams 1245 } else { 1246 return nil 1247 } 1248} 1249 1250func validateOpCreateDatasetImportJobInput(v *CreateDatasetImportJobInput) error { 1251 if v == nil { 1252 return nil 1253 } 1254 invalidParams := smithy.InvalidParamsError{Context: "CreateDatasetImportJobInput"} 1255 if v.DatasetImportJobName == nil { 1256 invalidParams.Add(smithy.NewErrParamRequired("DatasetImportJobName")) 1257 } 1258 if v.DatasetArn == nil { 1259 invalidParams.Add(smithy.NewErrParamRequired("DatasetArn")) 1260 } 1261 if v.DataSource == nil { 1262 invalidParams.Add(smithy.NewErrParamRequired("DataSource")) 1263 } else if v.DataSource != nil { 1264 if err := validateDataSource(v.DataSource); err != nil { 1265 invalidParams.AddNested("DataSource", err.(smithy.InvalidParamsError)) 1266 } 1267 } 1268 if v.Tags != nil { 1269 if err := validateTags(v.Tags); err != nil { 1270 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1271 } 1272 } 1273 if invalidParams.Len() > 0 { 1274 return invalidParams 1275 } else { 1276 return nil 1277 } 1278} 1279 1280func validateOpCreateDatasetInput(v *CreateDatasetInput) error { 1281 if v == nil { 1282 return nil 1283 } 1284 invalidParams := smithy.InvalidParamsError{Context: "CreateDatasetInput"} 1285 if v.DatasetName == nil { 1286 invalidParams.Add(smithy.NewErrParamRequired("DatasetName")) 1287 } 1288 if len(v.Domain) == 0 { 1289 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 1290 } 1291 if len(v.DatasetType) == 0 { 1292 invalidParams.Add(smithy.NewErrParamRequired("DatasetType")) 1293 } 1294 if v.Schema == nil { 1295 invalidParams.Add(smithy.NewErrParamRequired("Schema")) 1296 } 1297 if v.EncryptionConfig != nil { 1298 if err := validateEncryptionConfig(v.EncryptionConfig); err != nil { 1299 invalidParams.AddNested("EncryptionConfig", err.(smithy.InvalidParamsError)) 1300 } 1301 } 1302 if v.Tags != nil { 1303 if err := validateTags(v.Tags); err != nil { 1304 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1305 } 1306 } 1307 if invalidParams.Len() > 0 { 1308 return invalidParams 1309 } else { 1310 return nil 1311 } 1312} 1313 1314func validateOpCreateForecastExportJobInput(v *CreateForecastExportJobInput) error { 1315 if v == nil { 1316 return nil 1317 } 1318 invalidParams := smithy.InvalidParamsError{Context: "CreateForecastExportJobInput"} 1319 if v.ForecastExportJobName == nil { 1320 invalidParams.Add(smithy.NewErrParamRequired("ForecastExportJobName")) 1321 } 1322 if v.ForecastArn == nil { 1323 invalidParams.Add(smithy.NewErrParamRequired("ForecastArn")) 1324 } 1325 if v.Destination == nil { 1326 invalidParams.Add(smithy.NewErrParamRequired("Destination")) 1327 } else if v.Destination != nil { 1328 if err := validateDataDestination(v.Destination); err != nil { 1329 invalidParams.AddNested("Destination", err.(smithy.InvalidParamsError)) 1330 } 1331 } 1332 if v.Tags != nil { 1333 if err := validateTags(v.Tags); err != nil { 1334 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1335 } 1336 } 1337 if invalidParams.Len() > 0 { 1338 return invalidParams 1339 } else { 1340 return nil 1341 } 1342} 1343 1344func validateOpCreateForecastInput(v *CreateForecastInput) error { 1345 if v == nil { 1346 return nil 1347 } 1348 invalidParams := smithy.InvalidParamsError{Context: "CreateForecastInput"} 1349 if v.ForecastName == nil { 1350 invalidParams.Add(smithy.NewErrParamRequired("ForecastName")) 1351 } 1352 if v.PredictorArn == nil { 1353 invalidParams.Add(smithy.NewErrParamRequired("PredictorArn")) 1354 } 1355 if v.Tags != nil { 1356 if err := validateTags(v.Tags); err != nil { 1357 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1358 } 1359 } 1360 if invalidParams.Len() > 0 { 1361 return invalidParams 1362 } else { 1363 return nil 1364 } 1365} 1366 1367func validateOpCreatePredictorBacktestExportJobInput(v *CreatePredictorBacktestExportJobInput) error { 1368 if v == nil { 1369 return nil 1370 } 1371 invalidParams := smithy.InvalidParamsError{Context: "CreatePredictorBacktestExportJobInput"} 1372 if v.PredictorBacktestExportJobName == nil { 1373 invalidParams.Add(smithy.NewErrParamRequired("PredictorBacktestExportJobName")) 1374 } 1375 if v.PredictorArn == nil { 1376 invalidParams.Add(smithy.NewErrParamRequired("PredictorArn")) 1377 } 1378 if v.Destination == nil { 1379 invalidParams.Add(smithy.NewErrParamRequired("Destination")) 1380 } else if v.Destination != nil { 1381 if err := validateDataDestination(v.Destination); err != nil { 1382 invalidParams.AddNested("Destination", err.(smithy.InvalidParamsError)) 1383 } 1384 } 1385 if v.Tags != nil { 1386 if err := validateTags(v.Tags); err != nil { 1387 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1388 } 1389 } 1390 if invalidParams.Len() > 0 { 1391 return invalidParams 1392 } else { 1393 return nil 1394 } 1395} 1396 1397func validateOpCreatePredictorInput(v *CreatePredictorInput) error { 1398 if v == nil { 1399 return nil 1400 } 1401 invalidParams := smithy.InvalidParamsError{Context: "CreatePredictorInput"} 1402 if v.PredictorName == nil { 1403 invalidParams.Add(smithy.NewErrParamRequired("PredictorName")) 1404 } 1405 if v.ForecastHorizon == nil { 1406 invalidParams.Add(smithy.NewErrParamRequired("ForecastHorizon")) 1407 } 1408 if v.HPOConfig != nil { 1409 if err := validateHyperParameterTuningJobConfig(v.HPOConfig); err != nil { 1410 invalidParams.AddNested("HPOConfig", err.(smithy.InvalidParamsError)) 1411 } 1412 } 1413 if v.InputDataConfig == nil { 1414 invalidParams.Add(smithy.NewErrParamRequired("InputDataConfig")) 1415 } else if v.InputDataConfig != nil { 1416 if err := validateInputDataConfig(v.InputDataConfig); err != nil { 1417 invalidParams.AddNested("InputDataConfig", err.(smithy.InvalidParamsError)) 1418 } 1419 } 1420 if v.FeaturizationConfig == nil { 1421 invalidParams.Add(smithy.NewErrParamRequired("FeaturizationConfig")) 1422 } else if v.FeaturizationConfig != nil { 1423 if err := validateFeaturizationConfig(v.FeaturizationConfig); err != nil { 1424 invalidParams.AddNested("FeaturizationConfig", err.(smithy.InvalidParamsError)) 1425 } 1426 } 1427 if v.EncryptionConfig != nil { 1428 if err := validateEncryptionConfig(v.EncryptionConfig); err != nil { 1429 invalidParams.AddNested("EncryptionConfig", err.(smithy.InvalidParamsError)) 1430 } 1431 } 1432 if v.Tags != nil { 1433 if err := validateTags(v.Tags); err != nil { 1434 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1435 } 1436 } 1437 if invalidParams.Len() > 0 { 1438 return invalidParams 1439 } else { 1440 return nil 1441 } 1442} 1443 1444func validateOpDeleteDatasetGroupInput(v *DeleteDatasetGroupInput) error { 1445 if v == nil { 1446 return nil 1447 } 1448 invalidParams := smithy.InvalidParamsError{Context: "DeleteDatasetGroupInput"} 1449 if v.DatasetGroupArn == nil { 1450 invalidParams.Add(smithy.NewErrParamRequired("DatasetGroupArn")) 1451 } 1452 if invalidParams.Len() > 0 { 1453 return invalidParams 1454 } else { 1455 return nil 1456 } 1457} 1458 1459func validateOpDeleteDatasetImportJobInput(v *DeleteDatasetImportJobInput) error { 1460 if v == nil { 1461 return nil 1462 } 1463 invalidParams := smithy.InvalidParamsError{Context: "DeleteDatasetImportJobInput"} 1464 if v.DatasetImportJobArn == nil { 1465 invalidParams.Add(smithy.NewErrParamRequired("DatasetImportJobArn")) 1466 } 1467 if invalidParams.Len() > 0 { 1468 return invalidParams 1469 } else { 1470 return nil 1471 } 1472} 1473 1474func validateOpDeleteDatasetInput(v *DeleteDatasetInput) error { 1475 if v == nil { 1476 return nil 1477 } 1478 invalidParams := smithy.InvalidParamsError{Context: "DeleteDatasetInput"} 1479 if v.DatasetArn == nil { 1480 invalidParams.Add(smithy.NewErrParamRequired("DatasetArn")) 1481 } 1482 if invalidParams.Len() > 0 { 1483 return invalidParams 1484 } else { 1485 return nil 1486 } 1487} 1488 1489func validateOpDeleteForecastExportJobInput(v *DeleteForecastExportJobInput) error { 1490 if v == nil { 1491 return nil 1492 } 1493 invalidParams := smithy.InvalidParamsError{Context: "DeleteForecastExportJobInput"} 1494 if v.ForecastExportJobArn == nil { 1495 invalidParams.Add(smithy.NewErrParamRequired("ForecastExportJobArn")) 1496 } 1497 if invalidParams.Len() > 0 { 1498 return invalidParams 1499 } else { 1500 return nil 1501 } 1502} 1503 1504func validateOpDeleteForecastInput(v *DeleteForecastInput) error { 1505 if v == nil { 1506 return nil 1507 } 1508 invalidParams := smithy.InvalidParamsError{Context: "DeleteForecastInput"} 1509 if v.ForecastArn == nil { 1510 invalidParams.Add(smithy.NewErrParamRequired("ForecastArn")) 1511 } 1512 if invalidParams.Len() > 0 { 1513 return invalidParams 1514 } else { 1515 return nil 1516 } 1517} 1518 1519func validateOpDeletePredictorBacktestExportJobInput(v *DeletePredictorBacktestExportJobInput) error { 1520 if v == nil { 1521 return nil 1522 } 1523 invalidParams := smithy.InvalidParamsError{Context: "DeletePredictorBacktestExportJobInput"} 1524 if v.PredictorBacktestExportJobArn == nil { 1525 invalidParams.Add(smithy.NewErrParamRequired("PredictorBacktestExportJobArn")) 1526 } 1527 if invalidParams.Len() > 0 { 1528 return invalidParams 1529 } else { 1530 return nil 1531 } 1532} 1533 1534func validateOpDeletePredictorInput(v *DeletePredictorInput) error { 1535 if v == nil { 1536 return nil 1537 } 1538 invalidParams := smithy.InvalidParamsError{Context: "DeletePredictorInput"} 1539 if v.PredictorArn == nil { 1540 invalidParams.Add(smithy.NewErrParamRequired("PredictorArn")) 1541 } 1542 if invalidParams.Len() > 0 { 1543 return invalidParams 1544 } else { 1545 return nil 1546 } 1547} 1548 1549func validateOpDescribeDatasetGroupInput(v *DescribeDatasetGroupInput) error { 1550 if v == nil { 1551 return nil 1552 } 1553 invalidParams := smithy.InvalidParamsError{Context: "DescribeDatasetGroupInput"} 1554 if v.DatasetGroupArn == nil { 1555 invalidParams.Add(smithy.NewErrParamRequired("DatasetGroupArn")) 1556 } 1557 if invalidParams.Len() > 0 { 1558 return invalidParams 1559 } else { 1560 return nil 1561 } 1562} 1563 1564func validateOpDescribeDatasetImportJobInput(v *DescribeDatasetImportJobInput) error { 1565 if v == nil { 1566 return nil 1567 } 1568 invalidParams := smithy.InvalidParamsError{Context: "DescribeDatasetImportJobInput"} 1569 if v.DatasetImportJobArn == nil { 1570 invalidParams.Add(smithy.NewErrParamRequired("DatasetImportJobArn")) 1571 } 1572 if invalidParams.Len() > 0 { 1573 return invalidParams 1574 } else { 1575 return nil 1576 } 1577} 1578 1579func validateOpDescribeDatasetInput(v *DescribeDatasetInput) error { 1580 if v == nil { 1581 return nil 1582 } 1583 invalidParams := smithy.InvalidParamsError{Context: "DescribeDatasetInput"} 1584 if v.DatasetArn == nil { 1585 invalidParams.Add(smithy.NewErrParamRequired("DatasetArn")) 1586 } 1587 if invalidParams.Len() > 0 { 1588 return invalidParams 1589 } else { 1590 return nil 1591 } 1592} 1593 1594func validateOpDescribeForecastExportJobInput(v *DescribeForecastExportJobInput) error { 1595 if v == nil { 1596 return nil 1597 } 1598 invalidParams := smithy.InvalidParamsError{Context: "DescribeForecastExportJobInput"} 1599 if v.ForecastExportJobArn == nil { 1600 invalidParams.Add(smithy.NewErrParamRequired("ForecastExportJobArn")) 1601 } 1602 if invalidParams.Len() > 0 { 1603 return invalidParams 1604 } else { 1605 return nil 1606 } 1607} 1608 1609func validateOpDescribeForecastInput(v *DescribeForecastInput) error { 1610 if v == nil { 1611 return nil 1612 } 1613 invalidParams := smithy.InvalidParamsError{Context: "DescribeForecastInput"} 1614 if v.ForecastArn == nil { 1615 invalidParams.Add(smithy.NewErrParamRequired("ForecastArn")) 1616 } 1617 if invalidParams.Len() > 0 { 1618 return invalidParams 1619 } else { 1620 return nil 1621 } 1622} 1623 1624func validateOpDescribePredictorBacktestExportJobInput(v *DescribePredictorBacktestExportJobInput) error { 1625 if v == nil { 1626 return nil 1627 } 1628 invalidParams := smithy.InvalidParamsError{Context: "DescribePredictorBacktestExportJobInput"} 1629 if v.PredictorBacktestExportJobArn == nil { 1630 invalidParams.Add(smithy.NewErrParamRequired("PredictorBacktestExportJobArn")) 1631 } 1632 if invalidParams.Len() > 0 { 1633 return invalidParams 1634 } else { 1635 return nil 1636 } 1637} 1638 1639func validateOpDescribePredictorInput(v *DescribePredictorInput) error { 1640 if v == nil { 1641 return nil 1642 } 1643 invalidParams := smithy.InvalidParamsError{Context: "DescribePredictorInput"} 1644 if v.PredictorArn == nil { 1645 invalidParams.Add(smithy.NewErrParamRequired("PredictorArn")) 1646 } 1647 if invalidParams.Len() > 0 { 1648 return invalidParams 1649 } else { 1650 return nil 1651 } 1652} 1653 1654func validateOpGetAccuracyMetricsInput(v *GetAccuracyMetricsInput) error { 1655 if v == nil { 1656 return nil 1657 } 1658 invalidParams := smithy.InvalidParamsError{Context: "GetAccuracyMetricsInput"} 1659 if v.PredictorArn == nil { 1660 invalidParams.Add(smithy.NewErrParamRequired("PredictorArn")) 1661 } 1662 if invalidParams.Len() > 0 { 1663 return invalidParams 1664 } else { 1665 return nil 1666 } 1667} 1668 1669func validateOpListDatasetImportJobsInput(v *ListDatasetImportJobsInput) error { 1670 if v == nil { 1671 return nil 1672 } 1673 invalidParams := smithy.InvalidParamsError{Context: "ListDatasetImportJobsInput"} 1674 if v.Filters != nil { 1675 if err := validateFilters(v.Filters); err != nil { 1676 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 1677 } 1678 } 1679 if invalidParams.Len() > 0 { 1680 return invalidParams 1681 } else { 1682 return nil 1683 } 1684} 1685 1686func validateOpListForecastExportJobsInput(v *ListForecastExportJobsInput) error { 1687 if v == nil { 1688 return nil 1689 } 1690 invalidParams := smithy.InvalidParamsError{Context: "ListForecastExportJobsInput"} 1691 if v.Filters != nil { 1692 if err := validateFilters(v.Filters); err != nil { 1693 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 1694 } 1695 } 1696 if invalidParams.Len() > 0 { 1697 return invalidParams 1698 } else { 1699 return nil 1700 } 1701} 1702 1703func validateOpListForecastsInput(v *ListForecastsInput) error { 1704 if v == nil { 1705 return nil 1706 } 1707 invalidParams := smithy.InvalidParamsError{Context: "ListForecastsInput"} 1708 if v.Filters != nil { 1709 if err := validateFilters(v.Filters); err != nil { 1710 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 1711 } 1712 } 1713 if invalidParams.Len() > 0 { 1714 return invalidParams 1715 } else { 1716 return nil 1717 } 1718} 1719 1720func validateOpListPredictorBacktestExportJobsInput(v *ListPredictorBacktestExportJobsInput) error { 1721 if v == nil { 1722 return nil 1723 } 1724 invalidParams := smithy.InvalidParamsError{Context: "ListPredictorBacktestExportJobsInput"} 1725 if v.Filters != nil { 1726 if err := validateFilters(v.Filters); err != nil { 1727 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 1728 } 1729 } 1730 if invalidParams.Len() > 0 { 1731 return invalidParams 1732 } else { 1733 return nil 1734 } 1735} 1736 1737func validateOpListPredictorsInput(v *ListPredictorsInput) error { 1738 if v == nil { 1739 return nil 1740 } 1741 invalidParams := smithy.InvalidParamsError{Context: "ListPredictorsInput"} 1742 if v.Filters != nil { 1743 if err := validateFilters(v.Filters); err != nil { 1744 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 1745 } 1746 } 1747 if invalidParams.Len() > 0 { 1748 return invalidParams 1749 } else { 1750 return nil 1751 } 1752} 1753 1754func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 1755 if v == nil { 1756 return nil 1757 } 1758 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 1759 if v.ResourceArn == nil { 1760 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1761 } 1762 if invalidParams.Len() > 0 { 1763 return invalidParams 1764 } else { 1765 return nil 1766 } 1767} 1768 1769func validateOpStopResourceInput(v *StopResourceInput) error { 1770 if v == nil { 1771 return nil 1772 } 1773 invalidParams := smithy.InvalidParamsError{Context: "StopResourceInput"} 1774 if v.ResourceArn == nil { 1775 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1776 } 1777 if invalidParams.Len() > 0 { 1778 return invalidParams 1779 } else { 1780 return nil 1781 } 1782} 1783 1784func validateOpTagResourceInput(v *TagResourceInput) error { 1785 if v == nil { 1786 return nil 1787 } 1788 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 1789 if v.ResourceArn == nil { 1790 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1791 } 1792 if v.Tags == nil { 1793 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 1794 } else if v.Tags != nil { 1795 if err := validateTags(v.Tags); err != nil { 1796 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1797 } 1798 } 1799 if invalidParams.Len() > 0 { 1800 return invalidParams 1801 } else { 1802 return nil 1803 } 1804} 1805 1806func validateOpUntagResourceInput(v *UntagResourceInput) error { 1807 if v == nil { 1808 return nil 1809 } 1810 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 1811 if v.ResourceArn == nil { 1812 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1813 } 1814 if v.TagKeys == nil { 1815 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 1816 } 1817 if invalidParams.Len() > 0 { 1818 return invalidParams 1819 } else { 1820 return nil 1821 } 1822} 1823 1824func validateOpUpdateDatasetGroupInput(v *UpdateDatasetGroupInput) error { 1825 if v == nil { 1826 return nil 1827 } 1828 invalidParams := smithy.InvalidParamsError{Context: "UpdateDatasetGroupInput"} 1829 if v.DatasetGroupArn == nil { 1830 invalidParams.Add(smithy.NewErrParamRequired("DatasetGroupArn")) 1831 } 1832 if v.DatasetArns == nil { 1833 invalidParams.Add(smithy.NewErrParamRequired("DatasetArns")) 1834 } 1835 if invalidParams.Len() > 0 { 1836 return invalidParams 1837 } else { 1838 return nil 1839 } 1840} 1841