1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package mediaconnect 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/mediaconnect/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpAddFlowMediaStreams struct { 14} 15 16func (*validateOpAddFlowMediaStreams) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpAddFlowMediaStreams) 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.(*AddFlowMediaStreamsInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpAddFlowMediaStreamsInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpAddFlowOutputs struct { 34} 35 36func (*validateOpAddFlowOutputs) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpAddFlowOutputs) 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.(*AddFlowOutputsInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpAddFlowOutputsInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpAddFlowSources struct { 54} 55 56func (*validateOpAddFlowSources) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpAddFlowSources) 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.(*AddFlowSourcesInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpAddFlowSourcesInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpAddFlowVpcInterfaces struct { 74} 75 76func (*validateOpAddFlowVpcInterfaces) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpAddFlowVpcInterfaces) 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.(*AddFlowVpcInterfacesInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpAddFlowVpcInterfacesInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpCreateFlow struct { 94} 95 96func (*validateOpCreateFlow) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpCreateFlow) 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.(*CreateFlowInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpCreateFlowInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpDeleteFlow struct { 114} 115 116func (*validateOpDeleteFlow) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpDeleteFlow) 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.(*DeleteFlowInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpDeleteFlowInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpDescribeFlow struct { 134} 135 136func (*validateOpDescribeFlow) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpDescribeFlow) 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.(*DescribeFlowInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpDescribeFlowInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpDescribeOffering struct { 154} 155 156func (*validateOpDescribeOffering) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpDescribeOffering) 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.(*DescribeOfferingInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpDescribeOfferingInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpDescribeReservation struct { 174} 175 176func (*validateOpDescribeReservation) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpDescribeReservation) 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.(*DescribeReservationInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpDescribeReservationInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpGrantFlowEntitlements struct { 194} 195 196func (*validateOpGrantFlowEntitlements) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpGrantFlowEntitlements) 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.(*GrantFlowEntitlementsInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpGrantFlowEntitlementsInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpListTagsForResource struct { 214} 215 216func (*validateOpListTagsForResource) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpListTagsForResourceInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpPurchaseOffering struct { 234} 235 236func (*validateOpPurchaseOffering) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpPurchaseOffering) 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.(*PurchaseOfferingInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpPurchaseOfferingInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpRemoveFlowMediaStream struct { 254} 255 256func (*validateOpRemoveFlowMediaStream) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpRemoveFlowMediaStream) 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.(*RemoveFlowMediaStreamInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpRemoveFlowMediaStreamInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpRemoveFlowOutput struct { 274} 275 276func (*validateOpRemoveFlowOutput) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpRemoveFlowOutput) 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.(*RemoveFlowOutputInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpRemoveFlowOutputInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpRemoveFlowSource struct { 294} 295 296func (*validateOpRemoveFlowSource) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpRemoveFlowSource) 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.(*RemoveFlowSourceInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpRemoveFlowSourceInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpRemoveFlowVpcInterface struct { 314} 315 316func (*validateOpRemoveFlowVpcInterface) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpRemoveFlowVpcInterface) 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.(*RemoveFlowVpcInterfaceInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpRemoveFlowVpcInterfaceInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpRevokeFlowEntitlement struct { 334} 335 336func (*validateOpRevokeFlowEntitlement) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpRevokeFlowEntitlement) 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.(*RevokeFlowEntitlementInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpRevokeFlowEntitlementInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpStartFlow struct { 354} 355 356func (*validateOpStartFlow) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpStartFlow) 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.(*StartFlowInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpStartFlowInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpStopFlow struct { 374} 375 376func (*validateOpStopFlow) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpStopFlow) 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.(*StopFlowInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpStopFlowInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpTagResource struct { 394} 395 396func (*validateOpTagResource) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpTagResource) 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.(*TagResourceInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpTagResourceInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpUntagResource struct { 414} 415 416func (*validateOpUntagResource) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpUntagResource) 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.(*UntagResourceInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpUntagResourceInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpUpdateFlowEntitlement struct { 434} 435 436func (*validateOpUpdateFlowEntitlement) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpUpdateFlowEntitlement) 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.(*UpdateFlowEntitlementInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpUpdateFlowEntitlementInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpUpdateFlow struct { 454} 455 456func (*validateOpUpdateFlow) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpUpdateFlow) 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.(*UpdateFlowInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpUpdateFlowInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473type validateOpUpdateFlowMediaStream struct { 474} 475 476func (*validateOpUpdateFlowMediaStream) ID() string { 477 return "OperationInputValidation" 478} 479 480func (m *validateOpUpdateFlowMediaStream) 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.(*UpdateFlowMediaStreamInput) 484 if !ok { 485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 486 } 487 if err := validateOpUpdateFlowMediaStreamInput(input); err != nil { 488 return out, metadata, err 489 } 490 return next.HandleInitialize(ctx, in) 491} 492 493type validateOpUpdateFlowOutput struct { 494} 495 496func (*validateOpUpdateFlowOutput) ID() string { 497 return "OperationInputValidation" 498} 499 500func (m *validateOpUpdateFlowOutput) 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.(*UpdateFlowOutputInput) 504 if !ok { 505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 506 } 507 if err := validateOpUpdateFlowOutputInput(input); err != nil { 508 return out, metadata, err 509 } 510 return next.HandleInitialize(ctx, in) 511} 512 513type validateOpUpdateFlowSource struct { 514} 515 516func (*validateOpUpdateFlowSource) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpUpdateFlowSource) 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.(*UpdateFlowSourceInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpUpdateFlowSourceInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533func addOpAddFlowMediaStreamsValidationMiddleware(stack *middleware.Stack) error { 534 return stack.Initialize.Add(&validateOpAddFlowMediaStreams{}, middleware.After) 535} 536 537func addOpAddFlowOutputsValidationMiddleware(stack *middleware.Stack) error { 538 return stack.Initialize.Add(&validateOpAddFlowOutputs{}, middleware.After) 539} 540 541func addOpAddFlowSourcesValidationMiddleware(stack *middleware.Stack) error { 542 return stack.Initialize.Add(&validateOpAddFlowSources{}, middleware.After) 543} 544 545func addOpAddFlowVpcInterfacesValidationMiddleware(stack *middleware.Stack) error { 546 return stack.Initialize.Add(&validateOpAddFlowVpcInterfaces{}, middleware.After) 547} 548 549func addOpCreateFlowValidationMiddleware(stack *middleware.Stack) error { 550 return stack.Initialize.Add(&validateOpCreateFlow{}, middleware.After) 551} 552 553func addOpDeleteFlowValidationMiddleware(stack *middleware.Stack) error { 554 return stack.Initialize.Add(&validateOpDeleteFlow{}, middleware.After) 555} 556 557func addOpDescribeFlowValidationMiddleware(stack *middleware.Stack) error { 558 return stack.Initialize.Add(&validateOpDescribeFlow{}, middleware.After) 559} 560 561func addOpDescribeOfferingValidationMiddleware(stack *middleware.Stack) error { 562 return stack.Initialize.Add(&validateOpDescribeOffering{}, middleware.After) 563} 564 565func addOpDescribeReservationValidationMiddleware(stack *middleware.Stack) error { 566 return stack.Initialize.Add(&validateOpDescribeReservation{}, middleware.After) 567} 568 569func addOpGrantFlowEntitlementsValidationMiddleware(stack *middleware.Stack) error { 570 return stack.Initialize.Add(&validateOpGrantFlowEntitlements{}, middleware.After) 571} 572 573func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 574 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 575} 576 577func addOpPurchaseOfferingValidationMiddleware(stack *middleware.Stack) error { 578 return stack.Initialize.Add(&validateOpPurchaseOffering{}, middleware.After) 579} 580 581func addOpRemoveFlowMediaStreamValidationMiddleware(stack *middleware.Stack) error { 582 return stack.Initialize.Add(&validateOpRemoveFlowMediaStream{}, middleware.After) 583} 584 585func addOpRemoveFlowOutputValidationMiddleware(stack *middleware.Stack) error { 586 return stack.Initialize.Add(&validateOpRemoveFlowOutput{}, middleware.After) 587} 588 589func addOpRemoveFlowSourceValidationMiddleware(stack *middleware.Stack) error { 590 return stack.Initialize.Add(&validateOpRemoveFlowSource{}, middleware.After) 591} 592 593func addOpRemoveFlowVpcInterfaceValidationMiddleware(stack *middleware.Stack) error { 594 return stack.Initialize.Add(&validateOpRemoveFlowVpcInterface{}, middleware.After) 595} 596 597func addOpRevokeFlowEntitlementValidationMiddleware(stack *middleware.Stack) error { 598 return stack.Initialize.Add(&validateOpRevokeFlowEntitlement{}, middleware.After) 599} 600 601func addOpStartFlowValidationMiddleware(stack *middleware.Stack) error { 602 return stack.Initialize.Add(&validateOpStartFlow{}, middleware.After) 603} 604 605func addOpStopFlowValidationMiddleware(stack *middleware.Stack) error { 606 return stack.Initialize.Add(&validateOpStopFlow{}, middleware.After) 607} 608 609func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 610 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 611} 612 613func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 614 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 615} 616 617func addOpUpdateFlowEntitlementValidationMiddleware(stack *middleware.Stack) error { 618 return stack.Initialize.Add(&validateOpUpdateFlowEntitlement{}, middleware.After) 619} 620 621func addOpUpdateFlowValidationMiddleware(stack *middleware.Stack) error { 622 return stack.Initialize.Add(&validateOpUpdateFlow{}, middleware.After) 623} 624 625func addOpUpdateFlowMediaStreamValidationMiddleware(stack *middleware.Stack) error { 626 return stack.Initialize.Add(&validateOpUpdateFlowMediaStream{}, middleware.After) 627} 628 629func addOpUpdateFlowOutputValidationMiddleware(stack *middleware.Stack) error { 630 return stack.Initialize.Add(&validateOpUpdateFlowOutput{}, middleware.After) 631} 632 633func addOpUpdateFlowSourceValidationMiddleware(stack *middleware.Stack) error { 634 return stack.Initialize.Add(&validateOpUpdateFlowSource{}, middleware.After) 635} 636 637func validate__listOfAddMediaStreamRequest(v []types.AddMediaStreamRequest) error { 638 if v == nil { 639 return nil 640 } 641 invalidParams := smithy.InvalidParamsError{Context: "ListOfAddMediaStreamRequest"} 642 for i := range v { 643 if err := validateAddMediaStreamRequest(&v[i]); err != nil { 644 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 645 } 646 } 647 if invalidParams.Len() > 0 { 648 return invalidParams 649 } else { 650 return nil 651 } 652} 653 654func validate__listOfAddOutputRequest(v []types.AddOutputRequest) error { 655 if v == nil { 656 return nil 657 } 658 invalidParams := smithy.InvalidParamsError{Context: "ListOfAddOutputRequest"} 659 for i := range v { 660 if err := validateAddOutputRequest(&v[i]); err != nil { 661 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 662 } 663 } 664 if invalidParams.Len() > 0 { 665 return invalidParams 666 } else { 667 return nil 668 } 669} 670 671func validate__listOfDestinationConfigurationRequest(v []types.DestinationConfigurationRequest) error { 672 if v == nil { 673 return nil 674 } 675 invalidParams := smithy.InvalidParamsError{Context: "ListOfDestinationConfigurationRequest"} 676 for i := range v { 677 if err := validateDestinationConfigurationRequest(&v[i]); err != nil { 678 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 679 } 680 } 681 if invalidParams.Len() > 0 { 682 return invalidParams 683 } else { 684 return nil 685 } 686} 687 688func validate__listOfGrantEntitlementRequest(v []types.GrantEntitlementRequest) error { 689 if v == nil { 690 return nil 691 } 692 invalidParams := smithy.InvalidParamsError{Context: "ListOfGrantEntitlementRequest"} 693 for i := range v { 694 if err := validateGrantEntitlementRequest(&v[i]); err != nil { 695 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 696 } 697 } 698 if invalidParams.Len() > 0 { 699 return invalidParams 700 } else { 701 return nil 702 } 703} 704 705func validate__listOfInputConfigurationRequest(v []types.InputConfigurationRequest) error { 706 if v == nil { 707 return nil 708 } 709 invalidParams := smithy.InvalidParamsError{Context: "ListOfInputConfigurationRequest"} 710 for i := range v { 711 if err := validateInputConfigurationRequest(&v[i]); err != nil { 712 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 713 } 714 } 715 if invalidParams.Len() > 0 { 716 return invalidParams 717 } else { 718 return nil 719 } 720} 721 722func validate__listOfMediaStreamOutputConfigurationRequest(v []types.MediaStreamOutputConfigurationRequest) error { 723 if v == nil { 724 return nil 725 } 726 invalidParams := smithy.InvalidParamsError{Context: "ListOfMediaStreamOutputConfigurationRequest"} 727 for i := range v { 728 if err := validateMediaStreamOutputConfigurationRequest(&v[i]); err != nil { 729 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 730 } 731 } 732 if invalidParams.Len() > 0 { 733 return invalidParams 734 } else { 735 return nil 736 } 737} 738 739func validate__listOfMediaStreamSourceConfigurationRequest(v []types.MediaStreamSourceConfigurationRequest) error { 740 if v == nil { 741 return nil 742 } 743 invalidParams := smithy.InvalidParamsError{Context: "ListOfMediaStreamSourceConfigurationRequest"} 744 for i := range v { 745 if err := validateMediaStreamSourceConfigurationRequest(&v[i]); err != nil { 746 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 747 } 748 } 749 if invalidParams.Len() > 0 { 750 return invalidParams 751 } else { 752 return nil 753 } 754} 755 756func validate__listOfSetSourceRequest(v []types.SetSourceRequest) error { 757 if v == nil { 758 return nil 759 } 760 invalidParams := smithy.InvalidParamsError{Context: "ListOfSetSourceRequest"} 761 for i := range v { 762 if err := validateSetSourceRequest(&v[i]); err != nil { 763 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 764 } 765 } 766 if invalidParams.Len() > 0 { 767 return invalidParams 768 } else { 769 return nil 770 } 771} 772 773func validate__listOfVpcInterfaceRequest(v []types.VpcInterfaceRequest) error { 774 if v == nil { 775 return nil 776 } 777 invalidParams := smithy.InvalidParamsError{Context: "ListOfVpcInterfaceRequest"} 778 for i := range v { 779 if err := validateVpcInterfaceRequest(&v[i]); err != nil { 780 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 781 } 782 } 783 if invalidParams.Len() > 0 { 784 return invalidParams 785 } else { 786 return nil 787 } 788} 789 790func validateAddMediaStreamRequest(v *types.AddMediaStreamRequest) error { 791 if v == nil { 792 return nil 793 } 794 invalidParams := smithy.InvalidParamsError{Context: "AddMediaStreamRequest"} 795 if v.MediaStreamName == nil { 796 invalidParams.Add(smithy.NewErrParamRequired("MediaStreamName")) 797 } 798 if len(v.MediaStreamType) == 0 { 799 invalidParams.Add(smithy.NewErrParamRequired("MediaStreamType")) 800 } 801 if invalidParams.Len() > 0 { 802 return invalidParams 803 } else { 804 return nil 805 } 806} 807 808func validateAddOutputRequest(v *types.AddOutputRequest) error { 809 if v == nil { 810 return nil 811 } 812 invalidParams := smithy.InvalidParamsError{Context: "AddOutputRequest"} 813 if v.Encryption != nil { 814 if err := validateEncryption(v.Encryption); err != nil { 815 invalidParams.AddNested("Encryption", err.(smithy.InvalidParamsError)) 816 } 817 } 818 if v.MediaStreamOutputConfigurations != nil { 819 if err := validate__listOfMediaStreamOutputConfigurationRequest(v.MediaStreamOutputConfigurations); err != nil { 820 invalidParams.AddNested("MediaStreamOutputConfigurations", err.(smithy.InvalidParamsError)) 821 } 822 } 823 if len(v.Protocol) == 0 { 824 invalidParams.Add(smithy.NewErrParamRequired("Protocol")) 825 } 826 if invalidParams.Len() > 0 { 827 return invalidParams 828 } else { 829 return nil 830 } 831} 832 833func validateDestinationConfigurationRequest(v *types.DestinationConfigurationRequest) error { 834 if v == nil { 835 return nil 836 } 837 invalidParams := smithy.InvalidParamsError{Context: "DestinationConfigurationRequest"} 838 if v.DestinationIp == nil { 839 invalidParams.Add(smithy.NewErrParamRequired("DestinationIp")) 840 } 841 if v.Interface == nil { 842 invalidParams.Add(smithy.NewErrParamRequired("Interface")) 843 } else if v.Interface != nil { 844 if err := validateInterfaceRequest(v.Interface); err != nil { 845 invalidParams.AddNested("Interface", err.(smithy.InvalidParamsError)) 846 } 847 } 848 if invalidParams.Len() > 0 { 849 return invalidParams 850 } else { 851 return nil 852 } 853} 854 855func validateEncodingParametersRequest(v *types.EncodingParametersRequest) error { 856 if v == nil { 857 return nil 858 } 859 invalidParams := smithy.InvalidParamsError{Context: "EncodingParametersRequest"} 860 if len(v.EncoderProfile) == 0 { 861 invalidParams.Add(smithy.NewErrParamRequired("EncoderProfile")) 862 } 863 if invalidParams.Len() > 0 { 864 return invalidParams 865 } else { 866 return nil 867 } 868} 869 870func validateEncryption(v *types.Encryption) error { 871 if v == nil { 872 return nil 873 } 874 invalidParams := smithy.InvalidParamsError{Context: "Encryption"} 875 if v.RoleArn == nil { 876 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 877 } 878 if invalidParams.Len() > 0 { 879 return invalidParams 880 } else { 881 return nil 882 } 883} 884 885func validateGrantEntitlementRequest(v *types.GrantEntitlementRequest) error { 886 if v == nil { 887 return nil 888 } 889 invalidParams := smithy.InvalidParamsError{Context: "GrantEntitlementRequest"} 890 if v.Encryption != nil { 891 if err := validateEncryption(v.Encryption); err != nil { 892 invalidParams.AddNested("Encryption", err.(smithy.InvalidParamsError)) 893 } 894 } 895 if v.Subscribers == nil { 896 invalidParams.Add(smithy.NewErrParamRequired("Subscribers")) 897 } 898 if invalidParams.Len() > 0 { 899 return invalidParams 900 } else { 901 return nil 902 } 903} 904 905func validateInputConfigurationRequest(v *types.InputConfigurationRequest) error { 906 if v == nil { 907 return nil 908 } 909 invalidParams := smithy.InvalidParamsError{Context: "InputConfigurationRequest"} 910 if v.Interface == nil { 911 invalidParams.Add(smithy.NewErrParamRequired("Interface")) 912 } else if v.Interface != nil { 913 if err := validateInterfaceRequest(v.Interface); err != nil { 914 invalidParams.AddNested("Interface", err.(smithy.InvalidParamsError)) 915 } 916 } 917 if invalidParams.Len() > 0 { 918 return invalidParams 919 } else { 920 return nil 921 } 922} 923 924func validateInterfaceRequest(v *types.InterfaceRequest) error { 925 if v == nil { 926 return nil 927 } 928 invalidParams := smithy.InvalidParamsError{Context: "InterfaceRequest"} 929 if v.Name == nil { 930 invalidParams.Add(smithy.NewErrParamRequired("Name")) 931 } 932 if invalidParams.Len() > 0 { 933 return invalidParams 934 } else { 935 return nil 936 } 937} 938 939func validateMediaStreamOutputConfigurationRequest(v *types.MediaStreamOutputConfigurationRequest) error { 940 if v == nil { 941 return nil 942 } 943 invalidParams := smithy.InvalidParamsError{Context: "MediaStreamOutputConfigurationRequest"} 944 if v.DestinationConfigurations != nil { 945 if err := validate__listOfDestinationConfigurationRequest(v.DestinationConfigurations); err != nil { 946 invalidParams.AddNested("DestinationConfigurations", err.(smithy.InvalidParamsError)) 947 } 948 } 949 if len(v.EncodingName) == 0 { 950 invalidParams.Add(smithy.NewErrParamRequired("EncodingName")) 951 } 952 if v.EncodingParameters != nil { 953 if err := validateEncodingParametersRequest(v.EncodingParameters); err != nil { 954 invalidParams.AddNested("EncodingParameters", err.(smithy.InvalidParamsError)) 955 } 956 } 957 if v.MediaStreamName == nil { 958 invalidParams.Add(smithy.NewErrParamRequired("MediaStreamName")) 959 } 960 if invalidParams.Len() > 0 { 961 return invalidParams 962 } else { 963 return nil 964 } 965} 966 967func validateMediaStreamSourceConfigurationRequest(v *types.MediaStreamSourceConfigurationRequest) error { 968 if v == nil { 969 return nil 970 } 971 invalidParams := smithy.InvalidParamsError{Context: "MediaStreamSourceConfigurationRequest"} 972 if len(v.EncodingName) == 0 { 973 invalidParams.Add(smithy.NewErrParamRequired("EncodingName")) 974 } 975 if v.InputConfigurations != nil { 976 if err := validate__listOfInputConfigurationRequest(v.InputConfigurations); err != nil { 977 invalidParams.AddNested("InputConfigurations", err.(smithy.InvalidParamsError)) 978 } 979 } 980 if v.MediaStreamName == nil { 981 invalidParams.Add(smithy.NewErrParamRequired("MediaStreamName")) 982 } 983 if invalidParams.Len() > 0 { 984 return invalidParams 985 } else { 986 return nil 987 } 988} 989 990func validateSetSourceRequest(v *types.SetSourceRequest) error { 991 if v == nil { 992 return nil 993 } 994 invalidParams := smithy.InvalidParamsError{Context: "SetSourceRequest"} 995 if v.Decryption != nil { 996 if err := validateEncryption(v.Decryption); err != nil { 997 invalidParams.AddNested("Decryption", err.(smithy.InvalidParamsError)) 998 } 999 } 1000 if v.MediaStreamSourceConfigurations != nil { 1001 if err := validate__listOfMediaStreamSourceConfigurationRequest(v.MediaStreamSourceConfigurations); err != nil { 1002 invalidParams.AddNested("MediaStreamSourceConfigurations", err.(smithy.InvalidParamsError)) 1003 } 1004 } 1005 if invalidParams.Len() > 0 { 1006 return invalidParams 1007 } else { 1008 return nil 1009 } 1010} 1011 1012func validateVpcInterfaceRequest(v *types.VpcInterfaceRequest) error { 1013 if v == nil { 1014 return nil 1015 } 1016 invalidParams := smithy.InvalidParamsError{Context: "VpcInterfaceRequest"} 1017 if v.Name == nil { 1018 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1019 } 1020 if v.RoleArn == nil { 1021 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 1022 } 1023 if v.SecurityGroupIds == nil { 1024 invalidParams.Add(smithy.NewErrParamRequired("SecurityGroupIds")) 1025 } 1026 if v.SubnetId == nil { 1027 invalidParams.Add(smithy.NewErrParamRequired("SubnetId")) 1028 } 1029 if invalidParams.Len() > 0 { 1030 return invalidParams 1031 } else { 1032 return nil 1033 } 1034} 1035 1036func validateOpAddFlowMediaStreamsInput(v *AddFlowMediaStreamsInput) error { 1037 if v == nil { 1038 return nil 1039 } 1040 invalidParams := smithy.InvalidParamsError{Context: "AddFlowMediaStreamsInput"} 1041 if v.FlowArn == nil { 1042 invalidParams.Add(smithy.NewErrParamRequired("FlowArn")) 1043 } 1044 if v.MediaStreams == nil { 1045 invalidParams.Add(smithy.NewErrParamRequired("MediaStreams")) 1046 } else if v.MediaStreams != nil { 1047 if err := validate__listOfAddMediaStreamRequest(v.MediaStreams); err != nil { 1048 invalidParams.AddNested("MediaStreams", err.(smithy.InvalidParamsError)) 1049 } 1050 } 1051 if invalidParams.Len() > 0 { 1052 return invalidParams 1053 } else { 1054 return nil 1055 } 1056} 1057 1058func validateOpAddFlowOutputsInput(v *AddFlowOutputsInput) error { 1059 if v == nil { 1060 return nil 1061 } 1062 invalidParams := smithy.InvalidParamsError{Context: "AddFlowOutputsInput"} 1063 if v.FlowArn == nil { 1064 invalidParams.Add(smithy.NewErrParamRequired("FlowArn")) 1065 } 1066 if v.Outputs == nil { 1067 invalidParams.Add(smithy.NewErrParamRequired("Outputs")) 1068 } else if v.Outputs != nil { 1069 if err := validate__listOfAddOutputRequest(v.Outputs); err != nil { 1070 invalidParams.AddNested("Outputs", err.(smithy.InvalidParamsError)) 1071 } 1072 } 1073 if invalidParams.Len() > 0 { 1074 return invalidParams 1075 } else { 1076 return nil 1077 } 1078} 1079 1080func validateOpAddFlowSourcesInput(v *AddFlowSourcesInput) error { 1081 if v == nil { 1082 return nil 1083 } 1084 invalidParams := smithy.InvalidParamsError{Context: "AddFlowSourcesInput"} 1085 if v.FlowArn == nil { 1086 invalidParams.Add(smithy.NewErrParamRequired("FlowArn")) 1087 } 1088 if v.Sources == nil { 1089 invalidParams.Add(smithy.NewErrParamRequired("Sources")) 1090 } else if v.Sources != nil { 1091 if err := validate__listOfSetSourceRequest(v.Sources); err != nil { 1092 invalidParams.AddNested("Sources", err.(smithy.InvalidParamsError)) 1093 } 1094 } 1095 if invalidParams.Len() > 0 { 1096 return invalidParams 1097 } else { 1098 return nil 1099 } 1100} 1101 1102func validateOpAddFlowVpcInterfacesInput(v *AddFlowVpcInterfacesInput) error { 1103 if v == nil { 1104 return nil 1105 } 1106 invalidParams := smithy.InvalidParamsError{Context: "AddFlowVpcInterfacesInput"} 1107 if v.FlowArn == nil { 1108 invalidParams.Add(smithy.NewErrParamRequired("FlowArn")) 1109 } 1110 if v.VpcInterfaces == nil { 1111 invalidParams.Add(smithy.NewErrParamRequired("VpcInterfaces")) 1112 } else if v.VpcInterfaces != nil { 1113 if err := validate__listOfVpcInterfaceRequest(v.VpcInterfaces); err != nil { 1114 invalidParams.AddNested("VpcInterfaces", err.(smithy.InvalidParamsError)) 1115 } 1116 } 1117 if invalidParams.Len() > 0 { 1118 return invalidParams 1119 } else { 1120 return nil 1121 } 1122} 1123 1124func validateOpCreateFlowInput(v *CreateFlowInput) error { 1125 if v == nil { 1126 return nil 1127 } 1128 invalidParams := smithy.InvalidParamsError{Context: "CreateFlowInput"} 1129 if v.Entitlements != nil { 1130 if err := validate__listOfGrantEntitlementRequest(v.Entitlements); err != nil { 1131 invalidParams.AddNested("Entitlements", err.(smithy.InvalidParamsError)) 1132 } 1133 } 1134 if v.MediaStreams != nil { 1135 if err := validate__listOfAddMediaStreamRequest(v.MediaStreams); err != nil { 1136 invalidParams.AddNested("MediaStreams", err.(smithy.InvalidParamsError)) 1137 } 1138 } 1139 if v.Name == nil { 1140 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1141 } 1142 if v.Outputs != nil { 1143 if err := validate__listOfAddOutputRequest(v.Outputs); err != nil { 1144 invalidParams.AddNested("Outputs", err.(smithy.InvalidParamsError)) 1145 } 1146 } 1147 if v.Source != nil { 1148 if err := validateSetSourceRequest(v.Source); err != nil { 1149 invalidParams.AddNested("Source", err.(smithy.InvalidParamsError)) 1150 } 1151 } 1152 if v.Sources != nil { 1153 if err := validate__listOfSetSourceRequest(v.Sources); err != nil { 1154 invalidParams.AddNested("Sources", err.(smithy.InvalidParamsError)) 1155 } 1156 } 1157 if v.VpcInterfaces != nil { 1158 if err := validate__listOfVpcInterfaceRequest(v.VpcInterfaces); err != nil { 1159 invalidParams.AddNested("VpcInterfaces", err.(smithy.InvalidParamsError)) 1160 } 1161 } 1162 if invalidParams.Len() > 0 { 1163 return invalidParams 1164 } else { 1165 return nil 1166 } 1167} 1168 1169func validateOpDeleteFlowInput(v *DeleteFlowInput) error { 1170 if v == nil { 1171 return nil 1172 } 1173 invalidParams := smithy.InvalidParamsError{Context: "DeleteFlowInput"} 1174 if v.FlowArn == nil { 1175 invalidParams.Add(smithy.NewErrParamRequired("FlowArn")) 1176 } 1177 if invalidParams.Len() > 0 { 1178 return invalidParams 1179 } else { 1180 return nil 1181 } 1182} 1183 1184func validateOpDescribeFlowInput(v *DescribeFlowInput) error { 1185 if v == nil { 1186 return nil 1187 } 1188 invalidParams := smithy.InvalidParamsError{Context: "DescribeFlowInput"} 1189 if v.FlowArn == nil { 1190 invalidParams.Add(smithy.NewErrParamRequired("FlowArn")) 1191 } 1192 if invalidParams.Len() > 0 { 1193 return invalidParams 1194 } else { 1195 return nil 1196 } 1197} 1198 1199func validateOpDescribeOfferingInput(v *DescribeOfferingInput) error { 1200 if v == nil { 1201 return nil 1202 } 1203 invalidParams := smithy.InvalidParamsError{Context: "DescribeOfferingInput"} 1204 if v.OfferingArn == nil { 1205 invalidParams.Add(smithy.NewErrParamRequired("OfferingArn")) 1206 } 1207 if invalidParams.Len() > 0 { 1208 return invalidParams 1209 } else { 1210 return nil 1211 } 1212} 1213 1214func validateOpDescribeReservationInput(v *DescribeReservationInput) error { 1215 if v == nil { 1216 return nil 1217 } 1218 invalidParams := smithy.InvalidParamsError{Context: "DescribeReservationInput"} 1219 if v.ReservationArn == nil { 1220 invalidParams.Add(smithy.NewErrParamRequired("ReservationArn")) 1221 } 1222 if invalidParams.Len() > 0 { 1223 return invalidParams 1224 } else { 1225 return nil 1226 } 1227} 1228 1229func validateOpGrantFlowEntitlementsInput(v *GrantFlowEntitlementsInput) error { 1230 if v == nil { 1231 return nil 1232 } 1233 invalidParams := smithy.InvalidParamsError{Context: "GrantFlowEntitlementsInput"} 1234 if v.Entitlements == nil { 1235 invalidParams.Add(smithy.NewErrParamRequired("Entitlements")) 1236 } else if v.Entitlements != nil { 1237 if err := validate__listOfGrantEntitlementRequest(v.Entitlements); err != nil { 1238 invalidParams.AddNested("Entitlements", err.(smithy.InvalidParamsError)) 1239 } 1240 } 1241 if v.FlowArn == nil { 1242 invalidParams.Add(smithy.NewErrParamRequired("FlowArn")) 1243 } 1244 if invalidParams.Len() > 0 { 1245 return invalidParams 1246 } else { 1247 return nil 1248 } 1249} 1250 1251func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 1252 if v == nil { 1253 return nil 1254 } 1255 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 1256 if v.ResourceArn == nil { 1257 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1258 } 1259 if invalidParams.Len() > 0 { 1260 return invalidParams 1261 } else { 1262 return nil 1263 } 1264} 1265 1266func validateOpPurchaseOfferingInput(v *PurchaseOfferingInput) error { 1267 if v == nil { 1268 return nil 1269 } 1270 invalidParams := smithy.InvalidParamsError{Context: "PurchaseOfferingInput"} 1271 if v.OfferingArn == nil { 1272 invalidParams.Add(smithy.NewErrParamRequired("OfferingArn")) 1273 } 1274 if v.ReservationName == nil { 1275 invalidParams.Add(smithy.NewErrParamRequired("ReservationName")) 1276 } 1277 if v.Start == nil { 1278 invalidParams.Add(smithy.NewErrParamRequired("Start")) 1279 } 1280 if invalidParams.Len() > 0 { 1281 return invalidParams 1282 } else { 1283 return nil 1284 } 1285} 1286 1287func validateOpRemoveFlowMediaStreamInput(v *RemoveFlowMediaStreamInput) error { 1288 if v == nil { 1289 return nil 1290 } 1291 invalidParams := smithy.InvalidParamsError{Context: "RemoveFlowMediaStreamInput"} 1292 if v.FlowArn == nil { 1293 invalidParams.Add(smithy.NewErrParamRequired("FlowArn")) 1294 } 1295 if v.MediaStreamName == nil { 1296 invalidParams.Add(smithy.NewErrParamRequired("MediaStreamName")) 1297 } 1298 if invalidParams.Len() > 0 { 1299 return invalidParams 1300 } else { 1301 return nil 1302 } 1303} 1304 1305func validateOpRemoveFlowOutputInput(v *RemoveFlowOutputInput) error { 1306 if v == nil { 1307 return nil 1308 } 1309 invalidParams := smithy.InvalidParamsError{Context: "RemoveFlowOutputInput"} 1310 if v.FlowArn == nil { 1311 invalidParams.Add(smithy.NewErrParamRequired("FlowArn")) 1312 } 1313 if v.OutputArn == nil { 1314 invalidParams.Add(smithy.NewErrParamRequired("OutputArn")) 1315 } 1316 if invalidParams.Len() > 0 { 1317 return invalidParams 1318 } else { 1319 return nil 1320 } 1321} 1322 1323func validateOpRemoveFlowSourceInput(v *RemoveFlowSourceInput) error { 1324 if v == nil { 1325 return nil 1326 } 1327 invalidParams := smithy.InvalidParamsError{Context: "RemoveFlowSourceInput"} 1328 if v.FlowArn == nil { 1329 invalidParams.Add(smithy.NewErrParamRequired("FlowArn")) 1330 } 1331 if v.SourceArn == nil { 1332 invalidParams.Add(smithy.NewErrParamRequired("SourceArn")) 1333 } 1334 if invalidParams.Len() > 0 { 1335 return invalidParams 1336 } else { 1337 return nil 1338 } 1339} 1340 1341func validateOpRemoveFlowVpcInterfaceInput(v *RemoveFlowVpcInterfaceInput) error { 1342 if v == nil { 1343 return nil 1344 } 1345 invalidParams := smithy.InvalidParamsError{Context: "RemoveFlowVpcInterfaceInput"} 1346 if v.FlowArn == nil { 1347 invalidParams.Add(smithy.NewErrParamRequired("FlowArn")) 1348 } 1349 if v.VpcInterfaceName == nil { 1350 invalidParams.Add(smithy.NewErrParamRequired("VpcInterfaceName")) 1351 } 1352 if invalidParams.Len() > 0 { 1353 return invalidParams 1354 } else { 1355 return nil 1356 } 1357} 1358 1359func validateOpRevokeFlowEntitlementInput(v *RevokeFlowEntitlementInput) error { 1360 if v == nil { 1361 return nil 1362 } 1363 invalidParams := smithy.InvalidParamsError{Context: "RevokeFlowEntitlementInput"} 1364 if v.EntitlementArn == nil { 1365 invalidParams.Add(smithy.NewErrParamRequired("EntitlementArn")) 1366 } 1367 if v.FlowArn == nil { 1368 invalidParams.Add(smithy.NewErrParamRequired("FlowArn")) 1369 } 1370 if invalidParams.Len() > 0 { 1371 return invalidParams 1372 } else { 1373 return nil 1374 } 1375} 1376 1377func validateOpStartFlowInput(v *StartFlowInput) error { 1378 if v == nil { 1379 return nil 1380 } 1381 invalidParams := smithy.InvalidParamsError{Context: "StartFlowInput"} 1382 if v.FlowArn == nil { 1383 invalidParams.Add(smithy.NewErrParamRequired("FlowArn")) 1384 } 1385 if invalidParams.Len() > 0 { 1386 return invalidParams 1387 } else { 1388 return nil 1389 } 1390} 1391 1392func validateOpStopFlowInput(v *StopFlowInput) error { 1393 if v == nil { 1394 return nil 1395 } 1396 invalidParams := smithy.InvalidParamsError{Context: "StopFlowInput"} 1397 if v.FlowArn == nil { 1398 invalidParams.Add(smithy.NewErrParamRequired("FlowArn")) 1399 } 1400 if invalidParams.Len() > 0 { 1401 return invalidParams 1402 } else { 1403 return nil 1404 } 1405} 1406 1407func validateOpTagResourceInput(v *TagResourceInput) error { 1408 if v == nil { 1409 return nil 1410 } 1411 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 1412 if v.ResourceArn == nil { 1413 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1414 } 1415 if v.Tags == nil { 1416 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 1417 } 1418 if invalidParams.Len() > 0 { 1419 return invalidParams 1420 } else { 1421 return nil 1422 } 1423} 1424 1425func validateOpUntagResourceInput(v *UntagResourceInput) error { 1426 if v == nil { 1427 return nil 1428 } 1429 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 1430 if v.ResourceArn == nil { 1431 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1432 } 1433 if v.TagKeys == nil { 1434 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 1435 } 1436 if invalidParams.Len() > 0 { 1437 return invalidParams 1438 } else { 1439 return nil 1440 } 1441} 1442 1443func validateOpUpdateFlowEntitlementInput(v *UpdateFlowEntitlementInput) error { 1444 if v == nil { 1445 return nil 1446 } 1447 invalidParams := smithy.InvalidParamsError{Context: "UpdateFlowEntitlementInput"} 1448 if v.EntitlementArn == nil { 1449 invalidParams.Add(smithy.NewErrParamRequired("EntitlementArn")) 1450 } 1451 if v.FlowArn == nil { 1452 invalidParams.Add(smithy.NewErrParamRequired("FlowArn")) 1453 } 1454 if invalidParams.Len() > 0 { 1455 return invalidParams 1456 } else { 1457 return nil 1458 } 1459} 1460 1461func validateOpUpdateFlowInput(v *UpdateFlowInput) error { 1462 if v == nil { 1463 return nil 1464 } 1465 invalidParams := smithy.InvalidParamsError{Context: "UpdateFlowInput"} 1466 if v.FlowArn == nil { 1467 invalidParams.Add(smithy.NewErrParamRequired("FlowArn")) 1468 } 1469 if invalidParams.Len() > 0 { 1470 return invalidParams 1471 } else { 1472 return nil 1473 } 1474} 1475 1476func validateOpUpdateFlowMediaStreamInput(v *UpdateFlowMediaStreamInput) error { 1477 if v == nil { 1478 return nil 1479 } 1480 invalidParams := smithy.InvalidParamsError{Context: "UpdateFlowMediaStreamInput"} 1481 if v.FlowArn == nil { 1482 invalidParams.Add(smithy.NewErrParamRequired("FlowArn")) 1483 } 1484 if v.MediaStreamName == nil { 1485 invalidParams.Add(smithy.NewErrParamRequired("MediaStreamName")) 1486 } 1487 if invalidParams.Len() > 0 { 1488 return invalidParams 1489 } else { 1490 return nil 1491 } 1492} 1493 1494func validateOpUpdateFlowOutputInput(v *UpdateFlowOutputInput) error { 1495 if v == nil { 1496 return nil 1497 } 1498 invalidParams := smithy.InvalidParamsError{Context: "UpdateFlowOutputInput"} 1499 if v.FlowArn == nil { 1500 invalidParams.Add(smithy.NewErrParamRequired("FlowArn")) 1501 } 1502 if v.MediaStreamOutputConfigurations != nil { 1503 if err := validate__listOfMediaStreamOutputConfigurationRequest(v.MediaStreamOutputConfigurations); err != nil { 1504 invalidParams.AddNested("MediaStreamOutputConfigurations", err.(smithy.InvalidParamsError)) 1505 } 1506 } 1507 if v.OutputArn == nil { 1508 invalidParams.Add(smithy.NewErrParamRequired("OutputArn")) 1509 } 1510 if invalidParams.Len() > 0 { 1511 return invalidParams 1512 } else { 1513 return nil 1514 } 1515} 1516 1517func validateOpUpdateFlowSourceInput(v *UpdateFlowSourceInput) error { 1518 if v == nil { 1519 return nil 1520 } 1521 invalidParams := smithy.InvalidParamsError{Context: "UpdateFlowSourceInput"} 1522 if v.FlowArn == nil { 1523 invalidParams.Add(smithy.NewErrParamRequired("FlowArn")) 1524 } 1525 if v.MediaStreamSourceConfigurations != nil { 1526 if err := validate__listOfMediaStreamSourceConfigurationRequest(v.MediaStreamSourceConfigurations); err != nil { 1527 invalidParams.AddNested("MediaStreamSourceConfigurations", err.(smithy.InvalidParamsError)) 1528 } 1529 } 1530 if v.SourceArn == nil { 1531 invalidParams.Add(smithy.NewErrParamRequired("SourceArn")) 1532 } 1533 if invalidParams.Len() > 0 { 1534 return invalidParams 1535 } else { 1536 return nil 1537 } 1538} 1539