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