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 validateOpListTagsForResource struct {
354}
355
356func (*validateOpListTagsForResource) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpListTagsForResourceInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpListVodSources struct {
374}
375
376func (*validateOpListVodSources) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpListVodSources) 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.(*ListVodSourcesInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpListVodSourcesInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpPutChannelPolicy struct {
394}
395
396func (*validateOpPutChannelPolicy) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpPutChannelPolicy) 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.(*PutChannelPolicyInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpPutChannelPolicyInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpStartChannel struct {
414}
415
416func (*validateOpStartChannel) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpStartChannel) 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.(*StartChannelInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpStartChannelInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpStopChannel struct {
434}
435
436func (*validateOpStopChannel) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpStopChannel) 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.(*StopChannelInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpStopChannelInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpTagResource struct {
454}
455
456func (*validateOpTagResource) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpTagResource) 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.(*TagResourceInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpTagResourceInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpUntagResource struct {
474}
475
476func (*validateOpUntagResource) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpUntagResource) 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.(*UntagResourceInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpUntagResourceInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpUpdateChannel struct {
494}
495
496func (*validateOpUpdateChannel) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpUpdateChannel) 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.(*UpdateChannelInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpUpdateChannelInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpUpdateSourceLocation struct {
514}
515
516func (*validateOpUpdateSourceLocation) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpUpdateSourceLocation) 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.(*UpdateSourceLocationInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpUpdateSourceLocationInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpUpdateVodSource struct {
534}
535
536func (*validateOpUpdateVodSource) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpUpdateVodSource) 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.(*UpdateVodSourceInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpUpdateVodSourceInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553func addOpCreateChannelValidationMiddleware(stack *middleware.Stack) error {
554	return stack.Initialize.Add(&validateOpCreateChannel{}, middleware.After)
555}
556
557func addOpCreateProgramValidationMiddleware(stack *middleware.Stack) error {
558	return stack.Initialize.Add(&validateOpCreateProgram{}, middleware.After)
559}
560
561func addOpCreateSourceLocationValidationMiddleware(stack *middleware.Stack) error {
562	return stack.Initialize.Add(&validateOpCreateSourceLocation{}, middleware.After)
563}
564
565func addOpCreateVodSourceValidationMiddleware(stack *middleware.Stack) error {
566	return stack.Initialize.Add(&validateOpCreateVodSource{}, middleware.After)
567}
568
569func addOpDeleteChannelValidationMiddleware(stack *middleware.Stack) error {
570	return stack.Initialize.Add(&validateOpDeleteChannel{}, middleware.After)
571}
572
573func addOpDeleteChannelPolicyValidationMiddleware(stack *middleware.Stack) error {
574	return stack.Initialize.Add(&validateOpDeleteChannelPolicy{}, middleware.After)
575}
576
577func addOpDeletePlaybackConfigurationValidationMiddleware(stack *middleware.Stack) error {
578	return stack.Initialize.Add(&validateOpDeletePlaybackConfiguration{}, middleware.After)
579}
580
581func addOpDeleteProgramValidationMiddleware(stack *middleware.Stack) error {
582	return stack.Initialize.Add(&validateOpDeleteProgram{}, middleware.After)
583}
584
585func addOpDeleteSourceLocationValidationMiddleware(stack *middleware.Stack) error {
586	return stack.Initialize.Add(&validateOpDeleteSourceLocation{}, middleware.After)
587}
588
589func addOpDeleteVodSourceValidationMiddleware(stack *middleware.Stack) error {
590	return stack.Initialize.Add(&validateOpDeleteVodSource{}, middleware.After)
591}
592
593func addOpDescribeChannelValidationMiddleware(stack *middleware.Stack) error {
594	return stack.Initialize.Add(&validateOpDescribeChannel{}, middleware.After)
595}
596
597func addOpDescribeProgramValidationMiddleware(stack *middleware.Stack) error {
598	return stack.Initialize.Add(&validateOpDescribeProgram{}, middleware.After)
599}
600
601func addOpDescribeSourceLocationValidationMiddleware(stack *middleware.Stack) error {
602	return stack.Initialize.Add(&validateOpDescribeSourceLocation{}, middleware.After)
603}
604
605func addOpDescribeVodSourceValidationMiddleware(stack *middleware.Stack) error {
606	return stack.Initialize.Add(&validateOpDescribeVodSource{}, middleware.After)
607}
608
609func addOpGetChannelPolicyValidationMiddleware(stack *middleware.Stack) error {
610	return stack.Initialize.Add(&validateOpGetChannelPolicy{}, middleware.After)
611}
612
613func addOpGetChannelScheduleValidationMiddleware(stack *middleware.Stack) error {
614	return stack.Initialize.Add(&validateOpGetChannelSchedule{}, middleware.After)
615}
616
617func addOpGetPlaybackConfigurationValidationMiddleware(stack *middleware.Stack) error {
618	return stack.Initialize.Add(&validateOpGetPlaybackConfiguration{}, middleware.After)
619}
620
621func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
622	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
623}
624
625func addOpListVodSourcesValidationMiddleware(stack *middleware.Stack) error {
626	return stack.Initialize.Add(&validateOpListVodSources{}, middleware.After)
627}
628
629func addOpPutChannelPolicyValidationMiddleware(stack *middleware.Stack) error {
630	return stack.Initialize.Add(&validateOpPutChannelPolicy{}, middleware.After)
631}
632
633func addOpStartChannelValidationMiddleware(stack *middleware.Stack) error {
634	return stack.Initialize.Add(&validateOpStartChannel{}, middleware.After)
635}
636
637func addOpStopChannelValidationMiddleware(stack *middleware.Stack) error {
638	return stack.Initialize.Add(&validateOpStopChannel{}, middleware.After)
639}
640
641func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
642	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
643}
644
645func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
646	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
647}
648
649func addOpUpdateChannelValidationMiddleware(stack *middleware.Stack) error {
650	return stack.Initialize.Add(&validateOpUpdateChannel{}, middleware.After)
651}
652
653func addOpUpdateSourceLocationValidationMiddleware(stack *middleware.Stack) error {
654	return stack.Initialize.Add(&validateOpUpdateSourceLocation{}, middleware.After)
655}
656
657func addOpUpdateVodSourceValidationMiddleware(stack *middleware.Stack) error {
658	return stack.Initialize.Add(&validateOpUpdateVodSource{}, middleware.After)
659}
660
661func validateHttpConfiguration(v *types.HttpConfiguration) error {
662	if v == nil {
663		return nil
664	}
665	invalidParams := smithy.InvalidParamsError{Context: "HttpConfiguration"}
666	if v.BaseUrl == nil {
667		invalidParams.Add(smithy.NewErrParamRequired("BaseUrl"))
668	}
669	if invalidParams.Len() > 0 {
670		return invalidParams
671	} else {
672		return nil
673	}
674}
675
676func validateHttpPackageConfiguration(v *types.HttpPackageConfiguration) error {
677	if v == nil {
678		return nil
679	}
680	invalidParams := smithy.InvalidParamsError{Context: "HttpPackageConfiguration"}
681	if v.Path == nil {
682		invalidParams.Add(smithy.NewErrParamRequired("Path"))
683	}
684	if v.SourceGroup == nil {
685		invalidParams.Add(smithy.NewErrParamRequired("SourceGroup"))
686	}
687	if len(v.Type) == 0 {
688		invalidParams.Add(smithy.NewErrParamRequired("Type"))
689	}
690	if invalidParams.Len() > 0 {
691		return invalidParams
692	} else {
693		return nil
694	}
695}
696
697func validateHttpPackageConfigurations(v []types.HttpPackageConfiguration) error {
698	if v == nil {
699		return nil
700	}
701	invalidParams := smithy.InvalidParamsError{Context: "HttpPackageConfigurations"}
702	for i := range v {
703		if err := validateHttpPackageConfiguration(&v[i]); err != nil {
704			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
705		}
706	}
707	if invalidParams.Len() > 0 {
708		return invalidParams
709	} else {
710		return nil
711	}
712}
713
714func validateRequestOutputItem(v *types.RequestOutputItem) error {
715	if v == nil {
716		return nil
717	}
718	invalidParams := smithy.InvalidParamsError{Context: "RequestOutputItem"}
719	if v.ManifestName == nil {
720		invalidParams.Add(smithy.NewErrParamRequired("ManifestName"))
721	}
722	if v.SourceGroup == nil {
723		invalidParams.Add(smithy.NewErrParamRequired("SourceGroup"))
724	}
725	if invalidParams.Len() > 0 {
726		return invalidParams
727	} else {
728		return nil
729	}
730}
731
732func validateRequestOutputs(v []types.RequestOutputItem) error {
733	if v == nil {
734		return nil
735	}
736	invalidParams := smithy.InvalidParamsError{Context: "RequestOutputs"}
737	for i := range v {
738		if err := validateRequestOutputItem(&v[i]); err != nil {
739			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
740		}
741	}
742	if invalidParams.Len() > 0 {
743		return invalidParams
744	} else {
745		return nil
746	}
747}
748
749func validateScheduleConfiguration(v *types.ScheduleConfiguration) error {
750	if v == nil {
751		return nil
752	}
753	invalidParams := smithy.InvalidParamsError{Context: "ScheduleConfiguration"}
754	if v.Transition == nil {
755		invalidParams.Add(smithy.NewErrParamRequired("Transition"))
756	} else if v.Transition != nil {
757		if err := validateTransition(v.Transition); err != nil {
758			invalidParams.AddNested("Transition", err.(smithy.InvalidParamsError))
759		}
760	}
761	if invalidParams.Len() > 0 {
762		return invalidParams
763	} else {
764		return nil
765	}
766}
767
768func validateTransition(v *types.Transition) error {
769	if v == nil {
770		return nil
771	}
772	invalidParams := smithy.InvalidParamsError{Context: "Transition"}
773	if len(v.RelativePosition) == 0 {
774		invalidParams.Add(smithy.NewErrParamRequired("RelativePosition"))
775	}
776	if v.Type == nil {
777		invalidParams.Add(smithy.NewErrParamRequired("Type"))
778	}
779	if invalidParams.Len() > 0 {
780		return invalidParams
781	} else {
782		return nil
783	}
784}
785
786func validateOpCreateChannelInput(v *CreateChannelInput) error {
787	if v == nil {
788		return nil
789	}
790	invalidParams := smithy.InvalidParamsError{Context: "CreateChannelInput"}
791	if v.ChannelName == nil {
792		invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
793	}
794	if v.Outputs == nil {
795		invalidParams.Add(smithy.NewErrParamRequired("Outputs"))
796	} else if v.Outputs != nil {
797		if err := validateRequestOutputs(v.Outputs); err != nil {
798			invalidParams.AddNested("Outputs", err.(smithy.InvalidParamsError))
799		}
800	}
801	if len(v.PlaybackMode) == 0 {
802		invalidParams.Add(smithy.NewErrParamRequired("PlaybackMode"))
803	}
804	if invalidParams.Len() > 0 {
805		return invalidParams
806	} else {
807		return nil
808	}
809}
810
811func validateOpCreateProgramInput(v *CreateProgramInput) error {
812	if v == nil {
813		return nil
814	}
815	invalidParams := smithy.InvalidParamsError{Context: "CreateProgramInput"}
816	if v.ChannelName == nil {
817		invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
818	}
819	if v.ProgramName == nil {
820		invalidParams.Add(smithy.NewErrParamRequired("ProgramName"))
821	}
822	if v.ScheduleConfiguration == nil {
823		invalidParams.Add(smithy.NewErrParamRequired("ScheduleConfiguration"))
824	} else if v.ScheduleConfiguration != nil {
825		if err := validateScheduleConfiguration(v.ScheduleConfiguration); err != nil {
826			invalidParams.AddNested("ScheduleConfiguration", err.(smithy.InvalidParamsError))
827		}
828	}
829	if v.SourceLocationName == nil {
830		invalidParams.Add(smithy.NewErrParamRequired("SourceLocationName"))
831	}
832	if v.VodSourceName == nil {
833		invalidParams.Add(smithy.NewErrParamRequired("VodSourceName"))
834	}
835	if invalidParams.Len() > 0 {
836		return invalidParams
837	} else {
838		return nil
839	}
840}
841
842func validateOpCreateSourceLocationInput(v *CreateSourceLocationInput) error {
843	if v == nil {
844		return nil
845	}
846	invalidParams := smithy.InvalidParamsError{Context: "CreateSourceLocationInput"}
847	if v.HttpConfiguration == nil {
848		invalidParams.Add(smithy.NewErrParamRequired("HttpConfiguration"))
849	} else if v.HttpConfiguration != nil {
850		if err := validateHttpConfiguration(v.HttpConfiguration); err != nil {
851			invalidParams.AddNested("HttpConfiguration", err.(smithy.InvalidParamsError))
852		}
853	}
854	if v.SourceLocationName == nil {
855		invalidParams.Add(smithy.NewErrParamRequired("SourceLocationName"))
856	}
857	if invalidParams.Len() > 0 {
858		return invalidParams
859	} else {
860		return nil
861	}
862}
863
864func validateOpCreateVodSourceInput(v *CreateVodSourceInput) error {
865	if v == nil {
866		return nil
867	}
868	invalidParams := smithy.InvalidParamsError{Context: "CreateVodSourceInput"}
869	if v.HttpPackageConfigurations == nil {
870		invalidParams.Add(smithy.NewErrParamRequired("HttpPackageConfigurations"))
871	} else if v.HttpPackageConfigurations != nil {
872		if err := validateHttpPackageConfigurations(v.HttpPackageConfigurations); err != nil {
873			invalidParams.AddNested("HttpPackageConfigurations", err.(smithy.InvalidParamsError))
874		}
875	}
876	if v.SourceLocationName == nil {
877		invalidParams.Add(smithy.NewErrParamRequired("SourceLocationName"))
878	}
879	if v.VodSourceName == nil {
880		invalidParams.Add(smithy.NewErrParamRequired("VodSourceName"))
881	}
882	if invalidParams.Len() > 0 {
883		return invalidParams
884	} else {
885		return nil
886	}
887}
888
889func validateOpDeleteChannelInput(v *DeleteChannelInput) error {
890	if v == nil {
891		return nil
892	}
893	invalidParams := smithy.InvalidParamsError{Context: "DeleteChannelInput"}
894	if v.ChannelName == nil {
895		invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
896	}
897	if invalidParams.Len() > 0 {
898		return invalidParams
899	} else {
900		return nil
901	}
902}
903
904func validateOpDeleteChannelPolicyInput(v *DeleteChannelPolicyInput) error {
905	if v == nil {
906		return nil
907	}
908	invalidParams := smithy.InvalidParamsError{Context: "DeleteChannelPolicyInput"}
909	if v.ChannelName == nil {
910		invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
911	}
912	if invalidParams.Len() > 0 {
913		return invalidParams
914	} else {
915		return nil
916	}
917}
918
919func validateOpDeletePlaybackConfigurationInput(v *DeletePlaybackConfigurationInput) error {
920	if v == nil {
921		return nil
922	}
923	invalidParams := smithy.InvalidParamsError{Context: "DeletePlaybackConfigurationInput"}
924	if v.Name == nil {
925		invalidParams.Add(smithy.NewErrParamRequired("Name"))
926	}
927	if invalidParams.Len() > 0 {
928		return invalidParams
929	} else {
930		return nil
931	}
932}
933
934func validateOpDeleteProgramInput(v *DeleteProgramInput) error {
935	if v == nil {
936		return nil
937	}
938	invalidParams := smithy.InvalidParamsError{Context: "DeleteProgramInput"}
939	if v.ChannelName == nil {
940		invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
941	}
942	if v.ProgramName == nil {
943		invalidParams.Add(smithy.NewErrParamRequired("ProgramName"))
944	}
945	if invalidParams.Len() > 0 {
946		return invalidParams
947	} else {
948		return nil
949	}
950}
951
952func validateOpDeleteSourceLocationInput(v *DeleteSourceLocationInput) error {
953	if v == nil {
954		return nil
955	}
956	invalidParams := smithy.InvalidParamsError{Context: "DeleteSourceLocationInput"}
957	if v.SourceLocationName == nil {
958		invalidParams.Add(smithy.NewErrParamRequired("SourceLocationName"))
959	}
960	if invalidParams.Len() > 0 {
961		return invalidParams
962	} else {
963		return nil
964	}
965}
966
967func validateOpDeleteVodSourceInput(v *DeleteVodSourceInput) error {
968	if v == nil {
969		return nil
970	}
971	invalidParams := smithy.InvalidParamsError{Context: "DeleteVodSourceInput"}
972	if v.SourceLocationName == nil {
973		invalidParams.Add(smithy.NewErrParamRequired("SourceLocationName"))
974	}
975	if v.VodSourceName == nil {
976		invalidParams.Add(smithy.NewErrParamRequired("VodSourceName"))
977	}
978	if invalidParams.Len() > 0 {
979		return invalidParams
980	} else {
981		return nil
982	}
983}
984
985func validateOpDescribeChannelInput(v *DescribeChannelInput) error {
986	if v == nil {
987		return nil
988	}
989	invalidParams := smithy.InvalidParamsError{Context: "DescribeChannelInput"}
990	if v.ChannelName == nil {
991		invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
992	}
993	if invalidParams.Len() > 0 {
994		return invalidParams
995	} else {
996		return nil
997	}
998}
999
1000func validateOpDescribeProgramInput(v *DescribeProgramInput) error {
1001	if v == nil {
1002		return nil
1003	}
1004	invalidParams := smithy.InvalidParamsError{Context: "DescribeProgramInput"}
1005	if v.ChannelName == nil {
1006		invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
1007	}
1008	if v.ProgramName == nil {
1009		invalidParams.Add(smithy.NewErrParamRequired("ProgramName"))
1010	}
1011	if invalidParams.Len() > 0 {
1012		return invalidParams
1013	} else {
1014		return nil
1015	}
1016}
1017
1018func validateOpDescribeSourceLocationInput(v *DescribeSourceLocationInput) error {
1019	if v == nil {
1020		return nil
1021	}
1022	invalidParams := smithy.InvalidParamsError{Context: "DescribeSourceLocationInput"}
1023	if v.SourceLocationName == nil {
1024		invalidParams.Add(smithy.NewErrParamRequired("SourceLocationName"))
1025	}
1026	if invalidParams.Len() > 0 {
1027		return invalidParams
1028	} else {
1029		return nil
1030	}
1031}
1032
1033func validateOpDescribeVodSourceInput(v *DescribeVodSourceInput) error {
1034	if v == nil {
1035		return nil
1036	}
1037	invalidParams := smithy.InvalidParamsError{Context: "DescribeVodSourceInput"}
1038	if v.SourceLocationName == nil {
1039		invalidParams.Add(smithy.NewErrParamRequired("SourceLocationName"))
1040	}
1041	if v.VodSourceName == nil {
1042		invalidParams.Add(smithy.NewErrParamRequired("VodSourceName"))
1043	}
1044	if invalidParams.Len() > 0 {
1045		return invalidParams
1046	} else {
1047		return nil
1048	}
1049}
1050
1051func validateOpGetChannelPolicyInput(v *GetChannelPolicyInput) error {
1052	if v == nil {
1053		return nil
1054	}
1055	invalidParams := smithy.InvalidParamsError{Context: "GetChannelPolicyInput"}
1056	if v.ChannelName == nil {
1057		invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
1058	}
1059	if invalidParams.Len() > 0 {
1060		return invalidParams
1061	} else {
1062		return nil
1063	}
1064}
1065
1066func validateOpGetChannelScheduleInput(v *GetChannelScheduleInput) error {
1067	if v == nil {
1068		return nil
1069	}
1070	invalidParams := smithy.InvalidParamsError{Context: "GetChannelScheduleInput"}
1071	if v.ChannelName == nil {
1072		invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
1073	}
1074	if invalidParams.Len() > 0 {
1075		return invalidParams
1076	} else {
1077		return nil
1078	}
1079}
1080
1081func validateOpGetPlaybackConfigurationInput(v *GetPlaybackConfigurationInput) error {
1082	if v == nil {
1083		return nil
1084	}
1085	invalidParams := smithy.InvalidParamsError{Context: "GetPlaybackConfigurationInput"}
1086	if v.Name == nil {
1087		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1088	}
1089	if invalidParams.Len() > 0 {
1090		return invalidParams
1091	} else {
1092		return nil
1093	}
1094}
1095
1096func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
1097	if v == nil {
1098		return nil
1099	}
1100	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
1101	if v.ResourceArn == nil {
1102		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1103	}
1104	if invalidParams.Len() > 0 {
1105		return invalidParams
1106	} else {
1107		return nil
1108	}
1109}
1110
1111func validateOpListVodSourcesInput(v *ListVodSourcesInput) error {
1112	if v == nil {
1113		return nil
1114	}
1115	invalidParams := smithy.InvalidParamsError{Context: "ListVodSourcesInput"}
1116	if v.SourceLocationName == nil {
1117		invalidParams.Add(smithy.NewErrParamRequired("SourceLocationName"))
1118	}
1119	if invalidParams.Len() > 0 {
1120		return invalidParams
1121	} else {
1122		return nil
1123	}
1124}
1125
1126func validateOpPutChannelPolicyInput(v *PutChannelPolicyInput) error {
1127	if v == nil {
1128		return nil
1129	}
1130	invalidParams := smithy.InvalidParamsError{Context: "PutChannelPolicyInput"}
1131	if v.ChannelName == nil {
1132		invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
1133	}
1134	if v.Policy == nil {
1135		invalidParams.Add(smithy.NewErrParamRequired("Policy"))
1136	}
1137	if invalidParams.Len() > 0 {
1138		return invalidParams
1139	} else {
1140		return nil
1141	}
1142}
1143
1144func validateOpStartChannelInput(v *StartChannelInput) error {
1145	if v == nil {
1146		return nil
1147	}
1148	invalidParams := smithy.InvalidParamsError{Context: "StartChannelInput"}
1149	if v.ChannelName == nil {
1150		invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
1151	}
1152	if invalidParams.Len() > 0 {
1153		return invalidParams
1154	} else {
1155		return nil
1156	}
1157}
1158
1159func validateOpStopChannelInput(v *StopChannelInput) error {
1160	if v == nil {
1161		return nil
1162	}
1163	invalidParams := smithy.InvalidParamsError{Context: "StopChannelInput"}
1164	if v.ChannelName == nil {
1165		invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
1166	}
1167	if invalidParams.Len() > 0 {
1168		return invalidParams
1169	} else {
1170		return nil
1171	}
1172}
1173
1174func validateOpTagResourceInput(v *TagResourceInput) error {
1175	if v == nil {
1176		return nil
1177	}
1178	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
1179	if v.ResourceArn == nil {
1180		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1181	}
1182	if v.Tags == nil {
1183		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
1184	}
1185	if invalidParams.Len() > 0 {
1186		return invalidParams
1187	} else {
1188		return nil
1189	}
1190}
1191
1192func validateOpUntagResourceInput(v *UntagResourceInput) error {
1193	if v == nil {
1194		return nil
1195	}
1196	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
1197	if v.ResourceArn == nil {
1198		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1199	}
1200	if v.TagKeys == nil {
1201		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
1202	}
1203	if invalidParams.Len() > 0 {
1204		return invalidParams
1205	} else {
1206		return nil
1207	}
1208}
1209
1210func validateOpUpdateChannelInput(v *UpdateChannelInput) error {
1211	if v == nil {
1212		return nil
1213	}
1214	invalidParams := smithy.InvalidParamsError{Context: "UpdateChannelInput"}
1215	if v.ChannelName == nil {
1216		invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
1217	}
1218	if v.Outputs == nil {
1219		invalidParams.Add(smithy.NewErrParamRequired("Outputs"))
1220	} else if v.Outputs != nil {
1221		if err := validateRequestOutputs(v.Outputs); err != nil {
1222			invalidParams.AddNested("Outputs", err.(smithy.InvalidParamsError))
1223		}
1224	}
1225	if invalidParams.Len() > 0 {
1226		return invalidParams
1227	} else {
1228		return nil
1229	}
1230}
1231
1232func validateOpUpdateSourceLocationInput(v *UpdateSourceLocationInput) error {
1233	if v == nil {
1234		return nil
1235	}
1236	invalidParams := smithy.InvalidParamsError{Context: "UpdateSourceLocationInput"}
1237	if v.HttpConfiguration == nil {
1238		invalidParams.Add(smithy.NewErrParamRequired("HttpConfiguration"))
1239	} else if v.HttpConfiguration != nil {
1240		if err := validateHttpConfiguration(v.HttpConfiguration); err != nil {
1241			invalidParams.AddNested("HttpConfiguration", err.(smithy.InvalidParamsError))
1242		}
1243	}
1244	if v.SourceLocationName == nil {
1245		invalidParams.Add(smithy.NewErrParamRequired("SourceLocationName"))
1246	}
1247	if invalidParams.Len() > 0 {
1248		return invalidParams
1249	} else {
1250		return nil
1251	}
1252}
1253
1254func validateOpUpdateVodSourceInput(v *UpdateVodSourceInput) error {
1255	if v == nil {
1256		return nil
1257	}
1258	invalidParams := smithy.InvalidParamsError{Context: "UpdateVodSourceInput"}
1259	if v.HttpPackageConfigurations == nil {
1260		invalidParams.Add(smithy.NewErrParamRequired("HttpPackageConfigurations"))
1261	} else if v.HttpPackageConfigurations != nil {
1262		if err := validateHttpPackageConfigurations(v.HttpPackageConfigurations); err != nil {
1263			invalidParams.AddNested("HttpPackageConfigurations", err.(smithy.InvalidParamsError))
1264		}
1265	}
1266	if v.SourceLocationName == nil {
1267		invalidParams.Add(smithy.NewErrParamRequired("SourceLocationName"))
1268	}
1269	if v.VodSourceName == nil {
1270		invalidParams.Add(smithy.NewErrParamRequired("VodSourceName"))
1271	}
1272	if invalidParams.Len() > 0 {
1273		return invalidParams
1274	} else {
1275		return nil
1276	}
1277}
1278