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