1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package iotanalytics 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/iotanalytics/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpBatchPutMessage struct { 14} 15 16func (*validateOpBatchPutMessage) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpBatchPutMessage) 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.(*BatchPutMessageInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpBatchPutMessageInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpCancelPipelineReprocessing struct { 34} 35 36func (*validateOpCancelPipelineReprocessing) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpCancelPipelineReprocessing) 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.(*CancelPipelineReprocessingInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpCancelPipelineReprocessingInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpCreateChannel struct { 54} 55 56func (*validateOpCreateChannel) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpCreateChannel) 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.(*CreateChannelInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpCreateChannelInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpCreateDatasetContent struct { 74} 75 76func (*validateOpCreateDatasetContent) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpCreateDatasetContent) 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.(*CreateDatasetContentInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpCreateDatasetContentInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpCreateDataset struct { 94} 95 96func (*validateOpCreateDataset) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpCreateDataset) 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.(*CreateDatasetInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpCreateDatasetInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpCreateDatastore struct { 114} 115 116func (*validateOpCreateDatastore) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpCreateDatastore) 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.(*CreateDatastoreInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpCreateDatastoreInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpCreatePipeline struct { 134} 135 136func (*validateOpCreatePipeline) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpCreatePipeline) 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.(*CreatePipelineInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpCreatePipelineInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpDeleteChannel struct { 154} 155 156func (*validateOpDeleteChannel) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpDeleteChannel) 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.(*DeleteChannelInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpDeleteChannelInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpDeleteDatasetContent struct { 174} 175 176func (*validateOpDeleteDatasetContent) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpDeleteDatasetContent) 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.(*DeleteDatasetContentInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpDeleteDatasetContentInput(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 validateOpDeleteDatastore struct { 214} 215 216func (*validateOpDeleteDatastore) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpDeleteDatastore) 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.(*DeleteDatastoreInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpDeleteDatastoreInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpDeletePipeline struct { 234} 235 236func (*validateOpDeletePipeline) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpDeletePipeline) 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.(*DeletePipelineInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpDeletePipelineInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpDescribeChannel struct { 254} 255 256func (*validateOpDescribeChannel) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpDescribeChannel) 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.(*DescribeChannelInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpDescribeChannelInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpDescribeDataset struct { 274} 275 276func (*validateOpDescribeDataset) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpDescribeDataset) 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.(*DescribeDatasetInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpDescribeDatasetInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpDescribeDatastore struct { 294} 295 296func (*validateOpDescribeDatastore) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpDescribeDatastore) 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.(*DescribeDatastoreInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpDescribeDatastoreInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpDescribePipeline struct { 314} 315 316func (*validateOpDescribePipeline) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpDescribePipeline) 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.(*DescribePipelineInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpDescribePipelineInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpGetDatasetContent struct { 334} 335 336func (*validateOpGetDatasetContent) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpGetDatasetContent) 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.(*GetDatasetContentInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpGetDatasetContentInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpListDatasetContents struct { 354} 355 356func (*validateOpListDatasetContents) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpListDatasetContents) 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.(*ListDatasetContentsInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpListDatasetContentsInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpListTagsForResource struct { 374} 375 376func (*validateOpListTagsForResource) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpListTagsForResourceInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpPutLoggingOptions struct { 394} 395 396func (*validateOpPutLoggingOptions) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpPutLoggingOptions) 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.(*PutLoggingOptionsInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpPutLoggingOptionsInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpRunPipelineActivity struct { 414} 415 416func (*validateOpRunPipelineActivity) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpRunPipelineActivity) 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.(*RunPipelineActivityInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpRunPipelineActivityInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpSampleChannelData struct { 434} 435 436func (*validateOpSampleChannelData) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpSampleChannelData) 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.(*SampleChannelDataInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpSampleChannelDataInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpStartPipelineReprocessing struct { 454} 455 456func (*validateOpStartPipelineReprocessing) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpStartPipelineReprocessing) 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.(*StartPipelineReprocessingInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpStartPipelineReprocessingInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473type validateOpTagResource struct { 474} 475 476func (*validateOpTagResource) ID() string { 477 return "OperationInputValidation" 478} 479 480func (m *validateOpTagResource) 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.(*TagResourceInput) 484 if !ok { 485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 486 } 487 if err := validateOpTagResourceInput(input); err != nil { 488 return out, metadata, err 489 } 490 return next.HandleInitialize(ctx, in) 491} 492 493type validateOpUntagResource struct { 494} 495 496func (*validateOpUntagResource) ID() string { 497 return "OperationInputValidation" 498} 499 500func (m *validateOpUntagResource) 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.(*UntagResourceInput) 504 if !ok { 505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 506 } 507 if err := validateOpUntagResourceInput(input); err != nil { 508 return out, metadata, err 509 } 510 return next.HandleInitialize(ctx, in) 511} 512 513type validateOpUpdateChannel struct { 514} 515 516func (*validateOpUpdateChannel) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpUpdateChannel) 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.(*UpdateChannelInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpUpdateChannelInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533type validateOpUpdateDataset struct { 534} 535 536func (*validateOpUpdateDataset) ID() string { 537 return "OperationInputValidation" 538} 539 540func (m *validateOpUpdateDataset) 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.(*UpdateDatasetInput) 544 if !ok { 545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 546 } 547 if err := validateOpUpdateDatasetInput(input); err != nil { 548 return out, metadata, err 549 } 550 return next.HandleInitialize(ctx, in) 551} 552 553type validateOpUpdateDatastore struct { 554} 555 556func (*validateOpUpdateDatastore) ID() string { 557 return "OperationInputValidation" 558} 559 560func (m *validateOpUpdateDatastore) 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.(*UpdateDatastoreInput) 564 if !ok { 565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 566 } 567 if err := validateOpUpdateDatastoreInput(input); err != nil { 568 return out, metadata, err 569 } 570 return next.HandleInitialize(ctx, in) 571} 572 573type validateOpUpdatePipeline struct { 574} 575 576func (*validateOpUpdatePipeline) ID() string { 577 return "OperationInputValidation" 578} 579 580func (m *validateOpUpdatePipeline) 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.(*UpdatePipelineInput) 584 if !ok { 585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 586 } 587 if err := validateOpUpdatePipelineInput(input); err != nil { 588 return out, metadata, err 589 } 590 return next.HandleInitialize(ctx, in) 591} 592 593func addOpBatchPutMessageValidationMiddleware(stack *middleware.Stack) error { 594 return stack.Initialize.Add(&validateOpBatchPutMessage{}, middleware.After) 595} 596 597func addOpCancelPipelineReprocessingValidationMiddleware(stack *middleware.Stack) error { 598 return stack.Initialize.Add(&validateOpCancelPipelineReprocessing{}, middleware.After) 599} 600 601func addOpCreateChannelValidationMiddleware(stack *middleware.Stack) error { 602 return stack.Initialize.Add(&validateOpCreateChannel{}, middleware.After) 603} 604 605func addOpCreateDatasetContentValidationMiddleware(stack *middleware.Stack) error { 606 return stack.Initialize.Add(&validateOpCreateDatasetContent{}, middleware.After) 607} 608 609func addOpCreateDatasetValidationMiddleware(stack *middleware.Stack) error { 610 return stack.Initialize.Add(&validateOpCreateDataset{}, middleware.After) 611} 612 613func addOpCreateDatastoreValidationMiddleware(stack *middleware.Stack) error { 614 return stack.Initialize.Add(&validateOpCreateDatastore{}, middleware.After) 615} 616 617func addOpCreatePipelineValidationMiddleware(stack *middleware.Stack) error { 618 return stack.Initialize.Add(&validateOpCreatePipeline{}, middleware.After) 619} 620 621func addOpDeleteChannelValidationMiddleware(stack *middleware.Stack) error { 622 return stack.Initialize.Add(&validateOpDeleteChannel{}, middleware.After) 623} 624 625func addOpDeleteDatasetContentValidationMiddleware(stack *middleware.Stack) error { 626 return stack.Initialize.Add(&validateOpDeleteDatasetContent{}, middleware.After) 627} 628 629func addOpDeleteDatasetValidationMiddleware(stack *middleware.Stack) error { 630 return stack.Initialize.Add(&validateOpDeleteDataset{}, middleware.After) 631} 632 633func addOpDeleteDatastoreValidationMiddleware(stack *middleware.Stack) error { 634 return stack.Initialize.Add(&validateOpDeleteDatastore{}, middleware.After) 635} 636 637func addOpDeletePipelineValidationMiddleware(stack *middleware.Stack) error { 638 return stack.Initialize.Add(&validateOpDeletePipeline{}, middleware.After) 639} 640 641func addOpDescribeChannelValidationMiddleware(stack *middleware.Stack) error { 642 return stack.Initialize.Add(&validateOpDescribeChannel{}, middleware.After) 643} 644 645func addOpDescribeDatasetValidationMiddleware(stack *middleware.Stack) error { 646 return stack.Initialize.Add(&validateOpDescribeDataset{}, middleware.After) 647} 648 649func addOpDescribeDatastoreValidationMiddleware(stack *middleware.Stack) error { 650 return stack.Initialize.Add(&validateOpDescribeDatastore{}, middleware.After) 651} 652 653func addOpDescribePipelineValidationMiddleware(stack *middleware.Stack) error { 654 return stack.Initialize.Add(&validateOpDescribePipeline{}, middleware.After) 655} 656 657func addOpGetDatasetContentValidationMiddleware(stack *middleware.Stack) error { 658 return stack.Initialize.Add(&validateOpGetDatasetContent{}, middleware.After) 659} 660 661func addOpListDatasetContentsValidationMiddleware(stack *middleware.Stack) error { 662 return stack.Initialize.Add(&validateOpListDatasetContents{}, middleware.After) 663} 664 665func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 666 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 667} 668 669func addOpPutLoggingOptionsValidationMiddleware(stack *middleware.Stack) error { 670 return stack.Initialize.Add(&validateOpPutLoggingOptions{}, middleware.After) 671} 672 673func addOpRunPipelineActivityValidationMiddleware(stack *middleware.Stack) error { 674 return stack.Initialize.Add(&validateOpRunPipelineActivity{}, middleware.After) 675} 676 677func addOpSampleChannelDataValidationMiddleware(stack *middleware.Stack) error { 678 return stack.Initialize.Add(&validateOpSampleChannelData{}, middleware.After) 679} 680 681func addOpStartPipelineReprocessingValidationMiddleware(stack *middleware.Stack) error { 682 return stack.Initialize.Add(&validateOpStartPipelineReprocessing{}, middleware.After) 683} 684 685func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 686 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 687} 688 689func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 690 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 691} 692 693func addOpUpdateChannelValidationMiddleware(stack *middleware.Stack) error { 694 return stack.Initialize.Add(&validateOpUpdateChannel{}, middleware.After) 695} 696 697func addOpUpdateDatasetValidationMiddleware(stack *middleware.Stack) error { 698 return stack.Initialize.Add(&validateOpUpdateDataset{}, middleware.After) 699} 700 701func addOpUpdateDatastoreValidationMiddleware(stack *middleware.Stack) error { 702 return stack.Initialize.Add(&validateOpUpdateDatastore{}, middleware.After) 703} 704 705func addOpUpdatePipelineValidationMiddleware(stack *middleware.Stack) error { 706 return stack.Initialize.Add(&validateOpUpdatePipeline{}, middleware.After) 707} 708 709func validateAddAttributesActivity(v *types.AddAttributesActivity) error { 710 if v == nil { 711 return nil 712 } 713 invalidParams := smithy.InvalidParamsError{Context: "AddAttributesActivity"} 714 if v.Name == nil { 715 invalidParams.Add(smithy.NewErrParamRequired("Name")) 716 } 717 if v.Attributes == nil { 718 invalidParams.Add(smithy.NewErrParamRequired("Attributes")) 719 } 720 if invalidParams.Len() > 0 { 721 return invalidParams 722 } else { 723 return nil 724 } 725} 726 727func validateChannelActivity(v *types.ChannelActivity) error { 728 if v == nil { 729 return nil 730 } 731 invalidParams := smithy.InvalidParamsError{Context: "ChannelActivity"} 732 if v.Name == nil { 733 invalidParams.Add(smithy.NewErrParamRequired("Name")) 734 } 735 if v.ChannelName == nil { 736 invalidParams.Add(smithy.NewErrParamRequired("ChannelName")) 737 } 738 if invalidParams.Len() > 0 { 739 return invalidParams 740 } else { 741 return nil 742 } 743} 744 745func validateChannelStorage(v *types.ChannelStorage) error { 746 if v == nil { 747 return nil 748 } 749 invalidParams := smithy.InvalidParamsError{Context: "ChannelStorage"} 750 if v.CustomerManagedS3 != nil { 751 if err := validateCustomerManagedChannelS3Storage(v.CustomerManagedS3); err != nil { 752 invalidParams.AddNested("CustomerManagedS3", err.(smithy.InvalidParamsError)) 753 } 754 } 755 if invalidParams.Len() > 0 { 756 return invalidParams 757 } else { 758 return nil 759 } 760} 761 762func validateColumn(v *types.Column) error { 763 if v == nil { 764 return nil 765 } 766 invalidParams := smithy.InvalidParamsError{Context: "Column"} 767 if v.Name == nil { 768 invalidParams.Add(smithy.NewErrParamRequired("Name")) 769 } 770 if v.Type == nil { 771 invalidParams.Add(smithy.NewErrParamRequired("Type")) 772 } 773 if invalidParams.Len() > 0 { 774 return invalidParams 775 } else { 776 return nil 777 } 778} 779 780func validateColumns(v []types.Column) error { 781 if v == nil { 782 return nil 783 } 784 invalidParams := smithy.InvalidParamsError{Context: "Columns"} 785 for i := range v { 786 if err := validateColumn(&v[i]); err != nil { 787 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 788 } 789 } 790 if invalidParams.Len() > 0 { 791 return invalidParams 792 } else { 793 return nil 794 } 795} 796 797func validateContainerDatasetAction(v *types.ContainerDatasetAction) error { 798 if v == nil { 799 return nil 800 } 801 invalidParams := smithy.InvalidParamsError{Context: "ContainerDatasetAction"} 802 if v.Image == nil { 803 invalidParams.Add(smithy.NewErrParamRequired("Image")) 804 } 805 if v.ExecutionRoleArn == nil { 806 invalidParams.Add(smithy.NewErrParamRequired("ExecutionRoleArn")) 807 } 808 if v.ResourceConfiguration == nil { 809 invalidParams.Add(smithy.NewErrParamRequired("ResourceConfiguration")) 810 } else if v.ResourceConfiguration != nil { 811 if err := validateResourceConfiguration(v.ResourceConfiguration); err != nil { 812 invalidParams.AddNested("ResourceConfiguration", err.(smithy.InvalidParamsError)) 813 } 814 } 815 if v.Variables != nil { 816 if err := validateVariables(v.Variables); err != nil { 817 invalidParams.AddNested("Variables", err.(smithy.InvalidParamsError)) 818 } 819 } 820 if invalidParams.Len() > 0 { 821 return invalidParams 822 } else { 823 return nil 824 } 825} 826 827func validateCustomerManagedChannelS3Storage(v *types.CustomerManagedChannelS3Storage) error { 828 if v == nil { 829 return nil 830 } 831 invalidParams := smithy.InvalidParamsError{Context: "CustomerManagedChannelS3Storage"} 832 if v.Bucket == nil { 833 invalidParams.Add(smithy.NewErrParamRequired("Bucket")) 834 } 835 if v.RoleArn == nil { 836 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 837 } 838 if invalidParams.Len() > 0 { 839 return invalidParams 840 } else { 841 return nil 842 } 843} 844 845func validateCustomerManagedDatastoreS3Storage(v *types.CustomerManagedDatastoreS3Storage) error { 846 if v == nil { 847 return nil 848 } 849 invalidParams := smithy.InvalidParamsError{Context: "CustomerManagedDatastoreS3Storage"} 850 if v.Bucket == nil { 851 invalidParams.Add(smithy.NewErrParamRequired("Bucket")) 852 } 853 if v.RoleArn == nil { 854 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 855 } 856 if invalidParams.Len() > 0 { 857 return invalidParams 858 } else { 859 return nil 860 } 861} 862 863func validateDatasetAction(v *types.DatasetAction) error { 864 if v == nil { 865 return nil 866 } 867 invalidParams := smithy.InvalidParamsError{Context: "DatasetAction"} 868 if v.QueryAction != nil { 869 if err := validateSqlQueryDatasetAction(v.QueryAction); err != nil { 870 invalidParams.AddNested("QueryAction", err.(smithy.InvalidParamsError)) 871 } 872 } 873 if v.ContainerAction != nil { 874 if err := validateContainerDatasetAction(v.ContainerAction); err != nil { 875 invalidParams.AddNested("ContainerAction", err.(smithy.InvalidParamsError)) 876 } 877 } 878 if invalidParams.Len() > 0 { 879 return invalidParams 880 } else { 881 return nil 882 } 883} 884 885func validateDatasetActions(v []types.DatasetAction) error { 886 if v == nil { 887 return nil 888 } 889 invalidParams := smithy.InvalidParamsError{Context: "DatasetActions"} 890 for i := range v { 891 if err := validateDatasetAction(&v[i]); err != nil { 892 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 893 } 894 } 895 if invalidParams.Len() > 0 { 896 return invalidParams 897 } else { 898 return nil 899 } 900} 901 902func validateDatasetContentDeliveryDestination(v *types.DatasetContentDeliveryDestination) error { 903 if v == nil { 904 return nil 905 } 906 invalidParams := smithy.InvalidParamsError{Context: "DatasetContentDeliveryDestination"} 907 if v.IotEventsDestinationConfiguration != nil { 908 if err := validateIotEventsDestinationConfiguration(v.IotEventsDestinationConfiguration); err != nil { 909 invalidParams.AddNested("IotEventsDestinationConfiguration", err.(smithy.InvalidParamsError)) 910 } 911 } 912 if v.S3DestinationConfiguration != nil { 913 if err := validateS3DestinationConfiguration(v.S3DestinationConfiguration); err != nil { 914 invalidParams.AddNested("S3DestinationConfiguration", err.(smithy.InvalidParamsError)) 915 } 916 } 917 if invalidParams.Len() > 0 { 918 return invalidParams 919 } else { 920 return nil 921 } 922} 923 924func validateDatasetContentDeliveryRule(v *types.DatasetContentDeliveryRule) error { 925 if v == nil { 926 return nil 927 } 928 invalidParams := smithy.InvalidParamsError{Context: "DatasetContentDeliveryRule"} 929 if v.Destination == nil { 930 invalidParams.Add(smithy.NewErrParamRequired("Destination")) 931 } else if v.Destination != nil { 932 if err := validateDatasetContentDeliveryDestination(v.Destination); err != nil { 933 invalidParams.AddNested("Destination", err.(smithy.InvalidParamsError)) 934 } 935 } 936 if invalidParams.Len() > 0 { 937 return invalidParams 938 } else { 939 return nil 940 } 941} 942 943func validateDatasetContentDeliveryRules(v []types.DatasetContentDeliveryRule) error { 944 if v == nil { 945 return nil 946 } 947 invalidParams := smithy.InvalidParamsError{Context: "DatasetContentDeliveryRules"} 948 for i := range v { 949 if err := validateDatasetContentDeliveryRule(&v[i]); err != nil { 950 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 951 } 952 } 953 if invalidParams.Len() > 0 { 954 return invalidParams 955 } else { 956 return nil 957 } 958} 959 960func validateDatasetContentVersionValue(v *types.DatasetContentVersionValue) error { 961 if v == nil { 962 return nil 963 } 964 invalidParams := smithy.InvalidParamsError{Context: "DatasetContentVersionValue"} 965 if v.DatasetName == nil { 966 invalidParams.Add(smithy.NewErrParamRequired("DatasetName")) 967 } 968 if invalidParams.Len() > 0 { 969 return invalidParams 970 } else { 971 return nil 972 } 973} 974 975func validateDatasetTrigger(v *types.DatasetTrigger) error { 976 if v == nil { 977 return nil 978 } 979 invalidParams := smithy.InvalidParamsError{Context: "DatasetTrigger"} 980 if v.Dataset != nil { 981 if err := validateTriggeringDataset(v.Dataset); err != nil { 982 invalidParams.AddNested("Dataset", err.(smithy.InvalidParamsError)) 983 } 984 } 985 if invalidParams.Len() > 0 { 986 return invalidParams 987 } else { 988 return nil 989 } 990} 991 992func validateDatasetTriggers(v []types.DatasetTrigger) error { 993 if v == nil { 994 return nil 995 } 996 invalidParams := smithy.InvalidParamsError{Context: "DatasetTriggers"} 997 for i := range v { 998 if err := validateDatasetTrigger(&v[i]); err != nil { 999 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1000 } 1001 } 1002 if invalidParams.Len() > 0 { 1003 return invalidParams 1004 } else { 1005 return nil 1006 } 1007} 1008 1009func validateDatastoreActivity(v *types.DatastoreActivity) error { 1010 if v == nil { 1011 return nil 1012 } 1013 invalidParams := smithy.InvalidParamsError{Context: "DatastoreActivity"} 1014 if v.Name == nil { 1015 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1016 } 1017 if v.DatastoreName == nil { 1018 invalidParams.Add(smithy.NewErrParamRequired("DatastoreName")) 1019 } 1020 if invalidParams.Len() > 0 { 1021 return invalidParams 1022 } else { 1023 return nil 1024 } 1025} 1026 1027func validateDatastoreStorage(v types.DatastoreStorage) error { 1028 if v == nil { 1029 return nil 1030 } 1031 invalidParams := smithy.InvalidParamsError{Context: "DatastoreStorage"} 1032 switch uv := v.(type) { 1033 case *types.DatastoreStorageMemberCustomerManagedS3: 1034 if err := validateCustomerManagedDatastoreS3Storage(&uv.Value); err != nil { 1035 invalidParams.AddNested("[customerManagedS3]", err.(smithy.InvalidParamsError)) 1036 } 1037 1038 } 1039 if invalidParams.Len() > 0 { 1040 return invalidParams 1041 } else { 1042 return nil 1043 } 1044} 1045 1046func validateDeltaTime(v *types.DeltaTime) error { 1047 if v == nil { 1048 return nil 1049 } 1050 invalidParams := smithy.InvalidParamsError{Context: "DeltaTime"} 1051 if v.OffsetSeconds == nil { 1052 invalidParams.Add(smithy.NewErrParamRequired("OffsetSeconds")) 1053 } 1054 if v.TimeExpression == nil { 1055 invalidParams.Add(smithy.NewErrParamRequired("TimeExpression")) 1056 } 1057 if invalidParams.Len() > 0 { 1058 return invalidParams 1059 } else { 1060 return nil 1061 } 1062} 1063 1064func validateDeltaTimeSessionWindowConfiguration(v *types.DeltaTimeSessionWindowConfiguration) error { 1065 if v == nil { 1066 return nil 1067 } 1068 invalidParams := smithy.InvalidParamsError{Context: "DeltaTimeSessionWindowConfiguration"} 1069 if v.TimeoutInMinutes == nil { 1070 invalidParams.Add(smithy.NewErrParamRequired("TimeoutInMinutes")) 1071 } 1072 if invalidParams.Len() > 0 { 1073 return invalidParams 1074 } else { 1075 return nil 1076 } 1077} 1078 1079func validateDeviceRegistryEnrichActivity(v *types.DeviceRegistryEnrichActivity) error { 1080 if v == nil { 1081 return nil 1082 } 1083 invalidParams := smithy.InvalidParamsError{Context: "DeviceRegistryEnrichActivity"} 1084 if v.Name == nil { 1085 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1086 } 1087 if v.Attribute == nil { 1088 invalidParams.Add(smithy.NewErrParamRequired("Attribute")) 1089 } 1090 if v.ThingName == nil { 1091 invalidParams.Add(smithy.NewErrParamRequired("ThingName")) 1092 } 1093 if v.RoleArn == nil { 1094 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 1095 } 1096 if invalidParams.Len() > 0 { 1097 return invalidParams 1098 } else { 1099 return nil 1100 } 1101} 1102 1103func validateDeviceShadowEnrichActivity(v *types.DeviceShadowEnrichActivity) error { 1104 if v == nil { 1105 return nil 1106 } 1107 invalidParams := smithy.InvalidParamsError{Context: "DeviceShadowEnrichActivity"} 1108 if v.Name == nil { 1109 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1110 } 1111 if v.Attribute == nil { 1112 invalidParams.Add(smithy.NewErrParamRequired("Attribute")) 1113 } 1114 if v.ThingName == nil { 1115 invalidParams.Add(smithy.NewErrParamRequired("ThingName")) 1116 } 1117 if v.RoleArn == nil { 1118 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 1119 } 1120 if invalidParams.Len() > 0 { 1121 return invalidParams 1122 } else { 1123 return nil 1124 } 1125} 1126 1127func validateFileFormatConfiguration(v *types.FileFormatConfiguration) error { 1128 if v == nil { 1129 return nil 1130 } 1131 invalidParams := smithy.InvalidParamsError{Context: "FileFormatConfiguration"} 1132 if v.ParquetConfiguration != nil { 1133 if err := validateParquetConfiguration(v.ParquetConfiguration); err != nil { 1134 invalidParams.AddNested("ParquetConfiguration", err.(smithy.InvalidParamsError)) 1135 } 1136 } 1137 if invalidParams.Len() > 0 { 1138 return invalidParams 1139 } else { 1140 return nil 1141 } 1142} 1143 1144func validateFilterActivity(v *types.FilterActivity) error { 1145 if v == nil { 1146 return nil 1147 } 1148 invalidParams := smithy.InvalidParamsError{Context: "FilterActivity"} 1149 if v.Name == nil { 1150 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1151 } 1152 if v.Filter == nil { 1153 invalidParams.Add(smithy.NewErrParamRequired("Filter")) 1154 } 1155 if invalidParams.Len() > 0 { 1156 return invalidParams 1157 } else { 1158 return nil 1159 } 1160} 1161 1162func validateGlueConfiguration(v *types.GlueConfiguration) error { 1163 if v == nil { 1164 return nil 1165 } 1166 invalidParams := smithy.InvalidParamsError{Context: "GlueConfiguration"} 1167 if v.TableName == nil { 1168 invalidParams.Add(smithy.NewErrParamRequired("TableName")) 1169 } 1170 if v.DatabaseName == nil { 1171 invalidParams.Add(smithy.NewErrParamRequired("DatabaseName")) 1172 } 1173 if invalidParams.Len() > 0 { 1174 return invalidParams 1175 } else { 1176 return nil 1177 } 1178} 1179 1180func validateIotEventsDestinationConfiguration(v *types.IotEventsDestinationConfiguration) error { 1181 if v == nil { 1182 return nil 1183 } 1184 invalidParams := smithy.InvalidParamsError{Context: "IotEventsDestinationConfiguration"} 1185 if v.InputName == nil { 1186 invalidParams.Add(smithy.NewErrParamRequired("InputName")) 1187 } 1188 if v.RoleArn == nil { 1189 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 1190 } 1191 if invalidParams.Len() > 0 { 1192 return invalidParams 1193 } else { 1194 return nil 1195 } 1196} 1197 1198func validateLambdaActivity(v *types.LambdaActivity) error { 1199 if v == nil { 1200 return nil 1201 } 1202 invalidParams := smithy.InvalidParamsError{Context: "LambdaActivity"} 1203 if v.Name == nil { 1204 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1205 } 1206 if v.LambdaName == nil { 1207 invalidParams.Add(smithy.NewErrParamRequired("LambdaName")) 1208 } 1209 if v.BatchSize == nil { 1210 invalidParams.Add(smithy.NewErrParamRequired("BatchSize")) 1211 } 1212 if invalidParams.Len() > 0 { 1213 return invalidParams 1214 } else { 1215 return nil 1216 } 1217} 1218 1219func validateLateDataRule(v *types.LateDataRule) error { 1220 if v == nil { 1221 return nil 1222 } 1223 invalidParams := smithy.InvalidParamsError{Context: "LateDataRule"} 1224 if v.RuleConfiguration == nil { 1225 invalidParams.Add(smithy.NewErrParamRequired("RuleConfiguration")) 1226 } else if v.RuleConfiguration != nil { 1227 if err := validateLateDataRuleConfiguration(v.RuleConfiguration); err != nil { 1228 invalidParams.AddNested("RuleConfiguration", err.(smithy.InvalidParamsError)) 1229 } 1230 } 1231 if invalidParams.Len() > 0 { 1232 return invalidParams 1233 } else { 1234 return nil 1235 } 1236} 1237 1238func validateLateDataRuleConfiguration(v *types.LateDataRuleConfiguration) error { 1239 if v == nil { 1240 return nil 1241 } 1242 invalidParams := smithy.InvalidParamsError{Context: "LateDataRuleConfiguration"} 1243 if v.DeltaTimeSessionWindowConfiguration != nil { 1244 if err := validateDeltaTimeSessionWindowConfiguration(v.DeltaTimeSessionWindowConfiguration); err != nil { 1245 invalidParams.AddNested("DeltaTimeSessionWindowConfiguration", err.(smithy.InvalidParamsError)) 1246 } 1247 } 1248 if invalidParams.Len() > 0 { 1249 return invalidParams 1250 } else { 1251 return nil 1252 } 1253} 1254 1255func validateLateDataRules(v []types.LateDataRule) error { 1256 if v == nil { 1257 return nil 1258 } 1259 invalidParams := smithy.InvalidParamsError{Context: "LateDataRules"} 1260 for i := range v { 1261 if err := validateLateDataRule(&v[i]); err != nil { 1262 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1263 } 1264 } 1265 if invalidParams.Len() > 0 { 1266 return invalidParams 1267 } else { 1268 return nil 1269 } 1270} 1271 1272func validateLoggingOptions(v *types.LoggingOptions) error { 1273 if v == nil { 1274 return nil 1275 } 1276 invalidParams := smithy.InvalidParamsError{Context: "LoggingOptions"} 1277 if v.RoleArn == nil { 1278 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 1279 } 1280 if len(v.Level) == 0 { 1281 invalidParams.Add(smithy.NewErrParamRequired("Level")) 1282 } 1283 if invalidParams.Len() > 0 { 1284 return invalidParams 1285 } else { 1286 return nil 1287 } 1288} 1289 1290func validateMathActivity(v *types.MathActivity) error { 1291 if v == nil { 1292 return nil 1293 } 1294 invalidParams := smithy.InvalidParamsError{Context: "MathActivity"} 1295 if v.Name == nil { 1296 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1297 } 1298 if v.Attribute == nil { 1299 invalidParams.Add(smithy.NewErrParamRequired("Attribute")) 1300 } 1301 if v.Math == nil { 1302 invalidParams.Add(smithy.NewErrParamRequired("Math")) 1303 } 1304 if invalidParams.Len() > 0 { 1305 return invalidParams 1306 } else { 1307 return nil 1308 } 1309} 1310 1311func validateMessage(v *types.Message) error { 1312 if v == nil { 1313 return nil 1314 } 1315 invalidParams := smithy.InvalidParamsError{Context: "Message"} 1316 if v.MessageId == nil { 1317 invalidParams.Add(smithy.NewErrParamRequired("MessageId")) 1318 } 1319 if v.Payload == nil { 1320 invalidParams.Add(smithy.NewErrParamRequired("Payload")) 1321 } 1322 if invalidParams.Len() > 0 { 1323 return invalidParams 1324 } else { 1325 return nil 1326 } 1327} 1328 1329func validateMessages(v []types.Message) error { 1330 if v == nil { 1331 return nil 1332 } 1333 invalidParams := smithy.InvalidParamsError{Context: "Messages"} 1334 for i := range v { 1335 if err := validateMessage(&v[i]); err != nil { 1336 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1337 } 1338 } 1339 if invalidParams.Len() > 0 { 1340 return invalidParams 1341 } else { 1342 return nil 1343 } 1344} 1345 1346func validateOutputFileUriValue(v *types.OutputFileUriValue) error { 1347 if v == nil { 1348 return nil 1349 } 1350 invalidParams := smithy.InvalidParamsError{Context: "OutputFileUriValue"} 1351 if v.FileName == nil { 1352 invalidParams.Add(smithy.NewErrParamRequired("FileName")) 1353 } 1354 if invalidParams.Len() > 0 { 1355 return invalidParams 1356 } else { 1357 return nil 1358 } 1359} 1360 1361func validateParquetConfiguration(v *types.ParquetConfiguration) error { 1362 if v == nil { 1363 return nil 1364 } 1365 invalidParams := smithy.InvalidParamsError{Context: "ParquetConfiguration"} 1366 if v.SchemaDefinition != nil { 1367 if err := validateSchemaDefinition(v.SchemaDefinition); err != nil { 1368 invalidParams.AddNested("SchemaDefinition", err.(smithy.InvalidParamsError)) 1369 } 1370 } 1371 if invalidParams.Len() > 0 { 1372 return invalidParams 1373 } else { 1374 return nil 1375 } 1376} 1377 1378func validatePipelineActivities(v []types.PipelineActivity) error { 1379 if v == nil { 1380 return nil 1381 } 1382 invalidParams := smithy.InvalidParamsError{Context: "PipelineActivities"} 1383 for i := range v { 1384 if err := validatePipelineActivity(&v[i]); err != nil { 1385 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1386 } 1387 } 1388 if invalidParams.Len() > 0 { 1389 return invalidParams 1390 } else { 1391 return nil 1392 } 1393} 1394 1395func validatePipelineActivity(v *types.PipelineActivity) error { 1396 if v == nil { 1397 return nil 1398 } 1399 invalidParams := smithy.InvalidParamsError{Context: "PipelineActivity"} 1400 if v.Channel != nil { 1401 if err := validateChannelActivity(v.Channel); err != nil { 1402 invalidParams.AddNested("Channel", err.(smithy.InvalidParamsError)) 1403 } 1404 } 1405 if v.Lambda != nil { 1406 if err := validateLambdaActivity(v.Lambda); err != nil { 1407 invalidParams.AddNested("Lambda", err.(smithy.InvalidParamsError)) 1408 } 1409 } 1410 if v.Datastore != nil { 1411 if err := validateDatastoreActivity(v.Datastore); err != nil { 1412 invalidParams.AddNested("Datastore", err.(smithy.InvalidParamsError)) 1413 } 1414 } 1415 if v.AddAttributes != nil { 1416 if err := validateAddAttributesActivity(v.AddAttributes); err != nil { 1417 invalidParams.AddNested("AddAttributes", err.(smithy.InvalidParamsError)) 1418 } 1419 } 1420 if v.RemoveAttributes != nil { 1421 if err := validateRemoveAttributesActivity(v.RemoveAttributes); err != nil { 1422 invalidParams.AddNested("RemoveAttributes", err.(smithy.InvalidParamsError)) 1423 } 1424 } 1425 if v.SelectAttributes != nil { 1426 if err := validateSelectAttributesActivity(v.SelectAttributes); err != nil { 1427 invalidParams.AddNested("SelectAttributes", err.(smithy.InvalidParamsError)) 1428 } 1429 } 1430 if v.Filter != nil { 1431 if err := validateFilterActivity(v.Filter); err != nil { 1432 invalidParams.AddNested("Filter", err.(smithy.InvalidParamsError)) 1433 } 1434 } 1435 if v.Math != nil { 1436 if err := validateMathActivity(v.Math); err != nil { 1437 invalidParams.AddNested("Math", err.(smithy.InvalidParamsError)) 1438 } 1439 } 1440 if v.DeviceRegistryEnrich != nil { 1441 if err := validateDeviceRegistryEnrichActivity(v.DeviceRegistryEnrich); err != nil { 1442 invalidParams.AddNested("DeviceRegistryEnrich", err.(smithy.InvalidParamsError)) 1443 } 1444 } 1445 if v.DeviceShadowEnrich != nil { 1446 if err := validateDeviceShadowEnrichActivity(v.DeviceShadowEnrich); err != nil { 1447 invalidParams.AddNested("DeviceShadowEnrich", err.(smithy.InvalidParamsError)) 1448 } 1449 } 1450 if invalidParams.Len() > 0 { 1451 return invalidParams 1452 } else { 1453 return nil 1454 } 1455} 1456 1457func validateQueryFilter(v *types.QueryFilter) error { 1458 if v == nil { 1459 return nil 1460 } 1461 invalidParams := smithy.InvalidParamsError{Context: "QueryFilter"} 1462 if v.DeltaTime != nil { 1463 if err := validateDeltaTime(v.DeltaTime); err != nil { 1464 invalidParams.AddNested("DeltaTime", err.(smithy.InvalidParamsError)) 1465 } 1466 } 1467 if invalidParams.Len() > 0 { 1468 return invalidParams 1469 } else { 1470 return nil 1471 } 1472} 1473 1474func validateQueryFilters(v []types.QueryFilter) error { 1475 if v == nil { 1476 return nil 1477 } 1478 invalidParams := smithy.InvalidParamsError{Context: "QueryFilters"} 1479 for i := range v { 1480 if err := validateQueryFilter(&v[i]); err != nil { 1481 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1482 } 1483 } 1484 if invalidParams.Len() > 0 { 1485 return invalidParams 1486 } else { 1487 return nil 1488 } 1489} 1490 1491func validateRemoveAttributesActivity(v *types.RemoveAttributesActivity) error { 1492 if v == nil { 1493 return nil 1494 } 1495 invalidParams := smithy.InvalidParamsError{Context: "RemoveAttributesActivity"} 1496 if v.Name == nil { 1497 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1498 } 1499 if v.Attributes == nil { 1500 invalidParams.Add(smithy.NewErrParamRequired("Attributes")) 1501 } 1502 if invalidParams.Len() > 0 { 1503 return invalidParams 1504 } else { 1505 return nil 1506 } 1507} 1508 1509func validateResourceConfiguration(v *types.ResourceConfiguration) error { 1510 if v == nil { 1511 return nil 1512 } 1513 invalidParams := smithy.InvalidParamsError{Context: "ResourceConfiguration"} 1514 if len(v.ComputeType) == 0 { 1515 invalidParams.Add(smithy.NewErrParamRequired("ComputeType")) 1516 } 1517 if invalidParams.Len() > 0 { 1518 return invalidParams 1519 } else { 1520 return nil 1521 } 1522} 1523 1524func validateS3DestinationConfiguration(v *types.S3DestinationConfiguration) error { 1525 if v == nil { 1526 return nil 1527 } 1528 invalidParams := smithy.InvalidParamsError{Context: "S3DestinationConfiguration"} 1529 if v.Bucket == nil { 1530 invalidParams.Add(smithy.NewErrParamRequired("Bucket")) 1531 } 1532 if v.Key == nil { 1533 invalidParams.Add(smithy.NewErrParamRequired("Key")) 1534 } 1535 if v.GlueConfiguration != nil { 1536 if err := validateGlueConfiguration(v.GlueConfiguration); err != nil { 1537 invalidParams.AddNested("GlueConfiguration", err.(smithy.InvalidParamsError)) 1538 } 1539 } 1540 if v.RoleArn == nil { 1541 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 1542 } 1543 if invalidParams.Len() > 0 { 1544 return invalidParams 1545 } else { 1546 return nil 1547 } 1548} 1549 1550func validateSchemaDefinition(v *types.SchemaDefinition) error { 1551 if v == nil { 1552 return nil 1553 } 1554 invalidParams := smithy.InvalidParamsError{Context: "SchemaDefinition"} 1555 if v.Columns != nil { 1556 if err := validateColumns(v.Columns); err != nil { 1557 invalidParams.AddNested("Columns", err.(smithy.InvalidParamsError)) 1558 } 1559 } 1560 if invalidParams.Len() > 0 { 1561 return invalidParams 1562 } else { 1563 return nil 1564 } 1565} 1566 1567func validateSelectAttributesActivity(v *types.SelectAttributesActivity) error { 1568 if v == nil { 1569 return nil 1570 } 1571 invalidParams := smithy.InvalidParamsError{Context: "SelectAttributesActivity"} 1572 if v.Name == nil { 1573 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1574 } 1575 if v.Attributes == nil { 1576 invalidParams.Add(smithy.NewErrParamRequired("Attributes")) 1577 } 1578 if invalidParams.Len() > 0 { 1579 return invalidParams 1580 } else { 1581 return nil 1582 } 1583} 1584 1585func validateSqlQueryDatasetAction(v *types.SqlQueryDatasetAction) error { 1586 if v == nil { 1587 return nil 1588 } 1589 invalidParams := smithy.InvalidParamsError{Context: "SqlQueryDatasetAction"} 1590 if v.SqlQuery == nil { 1591 invalidParams.Add(smithy.NewErrParamRequired("SqlQuery")) 1592 } 1593 if v.Filters != nil { 1594 if err := validateQueryFilters(v.Filters); err != nil { 1595 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 1596 } 1597 } 1598 if invalidParams.Len() > 0 { 1599 return invalidParams 1600 } else { 1601 return nil 1602 } 1603} 1604 1605func validateTag(v *types.Tag) error { 1606 if v == nil { 1607 return nil 1608 } 1609 invalidParams := smithy.InvalidParamsError{Context: "Tag"} 1610 if v.Key == nil { 1611 invalidParams.Add(smithy.NewErrParamRequired("Key")) 1612 } 1613 if v.Value == nil { 1614 invalidParams.Add(smithy.NewErrParamRequired("Value")) 1615 } 1616 if invalidParams.Len() > 0 { 1617 return invalidParams 1618 } else { 1619 return nil 1620 } 1621} 1622 1623func validateTagList(v []types.Tag) error { 1624 if v == nil { 1625 return nil 1626 } 1627 invalidParams := smithy.InvalidParamsError{Context: "TagList"} 1628 for i := range v { 1629 if err := validateTag(&v[i]); err != nil { 1630 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1631 } 1632 } 1633 if invalidParams.Len() > 0 { 1634 return invalidParams 1635 } else { 1636 return nil 1637 } 1638} 1639 1640func validateTriggeringDataset(v *types.TriggeringDataset) error { 1641 if v == nil { 1642 return nil 1643 } 1644 invalidParams := smithy.InvalidParamsError{Context: "TriggeringDataset"} 1645 if v.Name == nil { 1646 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1647 } 1648 if invalidParams.Len() > 0 { 1649 return invalidParams 1650 } else { 1651 return nil 1652 } 1653} 1654 1655func validateVariable(v *types.Variable) error { 1656 if v == nil { 1657 return nil 1658 } 1659 invalidParams := smithy.InvalidParamsError{Context: "Variable"} 1660 if v.Name == nil { 1661 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1662 } 1663 if v.DatasetContentVersionValue != nil { 1664 if err := validateDatasetContentVersionValue(v.DatasetContentVersionValue); err != nil { 1665 invalidParams.AddNested("DatasetContentVersionValue", err.(smithy.InvalidParamsError)) 1666 } 1667 } 1668 if v.OutputFileUriValue != nil { 1669 if err := validateOutputFileUriValue(v.OutputFileUriValue); err != nil { 1670 invalidParams.AddNested("OutputFileUriValue", err.(smithy.InvalidParamsError)) 1671 } 1672 } 1673 if invalidParams.Len() > 0 { 1674 return invalidParams 1675 } else { 1676 return nil 1677 } 1678} 1679 1680func validateVariables(v []types.Variable) error { 1681 if v == nil { 1682 return nil 1683 } 1684 invalidParams := smithy.InvalidParamsError{Context: "Variables"} 1685 for i := range v { 1686 if err := validateVariable(&v[i]); err != nil { 1687 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1688 } 1689 } 1690 if invalidParams.Len() > 0 { 1691 return invalidParams 1692 } else { 1693 return nil 1694 } 1695} 1696 1697func validateOpBatchPutMessageInput(v *BatchPutMessageInput) error { 1698 if v == nil { 1699 return nil 1700 } 1701 invalidParams := smithy.InvalidParamsError{Context: "BatchPutMessageInput"} 1702 if v.ChannelName == nil { 1703 invalidParams.Add(smithy.NewErrParamRequired("ChannelName")) 1704 } 1705 if v.Messages == nil { 1706 invalidParams.Add(smithy.NewErrParamRequired("Messages")) 1707 } else if v.Messages != nil { 1708 if err := validateMessages(v.Messages); err != nil { 1709 invalidParams.AddNested("Messages", err.(smithy.InvalidParamsError)) 1710 } 1711 } 1712 if invalidParams.Len() > 0 { 1713 return invalidParams 1714 } else { 1715 return nil 1716 } 1717} 1718 1719func validateOpCancelPipelineReprocessingInput(v *CancelPipelineReprocessingInput) error { 1720 if v == nil { 1721 return nil 1722 } 1723 invalidParams := smithy.InvalidParamsError{Context: "CancelPipelineReprocessingInput"} 1724 if v.PipelineName == nil { 1725 invalidParams.Add(smithy.NewErrParamRequired("PipelineName")) 1726 } 1727 if v.ReprocessingId == nil { 1728 invalidParams.Add(smithy.NewErrParamRequired("ReprocessingId")) 1729 } 1730 if invalidParams.Len() > 0 { 1731 return invalidParams 1732 } else { 1733 return nil 1734 } 1735} 1736 1737func validateOpCreateChannelInput(v *CreateChannelInput) error { 1738 if v == nil { 1739 return nil 1740 } 1741 invalidParams := smithy.InvalidParamsError{Context: "CreateChannelInput"} 1742 if v.ChannelName == nil { 1743 invalidParams.Add(smithy.NewErrParamRequired("ChannelName")) 1744 } 1745 if v.ChannelStorage != nil { 1746 if err := validateChannelStorage(v.ChannelStorage); err != nil { 1747 invalidParams.AddNested("ChannelStorage", err.(smithy.InvalidParamsError)) 1748 } 1749 } 1750 if v.Tags != nil { 1751 if err := validateTagList(v.Tags); err != nil { 1752 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1753 } 1754 } 1755 if invalidParams.Len() > 0 { 1756 return invalidParams 1757 } else { 1758 return nil 1759 } 1760} 1761 1762func validateOpCreateDatasetContentInput(v *CreateDatasetContentInput) error { 1763 if v == nil { 1764 return nil 1765 } 1766 invalidParams := smithy.InvalidParamsError{Context: "CreateDatasetContentInput"} 1767 if v.DatasetName == nil { 1768 invalidParams.Add(smithy.NewErrParamRequired("DatasetName")) 1769 } 1770 if invalidParams.Len() > 0 { 1771 return invalidParams 1772 } else { 1773 return nil 1774 } 1775} 1776 1777func validateOpCreateDatasetInput(v *CreateDatasetInput) error { 1778 if v == nil { 1779 return nil 1780 } 1781 invalidParams := smithy.InvalidParamsError{Context: "CreateDatasetInput"} 1782 if v.DatasetName == nil { 1783 invalidParams.Add(smithy.NewErrParamRequired("DatasetName")) 1784 } 1785 if v.Actions == nil { 1786 invalidParams.Add(smithy.NewErrParamRequired("Actions")) 1787 } else if v.Actions != nil { 1788 if err := validateDatasetActions(v.Actions); err != nil { 1789 invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError)) 1790 } 1791 } 1792 if v.Triggers != nil { 1793 if err := validateDatasetTriggers(v.Triggers); err != nil { 1794 invalidParams.AddNested("Triggers", err.(smithy.InvalidParamsError)) 1795 } 1796 } 1797 if v.ContentDeliveryRules != nil { 1798 if err := validateDatasetContentDeliveryRules(v.ContentDeliveryRules); err != nil { 1799 invalidParams.AddNested("ContentDeliveryRules", err.(smithy.InvalidParamsError)) 1800 } 1801 } 1802 if v.Tags != nil { 1803 if err := validateTagList(v.Tags); err != nil { 1804 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1805 } 1806 } 1807 if v.LateDataRules != nil { 1808 if err := validateLateDataRules(v.LateDataRules); err != nil { 1809 invalidParams.AddNested("LateDataRules", err.(smithy.InvalidParamsError)) 1810 } 1811 } 1812 if invalidParams.Len() > 0 { 1813 return invalidParams 1814 } else { 1815 return nil 1816 } 1817} 1818 1819func validateOpCreateDatastoreInput(v *CreateDatastoreInput) error { 1820 if v == nil { 1821 return nil 1822 } 1823 invalidParams := smithy.InvalidParamsError{Context: "CreateDatastoreInput"} 1824 if v.DatastoreName == nil { 1825 invalidParams.Add(smithy.NewErrParamRequired("DatastoreName")) 1826 } 1827 if v.DatastoreStorage != nil { 1828 if err := validateDatastoreStorage(v.DatastoreStorage); err != nil { 1829 invalidParams.AddNested("DatastoreStorage", err.(smithy.InvalidParamsError)) 1830 } 1831 } 1832 if v.Tags != nil { 1833 if err := validateTagList(v.Tags); err != nil { 1834 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1835 } 1836 } 1837 if v.FileFormatConfiguration != nil { 1838 if err := validateFileFormatConfiguration(v.FileFormatConfiguration); err != nil { 1839 invalidParams.AddNested("FileFormatConfiguration", err.(smithy.InvalidParamsError)) 1840 } 1841 } 1842 if invalidParams.Len() > 0 { 1843 return invalidParams 1844 } else { 1845 return nil 1846 } 1847} 1848 1849func validateOpCreatePipelineInput(v *CreatePipelineInput) error { 1850 if v == nil { 1851 return nil 1852 } 1853 invalidParams := smithy.InvalidParamsError{Context: "CreatePipelineInput"} 1854 if v.PipelineName == nil { 1855 invalidParams.Add(smithy.NewErrParamRequired("PipelineName")) 1856 } 1857 if v.PipelineActivities == nil { 1858 invalidParams.Add(smithy.NewErrParamRequired("PipelineActivities")) 1859 } else if v.PipelineActivities != nil { 1860 if err := validatePipelineActivities(v.PipelineActivities); err != nil { 1861 invalidParams.AddNested("PipelineActivities", err.(smithy.InvalidParamsError)) 1862 } 1863 } 1864 if v.Tags != nil { 1865 if err := validateTagList(v.Tags); err != nil { 1866 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1867 } 1868 } 1869 if invalidParams.Len() > 0 { 1870 return invalidParams 1871 } else { 1872 return nil 1873 } 1874} 1875 1876func validateOpDeleteChannelInput(v *DeleteChannelInput) error { 1877 if v == nil { 1878 return nil 1879 } 1880 invalidParams := smithy.InvalidParamsError{Context: "DeleteChannelInput"} 1881 if v.ChannelName == nil { 1882 invalidParams.Add(smithy.NewErrParamRequired("ChannelName")) 1883 } 1884 if invalidParams.Len() > 0 { 1885 return invalidParams 1886 } else { 1887 return nil 1888 } 1889} 1890 1891func validateOpDeleteDatasetContentInput(v *DeleteDatasetContentInput) error { 1892 if v == nil { 1893 return nil 1894 } 1895 invalidParams := smithy.InvalidParamsError{Context: "DeleteDatasetContentInput"} 1896 if v.DatasetName == nil { 1897 invalidParams.Add(smithy.NewErrParamRequired("DatasetName")) 1898 } 1899 if invalidParams.Len() > 0 { 1900 return invalidParams 1901 } else { 1902 return nil 1903 } 1904} 1905 1906func validateOpDeleteDatasetInput(v *DeleteDatasetInput) error { 1907 if v == nil { 1908 return nil 1909 } 1910 invalidParams := smithy.InvalidParamsError{Context: "DeleteDatasetInput"} 1911 if v.DatasetName == nil { 1912 invalidParams.Add(smithy.NewErrParamRequired("DatasetName")) 1913 } 1914 if invalidParams.Len() > 0 { 1915 return invalidParams 1916 } else { 1917 return nil 1918 } 1919} 1920 1921func validateOpDeleteDatastoreInput(v *DeleteDatastoreInput) error { 1922 if v == nil { 1923 return nil 1924 } 1925 invalidParams := smithy.InvalidParamsError{Context: "DeleteDatastoreInput"} 1926 if v.DatastoreName == nil { 1927 invalidParams.Add(smithy.NewErrParamRequired("DatastoreName")) 1928 } 1929 if invalidParams.Len() > 0 { 1930 return invalidParams 1931 } else { 1932 return nil 1933 } 1934} 1935 1936func validateOpDeletePipelineInput(v *DeletePipelineInput) error { 1937 if v == nil { 1938 return nil 1939 } 1940 invalidParams := smithy.InvalidParamsError{Context: "DeletePipelineInput"} 1941 if v.PipelineName == nil { 1942 invalidParams.Add(smithy.NewErrParamRequired("PipelineName")) 1943 } 1944 if invalidParams.Len() > 0 { 1945 return invalidParams 1946 } else { 1947 return nil 1948 } 1949} 1950 1951func validateOpDescribeChannelInput(v *DescribeChannelInput) error { 1952 if v == nil { 1953 return nil 1954 } 1955 invalidParams := smithy.InvalidParamsError{Context: "DescribeChannelInput"} 1956 if v.ChannelName == nil { 1957 invalidParams.Add(smithy.NewErrParamRequired("ChannelName")) 1958 } 1959 if invalidParams.Len() > 0 { 1960 return invalidParams 1961 } else { 1962 return nil 1963 } 1964} 1965 1966func validateOpDescribeDatasetInput(v *DescribeDatasetInput) error { 1967 if v == nil { 1968 return nil 1969 } 1970 invalidParams := smithy.InvalidParamsError{Context: "DescribeDatasetInput"} 1971 if v.DatasetName == nil { 1972 invalidParams.Add(smithy.NewErrParamRequired("DatasetName")) 1973 } 1974 if invalidParams.Len() > 0 { 1975 return invalidParams 1976 } else { 1977 return nil 1978 } 1979} 1980 1981func validateOpDescribeDatastoreInput(v *DescribeDatastoreInput) error { 1982 if v == nil { 1983 return nil 1984 } 1985 invalidParams := smithy.InvalidParamsError{Context: "DescribeDatastoreInput"} 1986 if v.DatastoreName == nil { 1987 invalidParams.Add(smithy.NewErrParamRequired("DatastoreName")) 1988 } 1989 if invalidParams.Len() > 0 { 1990 return invalidParams 1991 } else { 1992 return nil 1993 } 1994} 1995 1996func validateOpDescribePipelineInput(v *DescribePipelineInput) error { 1997 if v == nil { 1998 return nil 1999 } 2000 invalidParams := smithy.InvalidParamsError{Context: "DescribePipelineInput"} 2001 if v.PipelineName == nil { 2002 invalidParams.Add(smithy.NewErrParamRequired("PipelineName")) 2003 } 2004 if invalidParams.Len() > 0 { 2005 return invalidParams 2006 } else { 2007 return nil 2008 } 2009} 2010 2011func validateOpGetDatasetContentInput(v *GetDatasetContentInput) error { 2012 if v == nil { 2013 return nil 2014 } 2015 invalidParams := smithy.InvalidParamsError{Context: "GetDatasetContentInput"} 2016 if v.DatasetName == nil { 2017 invalidParams.Add(smithy.NewErrParamRequired("DatasetName")) 2018 } 2019 if invalidParams.Len() > 0 { 2020 return invalidParams 2021 } else { 2022 return nil 2023 } 2024} 2025 2026func validateOpListDatasetContentsInput(v *ListDatasetContentsInput) error { 2027 if v == nil { 2028 return nil 2029 } 2030 invalidParams := smithy.InvalidParamsError{Context: "ListDatasetContentsInput"} 2031 if v.DatasetName == nil { 2032 invalidParams.Add(smithy.NewErrParamRequired("DatasetName")) 2033 } 2034 if invalidParams.Len() > 0 { 2035 return invalidParams 2036 } else { 2037 return nil 2038 } 2039} 2040 2041func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 2042 if v == nil { 2043 return nil 2044 } 2045 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 2046 if v.ResourceArn == nil { 2047 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 2048 } 2049 if invalidParams.Len() > 0 { 2050 return invalidParams 2051 } else { 2052 return nil 2053 } 2054} 2055 2056func validateOpPutLoggingOptionsInput(v *PutLoggingOptionsInput) error { 2057 if v == nil { 2058 return nil 2059 } 2060 invalidParams := smithy.InvalidParamsError{Context: "PutLoggingOptionsInput"} 2061 if v.LoggingOptions == nil { 2062 invalidParams.Add(smithy.NewErrParamRequired("LoggingOptions")) 2063 } else if v.LoggingOptions != nil { 2064 if err := validateLoggingOptions(v.LoggingOptions); err != nil { 2065 invalidParams.AddNested("LoggingOptions", err.(smithy.InvalidParamsError)) 2066 } 2067 } 2068 if invalidParams.Len() > 0 { 2069 return invalidParams 2070 } else { 2071 return nil 2072 } 2073} 2074 2075func validateOpRunPipelineActivityInput(v *RunPipelineActivityInput) error { 2076 if v == nil { 2077 return nil 2078 } 2079 invalidParams := smithy.InvalidParamsError{Context: "RunPipelineActivityInput"} 2080 if v.PipelineActivity == nil { 2081 invalidParams.Add(smithy.NewErrParamRequired("PipelineActivity")) 2082 } else if v.PipelineActivity != nil { 2083 if err := validatePipelineActivity(v.PipelineActivity); err != nil { 2084 invalidParams.AddNested("PipelineActivity", err.(smithy.InvalidParamsError)) 2085 } 2086 } 2087 if v.Payloads == nil { 2088 invalidParams.Add(smithy.NewErrParamRequired("Payloads")) 2089 } 2090 if invalidParams.Len() > 0 { 2091 return invalidParams 2092 } else { 2093 return nil 2094 } 2095} 2096 2097func validateOpSampleChannelDataInput(v *SampleChannelDataInput) error { 2098 if v == nil { 2099 return nil 2100 } 2101 invalidParams := smithy.InvalidParamsError{Context: "SampleChannelDataInput"} 2102 if v.ChannelName == nil { 2103 invalidParams.Add(smithy.NewErrParamRequired("ChannelName")) 2104 } 2105 if invalidParams.Len() > 0 { 2106 return invalidParams 2107 } else { 2108 return nil 2109 } 2110} 2111 2112func validateOpStartPipelineReprocessingInput(v *StartPipelineReprocessingInput) error { 2113 if v == nil { 2114 return nil 2115 } 2116 invalidParams := smithy.InvalidParamsError{Context: "StartPipelineReprocessingInput"} 2117 if v.PipelineName == nil { 2118 invalidParams.Add(smithy.NewErrParamRequired("PipelineName")) 2119 } 2120 if invalidParams.Len() > 0 { 2121 return invalidParams 2122 } else { 2123 return nil 2124 } 2125} 2126 2127func validateOpTagResourceInput(v *TagResourceInput) error { 2128 if v == nil { 2129 return nil 2130 } 2131 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 2132 if v.ResourceArn == nil { 2133 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 2134 } 2135 if v.Tags == nil { 2136 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 2137 } else if v.Tags != nil { 2138 if err := validateTagList(v.Tags); err != nil { 2139 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 2140 } 2141 } 2142 if invalidParams.Len() > 0 { 2143 return invalidParams 2144 } else { 2145 return nil 2146 } 2147} 2148 2149func validateOpUntagResourceInput(v *UntagResourceInput) error { 2150 if v == nil { 2151 return nil 2152 } 2153 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 2154 if v.ResourceArn == nil { 2155 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 2156 } 2157 if v.TagKeys == nil { 2158 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 2159 } 2160 if invalidParams.Len() > 0 { 2161 return invalidParams 2162 } else { 2163 return nil 2164 } 2165} 2166 2167func validateOpUpdateChannelInput(v *UpdateChannelInput) error { 2168 if v == nil { 2169 return nil 2170 } 2171 invalidParams := smithy.InvalidParamsError{Context: "UpdateChannelInput"} 2172 if v.ChannelName == nil { 2173 invalidParams.Add(smithy.NewErrParamRequired("ChannelName")) 2174 } 2175 if v.ChannelStorage != nil { 2176 if err := validateChannelStorage(v.ChannelStorage); err != nil { 2177 invalidParams.AddNested("ChannelStorage", err.(smithy.InvalidParamsError)) 2178 } 2179 } 2180 if invalidParams.Len() > 0 { 2181 return invalidParams 2182 } else { 2183 return nil 2184 } 2185} 2186 2187func validateOpUpdateDatasetInput(v *UpdateDatasetInput) error { 2188 if v == nil { 2189 return nil 2190 } 2191 invalidParams := smithy.InvalidParamsError{Context: "UpdateDatasetInput"} 2192 if v.DatasetName == nil { 2193 invalidParams.Add(smithy.NewErrParamRequired("DatasetName")) 2194 } 2195 if v.Actions == nil { 2196 invalidParams.Add(smithy.NewErrParamRequired("Actions")) 2197 } else if v.Actions != nil { 2198 if err := validateDatasetActions(v.Actions); err != nil { 2199 invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError)) 2200 } 2201 } 2202 if v.Triggers != nil { 2203 if err := validateDatasetTriggers(v.Triggers); err != nil { 2204 invalidParams.AddNested("Triggers", err.(smithy.InvalidParamsError)) 2205 } 2206 } 2207 if v.ContentDeliveryRules != nil { 2208 if err := validateDatasetContentDeliveryRules(v.ContentDeliveryRules); err != nil { 2209 invalidParams.AddNested("ContentDeliveryRules", err.(smithy.InvalidParamsError)) 2210 } 2211 } 2212 if v.LateDataRules != nil { 2213 if err := validateLateDataRules(v.LateDataRules); err != nil { 2214 invalidParams.AddNested("LateDataRules", err.(smithy.InvalidParamsError)) 2215 } 2216 } 2217 if invalidParams.Len() > 0 { 2218 return invalidParams 2219 } else { 2220 return nil 2221 } 2222} 2223 2224func validateOpUpdateDatastoreInput(v *UpdateDatastoreInput) error { 2225 if v == nil { 2226 return nil 2227 } 2228 invalidParams := smithy.InvalidParamsError{Context: "UpdateDatastoreInput"} 2229 if v.DatastoreName == nil { 2230 invalidParams.Add(smithy.NewErrParamRequired("DatastoreName")) 2231 } 2232 if v.DatastoreStorage != nil { 2233 if err := validateDatastoreStorage(v.DatastoreStorage); err != nil { 2234 invalidParams.AddNested("DatastoreStorage", err.(smithy.InvalidParamsError)) 2235 } 2236 } 2237 if v.FileFormatConfiguration != nil { 2238 if err := validateFileFormatConfiguration(v.FileFormatConfiguration); err != nil { 2239 invalidParams.AddNested("FileFormatConfiguration", err.(smithy.InvalidParamsError)) 2240 } 2241 } 2242 if invalidParams.Len() > 0 { 2243 return invalidParams 2244 } else { 2245 return nil 2246 } 2247} 2248 2249func validateOpUpdatePipelineInput(v *UpdatePipelineInput) error { 2250 if v == nil { 2251 return nil 2252 } 2253 invalidParams := smithy.InvalidParamsError{Context: "UpdatePipelineInput"} 2254 if v.PipelineName == nil { 2255 invalidParams.Add(smithy.NewErrParamRequired("PipelineName")) 2256 } 2257 if v.PipelineActivities == nil { 2258 invalidParams.Add(smithy.NewErrParamRequired("PipelineActivities")) 2259 } else if v.PipelineActivities != nil { 2260 if err := validatePipelineActivities(v.PipelineActivities); err != nil { 2261 invalidParams.AddNested("PipelineActivities", err.(smithy.InvalidParamsError)) 2262 } 2263 } 2264 if invalidParams.Len() > 0 { 2265 return invalidParams 2266 } else { 2267 return nil 2268 } 2269} 2270