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