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