1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package kinesisanalytics 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/kinesisanalytics/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpAddApplicationCloudWatchLoggingOption struct { 14} 15 16func (*validateOpAddApplicationCloudWatchLoggingOption) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpAddApplicationCloudWatchLoggingOption) 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.(*AddApplicationCloudWatchLoggingOptionInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpAddApplicationCloudWatchLoggingOptionInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpAddApplicationInput struct { 34} 35 36func (*validateOpAddApplicationInput) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpAddApplicationInput) 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.(*AddApplicationInputInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpAddApplicationInputInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpAddApplicationInputProcessingConfiguration struct { 54} 55 56func (*validateOpAddApplicationInputProcessingConfiguration) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpAddApplicationInputProcessingConfiguration) 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.(*AddApplicationInputProcessingConfigurationInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpAddApplicationInputProcessingConfigurationInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpAddApplicationOutput struct { 74} 75 76func (*validateOpAddApplicationOutput) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpAddApplicationOutput) 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.(*AddApplicationOutputInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpAddApplicationOutputInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpAddApplicationReferenceDataSource struct { 94} 95 96func (*validateOpAddApplicationReferenceDataSource) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpAddApplicationReferenceDataSource) 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.(*AddApplicationReferenceDataSourceInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpAddApplicationReferenceDataSourceInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpCreateApplication struct { 114} 115 116func (*validateOpCreateApplication) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpCreateApplication) 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.(*CreateApplicationInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpCreateApplicationInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpDeleteApplicationCloudWatchLoggingOption struct { 134} 135 136func (*validateOpDeleteApplicationCloudWatchLoggingOption) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpDeleteApplicationCloudWatchLoggingOption) 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.(*DeleteApplicationCloudWatchLoggingOptionInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpDeleteApplicationCloudWatchLoggingOptionInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpDeleteApplication struct { 154} 155 156func (*validateOpDeleteApplication) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpDeleteApplication) 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.(*DeleteApplicationInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpDeleteApplicationInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpDeleteApplicationInputProcessingConfiguration struct { 174} 175 176func (*validateOpDeleteApplicationInputProcessingConfiguration) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpDeleteApplicationInputProcessingConfiguration) 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.(*DeleteApplicationInputProcessingConfigurationInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpDeleteApplicationInputProcessingConfigurationInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpDeleteApplicationOutput struct { 194} 195 196func (*validateOpDeleteApplicationOutput) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpDeleteApplicationOutput) 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.(*DeleteApplicationOutputInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpDeleteApplicationOutputInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpDeleteApplicationReferenceDataSource struct { 214} 215 216func (*validateOpDeleteApplicationReferenceDataSource) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpDeleteApplicationReferenceDataSource) 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.(*DeleteApplicationReferenceDataSourceInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpDeleteApplicationReferenceDataSourceInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpDescribeApplication struct { 234} 235 236func (*validateOpDescribeApplication) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpDescribeApplication) 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.(*DescribeApplicationInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpDescribeApplicationInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpDiscoverInputSchema struct { 254} 255 256func (*validateOpDiscoverInputSchema) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpDiscoverInputSchema) 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.(*DiscoverInputSchemaInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpDiscoverInputSchemaInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpListTagsForResource struct { 274} 275 276func (*validateOpListTagsForResource) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpListTagsForResourceInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpStartApplication struct { 294} 295 296func (*validateOpStartApplication) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpStartApplication) 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.(*StartApplicationInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpStartApplicationInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpStopApplication struct { 314} 315 316func (*validateOpStopApplication) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpStopApplication) 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.(*StopApplicationInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpStopApplicationInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpTagResource struct { 334} 335 336func (*validateOpTagResource) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpTagResource) 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.(*TagResourceInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpTagResourceInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpUntagResource struct { 354} 355 356func (*validateOpUntagResource) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpUntagResource) 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.(*UntagResourceInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpUntagResourceInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpUpdateApplication struct { 374} 375 376func (*validateOpUpdateApplication) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpUpdateApplication) 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.(*UpdateApplicationInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpUpdateApplicationInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393func addOpAddApplicationCloudWatchLoggingOptionValidationMiddleware(stack *middleware.Stack) error { 394 return stack.Initialize.Add(&validateOpAddApplicationCloudWatchLoggingOption{}, middleware.After) 395} 396 397func addOpAddApplicationInputValidationMiddleware(stack *middleware.Stack) error { 398 return stack.Initialize.Add(&validateOpAddApplicationInput{}, middleware.After) 399} 400 401func addOpAddApplicationInputProcessingConfigurationValidationMiddleware(stack *middleware.Stack) error { 402 return stack.Initialize.Add(&validateOpAddApplicationInputProcessingConfiguration{}, middleware.After) 403} 404 405func addOpAddApplicationOutputValidationMiddleware(stack *middleware.Stack) error { 406 return stack.Initialize.Add(&validateOpAddApplicationOutput{}, middleware.After) 407} 408 409func addOpAddApplicationReferenceDataSourceValidationMiddleware(stack *middleware.Stack) error { 410 return stack.Initialize.Add(&validateOpAddApplicationReferenceDataSource{}, middleware.After) 411} 412 413func addOpCreateApplicationValidationMiddleware(stack *middleware.Stack) error { 414 return stack.Initialize.Add(&validateOpCreateApplication{}, middleware.After) 415} 416 417func addOpDeleteApplicationCloudWatchLoggingOptionValidationMiddleware(stack *middleware.Stack) error { 418 return stack.Initialize.Add(&validateOpDeleteApplicationCloudWatchLoggingOption{}, middleware.After) 419} 420 421func addOpDeleteApplicationValidationMiddleware(stack *middleware.Stack) error { 422 return stack.Initialize.Add(&validateOpDeleteApplication{}, middleware.After) 423} 424 425func addOpDeleteApplicationInputProcessingConfigurationValidationMiddleware(stack *middleware.Stack) error { 426 return stack.Initialize.Add(&validateOpDeleteApplicationInputProcessingConfiguration{}, middleware.After) 427} 428 429func addOpDeleteApplicationOutputValidationMiddleware(stack *middleware.Stack) error { 430 return stack.Initialize.Add(&validateOpDeleteApplicationOutput{}, middleware.After) 431} 432 433func addOpDeleteApplicationReferenceDataSourceValidationMiddleware(stack *middleware.Stack) error { 434 return stack.Initialize.Add(&validateOpDeleteApplicationReferenceDataSource{}, middleware.After) 435} 436 437func addOpDescribeApplicationValidationMiddleware(stack *middleware.Stack) error { 438 return stack.Initialize.Add(&validateOpDescribeApplication{}, middleware.After) 439} 440 441func addOpDiscoverInputSchemaValidationMiddleware(stack *middleware.Stack) error { 442 return stack.Initialize.Add(&validateOpDiscoverInputSchema{}, middleware.After) 443} 444 445func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 446 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 447} 448 449func addOpStartApplicationValidationMiddleware(stack *middleware.Stack) error { 450 return stack.Initialize.Add(&validateOpStartApplication{}, middleware.After) 451} 452 453func addOpStopApplicationValidationMiddleware(stack *middleware.Stack) error { 454 return stack.Initialize.Add(&validateOpStopApplication{}, middleware.After) 455} 456 457func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 458 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 459} 460 461func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 462 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 463} 464 465func addOpUpdateApplicationValidationMiddleware(stack *middleware.Stack) error { 466 return stack.Initialize.Add(&validateOpUpdateApplication{}, middleware.After) 467} 468 469func validateApplicationUpdate(v *types.ApplicationUpdate) error { 470 if v == nil { 471 return nil 472 } 473 invalidParams := smithy.InvalidParamsError{Context: "ApplicationUpdate"} 474 if v.InputUpdates != nil { 475 if err := validateInputUpdates(v.InputUpdates); err != nil { 476 invalidParams.AddNested("InputUpdates", err.(smithy.InvalidParamsError)) 477 } 478 } 479 if v.OutputUpdates != nil { 480 if err := validateOutputUpdates(v.OutputUpdates); err != nil { 481 invalidParams.AddNested("OutputUpdates", err.(smithy.InvalidParamsError)) 482 } 483 } 484 if v.ReferenceDataSourceUpdates != nil { 485 if err := validateReferenceDataSourceUpdates(v.ReferenceDataSourceUpdates); err != nil { 486 invalidParams.AddNested("ReferenceDataSourceUpdates", err.(smithy.InvalidParamsError)) 487 } 488 } 489 if v.CloudWatchLoggingOptionUpdates != nil { 490 if err := validateCloudWatchLoggingOptionUpdates(v.CloudWatchLoggingOptionUpdates); err != nil { 491 invalidParams.AddNested("CloudWatchLoggingOptionUpdates", err.(smithy.InvalidParamsError)) 492 } 493 } 494 if invalidParams.Len() > 0 { 495 return invalidParams 496 } else { 497 return nil 498 } 499} 500 501func validateCloudWatchLoggingOption(v *types.CloudWatchLoggingOption) error { 502 if v == nil { 503 return nil 504 } 505 invalidParams := smithy.InvalidParamsError{Context: "CloudWatchLoggingOption"} 506 if v.LogStreamARN == nil { 507 invalidParams.Add(smithy.NewErrParamRequired("LogStreamARN")) 508 } 509 if v.RoleARN == nil { 510 invalidParams.Add(smithy.NewErrParamRequired("RoleARN")) 511 } 512 if invalidParams.Len() > 0 { 513 return invalidParams 514 } else { 515 return nil 516 } 517} 518 519func validateCloudWatchLoggingOptions(v []types.CloudWatchLoggingOption) error { 520 if v == nil { 521 return nil 522 } 523 invalidParams := smithy.InvalidParamsError{Context: "CloudWatchLoggingOptions"} 524 for i := range v { 525 if err := validateCloudWatchLoggingOption(&v[i]); err != nil { 526 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 527 } 528 } 529 if invalidParams.Len() > 0 { 530 return invalidParams 531 } else { 532 return nil 533 } 534} 535 536func validateCloudWatchLoggingOptionUpdate(v *types.CloudWatchLoggingOptionUpdate) error { 537 if v == nil { 538 return nil 539 } 540 invalidParams := smithy.InvalidParamsError{Context: "CloudWatchLoggingOptionUpdate"} 541 if v.CloudWatchLoggingOptionId == nil { 542 invalidParams.Add(smithy.NewErrParamRequired("CloudWatchLoggingOptionId")) 543 } 544 if invalidParams.Len() > 0 { 545 return invalidParams 546 } else { 547 return nil 548 } 549} 550 551func validateCloudWatchLoggingOptionUpdates(v []types.CloudWatchLoggingOptionUpdate) error { 552 if v == nil { 553 return nil 554 } 555 invalidParams := smithy.InvalidParamsError{Context: "CloudWatchLoggingOptionUpdates"} 556 for i := range v { 557 if err := validateCloudWatchLoggingOptionUpdate(&v[i]); err != nil { 558 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 559 } 560 } 561 if invalidParams.Len() > 0 { 562 return invalidParams 563 } else { 564 return nil 565 } 566} 567 568func validateCSVMappingParameters(v *types.CSVMappingParameters) error { 569 if v == nil { 570 return nil 571 } 572 invalidParams := smithy.InvalidParamsError{Context: "CSVMappingParameters"} 573 if v.RecordRowDelimiter == nil { 574 invalidParams.Add(smithy.NewErrParamRequired("RecordRowDelimiter")) 575 } 576 if v.RecordColumnDelimiter == nil { 577 invalidParams.Add(smithy.NewErrParamRequired("RecordColumnDelimiter")) 578 } 579 if invalidParams.Len() > 0 { 580 return invalidParams 581 } else { 582 return nil 583 } 584} 585 586func validateDestinationSchema(v *types.DestinationSchema) error { 587 if v == nil { 588 return nil 589 } 590 invalidParams := smithy.InvalidParamsError{Context: "DestinationSchema"} 591 if len(v.RecordFormatType) == 0 { 592 invalidParams.Add(smithy.NewErrParamRequired("RecordFormatType")) 593 } 594 if invalidParams.Len() > 0 { 595 return invalidParams 596 } else { 597 return nil 598 } 599} 600 601func validateInput(v *types.Input) error { 602 if v == nil { 603 return nil 604 } 605 invalidParams := smithy.InvalidParamsError{Context: "Input"} 606 if v.NamePrefix == nil { 607 invalidParams.Add(smithy.NewErrParamRequired("NamePrefix")) 608 } 609 if v.InputProcessingConfiguration != nil { 610 if err := validateInputProcessingConfiguration(v.InputProcessingConfiguration); err != nil { 611 invalidParams.AddNested("InputProcessingConfiguration", err.(smithy.InvalidParamsError)) 612 } 613 } 614 if v.KinesisStreamsInput != nil { 615 if err := validateKinesisStreamsInput(v.KinesisStreamsInput); err != nil { 616 invalidParams.AddNested("KinesisStreamsInput", err.(smithy.InvalidParamsError)) 617 } 618 } 619 if v.KinesisFirehoseInput != nil { 620 if err := validateKinesisFirehoseInput(v.KinesisFirehoseInput); err != nil { 621 invalidParams.AddNested("KinesisFirehoseInput", err.(smithy.InvalidParamsError)) 622 } 623 } 624 if v.InputSchema == nil { 625 invalidParams.Add(smithy.NewErrParamRequired("InputSchema")) 626 } else if v.InputSchema != nil { 627 if err := validateSourceSchema(v.InputSchema); err != nil { 628 invalidParams.AddNested("InputSchema", err.(smithy.InvalidParamsError)) 629 } 630 } 631 if invalidParams.Len() > 0 { 632 return invalidParams 633 } else { 634 return nil 635 } 636} 637 638func validateInputConfiguration(v *types.InputConfiguration) error { 639 if v == nil { 640 return nil 641 } 642 invalidParams := smithy.InvalidParamsError{Context: "InputConfiguration"} 643 if v.Id == nil { 644 invalidParams.Add(smithy.NewErrParamRequired("Id")) 645 } 646 if v.InputStartingPositionConfiguration == nil { 647 invalidParams.Add(smithy.NewErrParamRequired("InputStartingPositionConfiguration")) 648 } 649 if invalidParams.Len() > 0 { 650 return invalidParams 651 } else { 652 return nil 653 } 654} 655 656func validateInputConfigurations(v []types.InputConfiguration) error { 657 if v == nil { 658 return nil 659 } 660 invalidParams := smithy.InvalidParamsError{Context: "InputConfigurations"} 661 for i := range v { 662 if err := validateInputConfiguration(&v[i]); err != nil { 663 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 664 } 665 } 666 if invalidParams.Len() > 0 { 667 return invalidParams 668 } else { 669 return nil 670 } 671} 672 673func validateInputLambdaProcessor(v *types.InputLambdaProcessor) error { 674 if v == nil { 675 return nil 676 } 677 invalidParams := smithy.InvalidParamsError{Context: "InputLambdaProcessor"} 678 if v.ResourceARN == nil { 679 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 680 } 681 if v.RoleARN == nil { 682 invalidParams.Add(smithy.NewErrParamRequired("RoleARN")) 683 } 684 if invalidParams.Len() > 0 { 685 return invalidParams 686 } else { 687 return nil 688 } 689} 690 691func validateInputProcessingConfiguration(v *types.InputProcessingConfiguration) error { 692 if v == nil { 693 return nil 694 } 695 invalidParams := smithy.InvalidParamsError{Context: "InputProcessingConfiguration"} 696 if v.InputLambdaProcessor == nil { 697 invalidParams.Add(smithy.NewErrParamRequired("InputLambdaProcessor")) 698 } else if v.InputLambdaProcessor != nil { 699 if err := validateInputLambdaProcessor(v.InputLambdaProcessor); err != nil { 700 invalidParams.AddNested("InputLambdaProcessor", err.(smithy.InvalidParamsError)) 701 } 702 } 703 if invalidParams.Len() > 0 { 704 return invalidParams 705 } else { 706 return nil 707 } 708} 709 710func validateInputProcessingConfigurationUpdate(v *types.InputProcessingConfigurationUpdate) error { 711 if v == nil { 712 return nil 713 } 714 invalidParams := smithy.InvalidParamsError{Context: "InputProcessingConfigurationUpdate"} 715 if v.InputLambdaProcessorUpdate == nil { 716 invalidParams.Add(smithy.NewErrParamRequired("InputLambdaProcessorUpdate")) 717 } 718 if invalidParams.Len() > 0 { 719 return invalidParams 720 } else { 721 return nil 722 } 723} 724 725func validateInputs(v []types.Input) error { 726 if v == nil { 727 return nil 728 } 729 invalidParams := smithy.InvalidParamsError{Context: "Inputs"} 730 for i := range v { 731 if err := validateInput(&v[i]); err != nil { 732 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 733 } 734 } 735 if invalidParams.Len() > 0 { 736 return invalidParams 737 } else { 738 return nil 739 } 740} 741 742func validateInputSchemaUpdate(v *types.InputSchemaUpdate) error { 743 if v == nil { 744 return nil 745 } 746 invalidParams := smithy.InvalidParamsError{Context: "InputSchemaUpdate"} 747 if v.RecordFormatUpdate != nil { 748 if err := validateRecordFormat(v.RecordFormatUpdate); err != nil { 749 invalidParams.AddNested("RecordFormatUpdate", err.(smithy.InvalidParamsError)) 750 } 751 } 752 if v.RecordColumnUpdates != nil { 753 if err := validateRecordColumns(v.RecordColumnUpdates); err != nil { 754 invalidParams.AddNested("RecordColumnUpdates", err.(smithy.InvalidParamsError)) 755 } 756 } 757 if invalidParams.Len() > 0 { 758 return invalidParams 759 } else { 760 return nil 761 } 762} 763 764func validateInputUpdate(v *types.InputUpdate) error { 765 if v == nil { 766 return nil 767 } 768 invalidParams := smithy.InvalidParamsError{Context: "InputUpdate"} 769 if v.InputId == nil { 770 invalidParams.Add(smithy.NewErrParamRequired("InputId")) 771 } 772 if v.InputProcessingConfigurationUpdate != nil { 773 if err := validateInputProcessingConfigurationUpdate(v.InputProcessingConfigurationUpdate); err != nil { 774 invalidParams.AddNested("InputProcessingConfigurationUpdate", err.(smithy.InvalidParamsError)) 775 } 776 } 777 if v.InputSchemaUpdate != nil { 778 if err := validateInputSchemaUpdate(v.InputSchemaUpdate); err != nil { 779 invalidParams.AddNested("InputSchemaUpdate", err.(smithy.InvalidParamsError)) 780 } 781 } 782 if invalidParams.Len() > 0 { 783 return invalidParams 784 } else { 785 return nil 786 } 787} 788 789func validateInputUpdates(v []types.InputUpdate) error { 790 if v == nil { 791 return nil 792 } 793 invalidParams := smithy.InvalidParamsError{Context: "InputUpdates"} 794 for i := range v { 795 if err := validateInputUpdate(&v[i]); err != nil { 796 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 797 } 798 } 799 if invalidParams.Len() > 0 { 800 return invalidParams 801 } else { 802 return nil 803 } 804} 805 806func validateJSONMappingParameters(v *types.JSONMappingParameters) error { 807 if v == nil { 808 return nil 809 } 810 invalidParams := smithy.InvalidParamsError{Context: "JSONMappingParameters"} 811 if v.RecordRowPath == nil { 812 invalidParams.Add(smithy.NewErrParamRequired("RecordRowPath")) 813 } 814 if invalidParams.Len() > 0 { 815 return invalidParams 816 } else { 817 return nil 818 } 819} 820 821func validateKinesisFirehoseInput(v *types.KinesisFirehoseInput) error { 822 if v == nil { 823 return nil 824 } 825 invalidParams := smithy.InvalidParamsError{Context: "KinesisFirehoseInput"} 826 if v.ResourceARN == nil { 827 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 828 } 829 if v.RoleARN == nil { 830 invalidParams.Add(smithy.NewErrParamRequired("RoleARN")) 831 } 832 if invalidParams.Len() > 0 { 833 return invalidParams 834 } else { 835 return nil 836 } 837} 838 839func validateKinesisFirehoseOutput(v *types.KinesisFirehoseOutput) error { 840 if v == nil { 841 return nil 842 } 843 invalidParams := smithy.InvalidParamsError{Context: "KinesisFirehoseOutput"} 844 if v.ResourceARN == nil { 845 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 846 } 847 if v.RoleARN == nil { 848 invalidParams.Add(smithy.NewErrParamRequired("RoleARN")) 849 } 850 if invalidParams.Len() > 0 { 851 return invalidParams 852 } else { 853 return nil 854 } 855} 856 857func validateKinesisStreamsInput(v *types.KinesisStreamsInput) error { 858 if v == nil { 859 return nil 860 } 861 invalidParams := smithy.InvalidParamsError{Context: "KinesisStreamsInput"} 862 if v.ResourceARN == nil { 863 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 864 } 865 if v.RoleARN == nil { 866 invalidParams.Add(smithy.NewErrParamRequired("RoleARN")) 867 } 868 if invalidParams.Len() > 0 { 869 return invalidParams 870 } else { 871 return nil 872 } 873} 874 875func validateKinesisStreamsOutput(v *types.KinesisStreamsOutput) error { 876 if v == nil { 877 return nil 878 } 879 invalidParams := smithy.InvalidParamsError{Context: "KinesisStreamsOutput"} 880 if v.ResourceARN == nil { 881 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 882 } 883 if v.RoleARN == nil { 884 invalidParams.Add(smithy.NewErrParamRequired("RoleARN")) 885 } 886 if invalidParams.Len() > 0 { 887 return invalidParams 888 } else { 889 return nil 890 } 891} 892 893func validateLambdaOutput(v *types.LambdaOutput) error { 894 if v == nil { 895 return nil 896 } 897 invalidParams := smithy.InvalidParamsError{Context: "LambdaOutput"} 898 if v.ResourceARN == nil { 899 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 900 } 901 if v.RoleARN == nil { 902 invalidParams.Add(smithy.NewErrParamRequired("RoleARN")) 903 } 904 if invalidParams.Len() > 0 { 905 return invalidParams 906 } else { 907 return nil 908 } 909} 910 911func validateMappingParameters(v *types.MappingParameters) error { 912 if v == nil { 913 return nil 914 } 915 invalidParams := smithy.InvalidParamsError{Context: "MappingParameters"} 916 if v.JSONMappingParameters != nil { 917 if err := validateJSONMappingParameters(v.JSONMappingParameters); err != nil { 918 invalidParams.AddNested("JSONMappingParameters", err.(smithy.InvalidParamsError)) 919 } 920 } 921 if v.CSVMappingParameters != nil { 922 if err := validateCSVMappingParameters(v.CSVMappingParameters); err != nil { 923 invalidParams.AddNested("CSVMappingParameters", err.(smithy.InvalidParamsError)) 924 } 925 } 926 if invalidParams.Len() > 0 { 927 return invalidParams 928 } else { 929 return nil 930 } 931} 932 933func validateOutput(v *types.Output) error { 934 if v == nil { 935 return nil 936 } 937 invalidParams := smithy.InvalidParamsError{Context: "Output"} 938 if v.Name == nil { 939 invalidParams.Add(smithy.NewErrParamRequired("Name")) 940 } 941 if v.KinesisStreamsOutput != nil { 942 if err := validateKinesisStreamsOutput(v.KinesisStreamsOutput); err != nil { 943 invalidParams.AddNested("KinesisStreamsOutput", err.(smithy.InvalidParamsError)) 944 } 945 } 946 if v.KinesisFirehoseOutput != nil { 947 if err := validateKinesisFirehoseOutput(v.KinesisFirehoseOutput); err != nil { 948 invalidParams.AddNested("KinesisFirehoseOutput", err.(smithy.InvalidParamsError)) 949 } 950 } 951 if v.LambdaOutput != nil { 952 if err := validateLambdaOutput(v.LambdaOutput); err != nil { 953 invalidParams.AddNested("LambdaOutput", err.(smithy.InvalidParamsError)) 954 } 955 } 956 if v.DestinationSchema == nil { 957 invalidParams.Add(smithy.NewErrParamRequired("DestinationSchema")) 958 } else if v.DestinationSchema != nil { 959 if err := validateDestinationSchema(v.DestinationSchema); err != nil { 960 invalidParams.AddNested("DestinationSchema", err.(smithy.InvalidParamsError)) 961 } 962 } 963 if invalidParams.Len() > 0 { 964 return invalidParams 965 } else { 966 return nil 967 } 968} 969 970func validateOutputs(v []types.Output) error { 971 if v == nil { 972 return nil 973 } 974 invalidParams := smithy.InvalidParamsError{Context: "Outputs"} 975 for i := range v { 976 if err := validateOutput(&v[i]); err != nil { 977 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 978 } 979 } 980 if invalidParams.Len() > 0 { 981 return invalidParams 982 } else { 983 return nil 984 } 985} 986 987func validateOutputUpdate(v *types.OutputUpdate) error { 988 if v == nil { 989 return nil 990 } 991 invalidParams := smithy.InvalidParamsError{Context: "OutputUpdate"} 992 if v.OutputId == nil { 993 invalidParams.Add(smithy.NewErrParamRequired("OutputId")) 994 } 995 if v.DestinationSchemaUpdate != nil { 996 if err := validateDestinationSchema(v.DestinationSchemaUpdate); err != nil { 997 invalidParams.AddNested("DestinationSchemaUpdate", err.(smithy.InvalidParamsError)) 998 } 999 } 1000 if invalidParams.Len() > 0 { 1001 return invalidParams 1002 } else { 1003 return nil 1004 } 1005} 1006 1007func validateOutputUpdates(v []types.OutputUpdate) error { 1008 if v == nil { 1009 return nil 1010 } 1011 invalidParams := smithy.InvalidParamsError{Context: "OutputUpdates"} 1012 for i := range v { 1013 if err := validateOutputUpdate(&v[i]); err != nil { 1014 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1015 } 1016 } 1017 if invalidParams.Len() > 0 { 1018 return invalidParams 1019 } else { 1020 return nil 1021 } 1022} 1023 1024func validateRecordColumn(v *types.RecordColumn) error { 1025 if v == nil { 1026 return nil 1027 } 1028 invalidParams := smithy.InvalidParamsError{Context: "RecordColumn"} 1029 if v.Name == nil { 1030 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1031 } 1032 if v.SqlType == nil { 1033 invalidParams.Add(smithy.NewErrParamRequired("SqlType")) 1034 } 1035 if invalidParams.Len() > 0 { 1036 return invalidParams 1037 } else { 1038 return nil 1039 } 1040} 1041 1042func validateRecordColumns(v []types.RecordColumn) error { 1043 if v == nil { 1044 return nil 1045 } 1046 invalidParams := smithy.InvalidParamsError{Context: "RecordColumns"} 1047 for i := range v { 1048 if err := validateRecordColumn(&v[i]); err != nil { 1049 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1050 } 1051 } 1052 if invalidParams.Len() > 0 { 1053 return invalidParams 1054 } else { 1055 return nil 1056 } 1057} 1058 1059func validateRecordFormat(v *types.RecordFormat) error { 1060 if v == nil { 1061 return nil 1062 } 1063 invalidParams := smithy.InvalidParamsError{Context: "RecordFormat"} 1064 if len(v.RecordFormatType) == 0 { 1065 invalidParams.Add(smithy.NewErrParamRequired("RecordFormatType")) 1066 } 1067 if v.MappingParameters != nil { 1068 if err := validateMappingParameters(v.MappingParameters); err != nil { 1069 invalidParams.AddNested("MappingParameters", err.(smithy.InvalidParamsError)) 1070 } 1071 } 1072 if invalidParams.Len() > 0 { 1073 return invalidParams 1074 } else { 1075 return nil 1076 } 1077} 1078 1079func validateReferenceDataSource(v *types.ReferenceDataSource) error { 1080 if v == nil { 1081 return nil 1082 } 1083 invalidParams := smithy.InvalidParamsError{Context: "ReferenceDataSource"} 1084 if v.TableName == nil { 1085 invalidParams.Add(smithy.NewErrParamRequired("TableName")) 1086 } 1087 if v.S3ReferenceDataSource != nil { 1088 if err := validateS3ReferenceDataSource(v.S3ReferenceDataSource); err != nil { 1089 invalidParams.AddNested("S3ReferenceDataSource", err.(smithy.InvalidParamsError)) 1090 } 1091 } 1092 if v.ReferenceSchema == nil { 1093 invalidParams.Add(smithy.NewErrParamRequired("ReferenceSchema")) 1094 } else if v.ReferenceSchema != nil { 1095 if err := validateSourceSchema(v.ReferenceSchema); err != nil { 1096 invalidParams.AddNested("ReferenceSchema", err.(smithy.InvalidParamsError)) 1097 } 1098 } 1099 if invalidParams.Len() > 0 { 1100 return invalidParams 1101 } else { 1102 return nil 1103 } 1104} 1105 1106func validateReferenceDataSourceUpdate(v *types.ReferenceDataSourceUpdate) error { 1107 if v == nil { 1108 return nil 1109 } 1110 invalidParams := smithy.InvalidParamsError{Context: "ReferenceDataSourceUpdate"} 1111 if v.ReferenceId == nil { 1112 invalidParams.Add(smithy.NewErrParamRequired("ReferenceId")) 1113 } 1114 if v.ReferenceSchemaUpdate != nil { 1115 if err := validateSourceSchema(v.ReferenceSchemaUpdate); err != nil { 1116 invalidParams.AddNested("ReferenceSchemaUpdate", err.(smithy.InvalidParamsError)) 1117 } 1118 } 1119 if invalidParams.Len() > 0 { 1120 return invalidParams 1121 } else { 1122 return nil 1123 } 1124} 1125 1126func validateReferenceDataSourceUpdates(v []types.ReferenceDataSourceUpdate) error { 1127 if v == nil { 1128 return nil 1129 } 1130 invalidParams := smithy.InvalidParamsError{Context: "ReferenceDataSourceUpdates"} 1131 for i := range v { 1132 if err := validateReferenceDataSourceUpdate(&v[i]); err != nil { 1133 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1134 } 1135 } 1136 if invalidParams.Len() > 0 { 1137 return invalidParams 1138 } else { 1139 return nil 1140 } 1141} 1142 1143func validateS3Configuration(v *types.S3Configuration) error { 1144 if v == nil { 1145 return nil 1146 } 1147 invalidParams := smithy.InvalidParamsError{Context: "S3Configuration"} 1148 if v.RoleARN == nil { 1149 invalidParams.Add(smithy.NewErrParamRequired("RoleARN")) 1150 } 1151 if v.BucketARN == nil { 1152 invalidParams.Add(smithy.NewErrParamRequired("BucketARN")) 1153 } 1154 if v.FileKey == nil { 1155 invalidParams.Add(smithy.NewErrParamRequired("FileKey")) 1156 } 1157 if invalidParams.Len() > 0 { 1158 return invalidParams 1159 } else { 1160 return nil 1161 } 1162} 1163 1164func validateS3ReferenceDataSource(v *types.S3ReferenceDataSource) error { 1165 if v == nil { 1166 return nil 1167 } 1168 invalidParams := smithy.InvalidParamsError{Context: "S3ReferenceDataSource"} 1169 if v.BucketARN == nil { 1170 invalidParams.Add(smithy.NewErrParamRequired("BucketARN")) 1171 } 1172 if v.FileKey == nil { 1173 invalidParams.Add(smithy.NewErrParamRequired("FileKey")) 1174 } 1175 if v.ReferenceRoleARN == nil { 1176 invalidParams.Add(smithy.NewErrParamRequired("ReferenceRoleARN")) 1177 } 1178 if invalidParams.Len() > 0 { 1179 return invalidParams 1180 } else { 1181 return nil 1182 } 1183} 1184 1185func validateSourceSchema(v *types.SourceSchema) error { 1186 if v == nil { 1187 return nil 1188 } 1189 invalidParams := smithy.InvalidParamsError{Context: "SourceSchema"} 1190 if v.RecordFormat == nil { 1191 invalidParams.Add(smithy.NewErrParamRequired("RecordFormat")) 1192 } else if v.RecordFormat != nil { 1193 if err := validateRecordFormat(v.RecordFormat); err != nil { 1194 invalidParams.AddNested("RecordFormat", err.(smithy.InvalidParamsError)) 1195 } 1196 } 1197 if v.RecordColumns == nil { 1198 invalidParams.Add(smithy.NewErrParamRequired("RecordColumns")) 1199 } else if v.RecordColumns != nil { 1200 if err := validateRecordColumns(v.RecordColumns); err != nil { 1201 invalidParams.AddNested("RecordColumns", err.(smithy.InvalidParamsError)) 1202 } 1203 } 1204 if invalidParams.Len() > 0 { 1205 return invalidParams 1206 } else { 1207 return nil 1208 } 1209} 1210 1211func validateTag(v *types.Tag) error { 1212 if v == nil { 1213 return nil 1214 } 1215 invalidParams := smithy.InvalidParamsError{Context: "Tag"} 1216 if v.Key == nil { 1217 invalidParams.Add(smithy.NewErrParamRequired("Key")) 1218 } 1219 if invalidParams.Len() > 0 { 1220 return invalidParams 1221 } else { 1222 return nil 1223 } 1224} 1225 1226func validateTags(v []types.Tag) error { 1227 if v == nil { 1228 return nil 1229 } 1230 invalidParams := smithy.InvalidParamsError{Context: "Tags"} 1231 for i := range v { 1232 if err := validateTag(&v[i]); err != nil { 1233 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1234 } 1235 } 1236 if invalidParams.Len() > 0 { 1237 return invalidParams 1238 } else { 1239 return nil 1240 } 1241} 1242 1243func validateOpAddApplicationCloudWatchLoggingOptionInput(v *AddApplicationCloudWatchLoggingOptionInput) error { 1244 if v == nil { 1245 return nil 1246 } 1247 invalidParams := smithy.InvalidParamsError{Context: "AddApplicationCloudWatchLoggingOptionInput"} 1248 if v.ApplicationName == nil { 1249 invalidParams.Add(smithy.NewErrParamRequired("ApplicationName")) 1250 } 1251 if v.CurrentApplicationVersionId == nil { 1252 invalidParams.Add(smithy.NewErrParamRequired("CurrentApplicationVersionId")) 1253 } 1254 if v.CloudWatchLoggingOption == nil { 1255 invalidParams.Add(smithy.NewErrParamRequired("CloudWatchLoggingOption")) 1256 } else if v.CloudWatchLoggingOption != nil { 1257 if err := validateCloudWatchLoggingOption(v.CloudWatchLoggingOption); err != nil { 1258 invalidParams.AddNested("CloudWatchLoggingOption", err.(smithy.InvalidParamsError)) 1259 } 1260 } 1261 if invalidParams.Len() > 0 { 1262 return invalidParams 1263 } else { 1264 return nil 1265 } 1266} 1267 1268func validateOpAddApplicationInputInput(v *AddApplicationInputInput) error { 1269 if v == nil { 1270 return nil 1271 } 1272 invalidParams := smithy.InvalidParamsError{Context: "AddApplicationInputInput"} 1273 if v.ApplicationName == nil { 1274 invalidParams.Add(smithy.NewErrParamRequired("ApplicationName")) 1275 } 1276 if v.CurrentApplicationVersionId == nil { 1277 invalidParams.Add(smithy.NewErrParamRequired("CurrentApplicationVersionId")) 1278 } 1279 if v.Input == nil { 1280 invalidParams.Add(smithy.NewErrParamRequired("Input")) 1281 } else if v.Input != nil { 1282 if err := validateInput(v.Input); err != nil { 1283 invalidParams.AddNested("Input", err.(smithy.InvalidParamsError)) 1284 } 1285 } 1286 if invalidParams.Len() > 0 { 1287 return invalidParams 1288 } else { 1289 return nil 1290 } 1291} 1292 1293func validateOpAddApplicationInputProcessingConfigurationInput(v *AddApplicationInputProcessingConfigurationInput) error { 1294 if v == nil { 1295 return nil 1296 } 1297 invalidParams := smithy.InvalidParamsError{Context: "AddApplicationInputProcessingConfigurationInput"} 1298 if v.ApplicationName == nil { 1299 invalidParams.Add(smithy.NewErrParamRequired("ApplicationName")) 1300 } 1301 if v.CurrentApplicationVersionId == nil { 1302 invalidParams.Add(smithy.NewErrParamRequired("CurrentApplicationVersionId")) 1303 } 1304 if v.InputId == nil { 1305 invalidParams.Add(smithy.NewErrParamRequired("InputId")) 1306 } 1307 if v.InputProcessingConfiguration == nil { 1308 invalidParams.Add(smithy.NewErrParamRequired("InputProcessingConfiguration")) 1309 } else if v.InputProcessingConfiguration != nil { 1310 if err := validateInputProcessingConfiguration(v.InputProcessingConfiguration); err != nil { 1311 invalidParams.AddNested("InputProcessingConfiguration", err.(smithy.InvalidParamsError)) 1312 } 1313 } 1314 if invalidParams.Len() > 0 { 1315 return invalidParams 1316 } else { 1317 return nil 1318 } 1319} 1320 1321func validateOpAddApplicationOutputInput(v *AddApplicationOutputInput) error { 1322 if v == nil { 1323 return nil 1324 } 1325 invalidParams := smithy.InvalidParamsError{Context: "AddApplicationOutputInput"} 1326 if v.ApplicationName == nil { 1327 invalidParams.Add(smithy.NewErrParamRequired("ApplicationName")) 1328 } 1329 if v.CurrentApplicationVersionId == nil { 1330 invalidParams.Add(smithy.NewErrParamRequired("CurrentApplicationVersionId")) 1331 } 1332 if v.Output == nil { 1333 invalidParams.Add(smithy.NewErrParamRequired("Output")) 1334 } else if v.Output != nil { 1335 if err := validateOutput(v.Output); err != nil { 1336 invalidParams.AddNested("Output", err.(smithy.InvalidParamsError)) 1337 } 1338 } 1339 if invalidParams.Len() > 0 { 1340 return invalidParams 1341 } else { 1342 return nil 1343 } 1344} 1345 1346func validateOpAddApplicationReferenceDataSourceInput(v *AddApplicationReferenceDataSourceInput) error { 1347 if v == nil { 1348 return nil 1349 } 1350 invalidParams := smithy.InvalidParamsError{Context: "AddApplicationReferenceDataSourceInput"} 1351 if v.ApplicationName == nil { 1352 invalidParams.Add(smithy.NewErrParamRequired("ApplicationName")) 1353 } 1354 if v.CurrentApplicationVersionId == nil { 1355 invalidParams.Add(smithy.NewErrParamRequired("CurrentApplicationVersionId")) 1356 } 1357 if v.ReferenceDataSource == nil { 1358 invalidParams.Add(smithy.NewErrParamRequired("ReferenceDataSource")) 1359 } else if v.ReferenceDataSource != nil { 1360 if err := validateReferenceDataSource(v.ReferenceDataSource); err != nil { 1361 invalidParams.AddNested("ReferenceDataSource", err.(smithy.InvalidParamsError)) 1362 } 1363 } 1364 if invalidParams.Len() > 0 { 1365 return invalidParams 1366 } else { 1367 return nil 1368 } 1369} 1370 1371func validateOpCreateApplicationInput(v *CreateApplicationInput) error { 1372 if v == nil { 1373 return nil 1374 } 1375 invalidParams := smithy.InvalidParamsError{Context: "CreateApplicationInput"} 1376 if v.ApplicationName == nil { 1377 invalidParams.Add(smithy.NewErrParamRequired("ApplicationName")) 1378 } 1379 if v.Inputs != nil { 1380 if err := validateInputs(v.Inputs); err != nil { 1381 invalidParams.AddNested("Inputs", err.(smithy.InvalidParamsError)) 1382 } 1383 } 1384 if v.Outputs != nil { 1385 if err := validateOutputs(v.Outputs); err != nil { 1386 invalidParams.AddNested("Outputs", err.(smithy.InvalidParamsError)) 1387 } 1388 } 1389 if v.CloudWatchLoggingOptions != nil { 1390 if err := validateCloudWatchLoggingOptions(v.CloudWatchLoggingOptions); err != nil { 1391 invalidParams.AddNested("CloudWatchLoggingOptions", err.(smithy.InvalidParamsError)) 1392 } 1393 } 1394 if v.Tags != nil { 1395 if err := validateTags(v.Tags); err != nil { 1396 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1397 } 1398 } 1399 if invalidParams.Len() > 0 { 1400 return invalidParams 1401 } else { 1402 return nil 1403 } 1404} 1405 1406func validateOpDeleteApplicationCloudWatchLoggingOptionInput(v *DeleteApplicationCloudWatchLoggingOptionInput) error { 1407 if v == nil { 1408 return nil 1409 } 1410 invalidParams := smithy.InvalidParamsError{Context: "DeleteApplicationCloudWatchLoggingOptionInput"} 1411 if v.ApplicationName == nil { 1412 invalidParams.Add(smithy.NewErrParamRequired("ApplicationName")) 1413 } 1414 if v.CurrentApplicationVersionId == nil { 1415 invalidParams.Add(smithy.NewErrParamRequired("CurrentApplicationVersionId")) 1416 } 1417 if v.CloudWatchLoggingOptionId == nil { 1418 invalidParams.Add(smithy.NewErrParamRequired("CloudWatchLoggingOptionId")) 1419 } 1420 if invalidParams.Len() > 0 { 1421 return invalidParams 1422 } else { 1423 return nil 1424 } 1425} 1426 1427func validateOpDeleteApplicationInput(v *DeleteApplicationInput) error { 1428 if v == nil { 1429 return nil 1430 } 1431 invalidParams := smithy.InvalidParamsError{Context: "DeleteApplicationInput"} 1432 if v.ApplicationName == nil { 1433 invalidParams.Add(smithy.NewErrParamRequired("ApplicationName")) 1434 } 1435 if v.CreateTimestamp == nil { 1436 invalidParams.Add(smithy.NewErrParamRequired("CreateTimestamp")) 1437 } 1438 if invalidParams.Len() > 0 { 1439 return invalidParams 1440 } else { 1441 return nil 1442 } 1443} 1444 1445func validateOpDeleteApplicationInputProcessingConfigurationInput(v *DeleteApplicationInputProcessingConfigurationInput) error { 1446 if v == nil { 1447 return nil 1448 } 1449 invalidParams := smithy.InvalidParamsError{Context: "DeleteApplicationInputProcessingConfigurationInput"} 1450 if v.ApplicationName == nil { 1451 invalidParams.Add(smithy.NewErrParamRequired("ApplicationName")) 1452 } 1453 if v.CurrentApplicationVersionId == nil { 1454 invalidParams.Add(smithy.NewErrParamRequired("CurrentApplicationVersionId")) 1455 } 1456 if v.InputId == nil { 1457 invalidParams.Add(smithy.NewErrParamRequired("InputId")) 1458 } 1459 if invalidParams.Len() > 0 { 1460 return invalidParams 1461 } else { 1462 return nil 1463 } 1464} 1465 1466func validateOpDeleteApplicationOutputInput(v *DeleteApplicationOutputInput) error { 1467 if v == nil { 1468 return nil 1469 } 1470 invalidParams := smithy.InvalidParamsError{Context: "DeleteApplicationOutputInput"} 1471 if v.ApplicationName == nil { 1472 invalidParams.Add(smithy.NewErrParamRequired("ApplicationName")) 1473 } 1474 if v.CurrentApplicationVersionId == nil { 1475 invalidParams.Add(smithy.NewErrParamRequired("CurrentApplicationVersionId")) 1476 } 1477 if v.OutputId == nil { 1478 invalidParams.Add(smithy.NewErrParamRequired("OutputId")) 1479 } 1480 if invalidParams.Len() > 0 { 1481 return invalidParams 1482 } else { 1483 return nil 1484 } 1485} 1486 1487func validateOpDeleteApplicationReferenceDataSourceInput(v *DeleteApplicationReferenceDataSourceInput) error { 1488 if v == nil { 1489 return nil 1490 } 1491 invalidParams := smithy.InvalidParamsError{Context: "DeleteApplicationReferenceDataSourceInput"} 1492 if v.ApplicationName == nil { 1493 invalidParams.Add(smithy.NewErrParamRequired("ApplicationName")) 1494 } 1495 if v.CurrentApplicationVersionId == nil { 1496 invalidParams.Add(smithy.NewErrParamRequired("CurrentApplicationVersionId")) 1497 } 1498 if v.ReferenceId == nil { 1499 invalidParams.Add(smithy.NewErrParamRequired("ReferenceId")) 1500 } 1501 if invalidParams.Len() > 0 { 1502 return invalidParams 1503 } else { 1504 return nil 1505 } 1506} 1507 1508func validateOpDescribeApplicationInput(v *DescribeApplicationInput) error { 1509 if v == nil { 1510 return nil 1511 } 1512 invalidParams := smithy.InvalidParamsError{Context: "DescribeApplicationInput"} 1513 if v.ApplicationName == nil { 1514 invalidParams.Add(smithy.NewErrParamRequired("ApplicationName")) 1515 } 1516 if invalidParams.Len() > 0 { 1517 return invalidParams 1518 } else { 1519 return nil 1520 } 1521} 1522 1523func validateOpDiscoverInputSchemaInput(v *DiscoverInputSchemaInput) error { 1524 if v == nil { 1525 return nil 1526 } 1527 invalidParams := smithy.InvalidParamsError{Context: "DiscoverInputSchemaInput"} 1528 if v.S3Configuration != nil { 1529 if err := validateS3Configuration(v.S3Configuration); err != nil { 1530 invalidParams.AddNested("S3Configuration", err.(smithy.InvalidParamsError)) 1531 } 1532 } 1533 if v.InputProcessingConfiguration != nil { 1534 if err := validateInputProcessingConfiguration(v.InputProcessingConfiguration); err != nil { 1535 invalidParams.AddNested("InputProcessingConfiguration", err.(smithy.InvalidParamsError)) 1536 } 1537 } 1538 if invalidParams.Len() > 0 { 1539 return invalidParams 1540 } else { 1541 return nil 1542 } 1543} 1544 1545func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 1546 if v == nil { 1547 return nil 1548 } 1549 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 1550 if v.ResourceARN == nil { 1551 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 1552 } 1553 if invalidParams.Len() > 0 { 1554 return invalidParams 1555 } else { 1556 return nil 1557 } 1558} 1559 1560func validateOpStartApplicationInput(v *StartApplicationInput) error { 1561 if v == nil { 1562 return nil 1563 } 1564 invalidParams := smithy.InvalidParamsError{Context: "StartApplicationInput"} 1565 if v.ApplicationName == nil { 1566 invalidParams.Add(smithy.NewErrParamRequired("ApplicationName")) 1567 } 1568 if v.InputConfigurations == nil { 1569 invalidParams.Add(smithy.NewErrParamRequired("InputConfigurations")) 1570 } else if v.InputConfigurations != nil { 1571 if err := validateInputConfigurations(v.InputConfigurations); err != nil { 1572 invalidParams.AddNested("InputConfigurations", err.(smithy.InvalidParamsError)) 1573 } 1574 } 1575 if invalidParams.Len() > 0 { 1576 return invalidParams 1577 } else { 1578 return nil 1579 } 1580} 1581 1582func validateOpStopApplicationInput(v *StopApplicationInput) error { 1583 if v == nil { 1584 return nil 1585 } 1586 invalidParams := smithy.InvalidParamsError{Context: "StopApplicationInput"} 1587 if v.ApplicationName == nil { 1588 invalidParams.Add(smithy.NewErrParamRequired("ApplicationName")) 1589 } 1590 if invalidParams.Len() > 0 { 1591 return invalidParams 1592 } else { 1593 return nil 1594 } 1595} 1596 1597func validateOpTagResourceInput(v *TagResourceInput) error { 1598 if v == nil { 1599 return nil 1600 } 1601 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 1602 if v.ResourceARN == nil { 1603 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 1604 } 1605 if v.Tags == nil { 1606 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 1607 } else if v.Tags != nil { 1608 if err := validateTags(v.Tags); err != nil { 1609 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1610 } 1611 } 1612 if invalidParams.Len() > 0 { 1613 return invalidParams 1614 } else { 1615 return nil 1616 } 1617} 1618 1619func validateOpUntagResourceInput(v *UntagResourceInput) error { 1620 if v == nil { 1621 return nil 1622 } 1623 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 1624 if v.ResourceARN == nil { 1625 invalidParams.Add(smithy.NewErrParamRequired("ResourceARN")) 1626 } 1627 if v.TagKeys == nil { 1628 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 1629 } 1630 if invalidParams.Len() > 0 { 1631 return invalidParams 1632 } else { 1633 return nil 1634 } 1635} 1636 1637func validateOpUpdateApplicationInput(v *UpdateApplicationInput) error { 1638 if v == nil { 1639 return nil 1640 } 1641 invalidParams := smithy.InvalidParamsError{Context: "UpdateApplicationInput"} 1642 if v.ApplicationName == nil { 1643 invalidParams.Add(smithy.NewErrParamRequired("ApplicationName")) 1644 } 1645 if v.CurrentApplicationVersionId == nil { 1646 invalidParams.Add(smithy.NewErrParamRequired("CurrentApplicationVersionId")) 1647 } 1648 if v.ApplicationUpdate == nil { 1649 invalidParams.Add(smithy.NewErrParamRequired("ApplicationUpdate")) 1650 } else if v.ApplicationUpdate != nil { 1651 if err := validateApplicationUpdate(v.ApplicationUpdate); err != nil { 1652 invalidParams.AddNested("ApplicationUpdate", err.(smithy.InvalidParamsError)) 1653 } 1654 } 1655 if invalidParams.Len() > 0 { 1656 return invalidParams 1657 } else { 1658 return nil 1659 } 1660} 1661