1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package medialive 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/medialive/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpAcceptInputDeviceTransfer struct { 14} 15 16func (*validateOpAcceptInputDeviceTransfer) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpAcceptInputDeviceTransfer) 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.(*AcceptInputDeviceTransferInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpAcceptInputDeviceTransferInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpBatchUpdateSchedule struct { 34} 35 36func (*validateOpBatchUpdateSchedule) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpBatchUpdateSchedule) 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.(*BatchUpdateScheduleInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpBatchUpdateScheduleInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpCancelInputDeviceTransfer struct { 54} 55 56func (*validateOpCancelInputDeviceTransfer) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpCancelInputDeviceTransfer) 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.(*CancelInputDeviceTransferInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpCancelInputDeviceTransferInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpCreateChannel struct { 74} 75 76func (*validateOpCreateChannel) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpCreateChannel) 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.(*CreateChannelInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpCreateChannelInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpCreateInput struct { 94} 95 96func (*validateOpCreateInput) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpCreateInput) 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.(*CreateInputInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpCreateInputInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpCreateMultiplex struct { 114} 115 116func (*validateOpCreateMultiplex) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpCreateMultiplex) 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.(*CreateMultiplexInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpCreateMultiplexInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpCreateMultiplexProgram struct { 134} 135 136func (*validateOpCreateMultiplexProgram) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpCreateMultiplexProgram) 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.(*CreateMultiplexProgramInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpCreateMultiplexProgramInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpCreatePartnerInput struct { 154} 155 156func (*validateOpCreatePartnerInput) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpCreatePartnerInput) 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.(*CreatePartnerInputInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpCreatePartnerInputInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpCreateTags struct { 174} 175 176func (*validateOpCreateTags) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpCreateTags) 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.(*CreateTagsInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpCreateTagsInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpDeleteChannel struct { 194} 195 196func (*validateOpDeleteChannel) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpDeleteChannel) 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.(*DeleteChannelInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpDeleteChannelInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpDeleteInput struct { 214} 215 216func (*validateOpDeleteInput) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpDeleteInput) 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.(*DeleteInputInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpDeleteInputInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpDeleteInputSecurityGroup struct { 234} 235 236func (*validateOpDeleteInputSecurityGroup) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpDeleteInputSecurityGroup) 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.(*DeleteInputSecurityGroupInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpDeleteInputSecurityGroupInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpDeleteMultiplex struct { 254} 255 256func (*validateOpDeleteMultiplex) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpDeleteMultiplex) 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.(*DeleteMultiplexInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpDeleteMultiplexInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpDeleteMultiplexProgram struct { 274} 275 276func (*validateOpDeleteMultiplexProgram) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpDeleteMultiplexProgram) 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.(*DeleteMultiplexProgramInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpDeleteMultiplexProgramInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpDeleteReservation struct { 294} 295 296func (*validateOpDeleteReservation) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpDeleteReservation) 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.(*DeleteReservationInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpDeleteReservationInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpDeleteSchedule struct { 314} 315 316func (*validateOpDeleteSchedule) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpDeleteSchedule) 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.(*DeleteScheduleInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpDeleteScheduleInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpDeleteTags struct { 334} 335 336func (*validateOpDeleteTags) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpDeleteTags) 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.(*DeleteTagsInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpDeleteTagsInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpDescribeChannel struct { 354} 355 356func (*validateOpDescribeChannel) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpDescribeChannel) 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.(*DescribeChannelInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpDescribeChannelInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpDescribeInputDevice struct { 374} 375 376func (*validateOpDescribeInputDevice) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpDescribeInputDevice) 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.(*DescribeInputDeviceInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpDescribeInputDeviceInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpDescribeInputDeviceThumbnail struct { 394} 395 396func (*validateOpDescribeInputDeviceThumbnail) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpDescribeInputDeviceThumbnail) 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.(*DescribeInputDeviceThumbnailInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpDescribeInputDeviceThumbnailInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpDescribeInput struct { 414} 415 416func (*validateOpDescribeInput) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpDescribeInput) 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.(*DescribeInputInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpDescribeInputInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpDescribeInputSecurityGroup struct { 434} 435 436func (*validateOpDescribeInputSecurityGroup) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpDescribeInputSecurityGroup) 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.(*DescribeInputSecurityGroupInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpDescribeInputSecurityGroupInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpDescribeMultiplex struct { 454} 455 456func (*validateOpDescribeMultiplex) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpDescribeMultiplex) 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.(*DescribeMultiplexInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpDescribeMultiplexInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473type validateOpDescribeMultiplexProgram struct { 474} 475 476func (*validateOpDescribeMultiplexProgram) ID() string { 477 return "OperationInputValidation" 478} 479 480func (m *validateOpDescribeMultiplexProgram) 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.(*DescribeMultiplexProgramInput) 484 if !ok { 485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 486 } 487 if err := validateOpDescribeMultiplexProgramInput(input); err != nil { 488 return out, metadata, err 489 } 490 return next.HandleInitialize(ctx, in) 491} 492 493type validateOpDescribeOffering struct { 494} 495 496func (*validateOpDescribeOffering) ID() string { 497 return "OperationInputValidation" 498} 499 500func (m *validateOpDescribeOffering) 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.(*DescribeOfferingInput) 504 if !ok { 505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 506 } 507 if err := validateOpDescribeOfferingInput(input); err != nil { 508 return out, metadata, err 509 } 510 return next.HandleInitialize(ctx, in) 511} 512 513type validateOpDescribeReservation struct { 514} 515 516func (*validateOpDescribeReservation) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpDescribeReservation) 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.(*DescribeReservationInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpDescribeReservationInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533type validateOpDescribeSchedule struct { 534} 535 536func (*validateOpDescribeSchedule) ID() string { 537 return "OperationInputValidation" 538} 539 540func (m *validateOpDescribeSchedule) 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.(*DescribeScheduleInput) 544 if !ok { 545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 546 } 547 if err := validateOpDescribeScheduleInput(input); err != nil { 548 return out, metadata, err 549 } 550 return next.HandleInitialize(ctx, in) 551} 552 553type validateOpListInputDeviceTransfers struct { 554} 555 556func (*validateOpListInputDeviceTransfers) ID() string { 557 return "OperationInputValidation" 558} 559 560func (m *validateOpListInputDeviceTransfers) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 561 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 562) { 563 input, ok := in.Parameters.(*ListInputDeviceTransfersInput) 564 if !ok { 565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 566 } 567 if err := validateOpListInputDeviceTransfersInput(input); err != nil { 568 return out, metadata, err 569 } 570 return next.HandleInitialize(ctx, in) 571} 572 573type validateOpListMultiplexPrograms struct { 574} 575 576func (*validateOpListMultiplexPrograms) ID() string { 577 return "OperationInputValidation" 578} 579 580func (m *validateOpListMultiplexPrograms) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 581 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 582) { 583 input, ok := in.Parameters.(*ListMultiplexProgramsInput) 584 if !ok { 585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 586 } 587 if err := validateOpListMultiplexProgramsInput(input); err != nil { 588 return out, metadata, err 589 } 590 return next.HandleInitialize(ctx, in) 591} 592 593type validateOpListTagsForResource struct { 594} 595 596func (*validateOpListTagsForResource) ID() string { 597 return "OperationInputValidation" 598} 599 600func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 601 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 602) { 603 input, ok := in.Parameters.(*ListTagsForResourceInput) 604 if !ok { 605 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 606 } 607 if err := validateOpListTagsForResourceInput(input); err != nil { 608 return out, metadata, err 609 } 610 return next.HandleInitialize(ctx, in) 611} 612 613type validateOpPurchaseOffering struct { 614} 615 616func (*validateOpPurchaseOffering) ID() string { 617 return "OperationInputValidation" 618} 619 620func (m *validateOpPurchaseOffering) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 621 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 622) { 623 input, ok := in.Parameters.(*PurchaseOfferingInput) 624 if !ok { 625 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 626 } 627 if err := validateOpPurchaseOfferingInput(input); err != nil { 628 return out, metadata, err 629 } 630 return next.HandleInitialize(ctx, in) 631} 632 633type validateOpRejectInputDeviceTransfer struct { 634} 635 636func (*validateOpRejectInputDeviceTransfer) ID() string { 637 return "OperationInputValidation" 638} 639 640func (m *validateOpRejectInputDeviceTransfer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 641 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 642) { 643 input, ok := in.Parameters.(*RejectInputDeviceTransferInput) 644 if !ok { 645 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 646 } 647 if err := validateOpRejectInputDeviceTransferInput(input); err != nil { 648 return out, metadata, err 649 } 650 return next.HandleInitialize(ctx, in) 651} 652 653type validateOpStartChannel struct { 654} 655 656func (*validateOpStartChannel) ID() string { 657 return "OperationInputValidation" 658} 659 660func (m *validateOpStartChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 661 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 662) { 663 input, ok := in.Parameters.(*StartChannelInput) 664 if !ok { 665 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 666 } 667 if err := validateOpStartChannelInput(input); err != nil { 668 return out, metadata, err 669 } 670 return next.HandleInitialize(ctx, in) 671} 672 673type validateOpStartMultiplex struct { 674} 675 676func (*validateOpStartMultiplex) ID() string { 677 return "OperationInputValidation" 678} 679 680func (m *validateOpStartMultiplex) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 681 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 682) { 683 input, ok := in.Parameters.(*StartMultiplexInput) 684 if !ok { 685 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 686 } 687 if err := validateOpStartMultiplexInput(input); err != nil { 688 return out, metadata, err 689 } 690 return next.HandleInitialize(ctx, in) 691} 692 693type validateOpStopChannel struct { 694} 695 696func (*validateOpStopChannel) ID() string { 697 return "OperationInputValidation" 698} 699 700func (m *validateOpStopChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 701 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 702) { 703 input, ok := in.Parameters.(*StopChannelInput) 704 if !ok { 705 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 706 } 707 if err := validateOpStopChannelInput(input); err != nil { 708 return out, metadata, err 709 } 710 return next.HandleInitialize(ctx, in) 711} 712 713type validateOpStopMultiplex struct { 714} 715 716func (*validateOpStopMultiplex) ID() string { 717 return "OperationInputValidation" 718} 719 720func (m *validateOpStopMultiplex) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 721 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 722) { 723 input, ok := in.Parameters.(*StopMultiplexInput) 724 if !ok { 725 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 726 } 727 if err := validateOpStopMultiplexInput(input); err != nil { 728 return out, metadata, err 729 } 730 return next.HandleInitialize(ctx, in) 731} 732 733type validateOpTransferInputDevice struct { 734} 735 736func (*validateOpTransferInputDevice) ID() string { 737 return "OperationInputValidation" 738} 739 740func (m *validateOpTransferInputDevice) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 741 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 742) { 743 input, ok := in.Parameters.(*TransferInputDeviceInput) 744 if !ok { 745 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 746 } 747 if err := validateOpTransferInputDeviceInput(input); err != nil { 748 return out, metadata, err 749 } 750 return next.HandleInitialize(ctx, in) 751} 752 753type validateOpUpdateChannelClass struct { 754} 755 756func (*validateOpUpdateChannelClass) ID() string { 757 return "OperationInputValidation" 758} 759 760func (m *validateOpUpdateChannelClass) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 761 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 762) { 763 input, ok := in.Parameters.(*UpdateChannelClassInput) 764 if !ok { 765 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 766 } 767 if err := validateOpUpdateChannelClassInput(input); err != nil { 768 return out, metadata, err 769 } 770 return next.HandleInitialize(ctx, in) 771} 772 773type validateOpUpdateChannel struct { 774} 775 776func (*validateOpUpdateChannel) ID() string { 777 return "OperationInputValidation" 778} 779 780func (m *validateOpUpdateChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 781 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 782) { 783 input, ok := in.Parameters.(*UpdateChannelInput) 784 if !ok { 785 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 786 } 787 if err := validateOpUpdateChannelInput(input); err != nil { 788 return out, metadata, err 789 } 790 return next.HandleInitialize(ctx, in) 791} 792 793type validateOpUpdateInputDevice struct { 794} 795 796func (*validateOpUpdateInputDevice) ID() string { 797 return "OperationInputValidation" 798} 799 800func (m *validateOpUpdateInputDevice) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 801 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 802) { 803 input, ok := in.Parameters.(*UpdateInputDeviceInput) 804 if !ok { 805 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 806 } 807 if err := validateOpUpdateInputDeviceInput(input); err != nil { 808 return out, metadata, err 809 } 810 return next.HandleInitialize(ctx, in) 811} 812 813type validateOpUpdateInput struct { 814} 815 816func (*validateOpUpdateInput) ID() string { 817 return "OperationInputValidation" 818} 819 820func (m *validateOpUpdateInput) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 821 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 822) { 823 input, ok := in.Parameters.(*UpdateInputInput) 824 if !ok { 825 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 826 } 827 if err := validateOpUpdateInputInput(input); err != nil { 828 return out, metadata, err 829 } 830 return next.HandleInitialize(ctx, in) 831} 832 833type validateOpUpdateInputSecurityGroup struct { 834} 835 836func (*validateOpUpdateInputSecurityGroup) ID() string { 837 return "OperationInputValidation" 838} 839 840func (m *validateOpUpdateInputSecurityGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 841 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 842) { 843 input, ok := in.Parameters.(*UpdateInputSecurityGroupInput) 844 if !ok { 845 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 846 } 847 if err := validateOpUpdateInputSecurityGroupInput(input); err != nil { 848 return out, metadata, err 849 } 850 return next.HandleInitialize(ctx, in) 851} 852 853type validateOpUpdateMultiplex struct { 854} 855 856func (*validateOpUpdateMultiplex) ID() string { 857 return "OperationInputValidation" 858} 859 860func (m *validateOpUpdateMultiplex) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 861 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 862) { 863 input, ok := in.Parameters.(*UpdateMultiplexInput) 864 if !ok { 865 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 866 } 867 if err := validateOpUpdateMultiplexInput(input); err != nil { 868 return out, metadata, err 869 } 870 return next.HandleInitialize(ctx, in) 871} 872 873type validateOpUpdateMultiplexProgram struct { 874} 875 876func (*validateOpUpdateMultiplexProgram) ID() string { 877 return "OperationInputValidation" 878} 879 880func (m *validateOpUpdateMultiplexProgram) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 881 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 882) { 883 input, ok := in.Parameters.(*UpdateMultiplexProgramInput) 884 if !ok { 885 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 886 } 887 if err := validateOpUpdateMultiplexProgramInput(input); err != nil { 888 return out, metadata, err 889 } 890 return next.HandleInitialize(ctx, in) 891} 892 893type validateOpUpdateReservation struct { 894} 895 896func (*validateOpUpdateReservation) ID() string { 897 return "OperationInputValidation" 898} 899 900func (m *validateOpUpdateReservation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 901 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 902) { 903 input, ok := in.Parameters.(*UpdateReservationInput) 904 if !ok { 905 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 906 } 907 if err := validateOpUpdateReservationInput(input); err != nil { 908 return out, metadata, err 909 } 910 return next.HandleInitialize(ctx, in) 911} 912 913func addOpAcceptInputDeviceTransferValidationMiddleware(stack *middleware.Stack) error { 914 return stack.Initialize.Add(&validateOpAcceptInputDeviceTransfer{}, middleware.After) 915} 916 917func addOpBatchUpdateScheduleValidationMiddleware(stack *middleware.Stack) error { 918 return stack.Initialize.Add(&validateOpBatchUpdateSchedule{}, middleware.After) 919} 920 921func addOpCancelInputDeviceTransferValidationMiddleware(stack *middleware.Stack) error { 922 return stack.Initialize.Add(&validateOpCancelInputDeviceTransfer{}, middleware.After) 923} 924 925func addOpCreateChannelValidationMiddleware(stack *middleware.Stack) error { 926 return stack.Initialize.Add(&validateOpCreateChannel{}, middleware.After) 927} 928 929func addOpCreateInputValidationMiddleware(stack *middleware.Stack) error { 930 return stack.Initialize.Add(&validateOpCreateInput{}, middleware.After) 931} 932 933func addOpCreateMultiplexValidationMiddleware(stack *middleware.Stack) error { 934 return stack.Initialize.Add(&validateOpCreateMultiplex{}, middleware.After) 935} 936 937func addOpCreateMultiplexProgramValidationMiddleware(stack *middleware.Stack) error { 938 return stack.Initialize.Add(&validateOpCreateMultiplexProgram{}, middleware.After) 939} 940 941func addOpCreatePartnerInputValidationMiddleware(stack *middleware.Stack) error { 942 return stack.Initialize.Add(&validateOpCreatePartnerInput{}, middleware.After) 943} 944 945func addOpCreateTagsValidationMiddleware(stack *middleware.Stack) error { 946 return stack.Initialize.Add(&validateOpCreateTags{}, middleware.After) 947} 948 949func addOpDeleteChannelValidationMiddleware(stack *middleware.Stack) error { 950 return stack.Initialize.Add(&validateOpDeleteChannel{}, middleware.After) 951} 952 953func addOpDeleteInputValidationMiddleware(stack *middleware.Stack) error { 954 return stack.Initialize.Add(&validateOpDeleteInput{}, middleware.After) 955} 956 957func addOpDeleteInputSecurityGroupValidationMiddleware(stack *middleware.Stack) error { 958 return stack.Initialize.Add(&validateOpDeleteInputSecurityGroup{}, middleware.After) 959} 960 961func addOpDeleteMultiplexValidationMiddleware(stack *middleware.Stack) error { 962 return stack.Initialize.Add(&validateOpDeleteMultiplex{}, middleware.After) 963} 964 965func addOpDeleteMultiplexProgramValidationMiddleware(stack *middleware.Stack) error { 966 return stack.Initialize.Add(&validateOpDeleteMultiplexProgram{}, middleware.After) 967} 968 969func addOpDeleteReservationValidationMiddleware(stack *middleware.Stack) error { 970 return stack.Initialize.Add(&validateOpDeleteReservation{}, middleware.After) 971} 972 973func addOpDeleteScheduleValidationMiddleware(stack *middleware.Stack) error { 974 return stack.Initialize.Add(&validateOpDeleteSchedule{}, middleware.After) 975} 976 977func addOpDeleteTagsValidationMiddleware(stack *middleware.Stack) error { 978 return stack.Initialize.Add(&validateOpDeleteTags{}, middleware.After) 979} 980 981func addOpDescribeChannelValidationMiddleware(stack *middleware.Stack) error { 982 return stack.Initialize.Add(&validateOpDescribeChannel{}, middleware.After) 983} 984 985func addOpDescribeInputDeviceValidationMiddleware(stack *middleware.Stack) error { 986 return stack.Initialize.Add(&validateOpDescribeInputDevice{}, middleware.After) 987} 988 989func addOpDescribeInputDeviceThumbnailValidationMiddleware(stack *middleware.Stack) error { 990 return stack.Initialize.Add(&validateOpDescribeInputDeviceThumbnail{}, middleware.After) 991} 992 993func addOpDescribeInputValidationMiddleware(stack *middleware.Stack) error { 994 return stack.Initialize.Add(&validateOpDescribeInput{}, middleware.After) 995} 996 997func addOpDescribeInputSecurityGroupValidationMiddleware(stack *middleware.Stack) error { 998 return stack.Initialize.Add(&validateOpDescribeInputSecurityGroup{}, middleware.After) 999} 1000 1001func addOpDescribeMultiplexValidationMiddleware(stack *middleware.Stack) error { 1002 return stack.Initialize.Add(&validateOpDescribeMultiplex{}, middleware.After) 1003} 1004 1005func addOpDescribeMultiplexProgramValidationMiddleware(stack *middleware.Stack) error { 1006 return stack.Initialize.Add(&validateOpDescribeMultiplexProgram{}, middleware.After) 1007} 1008 1009func addOpDescribeOfferingValidationMiddleware(stack *middleware.Stack) error { 1010 return stack.Initialize.Add(&validateOpDescribeOffering{}, middleware.After) 1011} 1012 1013func addOpDescribeReservationValidationMiddleware(stack *middleware.Stack) error { 1014 return stack.Initialize.Add(&validateOpDescribeReservation{}, middleware.After) 1015} 1016 1017func addOpDescribeScheduleValidationMiddleware(stack *middleware.Stack) error { 1018 return stack.Initialize.Add(&validateOpDescribeSchedule{}, middleware.After) 1019} 1020 1021func addOpListInputDeviceTransfersValidationMiddleware(stack *middleware.Stack) error { 1022 return stack.Initialize.Add(&validateOpListInputDeviceTransfers{}, middleware.After) 1023} 1024 1025func addOpListMultiplexProgramsValidationMiddleware(stack *middleware.Stack) error { 1026 return stack.Initialize.Add(&validateOpListMultiplexPrograms{}, middleware.After) 1027} 1028 1029func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 1030 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 1031} 1032 1033func addOpPurchaseOfferingValidationMiddleware(stack *middleware.Stack) error { 1034 return stack.Initialize.Add(&validateOpPurchaseOffering{}, middleware.After) 1035} 1036 1037func addOpRejectInputDeviceTransferValidationMiddleware(stack *middleware.Stack) error { 1038 return stack.Initialize.Add(&validateOpRejectInputDeviceTransfer{}, middleware.After) 1039} 1040 1041func addOpStartChannelValidationMiddleware(stack *middleware.Stack) error { 1042 return stack.Initialize.Add(&validateOpStartChannel{}, middleware.After) 1043} 1044 1045func addOpStartMultiplexValidationMiddleware(stack *middleware.Stack) error { 1046 return stack.Initialize.Add(&validateOpStartMultiplex{}, middleware.After) 1047} 1048 1049func addOpStopChannelValidationMiddleware(stack *middleware.Stack) error { 1050 return stack.Initialize.Add(&validateOpStopChannel{}, middleware.After) 1051} 1052 1053func addOpStopMultiplexValidationMiddleware(stack *middleware.Stack) error { 1054 return stack.Initialize.Add(&validateOpStopMultiplex{}, middleware.After) 1055} 1056 1057func addOpTransferInputDeviceValidationMiddleware(stack *middleware.Stack) error { 1058 return stack.Initialize.Add(&validateOpTransferInputDevice{}, middleware.After) 1059} 1060 1061func addOpUpdateChannelClassValidationMiddleware(stack *middleware.Stack) error { 1062 return stack.Initialize.Add(&validateOpUpdateChannelClass{}, middleware.After) 1063} 1064 1065func addOpUpdateChannelValidationMiddleware(stack *middleware.Stack) error { 1066 return stack.Initialize.Add(&validateOpUpdateChannel{}, middleware.After) 1067} 1068 1069func addOpUpdateInputDeviceValidationMiddleware(stack *middleware.Stack) error { 1070 return stack.Initialize.Add(&validateOpUpdateInputDevice{}, middleware.After) 1071} 1072 1073func addOpUpdateInputValidationMiddleware(stack *middleware.Stack) error { 1074 return stack.Initialize.Add(&validateOpUpdateInput{}, middleware.After) 1075} 1076 1077func addOpUpdateInputSecurityGroupValidationMiddleware(stack *middleware.Stack) error { 1078 return stack.Initialize.Add(&validateOpUpdateInputSecurityGroup{}, middleware.After) 1079} 1080 1081func addOpUpdateMultiplexValidationMiddleware(stack *middleware.Stack) error { 1082 return stack.Initialize.Add(&validateOpUpdateMultiplex{}, middleware.After) 1083} 1084 1085func addOpUpdateMultiplexProgramValidationMiddleware(stack *middleware.Stack) error { 1086 return stack.Initialize.Add(&validateOpUpdateMultiplexProgram{}, middleware.After) 1087} 1088 1089func addOpUpdateReservationValidationMiddleware(stack *middleware.Stack) error { 1090 return stack.Initialize.Add(&validateOpUpdateReservation{}, middleware.After) 1091} 1092 1093func validate__listOfAudioChannelMapping(v []types.AudioChannelMapping) error { 1094 if v == nil { 1095 return nil 1096 } 1097 invalidParams := smithy.InvalidParamsError{Context: "ListOfAudioChannelMapping"} 1098 for i := range v { 1099 if err := validateAudioChannelMapping(&v[i]); err != nil { 1100 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1101 } 1102 } 1103 if invalidParams.Len() > 0 { 1104 return invalidParams 1105 } else { 1106 return nil 1107 } 1108} 1109 1110func validate__listOfAudioDescription(v []types.AudioDescription) error { 1111 if v == nil { 1112 return nil 1113 } 1114 invalidParams := smithy.InvalidParamsError{Context: "ListOfAudioDescription"} 1115 for i := range v { 1116 if err := validateAudioDescription(&v[i]); err != nil { 1117 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1118 } 1119 } 1120 if invalidParams.Len() > 0 { 1121 return invalidParams 1122 } else { 1123 return nil 1124 } 1125} 1126 1127func validate__listOfAudioSelector(v []types.AudioSelector) error { 1128 if v == nil { 1129 return nil 1130 } 1131 invalidParams := smithy.InvalidParamsError{Context: "ListOfAudioSelector"} 1132 for i := range v { 1133 if err := validateAudioSelector(&v[i]); err != nil { 1134 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1135 } 1136 } 1137 if invalidParams.Len() > 0 { 1138 return invalidParams 1139 } else { 1140 return nil 1141 } 1142} 1143 1144func validate__listOfAudioTrack(v []types.AudioTrack) error { 1145 if v == nil { 1146 return nil 1147 } 1148 invalidParams := smithy.InvalidParamsError{Context: "ListOfAudioTrack"} 1149 for i := range v { 1150 if err := validateAudioTrack(&v[i]); err != nil { 1151 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1152 } 1153 } 1154 if invalidParams.Len() > 0 { 1155 return invalidParams 1156 } else { 1157 return nil 1158 } 1159} 1160 1161func validate__listOfCaptionDescription(v []types.CaptionDescription) error { 1162 if v == nil { 1163 return nil 1164 } 1165 invalidParams := smithy.InvalidParamsError{Context: "ListOfCaptionDescription"} 1166 for i := range v { 1167 if err := validateCaptionDescription(&v[i]); err != nil { 1168 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1169 } 1170 } 1171 if invalidParams.Len() > 0 { 1172 return invalidParams 1173 } else { 1174 return nil 1175 } 1176} 1177 1178func validate__listOfCaptionLanguageMapping(v []types.CaptionLanguageMapping) error { 1179 if v == nil { 1180 return nil 1181 } 1182 invalidParams := smithy.InvalidParamsError{Context: "ListOfCaptionLanguageMapping"} 1183 for i := range v { 1184 if err := validateCaptionLanguageMapping(&v[i]); err != nil { 1185 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1186 } 1187 } 1188 if invalidParams.Len() > 0 { 1189 return invalidParams 1190 } else { 1191 return nil 1192 } 1193} 1194 1195func validate__listOfCaptionSelector(v []types.CaptionSelector) error { 1196 if v == nil { 1197 return nil 1198 } 1199 invalidParams := smithy.InvalidParamsError{Context: "ListOfCaptionSelector"} 1200 for i := range v { 1201 if err := validateCaptionSelector(&v[i]); err != nil { 1202 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1203 } 1204 } 1205 if invalidParams.Len() > 0 { 1206 return invalidParams 1207 } else { 1208 return nil 1209 } 1210} 1211 1212func validate__listOfFailoverCondition(v []types.FailoverCondition) error { 1213 if v == nil { 1214 return nil 1215 } 1216 invalidParams := smithy.InvalidParamsError{Context: "ListOfFailoverCondition"} 1217 for i := range v { 1218 if err := validateFailoverCondition(&v[i]); err != nil { 1219 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1220 } 1221 } 1222 if invalidParams.Len() > 0 { 1223 return invalidParams 1224 } else { 1225 return nil 1226 } 1227} 1228 1229func validate__listOfInputAttachment(v []types.InputAttachment) error { 1230 if v == nil { 1231 return nil 1232 } 1233 invalidParams := smithy.InvalidParamsError{Context: "ListOfInputAttachment"} 1234 for i := range v { 1235 if err := validateInputAttachment(&v[i]); err != nil { 1236 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1237 } 1238 } 1239 if invalidParams.Len() > 0 { 1240 return invalidParams 1241 } else { 1242 return nil 1243 } 1244} 1245 1246func validate__listOfInputChannelLevel(v []types.InputChannelLevel) error { 1247 if v == nil { 1248 return nil 1249 } 1250 invalidParams := smithy.InvalidParamsError{Context: "ListOfInputChannelLevel"} 1251 for i := range v { 1252 if err := validateInputChannelLevel(&v[i]); err != nil { 1253 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1254 } 1255 } 1256 if invalidParams.Len() > 0 { 1257 return invalidParams 1258 } else { 1259 return nil 1260 } 1261} 1262 1263func validate__listOfOutput(v []types.Output) error { 1264 if v == nil { 1265 return nil 1266 } 1267 invalidParams := smithy.InvalidParamsError{Context: "ListOfOutput"} 1268 for i := range v { 1269 if err := validateOutput(&v[i]); err != nil { 1270 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1271 } 1272 } 1273 if invalidParams.Len() > 0 { 1274 return invalidParams 1275 } else { 1276 return nil 1277 } 1278} 1279 1280func validate__listOfOutputGroup(v []types.OutputGroup) error { 1281 if v == nil { 1282 return nil 1283 } 1284 invalidParams := smithy.InvalidParamsError{Context: "ListOfOutputGroup"} 1285 for i := range v { 1286 if err := validateOutputGroup(&v[i]); err != nil { 1287 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1288 } 1289 } 1290 if invalidParams.Len() > 0 { 1291 return invalidParams 1292 } else { 1293 return nil 1294 } 1295} 1296 1297func validate__listOfPipelinePauseStateSettings(v []types.PipelinePauseStateSettings) error { 1298 if v == nil { 1299 return nil 1300 } 1301 invalidParams := smithy.InvalidParamsError{Context: "ListOfPipelinePauseStateSettings"} 1302 for i := range v { 1303 if err := validatePipelinePauseStateSettings(&v[i]); err != nil { 1304 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1305 } 1306 } 1307 if invalidParams.Len() > 0 { 1308 return invalidParams 1309 } else { 1310 return nil 1311 } 1312} 1313 1314func validate__listOfScheduleAction(v []types.ScheduleAction) error { 1315 if v == nil { 1316 return nil 1317 } 1318 invalidParams := smithy.InvalidParamsError{Context: "ListOfScheduleAction"} 1319 for i := range v { 1320 if err := validateScheduleAction(&v[i]); err != nil { 1321 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1322 } 1323 } 1324 if invalidParams.Len() > 0 { 1325 return invalidParams 1326 } else { 1327 return nil 1328 } 1329} 1330 1331func validate__listOfScte35Descriptor(v []types.Scte35Descriptor) error { 1332 if v == nil { 1333 return nil 1334 } 1335 invalidParams := smithy.InvalidParamsError{Context: "ListOfScte35Descriptor"} 1336 for i := range v { 1337 if err := validateScte35Descriptor(&v[i]); err != nil { 1338 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1339 } 1340 } 1341 if invalidParams.Len() > 0 { 1342 return invalidParams 1343 } else { 1344 return nil 1345 } 1346} 1347 1348func validate__listOfVideoDescription(v []types.VideoDescription) error { 1349 if v == nil { 1350 return nil 1351 } 1352 invalidParams := smithy.InvalidParamsError{Context: "ListOfVideoDescription"} 1353 for i := range v { 1354 if err := validateVideoDescription(&v[i]); err != nil { 1355 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1356 } 1357 } 1358 if invalidParams.Len() > 0 { 1359 return invalidParams 1360 } else { 1361 return nil 1362 } 1363} 1364 1365func validateArchiveContainerSettings(v *types.ArchiveContainerSettings) error { 1366 if v == nil { 1367 return nil 1368 } 1369 invalidParams := smithy.InvalidParamsError{Context: "ArchiveContainerSettings"} 1370 if v.M2tsSettings != nil { 1371 if err := validateM2tsSettings(v.M2tsSettings); err != nil { 1372 invalidParams.AddNested("M2tsSettings", err.(smithy.InvalidParamsError)) 1373 } 1374 } 1375 if invalidParams.Len() > 0 { 1376 return invalidParams 1377 } else { 1378 return nil 1379 } 1380} 1381 1382func validateArchiveGroupSettings(v *types.ArchiveGroupSettings) error { 1383 if v == nil { 1384 return nil 1385 } 1386 invalidParams := smithy.InvalidParamsError{Context: "ArchiveGroupSettings"} 1387 if v.Destination == nil { 1388 invalidParams.Add(smithy.NewErrParamRequired("Destination")) 1389 } 1390 if invalidParams.Len() > 0 { 1391 return invalidParams 1392 } else { 1393 return nil 1394 } 1395} 1396 1397func validateArchiveOutputSettings(v *types.ArchiveOutputSettings) error { 1398 if v == nil { 1399 return nil 1400 } 1401 invalidParams := smithy.InvalidParamsError{Context: "ArchiveOutputSettings"} 1402 if v.ContainerSettings == nil { 1403 invalidParams.Add(smithy.NewErrParamRequired("ContainerSettings")) 1404 } else if v.ContainerSettings != nil { 1405 if err := validateArchiveContainerSettings(v.ContainerSettings); err != nil { 1406 invalidParams.AddNested("ContainerSettings", err.(smithy.InvalidParamsError)) 1407 } 1408 } 1409 if invalidParams.Len() > 0 { 1410 return invalidParams 1411 } else { 1412 return nil 1413 } 1414} 1415 1416func validateAudioChannelMapping(v *types.AudioChannelMapping) error { 1417 if v == nil { 1418 return nil 1419 } 1420 invalidParams := smithy.InvalidParamsError{Context: "AudioChannelMapping"} 1421 if v.InputChannelLevels == nil { 1422 invalidParams.Add(smithy.NewErrParamRequired("InputChannelLevels")) 1423 } else if v.InputChannelLevels != nil { 1424 if err := validate__listOfInputChannelLevel(v.InputChannelLevels); err != nil { 1425 invalidParams.AddNested("InputChannelLevels", err.(smithy.InvalidParamsError)) 1426 } 1427 } 1428 if invalidParams.Len() > 0 { 1429 return invalidParams 1430 } else { 1431 return nil 1432 } 1433} 1434 1435func validateAudioDescription(v *types.AudioDescription) error { 1436 if v == nil { 1437 return nil 1438 } 1439 invalidParams := smithy.InvalidParamsError{Context: "AudioDescription"} 1440 if v.AudioSelectorName == nil { 1441 invalidParams.Add(smithy.NewErrParamRequired("AudioSelectorName")) 1442 } 1443 if v.Name == nil { 1444 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1445 } 1446 if v.RemixSettings != nil { 1447 if err := validateRemixSettings(v.RemixSettings); err != nil { 1448 invalidParams.AddNested("RemixSettings", err.(smithy.InvalidParamsError)) 1449 } 1450 } 1451 if invalidParams.Len() > 0 { 1452 return invalidParams 1453 } else { 1454 return nil 1455 } 1456} 1457 1458func validateAudioHlsRenditionSelection(v *types.AudioHlsRenditionSelection) error { 1459 if v == nil { 1460 return nil 1461 } 1462 invalidParams := smithy.InvalidParamsError{Context: "AudioHlsRenditionSelection"} 1463 if v.GroupId == nil { 1464 invalidParams.Add(smithy.NewErrParamRequired("GroupId")) 1465 } 1466 if v.Name == nil { 1467 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1468 } 1469 if invalidParams.Len() > 0 { 1470 return invalidParams 1471 } else { 1472 return nil 1473 } 1474} 1475 1476func validateAudioLanguageSelection(v *types.AudioLanguageSelection) error { 1477 if v == nil { 1478 return nil 1479 } 1480 invalidParams := smithy.InvalidParamsError{Context: "AudioLanguageSelection"} 1481 if v.LanguageCode == nil { 1482 invalidParams.Add(smithy.NewErrParamRequired("LanguageCode")) 1483 } 1484 if invalidParams.Len() > 0 { 1485 return invalidParams 1486 } else { 1487 return nil 1488 } 1489} 1490 1491func validateAudioOnlyHlsSettings(v *types.AudioOnlyHlsSettings) error { 1492 if v == nil { 1493 return nil 1494 } 1495 invalidParams := smithy.InvalidParamsError{Context: "AudioOnlyHlsSettings"} 1496 if v.AudioOnlyImage != nil { 1497 if err := validateInputLocation(v.AudioOnlyImage); err != nil { 1498 invalidParams.AddNested("AudioOnlyImage", err.(smithy.InvalidParamsError)) 1499 } 1500 } 1501 if invalidParams.Len() > 0 { 1502 return invalidParams 1503 } else { 1504 return nil 1505 } 1506} 1507 1508func validateAudioPidSelection(v *types.AudioPidSelection) error { 1509 if v == nil { 1510 return nil 1511 } 1512 invalidParams := smithy.InvalidParamsError{Context: "AudioPidSelection"} 1513 if invalidParams.Len() > 0 { 1514 return invalidParams 1515 } else { 1516 return nil 1517 } 1518} 1519 1520func validateAudioSelector(v *types.AudioSelector) error { 1521 if v == nil { 1522 return nil 1523 } 1524 invalidParams := smithy.InvalidParamsError{Context: "AudioSelector"} 1525 if v.Name == nil { 1526 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1527 } 1528 if v.SelectorSettings != nil { 1529 if err := validateAudioSelectorSettings(v.SelectorSettings); err != nil { 1530 invalidParams.AddNested("SelectorSettings", err.(smithy.InvalidParamsError)) 1531 } 1532 } 1533 if invalidParams.Len() > 0 { 1534 return invalidParams 1535 } else { 1536 return nil 1537 } 1538} 1539 1540func validateAudioSelectorSettings(v *types.AudioSelectorSettings) error { 1541 if v == nil { 1542 return nil 1543 } 1544 invalidParams := smithy.InvalidParamsError{Context: "AudioSelectorSettings"} 1545 if v.AudioHlsRenditionSelection != nil { 1546 if err := validateAudioHlsRenditionSelection(v.AudioHlsRenditionSelection); err != nil { 1547 invalidParams.AddNested("AudioHlsRenditionSelection", err.(smithy.InvalidParamsError)) 1548 } 1549 } 1550 if v.AudioLanguageSelection != nil { 1551 if err := validateAudioLanguageSelection(v.AudioLanguageSelection); err != nil { 1552 invalidParams.AddNested("AudioLanguageSelection", err.(smithy.InvalidParamsError)) 1553 } 1554 } 1555 if v.AudioPidSelection != nil { 1556 if err := validateAudioPidSelection(v.AudioPidSelection); err != nil { 1557 invalidParams.AddNested("AudioPidSelection", err.(smithy.InvalidParamsError)) 1558 } 1559 } 1560 if v.AudioTrackSelection != nil { 1561 if err := validateAudioTrackSelection(v.AudioTrackSelection); err != nil { 1562 invalidParams.AddNested("AudioTrackSelection", err.(smithy.InvalidParamsError)) 1563 } 1564 } 1565 if invalidParams.Len() > 0 { 1566 return invalidParams 1567 } else { 1568 return nil 1569 } 1570} 1571 1572func validateAudioSilenceFailoverSettings(v *types.AudioSilenceFailoverSettings) error { 1573 if v == nil { 1574 return nil 1575 } 1576 invalidParams := smithy.InvalidParamsError{Context: "AudioSilenceFailoverSettings"} 1577 if v.AudioSelectorName == nil { 1578 invalidParams.Add(smithy.NewErrParamRequired("AudioSelectorName")) 1579 } 1580 if invalidParams.Len() > 0 { 1581 return invalidParams 1582 } else { 1583 return nil 1584 } 1585} 1586 1587func validateAudioTrack(v *types.AudioTrack) error { 1588 if v == nil { 1589 return nil 1590 } 1591 invalidParams := smithy.InvalidParamsError{Context: "AudioTrack"} 1592 if invalidParams.Len() > 0 { 1593 return invalidParams 1594 } else { 1595 return nil 1596 } 1597} 1598 1599func validateAudioTrackSelection(v *types.AudioTrackSelection) error { 1600 if v == nil { 1601 return nil 1602 } 1603 invalidParams := smithy.InvalidParamsError{Context: "AudioTrackSelection"} 1604 if v.Tracks == nil { 1605 invalidParams.Add(smithy.NewErrParamRequired("Tracks")) 1606 } else if v.Tracks != nil { 1607 if err := validate__listOfAudioTrack(v.Tracks); err != nil { 1608 invalidParams.AddNested("Tracks", err.(smithy.InvalidParamsError)) 1609 } 1610 } 1611 if invalidParams.Len() > 0 { 1612 return invalidParams 1613 } else { 1614 return nil 1615 } 1616} 1617 1618func validateAutomaticInputFailoverSettings(v *types.AutomaticInputFailoverSettings) error { 1619 if v == nil { 1620 return nil 1621 } 1622 invalidParams := smithy.InvalidParamsError{Context: "AutomaticInputFailoverSettings"} 1623 if v.FailoverConditions != nil { 1624 if err := validate__listOfFailoverCondition(v.FailoverConditions); err != nil { 1625 invalidParams.AddNested("FailoverConditions", err.(smithy.InvalidParamsError)) 1626 } 1627 } 1628 if v.SecondaryInputId == nil { 1629 invalidParams.Add(smithy.NewErrParamRequired("SecondaryInputId")) 1630 } 1631 if invalidParams.Len() > 0 { 1632 return invalidParams 1633 } else { 1634 return nil 1635 } 1636} 1637 1638func validateAvailBlanking(v *types.AvailBlanking) error { 1639 if v == nil { 1640 return nil 1641 } 1642 invalidParams := smithy.InvalidParamsError{Context: "AvailBlanking"} 1643 if v.AvailBlankingImage != nil { 1644 if err := validateInputLocation(v.AvailBlankingImage); err != nil { 1645 invalidParams.AddNested("AvailBlankingImage", err.(smithy.InvalidParamsError)) 1646 } 1647 } 1648 if invalidParams.Len() > 0 { 1649 return invalidParams 1650 } else { 1651 return nil 1652 } 1653} 1654 1655func validateBatchScheduleActionCreateRequest(v *types.BatchScheduleActionCreateRequest) error { 1656 if v == nil { 1657 return nil 1658 } 1659 invalidParams := smithy.InvalidParamsError{Context: "BatchScheduleActionCreateRequest"} 1660 if v.ScheduleActions == nil { 1661 invalidParams.Add(smithy.NewErrParamRequired("ScheduleActions")) 1662 } else if v.ScheduleActions != nil { 1663 if err := validate__listOfScheduleAction(v.ScheduleActions); err != nil { 1664 invalidParams.AddNested("ScheduleActions", err.(smithy.InvalidParamsError)) 1665 } 1666 } 1667 if invalidParams.Len() > 0 { 1668 return invalidParams 1669 } else { 1670 return nil 1671 } 1672} 1673 1674func validateBatchScheduleActionDeleteRequest(v *types.BatchScheduleActionDeleteRequest) error { 1675 if v == nil { 1676 return nil 1677 } 1678 invalidParams := smithy.InvalidParamsError{Context: "BatchScheduleActionDeleteRequest"} 1679 if v.ActionNames == nil { 1680 invalidParams.Add(smithy.NewErrParamRequired("ActionNames")) 1681 } 1682 if invalidParams.Len() > 0 { 1683 return invalidParams 1684 } else { 1685 return nil 1686 } 1687} 1688 1689func validateBlackoutSlate(v *types.BlackoutSlate) error { 1690 if v == nil { 1691 return nil 1692 } 1693 invalidParams := smithy.InvalidParamsError{Context: "BlackoutSlate"} 1694 if v.BlackoutSlateImage != nil { 1695 if err := validateInputLocation(v.BlackoutSlateImage); err != nil { 1696 invalidParams.AddNested("BlackoutSlateImage", err.(smithy.InvalidParamsError)) 1697 } 1698 } 1699 if v.NetworkEndBlackoutImage != nil { 1700 if err := validateInputLocation(v.NetworkEndBlackoutImage); err != nil { 1701 invalidParams.AddNested("NetworkEndBlackoutImage", err.(smithy.InvalidParamsError)) 1702 } 1703 } 1704 if invalidParams.Len() > 0 { 1705 return invalidParams 1706 } else { 1707 return nil 1708 } 1709} 1710 1711func validateBurnInDestinationSettings(v *types.BurnInDestinationSettings) error { 1712 if v == nil { 1713 return nil 1714 } 1715 invalidParams := smithy.InvalidParamsError{Context: "BurnInDestinationSettings"} 1716 if v.Font != nil { 1717 if err := validateInputLocation(v.Font); err != nil { 1718 invalidParams.AddNested("Font", err.(smithy.InvalidParamsError)) 1719 } 1720 } 1721 if invalidParams.Len() > 0 { 1722 return invalidParams 1723 } else { 1724 return nil 1725 } 1726} 1727 1728func validateCaptionDescription(v *types.CaptionDescription) error { 1729 if v == nil { 1730 return nil 1731 } 1732 invalidParams := smithy.InvalidParamsError{Context: "CaptionDescription"} 1733 if v.CaptionSelectorName == nil { 1734 invalidParams.Add(smithy.NewErrParamRequired("CaptionSelectorName")) 1735 } 1736 if v.DestinationSettings != nil { 1737 if err := validateCaptionDestinationSettings(v.DestinationSettings); err != nil { 1738 invalidParams.AddNested("DestinationSettings", err.(smithy.InvalidParamsError)) 1739 } 1740 } 1741 if v.Name == nil { 1742 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1743 } 1744 if invalidParams.Len() > 0 { 1745 return invalidParams 1746 } else { 1747 return nil 1748 } 1749} 1750 1751func validateCaptionDestinationSettings(v *types.CaptionDestinationSettings) error { 1752 if v == nil { 1753 return nil 1754 } 1755 invalidParams := smithy.InvalidParamsError{Context: "CaptionDestinationSettings"} 1756 if v.BurnInDestinationSettings != nil { 1757 if err := validateBurnInDestinationSettings(v.BurnInDestinationSettings); err != nil { 1758 invalidParams.AddNested("BurnInDestinationSettings", err.(smithy.InvalidParamsError)) 1759 } 1760 } 1761 if v.DvbSubDestinationSettings != nil { 1762 if err := validateDvbSubDestinationSettings(v.DvbSubDestinationSettings); err != nil { 1763 invalidParams.AddNested("DvbSubDestinationSettings", err.(smithy.InvalidParamsError)) 1764 } 1765 } 1766 if invalidParams.Len() > 0 { 1767 return invalidParams 1768 } else { 1769 return nil 1770 } 1771} 1772 1773func validateCaptionLanguageMapping(v *types.CaptionLanguageMapping) error { 1774 if v == nil { 1775 return nil 1776 } 1777 invalidParams := smithy.InvalidParamsError{Context: "CaptionLanguageMapping"} 1778 if v.LanguageCode == nil { 1779 invalidParams.Add(smithy.NewErrParamRequired("LanguageCode")) 1780 } 1781 if v.LanguageDescription == nil { 1782 invalidParams.Add(smithy.NewErrParamRequired("LanguageDescription")) 1783 } 1784 if invalidParams.Len() > 0 { 1785 return invalidParams 1786 } else { 1787 return nil 1788 } 1789} 1790 1791func validateCaptionRectangle(v *types.CaptionRectangle) error { 1792 if v == nil { 1793 return nil 1794 } 1795 invalidParams := smithy.InvalidParamsError{Context: "CaptionRectangle"} 1796 if invalidParams.Len() > 0 { 1797 return invalidParams 1798 } else { 1799 return nil 1800 } 1801} 1802 1803func validateCaptionSelector(v *types.CaptionSelector) error { 1804 if v == nil { 1805 return nil 1806 } 1807 invalidParams := smithy.InvalidParamsError{Context: "CaptionSelector"} 1808 if v.Name == nil { 1809 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1810 } 1811 if v.SelectorSettings != nil { 1812 if err := validateCaptionSelectorSettings(v.SelectorSettings); err != nil { 1813 invalidParams.AddNested("SelectorSettings", err.(smithy.InvalidParamsError)) 1814 } 1815 } 1816 if invalidParams.Len() > 0 { 1817 return invalidParams 1818 } else { 1819 return nil 1820 } 1821} 1822 1823func validateCaptionSelectorSettings(v *types.CaptionSelectorSettings) error { 1824 if v == nil { 1825 return nil 1826 } 1827 invalidParams := smithy.InvalidParamsError{Context: "CaptionSelectorSettings"} 1828 if v.TeletextSourceSettings != nil { 1829 if err := validateTeletextSourceSettings(v.TeletextSourceSettings); err != nil { 1830 invalidParams.AddNested("TeletextSourceSettings", err.(smithy.InvalidParamsError)) 1831 } 1832 } 1833 if invalidParams.Len() > 0 { 1834 return invalidParams 1835 } else { 1836 return nil 1837 } 1838} 1839 1840func validateDvbNitSettings(v *types.DvbNitSettings) error { 1841 if v == nil { 1842 return nil 1843 } 1844 invalidParams := smithy.InvalidParamsError{Context: "DvbNitSettings"} 1845 if v.NetworkName == nil { 1846 invalidParams.Add(smithy.NewErrParamRequired("NetworkName")) 1847 } 1848 if invalidParams.Len() > 0 { 1849 return invalidParams 1850 } else { 1851 return nil 1852 } 1853} 1854 1855func validateDvbSubDestinationSettings(v *types.DvbSubDestinationSettings) error { 1856 if v == nil { 1857 return nil 1858 } 1859 invalidParams := smithy.InvalidParamsError{Context: "DvbSubDestinationSettings"} 1860 if v.Font != nil { 1861 if err := validateInputLocation(v.Font); err != nil { 1862 invalidParams.AddNested("Font", err.(smithy.InvalidParamsError)) 1863 } 1864 } 1865 if invalidParams.Len() > 0 { 1866 return invalidParams 1867 } else { 1868 return nil 1869 } 1870} 1871 1872func validateEncoderSettings(v *types.EncoderSettings) error { 1873 if v == nil { 1874 return nil 1875 } 1876 invalidParams := smithy.InvalidParamsError{Context: "EncoderSettings"} 1877 if v.AudioDescriptions == nil { 1878 invalidParams.Add(smithy.NewErrParamRequired("AudioDescriptions")) 1879 } else if v.AudioDescriptions != nil { 1880 if err := validate__listOfAudioDescription(v.AudioDescriptions); err != nil { 1881 invalidParams.AddNested("AudioDescriptions", err.(smithy.InvalidParamsError)) 1882 } 1883 } 1884 if v.AvailBlanking != nil { 1885 if err := validateAvailBlanking(v.AvailBlanking); err != nil { 1886 invalidParams.AddNested("AvailBlanking", err.(smithy.InvalidParamsError)) 1887 } 1888 } 1889 if v.BlackoutSlate != nil { 1890 if err := validateBlackoutSlate(v.BlackoutSlate); err != nil { 1891 invalidParams.AddNested("BlackoutSlate", err.(smithy.InvalidParamsError)) 1892 } 1893 } 1894 if v.CaptionDescriptions != nil { 1895 if err := validate__listOfCaptionDescription(v.CaptionDescriptions); err != nil { 1896 invalidParams.AddNested("CaptionDescriptions", err.(smithy.InvalidParamsError)) 1897 } 1898 } 1899 if v.GlobalConfiguration != nil { 1900 if err := validateGlobalConfiguration(v.GlobalConfiguration); err != nil { 1901 invalidParams.AddNested("GlobalConfiguration", err.(smithy.InvalidParamsError)) 1902 } 1903 } 1904 if v.MotionGraphicsConfiguration != nil { 1905 if err := validateMotionGraphicsConfiguration(v.MotionGraphicsConfiguration); err != nil { 1906 invalidParams.AddNested("MotionGraphicsConfiguration", err.(smithy.InvalidParamsError)) 1907 } 1908 } 1909 if v.OutputGroups == nil { 1910 invalidParams.Add(smithy.NewErrParamRequired("OutputGroups")) 1911 } else if v.OutputGroups != nil { 1912 if err := validate__listOfOutputGroup(v.OutputGroups); err != nil { 1913 invalidParams.AddNested("OutputGroups", err.(smithy.InvalidParamsError)) 1914 } 1915 } 1916 if v.TimecodeConfig == nil { 1917 invalidParams.Add(smithy.NewErrParamRequired("TimecodeConfig")) 1918 } else if v.TimecodeConfig != nil { 1919 if err := validateTimecodeConfig(v.TimecodeConfig); err != nil { 1920 invalidParams.AddNested("TimecodeConfig", err.(smithy.InvalidParamsError)) 1921 } 1922 } 1923 if v.VideoDescriptions == nil { 1924 invalidParams.Add(smithy.NewErrParamRequired("VideoDescriptions")) 1925 } else if v.VideoDescriptions != nil { 1926 if err := validate__listOfVideoDescription(v.VideoDescriptions); err != nil { 1927 invalidParams.AddNested("VideoDescriptions", err.(smithy.InvalidParamsError)) 1928 } 1929 } 1930 if invalidParams.Len() > 0 { 1931 return invalidParams 1932 } else { 1933 return nil 1934 } 1935} 1936 1937func validateFailoverCondition(v *types.FailoverCondition) error { 1938 if v == nil { 1939 return nil 1940 } 1941 invalidParams := smithy.InvalidParamsError{Context: "FailoverCondition"} 1942 if v.FailoverConditionSettings != nil { 1943 if err := validateFailoverConditionSettings(v.FailoverConditionSettings); err != nil { 1944 invalidParams.AddNested("FailoverConditionSettings", err.(smithy.InvalidParamsError)) 1945 } 1946 } 1947 if invalidParams.Len() > 0 { 1948 return invalidParams 1949 } else { 1950 return nil 1951 } 1952} 1953 1954func validateFailoverConditionSettings(v *types.FailoverConditionSettings) error { 1955 if v == nil { 1956 return nil 1957 } 1958 invalidParams := smithy.InvalidParamsError{Context: "FailoverConditionSettings"} 1959 if v.AudioSilenceSettings != nil { 1960 if err := validateAudioSilenceFailoverSettings(v.AudioSilenceSettings); err != nil { 1961 invalidParams.AddNested("AudioSilenceSettings", err.(smithy.InvalidParamsError)) 1962 } 1963 } 1964 if invalidParams.Len() > 0 { 1965 return invalidParams 1966 } else { 1967 return nil 1968 } 1969} 1970 1971func validateFixedModeScheduleActionStartSettings(v *types.FixedModeScheduleActionStartSettings) error { 1972 if v == nil { 1973 return nil 1974 } 1975 invalidParams := smithy.InvalidParamsError{Context: "FixedModeScheduleActionStartSettings"} 1976 if v.Time == nil { 1977 invalidParams.Add(smithy.NewErrParamRequired("Time")) 1978 } 1979 if invalidParams.Len() > 0 { 1980 return invalidParams 1981 } else { 1982 return nil 1983 } 1984} 1985 1986func validateFollowModeScheduleActionStartSettings(v *types.FollowModeScheduleActionStartSettings) error { 1987 if v == nil { 1988 return nil 1989 } 1990 invalidParams := smithy.InvalidParamsError{Context: "FollowModeScheduleActionStartSettings"} 1991 if len(v.FollowPoint) == 0 { 1992 invalidParams.Add(smithy.NewErrParamRequired("FollowPoint")) 1993 } 1994 if v.ReferenceActionName == nil { 1995 invalidParams.Add(smithy.NewErrParamRequired("ReferenceActionName")) 1996 } 1997 if invalidParams.Len() > 0 { 1998 return invalidParams 1999 } else { 2000 return nil 2001 } 2002} 2003 2004func validateFrameCaptureGroupSettings(v *types.FrameCaptureGroupSettings) error { 2005 if v == nil { 2006 return nil 2007 } 2008 invalidParams := smithy.InvalidParamsError{Context: "FrameCaptureGroupSettings"} 2009 if v.Destination == nil { 2010 invalidParams.Add(smithy.NewErrParamRequired("Destination")) 2011 } 2012 if invalidParams.Len() > 0 { 2013 return invalidParams 2014 } else { 2015 return nil 2016 } 2017} 2018 2019func validateGlobalConfiguration(v *types.GlobalConfiguration) error { 2020 if v == nil { 2021 return nil 2022 } 2023 invalidParams := smithy.InvalidParamsError{Context: "GlobalConfiguration"} 2024 if v.InputLossBehavior != nil { 2025 if err := validateInputLossBehavior(v.InputLossBehavior); err != nil { 2026 invalidParams.AddNested("InputLossBehavior", err.(smithy.InvalidParamsError)) 2027 } 2028 } 2029 if invalidParams.Len() > 0 { 2030 return invalidParams 2031 } else { 2032 return nil 2033 } 2034} 2035 2036func validateH265Settings(v *types.H265Settings) error { 2037 if v == nil { 2038 return nil 2039 } 2040 invalidParams := smithy.InvalidParamsError{Context: "H265Settings"} 2041 if invalidParams.Len() > 0 { 2042 return invalidParams 2043 } else { 2044 return nil 2045 } 2046} 2047 2048func validateHlsGroupSettings(v *types.HlsGroupSettings) error { 2049 if v == nil { 2050 return nil 2051 } 2052 invalidParams := smithy.InvalidParamsError{Context: "HlsGroupSettings"} 2053 if v.CaptionLanguageMappings != nil { 2054 if err := validate__listOfCaptionLanguageMapping(v.CaptionLanguageMappings); err != nil { 2055 invalidParams.AddNested("CaptionLanguageMappings", err.(smithy.InvalidParamsError)) 2056 } 2057 } 2058 if v.Destination == nil { 2059 invalidParams.Add(smithy.NewErrParamRequired("Destination")) 2060 } 2061 if v.KeyProviderSettings != nil { 2062 if err := validateKeyProviderSettings(v.KeyProviderSettings); err != nil { 2063 invalidParams.AddNested("KeyProviderSettings", err.(smithy.InvalidParamsError)) 2064 } 2065 } 2066 if invalidParams.Len() > 0 { 2067 return invalidParams 2068 } else { 2069 return nil 2070 } 2071} 2072 2073func validateHlsId3SegmentTaggingScheduleActionSettings(v *types.HlsId3SegmentTaggingScheduleActionSettings) error { 2074 if v == nil { 2075 return nil 2076 } 2077 invalidParams := smithy.InvalidParamsError{Context: "HlsId3SegmentTaggingScheduleActionSettings"} 2078 if v.Tag == nil { 2079 invalidParams.Add(smithy.NewErrParamRequired("Tag")) 2080 } 2081 if invalidParams.Len() > 0 { 2082 return invalidParams 2083 } else { 2084 return nil 2085 } 2086} 2087 2088func validateHlsOutputSettings(v *types.HlsOutputSettings) error { 2089 if v == nil { 2090 return nil 2091 } 2092 invalidParams := smithy.InvalidParamsError{Context: "HlsOutputSettings"} 2093 if v.HlsSettings == nil { 2094 invalidParams.Add(smithy.NewErrParamRequired("HlsSettings")) 2095 } else if v.HlsSettings != nil { 2096 if err := validateHlsSettings(v.HlsSettings); err != nil { 2097 invalidParams.AddNested("HlsSettings", err.(smithy.InvalidParamsError)) 2098 } 2099 } 2100 if invalidParams.Len() > 0 { 2101 return invalidParams 2102 } else { 2103 return nil 2104 } 2105} 2106 2107func validateHlsSettings(v *types.HlsSettings) error { 2108 if v == nil { 2109 return nil 2110 } 2111 invalidParams := smithy.InvalidParamsError{Context: "HlsSettings"} 2112 if v.AudioOnlyHlsSettings != nil { 2113 if err := validateAudioOnlyHlsSettings(v.AudioOnlyHlsSettings); err != nil { 2114 invalidParams.AddNested("AudioOnlyHlsSettings", err.(smithy.InvalidParamsError)) 2115 } 2116 } 2117 if v.StandardHlsSettings != nil { 2118 if err := validateStandardHlsSettings(v.StandardHlsSettings); err != nil { 2119 invalidParams.AddNested("StandardHlsSettings", err.(smithy.InvalidParamsError)) 2120 } 2121 } 2122 if invalidParams.Len() > 0 { 2123 return invalidParams 2124 } else { 2125 return nil 2126 } 2127} 2128 2129func validateHlsTimedMetadataScheduleActionSettings(v *types.HlsTimedMetadataScheduleActionSettings) error { 2130 if v == nil { 2131 return nil 2132 } 2133 invalidParams := smithy.InvalidParamsError{Context: "HlsTimedMetadataScheduleActionSettings"} 2134 if v.Id3 == nil { 2135 invalidParams.Add(smithy.NewErrParamRequired("Id3")) 2136 } 2137 if invalidParams.Len() > 0 { 2138 return invalidParams 2139 } else { 2140 return nil 2141 } 2142} 2143 2144func validateInputAttachment(v *types.InputAttachment) error { 2145 if v == nil { 2146 return nil 2147 } 2148 invalidParams := smithy.InvalidParamsError{Context: "InputAttachment"} 2149 if v.AutomaticInputFailoverSettings != nil { 2150 if err := validateAutomaticInputFailoverSettings(v.AutomaticInputFailoverSettings); err != nil { 2151 invalidParams.AddNested("AutomaticInputFailoverSettings", err.(smithy.InvalidParamsError)) 2152 } 2153 } 2154 if v.InputSettings != nil { 2155 if err := validateInputSettings(v.InputSettings); err != nil { 2156 invalidParams.AddNested("InputSettings", err.(smithy.InvalidParamsError)) 2157 } 2158 } 2159 if invalidParams.Len() > 0 { 2160 return invalidParams 2161 } else { 2162 return nil 2163 } 2164} 2165 2166func validateInputChannelLevel(v *types.InputChannelLevel) error { 2167 if v == nil { 2168 return nil 2169 } 2170 invalidParams := smithy.InvalidParamsError{Context: "InputChannelLevel"} 2171 if invalidParams.Len() > 0 { 2172 return invalidParams 2173 } else { 2174 return nil 2175 } 2176} 2177 2178func validateInputClippingSettings(v *types.InputClippingSettings) error { 2179 if v == nil { 2180 return nil 2181 } 2182 invalidParams := smithy.InvalidParamsError{Context: "InputClippingSettings"} 2183 if len(v.InputTimecodeSource) == 0 { 2184 invalidParams.Add(smithy.NewErrParamRequired("InputTimecodeSource")) 2185 } 2186 if invalidParams.Len() > 0 { 2187 return invalidParams 2188 } else { 2189 return nil 2190 } 2191} 2192 2193func validateInputLocation(v *types.InputLocation) error { 2194 if v == nil { 2195 return nil 2196 } 2197 invalidParams := smithy.InvalidParamsError{Context: "InputLocation"} 2198 if v.Uri == nil { 2199 invalidParams.Add(smithy.NewErrParamRequired("Uri")) 2200 } 2201 if invalidParams.Len() > 0 { 2202 return invalidParams 2203 } else { 2204 return nil 2205 } 2206} 2207 2208func validateInputLossBehavior(v *types.InputLossBehavior) error { 2209 if v == nil { 2210 return nil 2211 } 2212 invalidParams := smithy.InvalidParamsError{Context: "InputLossBehavior"} 2213 if v.InputLossImageSlate != nil { 2214 if err := validateInputLocation(v.InputLossImageSlate); err != nil { 2215 invalidParams.AddNested("InputLossImageSlate", err.(smithy.InvalidParamsError)) 2216 } 2217 } 2218 if invalidParams.Len() > 0 { 2219 return invalidParams 2220 } else { 2221 return nil 2222 } 2223} 2224 2225func validateInputPrepareScheduleActionSettings(v *types.InputPrepareScheduleActionSettings) error { 2226 if v == nil { 2227 return nil 2228 } 2229 invalidParams := smithy.InvalidParamsError{Context: "InputPrepareScheduleActionSettings"} 2230 if v.InputClippingSettings != nil { 2231 if err := validateInputClippingSettings(v.InputClippingSettings); err != nil { 2232 invalidParams.AddNested("InputClippingSettings", err.(smithy.InvalidParamsError)) 2233 } 2234 } 2235 if invalidParams.Len() > 0 { 2236 return invalidParams 2237 } else { 2238 return nil 2239 } 2240} 2241 2242func validateInputSettings(v *types.InputSettings) error { 2243 if v == nil { 2244 return nil 2245 } 2246 invalidParams := smithy.InvalidParamsError{Context: "InputSettings"} 2247 if v.AudioSelectors != nil { 2248 if err := validate__listOfAudioSelector(v.AudioSelectors); err != nil { 2249 invalidParams.AddNested("AudioSelectors", err.(smithy.InvalidParamsError)) 2250 } 2251 } 2252 if v.CaptionSelectors != nil { 2253 if err := validate__listOfCaptionSelector(v.CaptionSelectors); err != nil { 2254 invalidParams.AddNested("CaptionSelectors", err.(smithy.InvalidParamsError)) 2255 } 2256 } 2257 if invalidParams.Len() > 0 { 2258 return invalidParams 2259 } else { 2260 return nil 2261 } 2262} 2263 2264func validateInputSwitchScheduleActionSettings(v *types.InputSwitchScheduleActionSettings) error { 2265 if v == nil { 2266 return nil 2267 } 2268 invalidParams := smithy.InvalidParamsError{Context: "InputSwitchScheduleActionSettings"} 2269 if v.InputAttachmentNameReference == nil { 2270 invalidParams.Add(smithy.NewErrParamRequired("InputAttachmentNameReference")) 2271 } 2272 if v.InputClippingSettings != nil { 2273 if err := validateInputClippingSettings(v.InputClippingSettings); err != nil { 2274 invalidParams.AddNested("InputClippingSettings", err.(smithy.InvalidParamsError)) 2275 } 2276 } 2277 if invalidParams.Len() > 0 { 2278 return invalidParams 2279 } else { 2280 return nil 2281 } 2282} 2283 2284func validateInputVpcRequest(v *types.InputVpcRequest) error { 2285 if v == nil { 2286 return nil 2287 } 2288 invalidParams := smithy.InvalidParamsError{Context: "InputVpcRequest"} 2289 if v.SubnetIds == nil { 2290 invalidParams.Add(smithy.NewErrParamRequired("SubnetIds")) 2291 } 2292 if invalidParams.Len() > 0 { 2293 return invalidParams 2294 } else { 2295 return nil 2296 } 2297} 2298 2299func validateKeyProviderSettings(v *types.KeyProviderSettings) error { 2300 if v == nil { 2301 return nil 2302 } 2303 invalidParams := smithy.InvalidParamsError{Context: "KeyProviderSettings"} 2304 if v.StaticKeySettings != nil { 2305 if err := validateStaticKeySettings(v.StaticKeySettings); err != nil { 2306 invalidParams.AddNested("StaticKeySettings", err.(smithy.InvalidParamsError)) 2307 } 2308 } 2309 if invalidParams.Len() > 0 { 2310 return invalidParams 2311 } else { 2312 return nil 2313 } 2314} 2315 2316func validateM2tsSettings(v *types.M2tsSettings) error { 2317 if v == nil { 2318 return nil 2319 } 2320 invalidParams := smithy.InvalidParamsError{Context: "M2tsSettings"} 2321 if v.DvbNitSettings != nil { 2322 if err := validateDvbNitSettings(v.DvbNitSettings); err != nil { 2323 invalidParams.AddNested("DvbNitSettings", err.(smithy.InvalidParamsError)) 2324 } 2325 } 2326 if invalidParams.Len() > 0 { 2327 return invalidParams 2328 } else { 2329 return nil 2330 } 2331} 2332 2333func validateMediaPackageGroupSettings(v *types.MediaPackageGroupSettings) error { 2334 if v == nil { 2335 return nil 2336 } 2337 invalidParams := smithy.InvalidParamsError{Context: "MediaPackageGroupSettings"} 2338 if v.Destination == nil { 2339 invalidParams.Add(smithy.NewErrParamRequired("Destination")) 2340 } 2341 if invalidParams.Len() > 0 { 2342 return invalidParams 2343 } else { 2344 return nil 2345 } 2346} 2347 2348func validateMotionGraphicsConfiguration(v *types.MotionGraphicsConfiguration) error { 2349 if v == nil { 2350 return nil 2351 } 2352 invalidParams := smithy.InvalidParamsError{Context: "MotionGraphicsConfiguration"} 2353 if v.MotionGraphicsSettings == nil { 2354 invalidParams.Add(smithy.NewErrParamRequired("MotionGraphicsSettings")) 2355 } 2356 if invalidParams.Len() > 0 { 2357 return invalidParams 2358 } else { 2359 return nil 2360 } 2361} 2362 2363func validateMpeg2Settings(v *types.Mpeg2Settings) error { 2364 if v == nil { 2365 return nil 2366 } 2367 invalidParams := smithy.InvalidParamsError{Context: "Mpeg2Settings"} 2368 if invalidParams.Len() > 0 { 2369 return invalidParams 2370 } else { 2371 return nil 2372 } 2373} 2374 2375func validateMsSmoothGroupSettings(v *types.MsSmoothGroupSettings) error { 2376 if v == nil { 2377 return nil 2378 } 2379 invalidParams := smithy.InvalidParamsError{Context: "MsSmoothGroupSettings"} 2380 if v.Destination == nil { 2381 invalidParams.Add(smithy.NewErrParamRequired("Destination")) 2382 } 2383 if invalidParams.Len() > 0 { 2384 return invalidParams 2385 } else { 2386 return nil 2387 } 2388} 2389 2390func validateMultiplexOutputSettings(v *types.MultiplexOutputSettings) error { 2391 if v == nil { 2392 return nil 2393 } 2394 invalidParams := smithy.InvalidParamsError{Context: "MultiplexOutputSettings"} 2395 if v.Destination == nil { 2396 invalidParams.Add(smithy.NewErrParamRequired("Destination")) 2397 } 2398 if invalidParams.Len() > 0 { 2399 return invalidParams 2400 } else { 2401 return nil 2402 } 2403} 2404 2405func validateMultiplexProgramServiceDescriptor(v *types.MultiplexProgramServiceDescriptor) error { 2406 if v == nil { 2407 return nil 2408 } 2409 invalidParams := smithy.InvalidParamsError{Context: "MultiplexProgramServiceDescriptor"} 2410 if v.ProviderName == nil { 2411 invalidParams.Add(smithy.NewErrParamRequired("ProviderName")) 2412 } 2413 if v.ServiceName == nil { 2414 invalidParams.Add(smithy.NewErrParamRequired("ServiceName")) 2415 } 2416 if invalidParams.Len() > 0 { 2417 return invalidParams 2418 } else { 2419 return nil 2420 } 2421} 2422 2423func validateMultiplexProgramSettings(v *types.MultiplexProgramSettings) error { 2424 if v == nil { 2425 return nil 2426 } 2427 invalidParams := smithy.InvalidParamsError{Context: "MultiplexProgramSettings"} 2428 if v.ServiceDescriptor != nil { 2429 if err := validateMultiplexProgramServiceDescriptor(v.ServiceDescriptor); err != nil { 2430 invalidParams.AddNested("ServiceDescriptor", err.(smithy.InvalidParamsError)) 2431 } 2432 } 2433 if invalidParams.Len() > 0 { 2434 return invalidParams 2435 } else { 2436 return nil 2437 } 2438} 2439 2440func validateMultiplexSettings(v *types.MultiplexSettings) error { 2441 if v == nil { 2442 return nil 2443 } 2444 invalidParams := smithy.InvalidParamsError{Context: "MultiplexSettings"} 2445 if invalidParams.Len() > 0 { 2446 return invalidParams 2447 } else { 2448 return nil 2449 } 2450} 2451 2452func validateOutput(v *types.Output) error { 2453 if v == nil { 2454 return nil 2455 } 2456 invalidParams := smithy.InvalidParamsError{Context: "Output"} 2457 if v.OutputSettings == nil { 2458 invalidParams.Add(smithy.NewErrParamRequired("OutputSettings")) 2459 } else if v.OutputSettings != nil { 2460 if err := validateOutputSettings(v.OutputSettings); err != nil { 2461 invalidParams.AddNested("OutputSettings", err.(smithy.InvalidParamsError)) 2462 } 2463 } 2464 if invalidParams.Len() > 0 { 2465 return invalidParams 2466 } else { 2467 return nil 2468 } 2469} 2470 2471func validateOutputGroup(v *types.OutputGroup) error { 2472 if v == nil { 2473 return nil 2474 } 2475 invalidParams := smithy.InvalidParamsError{Context: "OutputGroup"} 2476 if v.OutputGroupSettings == nil { 2477 invalidParams.Add(smithy.NewErrParamRequired("OutputGroupSettings")) 2478 } else if v.OutputGroupSettings != nil { 2479 if err := validateOutputGroupSettings(v.OutputGroupSettings); err != nil { 2480 invalidParams.AddNested("OutputGroupSettings", err.(smithy.InvalidParamsError)) 2481 } 2482 } 2483 if v.Outputs == nil { 2484 invalidParams.Add(smithy.NewErrParamRequired("Outputs")) 2485 } else if v.Outputs != nil { 2486 if err := validate__listOfOutput(v.Outputs); err != nil { 2487 invalidParams.AddNested("Outputs", err.(smithy.InvalidParamsError)) 2488 } 2489 } 2490 if invalidParams.Len() > 0 { 2491 return invalidParams 2492 } else { 2493 return nil 2494 } 2495} 2496 2497func validateOutputGroupSettings(v *types.OutputGroupSettings) error { 2498 if v == nil { 2499 return nil 2500 } 2501 invalidParams := smithy.InvalidParamsError{Context: "OutputGroupSettings"} 2502 if v.ArchiveGroupSettings != nil { 2503 if err := validateArchiveGroupSettings(v.ArchiveGroupSettings); err != nil { 2504 invalidParams.AddNested("ArchiveGroupSettings", err.(smithy.InvalidParamsError)) 2505 } 2506 } 2507 if v.FrameCaptureGroupSettings != nil { 2508 if err := validateFrameCaptureGroupSettings(v.FrameCaptureGroupSettings); err != nil { 2509 invalidParams.AddNested("FrameCaptureGroupSettings", err.(smithy.InvalidParamsError)) 2510 } 2511 } 2512 if v.HlsGroupSettings != nil { 2513 if err := validateHlsGroupSettings(v.HlsGroupSettings); err != nil { 2514 invalidParams.AddNested("HlsGroupSettings", err.(smithy.InvalidParamsError)) 2515 } 2516 } 2517 if v.MediaPackageGroupSettings != nil { 2518 if err := validateMediaPackageGroupSettings(v.MediaPackageGroupSettings); err != nil { 2519 invalidParams.AddNested("MediaPackageGroupSettings", err.(smithy.InvalidParamsError)) 2520 } 2521 } 2522 if v.MsSmoothGroupSettings != nil { 2523 if err := validateMsSmoothGroupSettings(v.MsSmoothGroupSettings); err != nil { 2524 invalidParams.AddNested("MsSmoothGroupSettings", err.(smithy.InvalidParamsError)) 2525 } 2526 } 2527 if invalidParams.Len() > 0 { 2528 return invalidParams 2529 } else { 2530 return nil 2531 } 2532} 2533 2534func validateOutputSettings(v *types.OutputSettings) error { 2535 if v == nil { 2536 return nil 2537 } 2538 invalidParams := smithy.InvalidParamsError{Context: "OutputSettings"} 2539 if v.ArchiveOutputSettings != nil { 2540 if err := validateArchiveOutputSettings(v.ArchiveOutputSettings); err != nil { 2541 invalidParams.AddNested("ArchiveOutputSettings", err.(smithy.InvalidParamsError)) 2542 } 2543 } 2544 if v.HlsOutputSettings != nil { 2545 if err := validateHlsOutputSettings(v.HlsOutputSettings); err != nil { 2546 invalidParams.AddNested("HlsOutputSettings", err.(smithy.InvalidParamsError)) 2547 } 2548 } 2549 if v.MultiplexOutputSettings != nil { 2550 if err := validateMultiplexOutputSettings(v.MultiplexOutputSettings); err != nil { 2551 invalidParams.AddNested("MultiplexOutputSettings", err.(smithy.InvalidParamsError)) 2552 } 2553 } 2554 if v.RtmpOutputSettings != nil { 2555 if err := validateRtmpOutputSettings(v.RtmpOutputSettings); err != nil { 2556 invalidParams.AddNested("RtmpOutputSettings", err.(smithy.InvalidParamsError)) 2557 } 2558 } 2559 if v.UdpOutputSettings != nil { 2560 if err := validateUdpOutputSettings(v.UdpOutputSettings); err != nil { 2561 invalidParams.AddNested("UdpOutputSettings", err.(smithy.InvalidParamsError)) 2562 } 2563 } 2564 if invalidParams.Len() > 0 { 2565 return invalidParams 2566 } else { 2567 return nil 2568 } 2569} 2570 2571func validatePauseStateScheduleActionSettings(v *types.PauseStateScheduleActionSettings) error { 2572 if v == nil { 2573 return nil 2574 } 2575 invalidParams := smithy.InvalidParamsError{Context: "PauseStateScheduleActionSettings"} 2576 if v.Pipelines != nil { 2577 if err := validate__listOfPipelinePauseStateSettings(v.Pipelines); err != nil { 2578 invalidParams.AddNested("Pipelines", err.(smithy.InvalidParamsError)) 2579 } 2580 } 2581 if invalidParams.Len() > 0 { 2582 return invalidParams 2583 } else { 2584 return nil 2585 } 2586} 2587 2588func validatePipelinePauseStateSettings(v *types.PipelinePauseStateSettings) error { 2589 if v == nil { 2590 return nil 2591 } 2592 invalidParams := smithy.InvalidParamsError{Context: "PipelinePauseStateSettings"} 2593 if len(v.PipelineId) == 0 { 2594 invalidParams.Add(smithy.NewErrParamRequired("PipelineId")) 2595 } 2596 if invalidParams.Len() > 0 { 2597 return invalidParams 2598 } else { 2599 return nil 2600 } 2601} 2602 2603func validateRemixSettings(v *types.RemixSettings) error { 2604 if v == nil { 2605 return nil 2606 } 2607 invalidParams := smithy.InvalidParamsError{Context: "RemixSettings"} 2608 if v.ChannelMappings == nil { 2609 invalidParams.Add(smithy.NewErrParamRequired("ChannelMappings")) 2610 } else if v.ChannelMappings != nil { 2611 if err := validate__listOfAudioChannelMapping(v.ChannelMappings); err != nil { 2612 invalidParams.AddNested("ChannelMappings", err.(smithy.InvalidParamsError)) 2613 } 2614 } 2615 if invalidParams.Len() > 0 { 2616 return invalidParams 2617 } else { 2618 return nil 2619 } 2620} 2621 2622func validateRtmpOutputSettings(v *types.RtmpOutputSettings) error { 2623 if v == nil { 2624 return nil 2625 } 2626 invalidParams := smithy.InvalidParamsError{Context: "RtmpOutputSettings"} 2627 if v.Destination == nil { 2628 invalidParams.Add(smithy.NewErrParamRequired("Destination")) 2629 } 2630 if invalidParams.Len() > 0 { 2631 return invalidParams 2632 } else { 2633 return nil 2634 } 2635} 2636 2637func validateScheduleAction(v *types.ScheduleAction) error { 2638 if v == nil { 2639 return nil 2640 } 2641 invalidParams := smithy.InvalidParamsError{Context: "ScheduleAction"} 2642 if v.ActionName == nil { 2643 invalidParams.Add(smithy.NewErrParamRequired("ActionName")) 2644 } 2645 if v.ScheduleActionSettings == nil { 2646 invalidParams.Add(smithy.NewErrParamRequired("ScheduleActionSettings")) 2647 } else if v.ScheduleActionSettings != nil { 2648 if err := validateScheduleActionSettings(v.ScheduleActionSettings); err != nil { 2649 invalidParams.AddNested("ScheduleActionSettings", err.(smithy.InvalidParamsError)) 2650 } 2651 } 2652 if v.ScheduleActionStartSettings == nil { 2653 invalidParams.Add(smithy.NewErrParamRequired("ScheduleActionStartSettings")) 2654 } else if v.ScheduleActionStartSettings != nil { 2655 if err := validateScheduleActionStartSettings(v.ScheduleActionStartSettings); err != nil { 2656 invalidParams.AddNested("ScheduleActionStartSettings", err.(smithy.InvalidParamsError)) 2657 } 2658 } 2659 if invalidParams.Len() > 0 { 2660 return invalidParams 2661 } else { 2662 return nil 2663 } 2664} 2665 2666func validateScheduleActionSettings(v *types.ScheduleActionSettings) error { 2667 if v == nil { 2668 return nil 2669 } 2670 invalidParams := smithy.InvalidParamsError{Context: "ScheduleActionSettings"} 2671 if v.HlsId3SegmentTaggingSettings != nil { 2672 if err := validateHlsId3SegmentTaggingScheduleActionSettings(v.HlsId3SegmentTaggingSettings); err != nil { 2673 invalidParams.AddNested("HlsId3SegmentTaggingSettings", err.(smithy.InvalidParamsError)) 2674 } 2675 } 2676 if v.HlsTimedMetadataSettings != nil { 2677 if err := validateHlsTimedMetadataScheduleActionSettings(v.HlsTimedMetadataSettings); err != nil { 2678 invalidParams.AddNested("HlsTimedMetadataSettings", err.(smithy.InvalidParamsError)) 2679 } 2680 } 2681 if v.InputPrepareSettings != nil { 2682 if err := validateInputPrepareScheduleActionSettings(v.InputPrepareSettings); err != nil { 2683 invalidParams.AddNested("InputPrepareSettings", err.(smithy.InvalidParamsError)) 2684 } 2685 } 2686 if v.InputSwitchSettings != nil { 2687 if err := validateInputSwitchScheduleActionSettings(v.InputSwitchSettings); err != nil { 2688 invalidParams.AddNested("InputSwitchSettings", err.(smithy.InvalidParamsError)) 2689 } 2690 } 2691 if v.PauseStateSettings != nil { 2692 if err := validatePauseStateScheduleActionSettings(v.PauseStateSettings); err != nil { 2693 invalidParams.AddNested("PauseStateSettings", err.(smithy.InvalidParamsError)) 2694 } 2695 } 2696 if v.Scte35ReturnToNetworkSettings != nil { 2697 if err := validateScte35ReturnToNetworkScheduleActionSettings(v.Scte35ReturnToNetworkSettings); err != nil { 2698 invalidParams.AddNested("Scte35ReturnToNetworkSettings", err.(smithy.InvalidParamsError)) 2699 } 2700 } 2701 if v.Scte35SpliceInsertSettings != nil { 2702 if err := validateScte35SpliceInsertScheduleActionSettings(v.Scte35SpliceInsertSettings); err != nil { 2703 invalidParams.AddNested("Scte35SpliceInsertSettings", err.(smithy.InvalidParamsError)) 2704 } 2705 } 2706 if v.Scte35TimeSignalSettings != nil { 2707 if err := validateScte35TimeSignalScheduleActionSettings(v.Scte35TimeSignalSettings); err != nil { 2708 invalidParams.AddNested("Scte35TimeSignalSettings", err.(smithy.InvalidParamsError)) 2709 } 2710 } 2711 if v.StaticImageActivateSettings != nil { 2712 if err := validateStaticImageActivateScheduleActionSettings(v.StaticImageActivateSettings); err != nil { 2713 invalidParams.AddNested("StaticImageActivateSettings", err.(smithy.InvalidParamsError)) 2714 } 2715 } 2716 if invalidParams.Len() > 0 { 2717 return invalidParams 2718 } else { 2719 return nil 2720 } 2721} 2722 2723func validateScheduleActionStartSettings(v *types.ScheduleActionStartSettings) error { 2724 if v == nil { 2725 return nil 2726 } 2727 invalidParams := smithy.InvalidParamsError{Context: "ScheduleActionStartSettings"} 2728 if v.FixedModeScheduleActionStartSettings != nil { 2729 if err := validateFixedModeScheduleActionStartSettings(v.FixedModeScheduleActionStartSettings); err != nil { 2730 invalidParams.AddNested("FixedModeScheduleActionStartSettings", err.(smithy.InvalidParamsError)) 2731 } 2732 } 2733 if v.FollowModeScheduleActionStartSettings != nil { 2734 if err := validateFollowModeScheduleActionStartSettings(v.FollowModeScheduleActionStartSettings); err != nil { 2735 invalidParams.AddNested("FollowModeScheduleActionStartSettings", err.(smithy.InvalidParamsError)) 2736 } 2737 } 2738 if invalidParams.Len() > 0 { 2739 return invalidParams 2740 } else { 2741 return nil 2742 } 2743} 2744 2745func validateScte35DeliveryRestrictions(v *types.Scte35DeliveryRestrictions) error { 2746 if v == nil { 2747 return nil 2748 } 2749 invalidParams := smithy.InvalidParamsError{Context: "Scte35DeliveryRestrictions"} 2750 if len(v.ArchiveAllowedFlag) == 0 { 2751 invalidParams.Add(smithy.NewErrParamRequired("ArchiveAllowedFlag")) 2752 } 2753 if len(v.DeviceRestrictions) == 0 { 2754 invalidParams.Add(smithy.NewErrParamRequired("DeviceRestrictions")) 2755 } 2756 if len(v.NoRegionalBlackoutFlag) == 0 { 2757 invalidParams.Add(smithy.NewErrParamRequired("NoRegionalBlackoutFlag")) 2758 } 2759 if len(v.WebDeliveryAllowedFlag) == 0 { 2760 invalidParams.Add(smithy.NewErrParamRequired("WebDeliveryAllowedFlag")) 2761 } 2762 if invalidParams.Len() > 0 { 2763 return invalidParams 2764 } else { 2765 return nil 2766 } 2767} 2768 2769func validateScte35Descriptor(v *types.Scte35Descriptor) error { 2770 if v == nil { 2771 return nil 2772 } 2773 invalidParams := smithy.InvalidParamsError{Context: "Scte35Descriptor"} 2774 if v.Scte35DescriptorSettings == nil { 2775 invalidParams.Add(smithy.NewErrParamRequired("Scte35DescriptorSettings")) 2776 } else if v.Scte35DescriptorSettings != nil { 2777 if err := validateScte35DescriptorSettings(v.Scte35DescriptorSettings); err != nil { 2778 invalidParams.AddNested("Scte35DescriptorSettings", err.(smithy.InvalidParamsError)) 2779 } 2780 } 2781 if invalidParams.Len() > 0 { 2782 return invalidParams 2783 } else { 2784 return nil 2785 } 2786} 2787 2788func validateScte35DescriptorSettings(v *types.Scte35DescriptorSettings) error { 2789 if v == nil { 2790 return nil 2791 } 2792 invalidParams := smithy.InvalidParamsError{Context: "Scte35DescriptorSettings"} 2793 if v.SegmentationDescriptorScte35DescriptorSettings == nil { 2794 invalidParams.Add(smithy.NewErrParamRequired("SegmentationDescriptorScte35DescriptorSettings")) 2795 } else if v.SegmentationDescriptorScte35DescriptorSettings != nil { 2796 if err := validateScte35SegmentationDescriptor(v.SegmentationDescriptorScte35DescriptorSettings); err != nil { 2797 invalidParams.AddNested("SegmentationDescriptorScte35DescriptorSettings", err.(smithy.InvalidParamsError)) 2798 } 2799 } 2800 if invalidParams.Len() > 0 { 2801 return invalidParams 2802 } else { 2803 return nil 2804 } 2805} 2806 2807func validateScte35ReturnToNetworkScheduleActionSettings(v *types.Scte35ReturnToNetworkScheduleActionSettings) error { 2808 if v == nil { 2809 return nil 2810 } 2811 invalidParams := smithy.InvalidParamsError{Context: "Scte35ReturnToNetworkScheduleActionSettings"} 2812 if invalidParams.Len() > 0 { 2813 return invalidParams 2814 } else { 2815 return nil 2816 } 2817} 2818 2819func validateScte35SegmentationDescriptor(v *types.Scte35SegmentationDescriptor) error { 2820 if v == nil { 2821 return nil 2822 } 2823 invalidParams := smithy.InvalidParamsError{Context: "Scte35SegmentationDescriptor"} 2824 if v.DeliveryRestrictions != nil { 2825 if err := validateScte35DeliveryRestrictions(v.DeliveryRestrictions); err != nil { 2826 invalidParams.AddNested("DeliveryRestrictions", err.(smithy.InvalidParamsError)) 2827 } 2828 } 2829 if len(v.SegmentationCancelIndicator) == 0 { 2830 invalidParams.Add(smithy.NewErrParamRequired("SegmentationCancelIndicator")) 2831 } 2832 if invalidParams.Len() > 0 { 2833 return invalidParams 2834 } else { 2835 return nil 2836 } 2837} 2838 2839func validateScte35SpliceInsertScheduleActionSettings(v *types.Scte35SpliceInsertScheduleActionSettings) error { 2840 if v == nil { 2841 return nil 2842 } 2843 invalidParams := smithy.InvalidParamsError{Context: "Scte35SpliceInsertScheduleActionSettings"} 2844 if invalidParams.Len() > 0 { 2845 return invalidParams 2846 } else { 2847 return nil 2848 } 2849} 2850 2851func validateScte35TimeSignalScheduleActionSettings(v *types.Scte35TimeSignalScheduleActionSettings) error { 2852 if v == nil { 2853 return nil 2854 } 2855 invalidParams := smithy.InvalidParamsError{Context: "Scte35TimeSignalScheduleActionSettings"} 2856 if v.Scte35Descriptors == nil { 2857 invalidParams.Add(smithy.NewErrParamRequired("Scte35Descriptors")) 2858 } else if v.Scte35Descriptors != nil { 2859 if err := validate__listOfScte35Descriptor(v.Scte35Descriptors); err != nil { 2860 invalidParams.AddNested("Scte35Descriptors", err.(smithy.InvalidParamsError)) 2861 } 2862 } 2863 if invalidParams.Len() > 0 { 2864 return invalidParams 2865 } else { 2866 return nil 2867 } 2868} 2869 2870func validateStandardHlsSettings(v *types.StandardHlsSettings) error { 2871 if v == nil { 2872 return nil 2873 } 2874 invalidParams := smithy.InvalidParamsError{Context: "StandardHlsSettings"} 2875 if v.M3u8Settings == nil { 2876 invalidParams.Add(smithy.NewErrParamRequired("M3u8Settings")) 2877 } 2878 if invalidParams.Len() > 0 { 2879 return invalidParams 2880 } else { 2881 return nil 2882 } 2883} 2884 2885func validateStaticImageActivateScheduleActionSettings(v *types.StaticImageActivateScheduleActionSettings) error { 2886 if v == nil { 2887 return nil 2888 } 2889 invalidParams := smithy.InvalidParamsError{Context: "StaticImageActivateScheduleActionSettings"} 2890 if v.Image == nil { 2891 invalidParams.Add(smithy.NewErrParamRequired("Image")) 2892 } else if v.Image != nil { 2893 if err := validateInputLocation(v.Image); err != nil { 2894 invalidParams.AddNested("Image", err.(smithy.InvalidParamsError)) 2895 } 2896 } 2897 if invalidParams.Len() > 0 { 2898 return invalidParams 2899 } else { 2900 return nil 2901 } 2902} 2903 2904func validateStaticKeySettings(v *types.StaticKeySettings) error { 2905 if v == nil { 2906 return nil 2907 } 2908 invalidParams := smithy.InvalidParamsError{Context: "StaticKeySettings"} 2909 if v.KeyProviderServer != nil { 2910 if err := validateInputLocation(v.KeyProviderServer); err != nil { 2911 invalidParams.AddNested("KeyProviderServer", err.(smithy.InvalidParamsError)) 2912 } 2913 } 2914 if v.StaticKeyValue == nil { 2915 invalidParams.Add(smithy.NewErrParamRequired("StaticKeyValue")) 2916 } 2917 if invalidParams.Len() > 0 { 2918 return invalidParams 2919 } else { 2920 return nil 2921 } 2922} 2923 2924func validateTeletextSourceSettings(v *types.TeletextSourceSettings) error { 2925 if v == nil { 2926 return nil 2927 } 2928 invalidParams := smithy.InvalidParamsError{Context: "TeletextSourceSettings"} 2929 if v.OutputRectangle != nil { 2930 if err := validateCaptionRectangle(v.OutputRectangle); err != nil { 2931 invalidParams.AddNested("OutputRectangle", err.(smithy.InvalidParamsError)) 2932 } 2933 } 2934 if invalidParams.Len() > 0 { 2935 return invalidParams 2936 } else { 2937 return nil 2938 } 2939} 2940 2941func validateTimecodeConfig(v *types.TimecodeConfig) error { 2942 if v == nil { 2943 return nil 2944 } 2945 invalidParams := smithy.InvalidParamsError{Context: "TimecodeConfig"} 2946 if len(v.Source) == 0 { 2947 invalidParams.Add(smithy.NewErrParamRequired("Source")) 2948 } 2949 if invalidParams.Len() > 0 { 2950 return invalidParams 2951 } else { 2952 return nil 2953 } 2954} 2955 2956func validateUdpContainerSettings(v *types.UdpContainerSettings) error { 2957 if v == nil { 2958 return nil 2959 } 2960 invalidParams := smithy.InvalidParamsError{Context: "UdpContainerSettings"} 2961 if v.M2tsSettings != nil { 2962 if err := validateM2tsSettings(v.M2tsSettings); err != nil { 2963 invalidParams.AddNested("M2tsSettings", err.(smithy.InvalidParamsError)) 2964 } 2965 } 2966 if invalidParams.Len() > 0 { 2967 return invalidParams 2968 } else { 2969 return nil 2970 } 2971} 2972 2973func validateUdpOutputSettings(v *types.UdpOutputSettings) error { 2974 if v == nil { 2975 return nil 2976 } 2977 invalidParams := smithy.InvalidParamsError{Context: "UdpOutputSettings"} 2978 if v.ContainerSettings == nil { 2979 invalidParams.Add(smithy.NewErrParamRequired("ContainerSettings")) 2980 } else if v.ContainerSettings != nil { 2981 if err := validateUdpContainerSettings(v.ContainerSettings); err != nil { 2982 invalidParams.AddNested("ContainerSettings", err.(smithy.InvalidParamsError)) 2983 } 2984 } 2985 if v.Destination == nil { 2986 invalidParams.Add(smithy.NewErrParamRequired("Destination")) 2987 } 2988 if invalidParams.Len() > 0 { 2989 return invalidParams 2990 } else { 2991 return nil 2992 } 2993} 2994 2995func validateVideoCodecSettings(v *types.VideoCodecSettings) error { 2996 if v == nil { 2997 return nil 2998 } 2999 invalidParams := smithy.InvalidParamsError{Context: "VideoCodecSettings"} 3000 if v.H265Settings != nil { 3001 if err := validateH265Settings(v.H265Settings); err != nil { 3002 invalidParams.AddNested("H265Settings", err.(smithy.InvalidParamsError)) 3003 } 3004 } 3005 if v.Mpeg2Settings != nil { 3006 if err := validateMpeg2Settings(v.Mpeg2Settings); err != nil { 3007 invalidParams.AddNested("Mpeg2Settings", err.(smithy.InvalidParamsError)) 3008 } 3009 } 3010 if invalidParams.Len() > 0 { 3011 return invalidParams 3012 } else { 3013 return nil 3014 } 3015} 3016 3017func validateVideoDescription(v *types.VideoDescription) error { 3018 if v == nil { 3019 return nil 3020 } 3021 invalidParams := smithy.InvalidParamsError{Context: "VideoDescription"} 3022 if v.CodecSettings != nil { 3023 if err := validateVideoCodecSettings(v.CodecSettings); err != nil { 3024 invalidParams.AddNested("CodecSettings", err.(smithy.InvalidParamsError)) 3025 } 3026 } 3027 if v.Name == nil { 3028 invalidParams.Add(smithy.NewErrParamRequired("Name")) 3029 } 3030 if invalidParams.Len() > 0 { 3031 return invalidParams 3032 } else { 3033 return nil 3034 } 3035} 3036 3037func validateVpcOutputSettings(v *types.VpcOutputSettings) error { 3038 if v == nil { 3039 return nil 3040 } 3041 invalidParams := smithy.InvalidParamsError{Context: "VpcOutputSettings"} 3042 if v.SubnetIds == nil { 3043 invalidParams.Add(smithy.NewErrParamRequired("SubnetIds")) 3044 } 3045 if invalidParams.Len() > 0 { 3046 return invalidParams 3047 } else { 3048 return nil 3049 } 3050} 3051 3052func validateOpAcceptInputDeviceTransferInput(v *AcceptInputDeviceTransferInput) error { 3053 if v == nil { 3054 return nil 3055 } 3056 invalidParams := smithy.InvalidParamsError{Context: "AcceptInputDeviceTransferInput"} 3057 if v.InputDeviceId == nil { 3058 invalidParams.Add(smithy.NewErrParamRequired("InputDeviceId")) 3059 } 3060 if invalidParams.Len() > 0 { 3061 return invalidParams 3062 } else { 3063 return nil 3064 } 3065} 3066 3067func validateOpBatchUpdateScheduleInput(v *BatchUpdateScheduleInput) error { 3068 if v == nil { 3069 return nil 3070 } 3071 invalidParams := smithy.InvalidParamsError{Context: "BatchUpdateScheduleInput"} 3072 if v.ChannelId == nil { 3073 invalidParams.Add(smithy.NewErrParamRequired("ChannelId")) 3074 } 3075 if v.Creates != nil { 3076 if err := validateBatchScheduleActionCreateRequest(v.Creates); err != nil { 3077 invalidParams.AddNested("Creates", err.(smithy.InvalidParamsError)) 3078 } 3079 } 3080 if v.Deletes != nil { 3081 if err := validateBatchScheduleActionDeleteRequest(v.Deletes); err != nil { 3082 invalidParams.AddNested("Deletes", err.(smithy.InvalidParamsError)) 3083 } 3084 } 3085 if invalidParams.Len() > 0 { 3086 return invalidParams 3087 } else { 3088 return nil 3089 } 3090} 3091 3092func validateOpCancelInputDeviceTransferInput(v *CancelInputDeviceTransferInput) error { 3093 if v == nil { 3094 return nil 3095 } 3096 invalidParams := smithy.InvalidParamsError{Context: "CancelInputDeviceTransferInput"} 3097 if v.InputDeviceId == nil { 3098 invalidParams.Add(smithy.NewErrParamRequired("InputDeviceId")) 3099 } 3100 if invalidParams.Len() > 0 { 3101 return invalidParams 3102 } else { 3103 return nil 3104 } 3105} 3106 3107func validateOpCreateChannelInput(v *CreateChannelInput) error { 3108 if v == nil { 3109 return nil 3110 } 3111 invalidParams := smithy.InvalidParamsError{Context: "CreateChannelInput"} 3112 if v.EncoderSettings != nil { 3113 if err := validateEncoderSettings(v.EncoderSettings); err != nil { 3114 invalidParams.AddNested("EncoderSettings", err.(smithy.InvalidParamsError)) 3115 } 3116 } 3117 if v.InputAttachments != nil { 3118 if err := validate__listOfInputAttachment(v.InputAttachments); err != nil { 3119 invalidParams.AddNested("InputAttachments", err.(smithy.InvalidParamsError)) 3120 } 3121 } 3122 if v.Vpc != nil { 3123 if err := validateVpcOutputSettings(v.Vpc); err != nil { 3124 invalidParams.AddNested("Vpc", err.(smithy.InvalidParamsError)) 3125 } 3126 } 3127 if invalidParams.Len() > 0 { 3128 return invalidParams 3129 } else { 3130 return nil 3131 } 3132} 3133 3134func validateOpCreateInputInput(v *CreateInputInput) error { 3135 if v == nil { 3136 return nil 3137 } 3138 invalidParams := smithy.InvalidParamsError{Context: "CreateInputInput"} 3139 if v.Vpc != nil { 3140 if err := validateInputVpcRequest(v.Vpc); err != nil { 3141 invalidParams.AddNested("Vpc", err.(smithy.InvalidParamsError)) 3142 } 3143 } 3144 if invalidParams.Len() > 0 { 3145 return invalidParams 3146 } else { 3147 return nil 3148 } 3149} 3150 3151func validateOpCreateMultiplexInput(v *CreateMultiplexInput) error { 3152 if v == nil { 3153 return nil 3154 } 3155 invalidParams := smithy.InvalidParamsError{Context: "CreateMultiplexInput"} 3156 if v.AvailabilityZones == nil { 3157 invalidParams.Add(smithy.NewErrParamRequired("AvailabilityZones")) 3158 } 3159 if v.MultiplexSettings == nil { 3160 invalidParams.Add(smithy.NewErrParamRequired("MultiplexSettings")) 3161 } else if v.MultiplexSettings != nil { 3162 if err := validateMultiplexSettings(v.MultiplexSettings); err != nil { 3163 invalidParams.AddNested("MultiplexSettings", err.(smithy.InvalidParamsError)) 3164 } 3165 } 3166 if v.Name == nil { 3167 invalidParams.Add(smithy.NewErrParamRequired("Name")) 3168 } 3169 if v.RequestId == nil { 3170 invalidParams.Add(smithy.NewErrParamRequired("RequestId")) 3171 } 3172 if invalidParams.Len() > 0 { 3173 return invalidParams 3174 } else { 3175 return nil 3176 } 3177} 3178 3179func validateOpCreateMultiplexProgramInput(v *CreateMultiplexProgramInput) error { 3180 if v == nil { 3181 return nil 3182 } 3183 invalidParams := smithy.InvalidParamsError{Context: "CreateMultiplexProgramInput"} 3184 if v.MultiplexId == nil { 3185 invalidParams.Add(smithy.NewErrParamRequired("MultiplexId")) 3186 } 3187 if v.MultiplexProgramSettings == nil { 3188 invalidParams.Add(smithy.NewErrParamRequired("MultiplexProgramSettings")) 3189 } else if v.MultiplexProgramSettings != nil { 3190 if err := validateMultiplexProgramSettings(v.MultiplexProgramSettings); err != nil { 3191 invalidParams.AddNested("MultiplexProgramSettings", err.(smithy.InvalidParamsError)) 3192 } 3193 } 3194 if v.ProgramName == nil { 3195 invalidParams.Add(smithy.NewErrParamRequired("ProgramName")) 3196 } 3197 if v.RequestId == nil { 3198 invalidParams.Add(smithy.NewErrParamRequired("RequestId")) 3199 } 3200 if invalidParams.Len() > 0 { 3201 return invalidParams 3202 } else { 3203 return nil 3204 } 3205} 3206 3207func validateOpCreatePartnerInputInput(v *CreatePartnerInputInput) error { 3208 if v == nil { 3209 return nil 3210 } 3211 invalidParams := smithy.InvalidParamsError{Context: "CreatePartnerInputInput"} 3212 if v.InputId == nil { 3213 invalidParams.Add(smithy.NewErrParamRequired("InputId")) 3214 } 3215 if invalidParams.Len() > 0 { 3216 return invalidParams 3217 } else { 3218 return nil 3219 } 3220} 3221 3222func validateOpCreateTagsInput(v *CreateTagsInput) error { 3223 if v == nil { 3224 return nil 3225 } 3226 invalidParams := smithy.InvalidParamsError{Context: "CreateTagsInput"} 3227 if v.ResourceArn == nil { 3228 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 3229 } 3230 if invalidParams.Len() > 0 { 3231 return invalidParams 3232 } else { 3233 return nil 3234 } 3235} 3236 3237func validateOpDeleteChannelInput(v *DeleteChannelInput) error { 3238 if v == nil { 3239 return nil 3240 } 3241 invalidParams := smithy.InvalidParamsError{Context: "DeleteChannelInput"} 3242 if v.ChannelId == nil { 3243 invalidParams.Add(smithy.NewErrParamRequired("ChannelId")) 3244 } 3245 if invalidParams.Len() > 0 { 3246 return invalidParams 3247 } else { 3248 return nil 3249 } 3250} 3251 3252func validateOpDeleteInputInput(v *DeleteInputInput) error { 3253 if v == nil { 3254 return nil 3255 } 3256 invalidParams := smithy.InvalidParamsError{Context: "DeleteInputInput"} 3257 if v.InputId == nil { 3258 invalidParams.Add(smithy.NewErrParamRequired("InputId")) 3259 } 3260 if invalidParams.Len() > 0 { 3261 return invalidParams 3262 } else { 3263 return nil 3264 } 3265} 3266 3267func validateOpDeleteInputSecurityGroupInput(v *DeleteInputSecurityGroupInput) error { 3268 if v == nil { 3269 return nil 3270 } 3271 invalidParams := smithy.InvalidParamsError{Context: "DeleteInputSecurityGroupInput"} 3272 if v.InputSecurityGroupId == nil { 3273 invalidParams.Add(smithy.NewErrParamRequired("InputSecurityGroupId")) 3274 } 3275 if invalidParams.Len() > 0 { 3276 return invalidParams 3277 } else { 3278 return nil 3279 } 3280} 3281 3282func validateOpDeleteMultiplexInput(v *DeleteMultiplexInput) error { 3283 if v == nil { 3284 return nil 3285 } 3286 invalidParams := smithy.InvalidParamsError{Context: "DeleteMultiplexInput"} 3287 if v.MultiplexId == nil { 3288 invalidParams.Add(smithy.NewErrParamRequired("MultiplexId")) 3289 } 3290 if invalidParams.Len() > 0 { 3291 return invalidParams 3292 } else { 3293 return nil 3294 } 3295} 3296 3297func validateOpDeleteMultiplexProgramInput(v *DeleteMultiplexProgramInput) error { 3298 if v == nil { 3299 return nil 3300 } 3301 invalidParams := smithy.InvalidParamsError{Context: "DeleteMultiplexProgramInput"} 3302 if v.MultiplexId == nil { 3303 invalidParams.Add(smithy.NewErrParamRequired("MultiplexId")) 3304 } 3305 if v.ProgramName == nil { 3306 invalidParams.Add(smithy.NewErrParamRequired("ProgramName")) 3307 } 3308 if invalidParams.Len() > 0 { 3309 return invalidParams 3310 } else { 3311 return nil 3312 } 3313} 3314 3315func validateOpDeleteReservationInput(v *DeleteReservationInput) error { 3316 if v == nil { 3317 return nil 3318 } 3319 invalidParams := smithy.InvalidParamsError{Context: "DeleteReservationInput"} 3320 if v.ReservationId == nil { 3321 invalidParams.Add(smithy.NewErrParamRequired("ReservationId")) 3322 } 3323 if invalidParams.Len() > 0 { 3324 return invalidParams 3325 } else { 3326 return nil 3327 } 3328} 3329 3330func validateOpDeleteScheduleInput(v *DeleteScheduleInput) error { 3331 if v == nil { 3332 return nil 3333 } 3334 invalidParams := smithy.InvalidParamsError{Context: "DeleteScheduleInput"} 3335 if v.ChannelId == nil { 3336 invalidParams.Add(smithy.NewErrParamRequired("ChannelId")) 3337 } 3338 if invalidParams.Len() > 0 { 3339 return invalidParams 3340 } else { 3341 return nil 3342 } 3343} 3344 3345func validateOpDeleteTagsInput(v *DeleteTagsInput) error { 3346 if v == nil { 3347 return nil 3348 } 3349 invalidParams := smithy.InvalidParamsError{Context: "DeleteTagsInput"} 3350 if v.ResourceArn == nil { 3351 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 3352 } 3353 if v.TagKeys == nil { 3354 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 3355 } 3356 if invalidParams.Len() > 0 { 3357 return invalidParams 3358 } else { 3359 return nil 3360 } 3361} 3362 3363func validateOpDescribeChannelInput(v *DescribeChannelInput) error { 3364 if v == nil { 3365 return nil 3366 } 3367 invalidParams := smithy.InvalidParamsError{Context: "DescribeChannelInput"} 3368 if v.ChannelId == nil { 3369 invalidParams.Add(smithy.NewErrParamRequired("ChannelId")) 3370 } 3371 if invalidParams.Len() > 0 { 3372 return invalidParams 3373 } else { 3374 return nil 3375 } 3376} 3377 3378func validateOpDescribeInputDeviceInput(v *DescribeInputDeviceInput) error { 3379 if v == nil { 3380 return nil 3381 } 3382 invalidParams := smithy.InvalidParamsError{Context: "DescribeInputDeviceInput"} 3383 if v.InputDeviceId == nil { 3384 invalidParams.Add(smithy.NewErrParamRequired("InputDeviceId")) 3385 } 3386 if invalidParams.Len() > 0 { 3387 return invalidParams 3388 } else { 3389 return nil 3390 } 3391} 3392 3393func validateOpDescribeInputDeviceThumbnailInput(v *DescribeInputDeviceThumbnailInput) error { 3394 if v == nil { 3395 return nil 3396 } 3397 invalidParams := smithy.InvalidParamsError{Context: "DescribeInputDeviceThumbnailInput"} 3398 if v.InputDeviceId == nil { 3399 invalidParams.Add(smithy.NewErrParamRequired("InputDeviceId")) 3400 } 3401 if len(v.Accept) == 0 { 3402 invalidParams.Add(smithy.NewErrParamRequired("Accept")) 3403 } 3404 if invalidParams.Len() > 0 { 3405 return invalidParams 3406 } else { 3407 return nil 3408 } 3409} 3410 3411func validateOpDescribeInputInput(v *DescribeInputInput) error { 3412 if v == nil { 3413 return nil 3414 } 3415 invalidParams := smithy.InvalidParamsError{Context: "DescribeInputInput"} 3416 if v.InputId == nil { 3417 invalidParams.Add(smithy.NewErrParamRequired("InputId")) 3418 } 3419 if invalidParams.Len() > 0 { 3420 return invalidParams 3421 } else { 3422 return nil 3423 } 3424} 3425 3426func validateOpDescribeInputSecurityGroupInput(v *DescribeInputSecurityGroupInput) error { 3427 if v == nil { 3428 return nil 3429 } 3430 invalidParams := smithy.InvalidParamsError{Context: "DescribeInputSecurityGroupInput"} 3431 if v.InputSecurityGroupId == nil { 3432 invalidParams.Add(smithy.NewErrParamRequired("InputSecurityGroupId")) 3433 } 3434 if invalidParams.Len() > 0 { 3435 return invalidParams 3436 } else { 3437 return nil 3438 } 3439} 3440 3441func validateOpDescribeMultiplexInput(v *DescribeMultiplexInput) error { 3442 if v == nil { 3443 return nil 3444 } 3445 invalidParams := smithy.InvalidParamsError{Context: "DescribeMultiplexInput"} 3446 if v.MultiplexId == nil { 3447 invalidParams.Add(smithy.NewErrParamRequired("MultiplexId")) 3448 } 3449 if invalidParams.Len() > 0 { 3450 return invalidParams 3451 } else { 3452 return nil 3453 } 3454} 3455 3456func validateOpDescribeMultiplexProgramInput(v *DescribeMultiplexProgramInput) error { 3457 if v == nil { 3458 return nil 3459 } 3460 invalidParams := smithy.InvalidParamsError{Context: "DescribeMultiplexProgramInput"} 3461 if v.MultiplexId == nil { 3462 invalidParams.Add(smithy.NewErrParamRequired("MultiplexId")) 3463 } 3464 if v.ProgramName == nil { 3465 invalidParams.Add(smithy.NewErrParamRequired("ProgramName")) 3466 } 3467 if invalidParams.Len() > 0 { 3468 return invalidParams 3469 } else { 3470 return nil 3471 } 3472} 3473 3474func validateOpDescribeOfferingInput(v *DescribeOfferingInput) error { 3475 if v == nil { 3476 return nil 3477 } 3478 invalidParams := smithy.InvalidParamsError{Context: "DescribeOfferingInput"} 3479 if v.OfferingId == nil { 3480 invalidParams.Add(smithy.NewErrParamRequired("OfferingId")) 3481 } 3482 if invalidParams.Len() > 0 { 3483 return invalidParams 3484 } else { 3485 return nil 3486 } 3487} 3488 3489func validateOpDescribeReservationInput(v *DescribeReservationInput) error { 3490 if v == nil { 3491 return nil 3492 } 3493 invalidParams := smithy.InvalidParamsError{Context: "DescribeReservationInput"} 3494 if v.ReservationId == nil { 3495 invalidParams.Add(smithy.NewErrParamRequired("ReservationId")) 3496 } 3497 if invalidParams.Len() > 0 { 3498 return invalidParams 3499 } else { 3500 return nil 3501 } 3502} 3503 3504func validateOpDescribeScheduleInput(v *DescribeScheduleInput) error { 3505 if v == nil { 3506 return nil 3507 } 3508 invalidParams := smithy.InvalidParamsError{Context: "DescribeScheduleInput"} 3509 if v.ChannelId == nil { 3510 invalidParams.Add(smithy.NewErrParamRequired("ChannelId")) 3511 } 3512 if invalidParams.Len() > 0 { 3513 return invalidParams 3514 } else { 3515 return nil 3516 } 3517} 3518 3519func validateOpListInputDeviceTransfersInput(v *ListInputDeviceTransfersInput) error { 3520 if v == nil { 3521 return nil 3522 } 3523 invalidParams := smithy.InvalidParamsError{Context: "ListInputDeviceTransfersInput"} 3524 if v.TransferType == nil { 3525 invalidParams.Add(smithy.NewErrParamRequired("TransferType")) 3526 } 3527 if invalidParams.Len() > 0 { 3528 return invalidParams 3529 } else { 3530 return nil 3531 } 3532} 3533 3534func validateOpListMultiplexProgramsInput(v *ListMultiplexProgramsInput) error { 3535 if v == nil { 3536 return nil 3537 } 3538 invalidParams := smithy.InvalidParamsError{Context: "ListMultiplexProgramsInput"} 3539 if v.MultiplexId == nil { 3540 invalidParams.Add(smithy.NewErrParamRequired("MultiplexId")) 3541 } 3542 if invalidParams.Len() > 0 { 3543 return invalidParams 3544 } else { 3545 return nil 3546 } 3547} 3548 3549func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 3550 if v == nil { 3551 return nil 3552 } 3553 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 3554 if v.ResourceArn == nil { 3555 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 3556 } 3557 if invalidParams.Len() > 0 { 3558 return invalidParams 3559 } else { 3560 return nil 3561 } 3562} 3563 3564func validateOpPurchaseOfferingInput(v *PurchaseOfferingInput) error { 3565 if v == nil { 3566 return nil 3567 } 3568 invalidParams := smithy.InvalidParamsError{Context: "PurchaseOfferingInput"} 3569 if v.OfferingId == nil { 3570 invalidParams.Add(smithy.NewErrParamRequired("OfferingId")) 3571 } 3572 if invalidParams.Len() > 0 { 3573 return invalidParams 3574 } else { 3575 return nil 3576 } 3577} 3578 3579func validateOpRejectInputDeviceTransferInput(v *RejectInputDeviceTransferInput) error { 3580 if v == nil { 3581 return nil 3582 } 3583 invalidParams := smithy.InvalidParamsError{Context: "RejectInputDeviceTransferInput"} 3584 if v.InputDeviceId == nil { 3585 invalidParams.Add(smithy.NewErrParamRequired("InputDeviceId")) 3586 } 3587 if invalidParams.Len() > 0 { 3588 return invalidParams 3589 } else { 3590 return nil 3591 } 3592} 3593 3594func validateOpStartChannelInput(v *StartChannelInput) error { 3595 if v == nil { 3596 return nil 3597 } 3598 invalidParams := smithy.InvalidParamsError{Context: "StartChannelInput"} 3599 if v.ChannelId == nil { 3600 invalidParams.Add(smithy.NewErrParamRequired("ChannelId")) 3601 } 3602 if invalidParams.Len() > 0 { 3603 return invalidParams 3604 } else { 3605 return nil 3606 } 3607} 3608 3609func validateOpStartMultiplexInput(v *StartMultiplexInput) error { 3610 if v == nil { 3611 return nil 3612 } 3613 invalidParams := smithy.InvalidParamsError{Context: "StartMultiplexInput"} 3614 if v.MultiplexId == nil { 3615 invalidParams.Add(smithy.NewErrParamRequired("MultiplexId")) 3616 } 3617 if invalidParams.Len() > 0 { 3618 return invalidParams 3619 } else { 3620 return nil 3621 } 3622} 3623 3624func validateOpStopChannelInput(v *StopChannelInput) error { 3625 if v == nil { 3626 return nil 3627 } 3628 invalidParams := smithy.InvalidParamsError{Context: "StopChannelInput"} 3629 if v.ChannelId == nil { 3630 invalidParams.Add(smithy.NewErrParamRequired("ChannelId")) 3631 } 3632 if invalidParams.Len() > 0 { 3633 return invalidParams 3634 } else { 3635 return nil 3636 } 3637} 3638 3639func validateOpStopMultiplexInput(v *StopMultiplexInput) error { 3640 if v == nil { 3641 return nil 3642 } 3643 invalidParams := smithy.InvalidParamsError{Context: "StopMultiplexInput"} 3644 if v.MultiplexId == nil { 3645 invalidParams.Add(smithy.NewErrParamRequired("MultiplexId")) 3646 } 3647 if invalidParams.Len() > 0 { 3648 return invalidParams 3649 } else { 3650 return nil 3651 } 3652} 3653 3654func validateOpTransferInputDeviceInput(v *TransferInputDeviceInput) error { 3655 if v == nil { 3656 return nil 3657 } 3658 invalidParams := smithy.InvalidParamsError{Context: "TransferInputDeviceInput"} 3659 if v.InputDeviceId == nil { 3660 invalidParams.Add(smithy.NewErrParamRequired("InputDeviceId")) 3661 } 3662 if invalidParams.Len() > 0 { 3663 return invalidParams 3664 } else { 3665 return nil 3666 } 3667} 3668 3669func validateOpUpdateChannelClassInput(v *UpdateChannelClassInput) error { 3670 if v == nil { 3671 return nil 3672 } 3673 invalidParams := smithy.InvalidParamsError{Context: "UpdateChannelClassInput"} 3674 if len(v.ChannelClass) == 0 { 3675 invalidParams.Add(smithy.NewErrParamRequired("ChannelClass")) 3676 } 3677 if v.ChannelId == nil { 3678 invalidParams.Add(smithy.NewErrParamRequired("ChannelId")) 3679 } 3680 if invalidParams.Len() > 0 { 3681 return invalidParams 3682 } else { 3683 return nil 3684 } 3685} 3686 3687func validateOpUpdateChannelInput(v *UpdateChannelInput) error { 3688 if v == nil { 3689 return nil 3690 } 3691 invalidParams := smithy.InvalidParamsError{Context: "UpdateChannelInput"} 3692 if v.ChannelId == nil { 3693 invalidParams.Add(smithy.NewErrParamRequired("ChannelId")) 3694 } 3695 if v.EncoderSettings != nil { 3696 if err := validateEncoderSettings(v.EncoderSettings); err != nil { 3697 invalidParams.AddNested("EncoderSettings", err.(smithy.InvalidParamsError)) 3698 } 3699 } 3700 if v.InputAttachments != nil { 3701 if err := validate__listOfInputAttachment(v.InputAttachments); err != nil { 3702 invalidParams.AddNested("InputAttachments", err.(smithy.InvalidParamsError)) 3703 } 3704 } 3705 if invalidParams.Len() > 0 { 3706 return invalidParams 3707 } else { 3708 return nil 3709 } 3710} 3711 3712func validateOpUpdateInputDeviceInput(v *UpdateInputDeviceInput) error { 3713 if v == nil { 3714 return nil 3715 } 3716 invalidParams := smithy.InvalidParamsError{Context: "UpdateInputDeviceInput"} 3717 if v.InputDeviceId == nil { 3718 invalidParams.Add(smithy.NewErrParamRequired("InputDeviceId")) 3719 } 3720 if invalidParams.Len() > 0 { 3721 return invalidParams 3722 } else { 3723 return nil 3724 } 3725} 3726 3727func validateOpUpdateInputInput(v *UpdateInputInput) error { 3728 if v == nil { 3729 return nil 3730 } 3731 invalidParams := smithy.InvalidParamsError{Context: "UpdateInputInput"} 3732 if v.InputId == nil { 3733 invalidParams.Add(smithy.NewErrParamRequired("InputId")) 3734 } 3735 if invalidParams.Len() > 0 { 3736 return invalidParams 3737 } else { 3738 return nil 3739 } 3740} 3741 3742func validateOpUpdateInputSecurityGroupInput(v *UpdateInputSecurityGroupInput) error { 3743 if v == nil { 3744 return nil 3745 } 3746 invalidParams := smithy.InvalidParamsError{Context: "UpdateInputSecurityGroupInput"} 3747 if v.InputSecurityGroupId == nil { 3748 invalidParams.Add(smithy.NewErrParamRequired("InputSecurityGroupId")) 3749 } 3750 if invalidParams.Len() > 0 { 3751 return invalidParams 3752 } else { 3753 return nil 3754 } 3755} 3756 3757func validateOpUpdateMultiplexInput(v *UpdateMultiplexInput) error { 3758 if v == nil { 3759 return nil 3760 } 3761 invalidParams := smithy.InvalidParamsError{Context: "UpdateMultiplexInput"} 3762 if v.MultiplexId == nil { 3763 invalidParams.Add(smithy.NewErrParamRequired("MultiplexId")) 3764 } 3765 if v.MultiplexSettings != nil { 3766 if err := validateMultiplexSettings(v.MultiplexSettings); err != nil { 3767 invalidParams.AddNested("MultiplexSettings", err.(smithy.InvalidParamsError)) 3768 } 3769 } 3770 if invalidParams.Len() > 0 { 3771 return invalidParams 3772 } else { 3773 return nil 3774 } 3775} 3776 3777func validateOpUpdateMultiplexProgramInput(v *UpdateMultiplexProgramInput) error { 3778 if v == nil { 3779 return nil 3780 } 3781 invalidParams := smithy.InvalidParamsError{Context: "UpdateMultiplexProgramInput"} 3782 if v.MultiplexId == nil { 3783 invalidParams.Add(smithy.NewErrParamRequired("MultiplexId")) 3784 } 3785 if v.MultiplexProgramSettings != nil { 3786 if err := validateMultiplexProgramSettings(v.MultiplexProgramSettings); err != nil { 3787 invalidParams.AddNested("MultiplexProgramSettings", err.(smithy.InvalidParamsError)) 3788 } 3789 } 3790 if v.ProgramName == nil { 3791 invalidParams.Add(smithy.NewErrParamRequired("ProgramName")) 3792 } 3793 if invalidParams.Len() > 0 { 3794 return invalidParams 3795 } else { 3796 return nil 3797 } 3798} 3799 3800func validateOpUpdateReservationInput(v *UpdateReservationInput) error { 3801 if v == nil { 3802 return nil 3803 } 3804 invalidParams := smithy.InvalidParamsError{Context: "UpdateReservationInput"} 3805 if v.ReservationId == nil { 3806 invalidParams.Add(smithy.NewErrParamRequired("ReservationId")) 3807 } 3808 if invalidParams.Len() > 0 { 3809 return invalidParams 3810 } else { 3811 return nil 3812 } 3813} 3814