1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package ivs 4 5import ( 6 "context" 7 "fmt" 8 smithy "github.com/aws/smithy-go" 9 "github.com/aws/smithy-go/middleware" 10) 11 12type validateOpBatchGetChannel struct { 13} 14 15func (*validateOpBatchGetChannel) ID() string { 16 return "OperationInputValidation" 17} 18 19func (m *validateOpBatchGetChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 20 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 21) { 22 input, ok := in.Parameters.(*BatchGetChannelInput) 23 if !ok { 24 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 25 } 26 if err := validateOpBatchGetChannelInput(input); err != nil { 27 return out, metadata, err 28 } 29 return next.HandleInitialize(ctx, in) 30} 31 32type validateOpBatchGetStreamKey struct { 33} 34 35func (*validateOpBatchGetStreamKey) ID() string { 36 return "OperationInputValidation" 37} 38 39func (m *validateOpBatchGetStreamKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 40 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 41) { 42 input, ok := in.Parameters.(*BatchGetStreamKeyInput) 43 if !ok { 44 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 45 } 46 if err := validateOpBatchGetStreamKeyInput(input); err != nil { 47 return out, metadata, err 48 } 49 return next.HandleInitialize(ctx, in) 50} 51 52type validateOpCreateStreamKey struct { 53} 54 55func (*validateOpCreateStreamKey) ID() string { 56 return "OperationInputValidation" 57} 58 59func (m *validateOpCreateStreamKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 60 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 61) { 62 input, ok := in.Parameters.(*CreateStreamKeyInput) 63 if !ok { 64 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 65 } 66 if err := validateOpCreateStreamKeyInput(input); err != nil { 67 return out, metadata, err 68 } 69 return next.HandleInitialize(ctx, in) 70} 71 72type validateOpDeleteChannel struct { 73} 74 75func (*validateOpDeleteChannel) ID() string { 76 return "OperationInputValidation" 77} 78 79func (m *validateOpDeleteChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 80 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 81) { 82 input, ok := in.Parameters.(*DeleteChannelInput) 83 if !ok { 84 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 85 } 86 if err := validateOpDeleteChannelInput(input); err != nil { 87 return out, metadata, err 88 } 89 return next.HandleInitialize(ctx, in) 90} 91 92type validateOpDeletePlaybackKeyPair struct { 93} 94 95func (*validateOpDeletePlaybackKeyPair) ID() string { 96 return "OperationInputValidation" 97} 98 99func (m *validateOpDeletePlaybackKeyPair) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 100 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 101) { 102 input, ok := in.Parameters.(*DeletePlaybackKeyPairInput) 103 if !ok { 104 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 105 } 106 if err := validateOpDeletePlaybackKeyPairInput(input); err != nil { 107 return out, metadata, err 108 } 109 return next.HandleInitialize(ctx, in) 110} 111 112type validateOpDeleteStreamKey struct { 113} 114 115func (*validateOpDeleteStreamKey) ID() string { 116 return "OperationInputValidation" 117} 118 119func (m *validateOpDeleteStreamKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 120 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 121) { 122 input, ok := in.Parameters.(*DeleteStreamKeyInput) 123 if !ok { 124 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 125 } 126 if err := validateOpDeleteStreamKeyInput(input); err != nil { 127 return out, metadata, err 128 } 129 return next.HandleInitialize(ctx, in) 130} 131 132type validateOpGetChannel struct { 133} 134 135func (*validateOpGetChannel) ID() string { 136 return "OperationInputValidation" 137} 138 139func (m *validateOpGetChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 140 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 141) { 142 input, ok := in.Parameters.(*GetChannelInput) 143 if !ok { 144 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 145 } 146 if err := validateOpGetChannelInput(input); err != nil { 147 return out, metadata, err 148 } 149 return next.HandleInitialize(ctx, in) 150} 151 152type validateOpGetPlaybackKeyPair struct { 153} 154 155func (*validateOpGetPlaybackKeyPair) ID() string { 156 return "OperationInputValidation" 157} 158 159func (m *validateOpGetPlaybackKeyPair) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 160 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 161) { 162 input, ok := in.Parameters.(*GetPlaybackKeyPairInput) 163 if !ok { 164 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 165 } 166 if err := validateOpGetPlaybackKeyPairInput(input); err != nil { 167 return out, metadata, err 168 } 169 return next.HandleInitialize(ctx, in) 170} 171 172type validateOpGetStream struct { 173} 174 175func (*validateOpGetStream) ID() string { 176 return "OperationInputValidation" 177} 178 179func (m *validateOpGetStream) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 180 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 181) { 182 input, ok := in.Parameters.(*GetStreamInput) 183 if !ok { 184 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 185 } 186 if err := validateOpGetStreamInput(input); err != nil { 187 return out, metadata, err 188 } 189 return next.HandleInitialize(ctx, in) 190} 191 192type validateOpGetStreamKey struct { 193} 194 195func (*validateOpGetStreamKey) ID() string { 196 return "OperationInputValidation" 197} 198 199func (m *validateOpGetStreamKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 200 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 201) { 202 input, ok := in.Parameters.(*GetStreamKeyInput) 203 if !ok { 204 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 205 } 206 if err := validateOpGetStreamKeyInput(input); err != nil { 207 return out, metadata, err 208 } 209 return next.HandleInitialize(ctx, in) 210} 211 212type validateOpImportPlaybackKeyPair struct { 213} 214 215func (*validateOpImportPlaybackKeyPair) ID() string { 216 return "OperationInputValidation" 217} 218 219func (m *validateOpImportPlaybackKeyPair) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 220 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 221) { 222 input, ok := in.Parameters.(*ImportPlaybackKeyPairInput) 223 if !ok { 224 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 225 } 226 if err := validateOpImportPlaybackKeyPairInput(input); err != nil { 227 return out, metadata, err 228 } 229 return next.HandleInitialize(ctx, in) 230} 231 232type validateOpListStreamKeys struct { 233} 234 235func (*validateOpListStreamKeys) ID() string { 236 return "OperationInputValidation" 237} 238 239func (m *validateOpListStreamKeys) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 240 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 241) { 242 input, ok := in.Parameters.(*ListStreamKeysInput) 243 if !ok { 244 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 245 } 246 if err := validateOpListStreamKeysInput(input); err != nil { 247 return out, metadata, err 248 } 249 return next.HandleInitialize(ctx, in) 250} 251 252type validateOpListTagsForResource struct { 253} 254 255func (*validateOpListTagsForResource) ID() string { 256 return "OperationInputValidation" 257} 258 259func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 260 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 261) { 262 input, ok := in.Parameters.(*ListTagsForResourceInput) 263 if !ok { 264 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 265 } 266 if err := validateOpListTagsForResourceInput(input); err != nil { 267 return out, metadata, err 268 } 269 return next.HandleInitialize(ctx, in) 270} 271 272type validateOpPutMetadata struct { 273} 274 275func (*validateOpPutMetadata) ID() string { 276 return "OperationInputValidation" 277} 278 279func (m *validateOpPutMetadata) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 280 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 281) { 282 input, ok := in.Parameters.(*PutMetadataInput) 283 if !ok { 284 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 285 } 286 if err := validateOpPutMetadataInput(input); err != nil { 287 return out, metadata, err 288 } 289 return next.HandleInitialize(ctx, in) 290} 291 292type validateOpStopStream struct { 293} 294 295func (*validateOpStopStream) ID() string { 296 return "OperationInputValidation" 297} 298 299func (m *validateOpStopStream) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 300 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 301) { 302 input, ok := in.Parameters.(*StopStreamInput) 303 if !ok { 304 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 305 } 306 if err := validateOpStopStreamInput(input); err != nil { 307 return out, metadata, err 308 } 309 return next.HandleInitialize(ctx, in) 310} 311 312type validateOpTagResource struct { 313} 314 315func (*validateOpTagResource) ID() string { 316 return "OperationInputValidation" 317} 318 319func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 320 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 321) { 322 input, ok := in.Parameters.(*TagResourceInput) 323 if !ok { 324 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 325 } 326 if err := validateOpTagResourceInput(input); err != nil { 327 return out, metadata, err 328 } 329 return next.HandleInitialize(ctx, in) 330} 331 332type validateOpUntagResource struct { 333} 334 335func (*validateOpUntagResource) ID() string { 336 return "OperationInputValidation" 337} 338 339func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 340 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 341) { 342 input, ok := in.Parameters.(*UntagResourceInput) 343 if !ok { 344 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 345 } 346 if err := validateOpUntagResourceInput(input); err != nil { 347 return out, metadata, err 348 } 349 return next.HandleInitialize(ctx, in) 350} 351 352type validateOpUpdateChannel struct { 353} 354 355func (*validateOpUpdateChannel) ID() string { 356 return "OperationInputValidation" 357} 358 359func (m *validateOpUpdateChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 360 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 361) { 362 input, ok := in.Parameters.(*UpdateChannelInput) 363 if !ok { 364 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 365 } 366 if err := validateOpUpdateChannelInput(input); err != nil { 367 return out, metadata, err 368 } 369 return next.HandleInitialize(ctx, in) 370} 371 372func addOpBatchGetChannelValidationMiddleware(stack *middleware.Stack) error { 373 return stack.Initialize.Add(&validateOpBatchGetChannel{}, middleware.After) 374} 375 376func addOpBatchGetStreamKeyValidationMiddleware(stack *middleware.Stack) error { 377 return stack.Initialize.Add(&validateOpBatchGetStreamKey{}, middleware.After) 378} 379 380func addOpCreateStreamKeyValidationMiddleware(stack *middleware.Stack) error { 381 return stack.Initialize.Add(&validateOpCreateStreamKey{}, middleware.After) 382} 383 384func addOpDeleteChannelValidationMiddleware(stack *middleware.Stack) error { 385 return stack.Initialize.Add(&validateOpDeleteChannel{}, middleware.After) 386} 387 388func addOpDeletePlaybackKeyPairValidationMiddleware(stack *middleware.Stack) error { 389 return stack.Initialize.Add(&validateOpDeletePlaybackKeyPair{}, middleware.After) 390} 391 392func addOpDeleteStreamKeyValidationMiddleware(stack *middleware.Stack) error { 393 return stack.Initialize.Add(&validateOpDeleteStreamKey{}, middleware.After) 394} 395 396func addOpGetChannelValidationMiddleware(stack *middleware.Stack) error { 397 return stack.Initialize.Add(&validateOpGetChannel{}, middleware.After) 398} 399 400func addOpGetPlaybackKeyPairValidationMiddleware(stack *middleware.Stack) error { 401 return stack.Initialize.Add(&validateOpGetPlaybackKeyPair{}, middleware.After) 402} 403 404func addOpGetStreamValidationMiddleware(stack *middleware.Stack) error { 405 return stack.Initialize.Add(&validateOpGetStream{}, middleware.After) 406} 407 408func addOpGetStreamKeyValidationMiddleware(stack *middleware.Stack) error { 409 return stack.Initialize.Add(&validateOpGetStreamKey{}, middleware.After) 410} 411 412func addOpImportPlaybackKeyPairValidationMiddleware(stack *middleware.Stack) error { 413 return stack.Initialize.Add(&validateOpImportPlaybackKeyPair{}, middleware.After) 414} 415 416func addOpListStreamKeysValidationMiddleware(stack *middleware.Stack) error { 417 return stack.Initialize.Add(&validateOpListStreamKeys{}, middleware.After) 418} 419 420func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 421 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 422} 423 424func addOpPutMetadataValidationMiddleware(stack *middleware.Stack) error { 425 return stack.Initialize.Add(&validateOpPutMetadata{}, middleware.After) 426} 427 428func addOpStopStreamValidationMiddleware(stack *middleware.Stack) error { 429 return stack.Initialize.Add(&validateOpStopStream{}, middleware.After) 430} 431 432func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 433 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 434} 435 436func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 437 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 438} 439 440func addOpUpdateChannelValidationMiddleware(stack *middleware.Stack) error { 441 return stack.Initialize.Add(&validateOpUpdateChannel{}, middleware.After) 442} 443 444func validateOpBatchGetChannelInput(v *BatchGetChannelInput) error { 445 if v == nil { 446 return nil 447 } 448 invalidParams := smithy.InvalidParamsError{Context: "BatchGetChannelInput"} 449 if v.Arns == nil { 450 invalidParams.Add(smithy.NewErrParamRequired("Arns")) 451 } 452 if invalidParams.Len() > 0 { 453 return invalidParams 454 } else { 455 return nil 456 } 457} 458 459func validateOpBatchGetStreamKeyInput(v *BatchGetStreamKeyInput) error { 460 if v == nil { 461 return nil 462 } 463 invalidParams := smithy.InvalidParamsError{Context: "BatchGetStreamKeyInput"} 464 if v.Arns == nil { 465 invalidParams.Add(smithy.NewErrParamRequired("Arns")) 466 } 467 if invalidParams.Len() > 0 { 468 return invalidParams 469 } else { 470 return nil 471 } 472} 473 474func validateOpCreateStreamKeyInput(v *CreateStreamKeyInput) error { 475 if v == nil { 476 return nil 477 } 478 invalidParams := smithy.InvalidParamsError{Context: "CreateStreamKeyInput"} 479 if v.ChannelArn == nil { 480 invalidParams.Add(smithy.NewErrParamRequired("ChannelArn")) 481 } 482 if invalidParams.Len() > 0 { 483 return invalidParams 484 } else { 485 return nil 486 } 487} 488 489func validateOpDeleteChannelInput(v *DeleteChannelInput) error { 490 if v == nil { 491 return nil 492 } 493 invalidParams := smithy.InvalidParamsError{Context: "DeleteChannelInput"} 494 if v.Arn == nil { 495 invalidParams.Add(smithy.NewErrParamRequired("Arn")) 496 } 497 if invalidParams.Len() > 0 { 498 return invalidParams 499 } else { 500 return nil 501 } 502} 503 504func validateOpDeletePlaybackKeyPairInput(v *DeletePlaybackKeyPairInput) error { 505 if v == nil { 506 return nil 507 } 508 invalidParams := smithy.InvalidParamsError{Context: "DeletePlaybackKeyPairInput"} 509 if v.Arn == nil { 510 invalidParams.Add(smithy.NewErrParamRequired("Arn")) 511 } 512 if invalidParams.Len() > 0 { 513 return invalidParams 514 } else { 515 return nil 516 } 517} 518 519func validateOpDeleteStreamKeyInput(v *DeleteStreamKeyInput) error { 520 if v == nil { 521 return nil 522 } 523 invalidParams := smithy.InvalidParamsError{Context: "DeleteStreamKeyInput"} 524 if v.Arn == nil { 525 invalidParams.Add(smithy.NewErrParamRequired("Arn")) 526 } 527 if invalidParams.Len() > 0 { 528 return invalidParams 529 } else { 530 return nil 531 } 532} 533 534func validateOpGetChannelInput(v *GetChannelInput) error { 535 if v == nil { 536 return nil 537 } 538 invalidParams := smithy.InvalidParamsError{Context: "GetChannelInput"} 539 if v.Arn == nil { 540 invalidParams.Add(smithy.NewErrParamRequired("Arn")) 541 } 542 if invalidParams.Len() > 0 { 543 return invalidParams 544 } else { 545 return nil 546 } 547} 548 549func validateOpGetPlaybackKeyPairInput(v *GetPlaybackKeyPairInput) error { 550 if v == nil { 551 return nil 552 } 553 invalidParams := smithy.InvalidParamsError{Context: "GetPlaybackKeyPairInput"} 554 if v.Arn == nil { 555 invalidParams.Add(smithy.NewErrParamRequired("Arn")) 556 } 557 if invalidParams.Len() > 0 { 558 return invalidParams 559 } else { 560 return nil 561 } 562} 563 564func validateOpGetStreamInput(v *GetStreamInput) error { 565 if v == nil { 566 return nil 567 } 568 invalidParams := smithy.InvalidParamsError{Context: "GetStreamInput"} 569 if v.ChannelArn == nil { 570 invalidParams.Add(smithy.NewErrParamRequired("ChannelArn")) 571 } 572 if invalidParams.Len() > 0 { 573 return invalidParams 574 } else { 575 return nil 576 } 577} 578 579func validateOpGetStreamKeyInput(v *GetStreamKeyInput) error { 580 if v == nil { 581 return nil 582 } 583 invalidParams := smithy.InvalidParamsError{Context: "GetStreamKeyInput"} 584 if v.Arn == nil { 585 invalidParams.Add(smithy.NewErrParamRequired("Arn")) 586 } 587 if invalidParams.Len() > 0 { 588 return invalidParams 589 } else { 590 return nil 591 } 592} 593 594func validateOpImportPlaybackKeyPairInput(v *ImportPlaybackKeyPairInput) error { 595 if v == nil { 596 return nil 597 } 598 invalidParams := smithy.InvalidParamsError{Context: "ImportPlaybackKeyPairInput"} 599 if v.PublicKeyMaterial == nil { 600 invalidParams.Add(smithy.NewErrParamRequired("PublicKeyMaterial")) 601 } 602 if invalidParams.Len() > 0 { 603 return invalidParams 604 } else { 605 return nil 606 } 607} 608 609func validateOpListStreamKeysInput(v *ListStreamKeysInput) error { 610 if v == nil { 611 return nil 612 } 613 invalidParams := smithy.InvalidParamsError{Context: "ListStreamKeysInput"} 614 if v.ChannelArn == nil { 615 invalidParams.Add(smithy.NewErrParamRequired("ChannelArn")) 616 } 617 if invalidParams.Len() > 0 { 618 return invalidParams 619 } else { 620 return nil 621 } 622} 623 624func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 625 if v == nil { 626 return nil 627 } 628 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 629 if v.ResourceArn == nil { 630 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 631 } 632 if invalidParams.Len() > 0 { 633 return invalidParams 634 } else { 635 return nil 636 } 637} 638 639func validateOpPutMetadataInput(v *PutMetadataInput) error { 640 if v == nil { 641 return nil 642 } 643 invalidParams := smithy.InvalidParamsError{Context: "PutMetadataInput"} 644 if v.ChannelArn == nil { 645 invalidParams.Add(smithy.NewErrParamRequired("ChannelArn")) 646 } 647 if v.Metadata == nil { 648 invalidParams.Add(smithy.NewErrParamRequired("Metadata")) 649 } 650 if invalidParams.Len() > 0 { 651 return invalidParams 652 } else { 653 return nil 654 } 655} 656 657func validateOpStopStreamInput(v *StopStreamInput) error { 658 if v == nil { 659 return nil 660 } 661 invalidParams := smithy.InvalidParamsError{Context: "StopStreamInput"} 662 if v.ChannelArn == nil { 663 invalidParams.Add(smithy.NewErrParamRequired("ChannelArn")) 664 } 665 if invalidParams.Len() > 0 { 666 return invalidParams 667 } else { 668 return nil 669 } 670} 671 672func validateOpTagResourceInput(v *TagResourceInput) error { 673 if v == nil { 674 return nil 675 } 676 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 677 if v.ResourceArn == nil { 678 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 679 } 680 if v.Tags == nil { 681 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 682 } 683 if invalidParams.Len() > 0 { 684 return invalidParams 685 } else { 686 return nil 687 } 688} 689 690func validateOpUntagResourceInput(v *UntagResourceInput) error { 691 if v == nil { 692 return nil 693 } 694 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 695 if v.ResourceArn == nil { 696 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 697 } 698 if v.TagKeys == nil { 699 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 700 } 701 if invalidParams.Len() > 0 { 702 return invalidParams 703 } else { 704 return nil 705 } 706} 707 708func validateOpUpdateChannelInput(v *UpdateChannelInput) error { 709 if v == nil { 710 return nil 711 } 712 invalidParams := smithy.InvalidParamsError{Context: "UpdateChannelInput"} 713 if v.Arn == nil { 714 invalidParams.Add(smithy.NewErrParamRequired("Arn")) 715 } 716 if invalidParams.Len() > 0 { 717 return invalidParams 718 } else { 719 return nil 720 } 721} 722