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