1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package lookoutequipment 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/lookoutequipment/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpCreateDataset struct { 14} 15 16func (*validateOpCreateDataset) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpCreateDataset) 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.(*CreateDatasetInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpCreateDatasetInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpCreateInferenceScheduler struct { 34} 35 36func (*validateOpCreateInferenceScheduler) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpCreateInferenceScheduler) 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.(*CreateInferenceSchedulerInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpCreateInferenceSchedulerInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpCreateModel struct { 54} 55 56func (*validateOpCreateModel) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpCreateModel) 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.(*CreateModelInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpCreateModelInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpDeleteDataset struct { 74} 75 76func (*validateOpDeleteDataset) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpDeleteDataset) 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.(*DeleteDatasetInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpDeleteDatasetInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpDeleteInferenceScheduler struct { 94} 95 96func (*validateOpDeleteInferenceScheduler) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpDeleteInferenceScheduler) 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.(*DeleteInferenceSchedulerInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpDeleteInferenceSchedulerInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpDeleteModel struct { 114} 115 116func (*validateOpDeleteModel) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpDeleteModel) 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.(*DeleteModelInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpDeleteModelInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpDescribeDataIngestionJob struct { 134} 135 136func (*validateOpDescribeDataIngestionJob) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpDescribeDataIngestionJob) 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.(*DescribeDataIngestionJobInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpDescribeDataIngestionJobInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpDescribeDataset struct { 154} 155 156func (*validateOpDescribeDataset) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpDescribeDataset) 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.(*DescribeDatasetInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpDescribeDatasetInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpDescribeInferenceScheduler struct { 174} 175 176func (*validateOpDescribeInferenceScheduler) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpDescribeInferenceScheduler) 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.(*DescribeInferenceSchedulerInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpDescribeInferenceSchedulerInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpDescribeModel struct { 194} 195 196func (*validateOpDescribeModel) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpDescribeModel) 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.(*DescribeModelInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpDescribeModelInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpListInferenceExecutions struct { 214} 215 216func (*validateOpListInferenceExecutions) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpListInferenceExecutions) 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.(*ListInferenceExecutionsInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpListInferenceExecutionsInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpListTagsForResource struct { 234} 235 236func (*validateOpListTagsForResource) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpListTagsForResourceInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpStartDataIngestionJob struct { 254} 255 256func (*validateOpStartDataIngestionJob) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpStartDataIngestionJob) 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.(*StartDataIngestionJobInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpStartDataIngestionJobInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpStartInferenceScheduler struct { 274} 275 276func (*validateOpStartInferenceScheduler) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpStartInferenceScheduler) 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.(*StartInferenceSchedulerInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpStartInferenceSchedulerInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpStopInferenceScheduler struct { 294} 295 296func (*validateOpStopInferenceScheduler) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpStopInferenceScheduler) 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.(*StopInferenceSchedulerInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpStopInferenceSchedulerInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpTagResource struct { 314} 315 316func (*validateOpTagResource) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpTagResource) 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.(*TagResourceInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpTagResourceInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpUntagResource struct { 334} 335 336func (*validateOpUntagResource) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpUntagResource) 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.(*UntagResourceInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpUntagResourceInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpUpdateInferenceScheduler struct { 354} 355 356func (*validateOpUpdateInferenceScheduler) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpUpdateInferenceScheduler) 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.(*UpdateInferenceSchedulerInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpUpdateInferenceSchedulerInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373func addOpCreateDatasetValidationMiddleware(stack *middleware.Stack) error { 374 return stack.Initialize.Add(&validateOpCreateDataset{}, middleware.After) 375} 376 377func addOpCreateInferenceSchedulerValidationMiddleware(stack *middleware.Stack) error { 378 return stack.Initialize.Add(&validateOpCreateInferenceScheduler{}, middleware.After) 379} 380 381func addOpCreateModelValidationMiddleware(stack *middleware.Stack) error { 382 return stack.Initialize.Add(&validateOpCreateModel{}, middleware.After) 383} 384 385func addOpDeleteDatasetValidationMiddleware(stack *middleware.Stack) error { 386 return stack.Initialize.Add(&validateOpDeleteDataset{}, middleware.After) 387} 388 389func addOpDeleteInferenceSchedulerValidationMiddleware(stack *middleware.Stack) error { 390 return stack.Initialize.Add(&validateOpDeleteInferenceScheduler{}, middleware.After) 391} 392 393func addOpDeleteModelValidationMiddleware(stack *middleware.Stack) error { 394 return stack.Initialize.Add(&validateOpDeleteModel{}, middleware.After) 395} 396 397func addOpDescribeDataIngestionJobValidationMiddleware(stack *middleware.Stack) error { 398 return stack.Initialize.Add(&validateOpDescribeDataIngestionJob{}, middleware.After) 399} 400 401func addOpDescribeDatasetValidationMiddleware(stack *middleware.Stack) error { 402 return stack.Initialize.Add(&validateOpDescribeDataset{}, middleware.After) 403} 404 405func addOpDescribeInferenceSchedulerValidationMiddleware(stack *middleware.Stack) error { 406 return stack.Initialize.Add(&validateOpDescribeInferenceScheduler{}, middleware.After) 407} 408 409func addOpDescribeModelValidationMiddleware(stack *middleware.Stack) error { 410 return stack.Initialize.Add(&validateOpDescribeModel{}, middleware.After) 411} 412 413func addOpListInferenceExecutionsValidationMiddleware(stack *middleware.Stack) error { 414 return stack.Initialize.Add(&validateOpListInferenceExecutions{}, middleware.After) 415} 416 417func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 418 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 419} 420 421func addOpStartDataIngestionJobValidationMiddleware(stack *middleware.Stack) error { 422 return stack.Initialize.Add(&validateOpStartDataIngestionJob{}, middleware.After) 423} 424 425func addOpStartInferenceSchedulerValidationMiddleware(stack *middleware.Stack) error { 426 return stack.Initialize.Add(&validateOpStartInferenceScheduler{}, middleware.After) 427} 428 429func addOpStopInferenceSchedulerValidationMiddleware(stack *middleware.Stack) error { 430 return stack.Initialize.Add(&validateOpStopInferenceScheduler{}, middleware.After) 431} 432 433func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 434 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 435} 436 437func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 438 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 439} 440 441func addOpUpdateInferenceSchedulerValidationMiddleware(stack *middleware.Stack) error { 442 return stack.Initialize.Add(&validateOpUpdateInferenceScheduler{}, middleware.After) 443} 444 445func validateInferenceInputConfiguration(v *types.InferenceInputConfiguration) error { 446 if v == nil { 447 return nil 448 } 449 invalidParams := smithy.InvalidParamsError{Context: "InferenceInputConfiguration"} 450 if v.S3InputConfiguration != nil { 451 if err := validateInferenceS3InputConfiguration(v.S3InputConfiguration); err != nil { 452 invalidParams.AddNested("S3InputConfiguration", err.(smithy.InvalidParamsError)) 453 } 454 } 455 if invalidParams.Len() > 0 { 456 return invalidParams 457 } else { 458 return nil 459 } 460} 461 462func validateInferenceOutputConfiguration(v *types.InferenceOutputConfiguration) error { 463 if v == nil { 464 return nil 465 } 466 invalidParams := smithy.InvalidParamsError{Context: "InferenceOutputConfiguration"} 467 if v.S3OutputConfiguration == nil { 468 invalidParams.Add(smithy.NewErrParamRequired("S3OutputConfiguration")) 469 } else if v.S3OutputConfiguration != nil { 470 if err := validateInferenceS3OutputConfiguration(v.S3OutputConfiguration); err != nil { 471 invalidParams.AddNested("S3OutputConfiguration", err.(smithy.InvalidParamsError)) 472 } 473 } 474 if invalidParams.Len() > 0 { 475 return invalidParams 476 } else { 477 return nil 478 } 479} 480 481func validateInferenceS3InputConfiguration(v *types.InferenceS3InputConfiguration) error { 482 if v == nil { 483 return nil 484 } 485 invalidParams := smithy.InvalidParamsError{Context: "InferenceS3InputConfiguration"} 486 if v.Bucket == nil { 487 invalidParams.Add(smithy.NewErrParamRequired("Bucket")) 488 } 489 if invalidParams.Len() > 0 { 490 return invalidParams 491 } else { 492 return nil 493 } 494} 495 496func validateInferenceS3OutputConfiguration(v *types.InferenceS3OutputConfiguration) error { 497 if v == nil { 498 return nil 499 } 500 invalidParams := smithy.InvalidParamsError{Context: "InferenceS3OutputConfiguration"} 501 if v.Bucket == nil { 502 invalidParams.Add(smithy.NewErrParamRequired("Bucket")) 503 } 504 if invalidParams.Len() > 0 { 505 return invalidParams 506 } else { 507 return nil 508 } 509} 510 511func validateIngestionInputConfiguration(v *types.IngestionInputConfiguration) error { 512 if v == nil { 513 return nil 514 } 515 invalidParams := smithy.InvalidParamsError{Context: "IngestionInputConfiguration"} 516 if v.S3InputConfiguration == nil { 517 invalidParams.Add(smithy.NewErrParamRequired("S3InputConfiguration")) 518 } else if v.S3InputConfiguration != nil { 519 if err := validateIngestionS3InputConfiguration(v.S3InputConfiguration); err != nil { 520 invalidParams.AddNested("S3InputConfiguration", err.(smithy.InvalidParamsError)) 521 } 522 } 523 if invalidParams.Len() > 0 { 524 return invalidParams 525 } else { 526 return nil 527 } 528} 529 530func validateIngestionS3InputConfiguration(v *types.IngestionS3InputConfiguration) error { 531 if v == nil { 532 return nil 533 } 534 invalidParams := smithy.InvalidParamsError{Context: "IngestionS3InputConfiguration"} 535 if v.Bucket == nil { 536 invalidParams.Add(smithy.NewErrParamRequired("Bucket")) 537 } 538 if invalidParams.Len() > 0 { 539 return invalidParams 540 } else { 541 return nil 542 } 543} 544 545func validateLabelsInputConfiguration(v *types.LabelsInputConfiguration) error { 546 if v == nil { 547 return nil 548 } 549 invalidParams := smithy.InvalidParamsError{Context: "LabelsInputConfiguration"} 550 if v.S3InputConfiguration == nil { 551 invalidParams.Add(smithy.NewErrParamRequired("S3InputConfiguration")) 552 } else if v.S3InputConfiguration != nil { 553 if err := validateLabelsS3InputConfiguration(v.S3InputConfiguration); err != nil { 554 invalidParams.AddNested("S3InputConfiguration", err.(smithy.InvalidParamsError)) 555 } 556 } 557 if invalidParams.Len() > 0 { 558 return invalidParams 559 } else { 560 return nil 561 } 562} 563 564func validateLabelsS3InputConfiguration(v *types.LabelsS3InputConfiguration) error { 565 if v == nil { 566 return nil 567 } 568 invalidParams := smithy.InvalidParamsError{Context: "LabelsS3InputConfiguration"} 569 if v.Bucket == nil { 570 invalidParams.Add(smithy.NewErrParamRequired("Bucket")) 571 } 572 if invalidParams.Len() > 0 { 573 return invalidParams 574 } else { 575 return nil 576 } 577} 578 579func validateTag(v *types.Tag) error { 580 if v == nil { 581 return nil 582 } 583 invalidParams := smithy.InvalidParamsError{Context: "Tag"} 584 if v.Key == nil { 585 invalidParams.Add(smithy.NewErrParamRequired("Key")) 586 } 587 if v.Value == nil { 588 invalidParams.Add(smithy.NewErrParamRequired("Value")) 589 } 590 if invalidParams.Len() > 0 { 591 return invalidParams 592 } else { 593 return nil 594 } 595} 596 597func validateTagList(v []types.Tag) error { 598 if v == nil { 599 return nil 600 } 601 invalidParams := smithy.InvalidParamsError{Context: "TagList"} 602 for i := range v { 603 if err := validateTag(&v[i]); err != nil { 604 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 605 } 606 } 607 if invalidParams.Len() > 0 { 608 return invalidParams 609 } else { 610 return nil 611 } 612} 613 614func validateOpCreateDatasetInput(v *CreateDatasetInput) error { 615 if v == nil { 616 return nil 617 } 618 invalidParams := smithy.InvalidParamsError{Context: "CreateDatasetInput"} 619 if v.DatasetName == nil { 620 invalidParams.Add(smithy.NewErrParamRequired("DatasetName")) 621 } 622 if v.DatasetSchema == nil { 623 invalidParams.Add(smithy.NewErrParamRequired("DatasetSchema")) 624 } 625 if v.ClientToken == nil { 626 invalidParams.Add(smithy.NewErrParamRequired("ClientToken")) 627 } 628 if v.Tags != nil { 629 if err := validateTagList(v.Tags); err != nil { 630 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 631 } 632 } 633 if invalidParams.Len() > 0 { 634 return invalidParams 635 } else { 636 return nil 637 } 638} 639 640func validateOpCreateInferenceSchedulerInput(v *CreateInferenceSchedulerInput) error { 641 if v == nil { 642 return nil 643 } 644 invalidParams := smithy.InvalidParamsError{Context: "CreateInferenceSchedulerInput"} 645 if v.ModelName == nil { 646 invalidParams.Add(smithy.NewErrParamRequired("ModelName")) 647 } 648 if v.InferenceSchedulerName == nil { 649 invalidParams.Add(smithy.NewErrParamRequired("InferenceSchedulerName")) 650 } 651 if len(v.DataUploadFrequency) == 0 { 652 invalidParams.Add(smithy.NewErrParamRequired("DataUploadFrequency")) 653 } 654 if v.DataInputConfiguration == nil { 655 invalidParams.Add(smithy.NewErrParamRequired("DataInputConfiguration")) 656 } else if v.DataInputConfiguration != nil { 657 if err := validateInferenceInputConfiguration(v.DataInputConfiguration); err != nil { 658 invalidParams.AddNested("DataInputConfiguration", err.(smithy.InvalidParamsError)) 659 } 660 } 661 if v.DataOutputConfiguration == nil { 662 invalidParams.Add(smithy.NewErrParamRequired("DataOutputConfiguration")) 663 } else if v.DataOutputConfiguration != nil { 664 if err := validateInferenceOutputConfiguration(v.DataOutputConfiguration); err != nil { 665 invalidParams.AddNested("DataOutputConfiguration", err.(smithy.InvalidParamsError)) 666 } 667 } 668 if v.RoleArn == nil { 669 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 670 } 671 if v.ClientToken == nil { 672 invalidParams.Add(smithy.NewErrParamRequired("ClientToken")) 673 } 674 if v.Tags != nil { 675 if err := validateTagList(v.Tags); err != nil { 676 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 677 } 678 } 679 if invalidParams.Len() > 0 { 680 return invalidParams 681 } else { 682 return nil 683 } 684} 685 686func validateOpCreateModelInput(v *CreateModelInput) error { 687 if v == nil { 688 return nil 689 } 690 invalidParams := smithy.InvalidParamsError{Context: "CreateModelInput"} 691 if v.ModelName == nil { 692 invalidParams.Add(smithy.NewErrParamRequired("ModelName")) 693 } 694 if v.DatasetName == nil { 695 invalidParams.Add(smithy.NewErrParamRequired("DatasetName")) 696 } 697 if v.LabelsInputConfiguration != nil { 698 if err := validateLabelsInputConfiguration(v.LabelsInputConfiguration); err != nil { 699 invalidParams.AddNested("LabelsInputConfiguration", err.(smithy.InvalidParamsError)) 700 } 701 } 702 if v.ClientToken == nil { 703 invalidParams.Add(smithy.NewErrParamRequired("ClientToken")) 704 } 705 if v.Tags != nil { 706 if err := validateTagList(v.Tags); err != nil { 707 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 708 } 709 } 710 if invalidParams.Len() > 0 { 711 return invalidParams 712 } else { 713 return nil 714 } 715} 716 717func validateOpDeleteDatasetInput(v *DeleteDatasetInput) error { 718 if v == nil { 719 return nil 720 } 721 invalidParams := smithy.InvalidParamsError{Context: "DeleteDatasetInput"} 722 if v.DatasetName == nil { 723 invalidParams.Add(smithy.NewErrParamRequired("DatasetName")) 724 } 725 if invalidParams.Len() > 0 { 726 return invalidParams 727 } else { 728 return nil 729 } 730} 731 732func validateOpDeleteInferenceSchedulerInput(v *DeleteInferenceSchedulerInput) error { 733 if v == nil { 734 return nil 735 } 736 invalidParams := smithy.InvalidParamsError{Context: "DeleteInferenceSchedulerInput"} 737 if v.InferenceSchedulerName == nil { 738 invalidParams.Add(smithy.NewErrParamRequired("InferenceSchedulerName")) 739 } 740 if invalidParams.Len() > 0 { 741 return invalidParams 742 } else { 743 return nil 744 } 745} 746 747func validateOpDeleteModelInput(v *DeleteModelInput) error { 748 if v == nil { 749 return nil 750 } 751 invalidParams := smithy.InvalidParamsError{Context: "DeleteModelInput"} 752 if v.ModelName == nil { 753 invalidParams.Add(smithy.NewErrParamRequired("ModelName")) 754 } 755 if invalidParams.Len() > 0 { 756 return invalidParams 757 } else { 758 return nil 759 } 760} 761 762func validateOpDescribeDataIngestionJobInput(v *DescribeDataIngestionJobInput) error { 763 if v == nil { 764 return nil 765 } 766 invalidParams := smithy.InvalidParamsError{Context: "DescribeDataIngestionJobInput"} 767 if v.JobId == nil { 768 invalidParams.Add(smithy.NewErrParamRequired("JobId")) 769 } 770 if invalidParams.Len() > 0 { 771 return invalidParams 772 } else { 773 return nil 774 } 775} 776 777func validateOpDescribeDatasetInput(v *DescribeDatasetInput) error { 778 if v == nil { 779 return nil 780 } 781 invalidParams := smithy.InvalidParamsError{Context: "DescribeDatasetInput"} 782 if v.DatasetName == nil { 783 invalidParams.Add(smithy.NewErrParamRequired("DatasetName")) 784 } 785 if invalidParams.Len() > 0 { 786 return invalidParams 787 } else { 788 return nil 789 } 790} 791 792func validateOpDescribeInferenceSchedulerInput(v *DescribeInferenceSchedulerInput) error { 793 if v == nil { 794 return nil 795 } 796 invalidParams := smithy.InvalidParamsError{Context: "DescribeInferenceSchedulerInput"} 797 if v.InferenceSchedulerName == nil { 798 invalidParams.Add(smithy.NewErrParamRequired("InferenceSchedulerName")) 799 } 800 if invalidParams.Len() > 0 { 801 return invalidParams 802 } else { 803 return nil 804 } 805} 806 807func validateOpDescribeModelInput(v *DescribeModelInput) error { 808 if v == nil { 809 return nil 810 } 811 invalidParams := smithy.InvalidParamsError{Context: "DescribeModelInput"} 812 if v.ModelName == nil { 813 invalidParams.Add(smithy.NewErrParamRequired("ModelName")) 814 } 815 if invalidParams.Len() > 0 { 816 return invalidParams 817 } else { 818 return nil 819 } 820} 821 822func validateOpListInferenceExecutionsInput(v *ListInferenceExecutionsInput) error { 823 if v == nil { 824 return nil 825 } 826 invalidParams := smithy.InvalidParamsError{Context: "ListInferenceExecutionsInput"} 827 if v.InferenceSchedulerName == nil { 828 invalidParams.Add(smithy.NewErrParamRequired("InferenceSchedulerName")) 829 } 830 if invalidParams.Len() > 0 { 831 return invalidParams 832 } else { 833 return nil 834 } 835} 836 837func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 838 if v == nil { 839 return nil 840 } 841 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 842 if v.ResourceArn == nil { 843 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 844 } 845 if invalidParams.Len() > 0 { 846 return invalidParams 847 } else { 848 return nil 849 } 850} 851 852func validateOpStartDataIngestionJobInput(v *StartDataIngestionJobInput) error { 853 if v == nil { 854 return nil 855 } 856 invalidParams := smithy.InvalidParamsError{Context: "StartDataIngestionJobInput"} 857 if v.DatasetName == nil { 858 invalidParams.Add(smithy.NewErrParamRequired("DatasetName")) 859 } 860 if v.IngestionInputConfiguration == nil { 861 invalidParams.Add(smithy.NewErrParamRequired("IngestionInputConfiguration")) 862 } else if v.IngestionInputConfiguration != nil { 863 if err := validateIngestionInputConfiguration(v.IngestionInputConfiguration); err != nil { 864 invalidParams.AddNested("IngestionInputConfiguration", err.(smithy.InvalidParamsError)) 865 } 866 } 867 if v.RoleArn == nil { 868 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 869 } 870 if v.ClientToken == nil { 871 invalidParams.Add(smithy.NewErrParamRequired("ClientToken")) 872 } 873 if invalidParams.Len() > 0 { 874 return invalidParams 875 } else { 876 return nil 877 } 878} 879 880func validateOpStartInferenceSchedulerInput(v *StartInferenceSchedulerInput) error { 881 if v == nil { 882 return nil 883 } 884 invalidParams := smithy.InvalidParamsError{Context: "StartInferenceSchedulerInput"} 885 if v.InferenceSchedulerName == nil { 886 invalidParams.Add(smithy.NewErrParamRequired("InferenceSchedulerName")) 887 } 888 if invalidParams.Len() > 0 { 889 return invalidParams 890 } else { 891 return nil 892 } 893} 894 895func validateOpStopInferenceSchedulerInput(v *StopInferenceSchedulerInput) error { 896 if v == nil { 897 return nil 898 } 899 invalidParams := smithy.InvalidParamsError{Context: "StopInferenceSchedulerInput"} 900 if v.InferenceSchedulerName == nil { 901 invalidParams.Add(smithy.NewErrParamRequired("InferenceSchedulerName")) 902 } 903 if invalidParams.Len() > 0 { 904 return invalidParams 905 } else { 906 return nil 907 } 908} 909 910func validateOpTagResourceInput(v *TagResourceInput) error { 911 if v == nil { 912 return nil 913 } 914 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 915 if v.ResourceArn == nil { 916 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 917 } 918 if v.Tags == nil { 919 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 920 } else if v.Tags != nil { 921 if err := validateTagList(v.Tags); err != nil { 922 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 923 } 924 } 925 if invalidParams.Len() > 0 { 926 return invalidParams 927 } else { 928 return nil 929 } 930} 931 932func validateOpUntagResourceInput(v *UntagResourceInput) error { 933 if v == nil { 934 return nil 935 } 936 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 937 if v.ResourceArn == nil { 938 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 939 } 940 if v.TagKeys == nil { 941 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 942 } 943 if invalidParams.Len() > 0 { 944 return invalidParams 945 } else { 946 return nil 947 } 948} 949 950func validateOpUpdateInferenceSchedulerInput(v *UpdateInferenceSchedulerInput) error { 951 if v == nil { 952 return nil 953 } 954 invalidParams := smithy.InvalidParamsError{Context: "UpdateInferenceSchedulerInput"} 955 if v.InferenceSchedulerName == nil { 956 invalidParams.Add(smithy.NewErrParamRequired("InferenceSchedulerName")) 957 } 958 if v.DataInputConfiguration != nil { 959 if err := validateInferenceInputConfiguration(v.DataInputConfiguration); err != nil { 960 invalidParams.AddNested("DataInputConfiguration", err.(smithy.InvalidParamsError)) 961 } 962 } 963 if v.DataOutputConfiguration != nil { 964 if err := validateInferenceOutputConfiguration(v.DataOutputConfiguration); err != nil { 965 invalidParams.AddNested("DataOutputConfiguration", err.(smithy.InvalidParamsError)) 966 } 967 } 968 if invalidParams.Len() > 0 { 969 return invalidParams 970 } else { 971 return nil 972 } 973} 974