1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package ivs
4
5import (
6	"context"
7	"fmt"
8	smithy "github.com/aws/smithy-go"
9	"github.com/aws/smithy-go/middleware"
10)
11
12type validateOpBatchGetChannel struct {
13}
14
15func (*validateOpBatchGetChannel) ID() string {
16	return "OperationInputValidation"
17}
18
19func (m *validateOpBatchGetChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
20	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
21) {
22	input, ok := in.Parameters.(*BatchGetChannelInput)
23	if !ok {
24		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
25	}
26	if err := validateOpBatchGetChannelInput(input); err != nil {
27		return out, metadata, err
28	}
29	return next.HandleInitialize(ctx, in)
30}
31
32type validateOpBatchGetStreamKey struct {
33}
34
35func (*validateOpBatchGetStreamKey) ID() string {
36	return "OperationInputValidation"
37}
38
39func (m *validateOpBatchGetStreamKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
40	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
41) {
42	input, ok := in.Parameters.(*BatchGetStreamKeyInput)
43	if !ok {
44		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
45	}
46	if err := validateOpBatchGetStreamKeyInput(input); err != nil {
47		return out, metadata, err
48	}
49	return next.HandleInitialize(ctx, in)
50}
51
52type validateOpCreateStreamKey struct {
53}
54
55func (*validateOpCreateStreamKey) ID() string {
56	return "OperationInputValidation"
57}
58
59func (m *validateOpCreateStreamKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
60	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
61) {
62	input, ok := in.Parameters.(*CreateStreamKeyInput)
63	if !ok {
64		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
65	}
66	if err := validateOpCreateStreamKeyInput(input); err != nil {
67		return out, metadata, err
68	}
69	return next.HandleInitialize(ctx, in)
70}
71
72type validateOpDeleteChannel struct {
73}
74
75func (*validateOpDeleteChannel) ID() string {
76	return "OperationInputValidation"
77}
78
79func (m *validateOpDeleteChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
80	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
81) {
82	input, ok := in.Parameters.(*DeleteChannelInput)
83	if !ok {
84		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
85	}
86	if err := validateOpDeleteChannelInput(input); err != nil {
87		return out, metadata, err
88	}
89	return next.HandleInitialize(ctx, in)
90}
91
92type validateOpDeletePlaybackKeyPair struct {
93}
94
95func (*validateOpDeletePlaybackKeyPair) ID() string {
96	return "OperationInputValidation"
97}
98
99func (m *validateOpDeletePlaybackKeyPair) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
100	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
101) {
102	input, ok := in.Parameters.(*DeletePlaybackKeyPairInput)
103	if !ok {
104		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
105	}
106	if err := validateOpDeletePlaybackKeyPairInput(input); err != nil {
107		return out, metadata, err
108	}
109	return next.HandleInitialize(ctx, in)
110}
111
112type validateOpDeleteStreamKey struct {
113}
114
115func (*validateOpDeleteStreamKey) ID() string {
116	return "OperationInputValidation"
117}
118
119func (m *validateOpDeleteStreamKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
120	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
121) {
122	input, ok := in.Parameters.(*DeleteStreamKeyInput)
123	if !ok {
124		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
125	}
126	if err := validateOpDeleteStreamKeyInput(input); err != nil {
127		return out, metadata, err
128	}
129	return next.HandleInitialize(ctx, in)
130}
131
132type validateOpGetChannel struct {
133}
134
135func (*validateOpGetChannel) ID() string {
136	return "OperationInputValidation"
137}
138
139func (m *validateOpGetChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
140	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
141) {
142	input, ok := in.Parameters.(*GetChannelInput)
143	if !ok {
144		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
145	}
146	if err := validateOpGetChannelInput(input); err != nil {
147		return out, metadata, err
148	}
149	return next.HandleInitialize(ctx, in)
150}
151
152type validateOpGetPlaybackKeyPair struct {
153}
154
155func (*validateOpGetPlaybackKeyPair) ID() string {
156	return "OperationInputValidation"
157}
158
159func (m *validateOpGetPlaybackKeyPair) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
160	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
161) {
162	input, ok := in.Parameters.(*GetPlaybackKeyPairInput)
163	if !ok {
164		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
165	}
166	if err := validateOpGetPlaybackKeyPairInput(input); err != nil {
167		return out, metadata, err
168	}
169	return next.HandleInitialize(ctx, in)
170}
171
172type validateOpGetStream struct {
173}
174
175func (*validateOpGetStream) ID() string {
176	return "OperationInputValidation"
177}
178
179func (m *validateOpGetStream) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
180	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
181) {
182	input, ok := in.Parameters.(*GetStreamInput)
183	if !ok {
184		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
185	}
186	if err := validateOpGetStreamInput(input); err != nil {
187		return out, metadata, err
188	}
189	return next.HandleInitialize(ctx, in)
190}
191
192type validateOpGetStreamKey struct {
193}
194
195func (*validateOpGetStreamKey) ID() string {
196	return "OperationInputValidation"
197}
198
199func (m *validateOpGetStreamKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
200	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
201) {
202	input, ok := in.Parameters.(*GetStreamKeyInput)
203	if !ok {
204		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
205	}
206	if err := validateOpGetStreamKeyInput(input); err != nil {
207		return out, metadata, err
208	}
209	return next.HandleInitialize(ctx, in)
210}
211
212type validateOpImportPlaybackKeyPair struct {
213}
214
215func (*validateOpImportPlaybackKeyPair) ID() string {
216	return "OperationInputValidation"
217}
218
219func (m *validateOpImportPlaybackKeyPair) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
220	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
221) {
222	input, ok := in.Parameters.(*ImportPlaybackKeyPairInput)
223	if !ok {
224		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
225	}
226	if err := validateOpImportPlaybackKeyPairInput(input); err != nil {
227		return out, metadata, err
228	}
229	return next.HandleInitialize(ctx, in)
230}
231
232type validateOpListStreamKeys struct {
233}
234
235func (*validateOpListStreamKeys) ID() string {
236	return "OperationInputValidation"
237}
238
239func (m *validateOpListStreamKeys) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
240	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
241) {
242	input, ok := in.Parameters.(*ListStreamKeysInput)
243	if !ok {
244		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
245	}
246	if err := validateOpListStreamKeysInput(input); err != nil {
247		return out, metadata, err
248	}
249	return next.HandleInitialize(ctx, in)
250}
251
252type validateOpListTagsForResource struct {
253}
254
255func (*validateOpListTagsForResource) ID() string {
256	return "OperationInputValidation"
257}
258
259func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
260	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
261) {
262	input, ok := in.Parameters.(*ListTagsForResourceInput)
263	if !ok {
264		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
265	}
266	if err := validateOpListTagsForResourceInput(input); err != nil {
267		return out, metadata, err
268	}
269	return next.HandleInitialize(ctx, in)
270}
271
272type validateOpPutMetadata struct {
273}
274
275func (*validateOpPutMetadata) ID() string {
276	return "OperationInputValidation"
277}
278
279func (m *validateOpPutMetadata) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
280	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
281) {
282	input, ok := in.Parameters.(*PutMetadataInput)
283	if !ok {
284		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
285	}
286	if err := validateOpPutMetadataInput(input); err != nil {
287		return out, metadata, err
288	}
289	return next.HandleInitialize(ctx, in)
290}
291
292type validateOpStopStream struct {
293}
294
295func (*validateOpStopStream) ID() string {
296	return "OperationInputValidation"
297}
298
299func (m *validateOpStopStream) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
300	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
301) {
302	input, ok := in.Parameters.(*StopStreamInput)
303	if !ok {
304		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
305	}
306	if err := validateOpStopStreamInput(input); err != nil {
307		return out, metadata, err
308	}
309	return next.HandleInitialize(ctx, in)
310}
311
312type validateOpTagResource struct {
313}
314
315func (*validateOpTagResource) ID() string {
316	return "OperationInputValidation"
317}
318
319func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
320	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
321) {
322	input, ok := in.Parameters.(*TagResourceInput)
323	if !ok {
324		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
325	}
326	if err := validateOpTagResourceInput(input); err != nil {
327		return out, metadata, err
328	}
329	return next.HandleInitialize(ctx, in)
330}
331
332type validateOpUntagResource struct {
333}
334
335func (*validateOpUntagResource) ID() string {
336	return "OperationInputValidation"
337}
338
339func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
340	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
341) {
342	input, ok := in.Parameters.(*UntagResourceInput)
343	if !ok {
344		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
345	}
346	if err := validateOpUntagResourceInput(input); err != nil {
347		return out, metadata, err
348	}
349	return next.HandleInitialize(ctx, in)
350}
351
352type validateOpUpdateChannel struct {
353}
354
355func (*validateOpUpdateChannel) ID() string {
356	return "OperationInputValidation"
357}
358
359func (m *validateOpUpdateChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
360	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
361) {
362	input, ok := in.Parameters.(*UpdateChannelInput)
363	if !ok {
364		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
365	}
366	if err := validateOpUpdateChannelInput(input); err != nil {
367		return out, metadata, err
368	}
369	return next.HandleInitialize(ctx, in)
370}
371
372func addOpBatchGetChannelValidationMiddleware(stack *middleware.Stack) error {
373	return stack.Initialize.Add(&validateOpBatchGetChannel{}, middleware.After)
374}
375
376func addOpBatchGetStreamKeyValidationMiddleware(stack *middleware.Stack) error {
377	return stack.Initialize.Add(&validateOpBatchGetStreamKey{}, middleware.After)
378}
379
380func addOpCreateStreamKeyValidationMiddleware(stack *middleware.Stack) error {
381	return stack.Initialize.Add(&validateOpCreateStreamKey{}, middleware.After)
382}
383
384func addOpDeleteChannelValidationMiddleware(stack *middleware.Stack) error {
385	return stack.Initialize.Add(&validateOpDeleteChannel{}, middleware.After)
386}
387
388func addOpDeletePlaybackKeyPairValidationMiddleware(stack *middleware.Stack) error {
389	return stack.Initialize.Add(&validateOpDeletePlaybackKeyPair{}, middleware.After)
390}
391
392func addOpDeleteStreamKeyValidationMiddleware(stack *middleware.Stack) error {
393	return stack.Initialize.Add(&validateOpDeleteStreamKey{}, middleware.After)
394}
395
396func addOpGetChannelValidationMiddleware(stack *middleware.Stack) error {
397	return stack.Initialize.Add(&validateOpGetChannel{}, middleware.After)
398}
399
400func addOpGetPlaybackKeyPairValidationMiddleware(stack *middleware.Stack) error {
401	return stack.Initialize.Add(&validateOpGetPlaybackKeyPair{}, middleware.After)
402}
403
404func addOpGetStreamValidationMiddleware(stack *middleware.Stack) error {
405	return stack.Initialize.Add(&validateOpGetStream{}, middleware.After)
406}
407
408func addOpGetStreamKeyValidationMiddleware(stack *middleware.Stack) error {
409	return stack.Initialize.Add(&validateOpGetStreamKey{}, middleware.After)
410}
411
412func addOpImportPlaybackKeyPairValidationMiddleware(stack *middleware.Stack) error {
413	return stack.Initialize.Add(&validateOpImportPlaybackKeyPair{}, middleware.After)
414}
415
416func addOpListStreamKeysValidationMiddleware(stack *middleware.Stack) error {
417	return stack.Initialize.Add(&validateOpListStreamKeys{}, middleware.After)
418}
419
420func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
421	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
422}
423
424func addOpPutMetadataValidationMiddleware(stack *middleware.Stack) error {
425	return stack.Initialize.Add(&validateOpPutMetadata{}, middleware.After)
426}
427
428func addOpStopStreamValidationMiddleware(stack *middleware.Stack) error {
429	return stack.Initialize.Add(&validateOpStopStream{}, middleware.After)
430}
431
432func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
433	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
434}
435
436func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
437	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
438}
439
440func addOpUpdateChannelValidationMiddleware(stack *middleware.Stack) error {
441	return stack.Initialize.Add(&validateOpUpdateChannel{}, middleware.After)
442}
443
444func validateOpBatchGetChannelInput(v *BatchGetChannelInput) error {
445	if v == nil {
446		return nil
447	}
448	invalidParams := smithy.InvalidParamsError{Context: "BatchGetChannelInput"}
449	if v.Arns == nil {
450		invalidParams.Add(smithy.NewErrParamRequired("Arns"))
451	}
452	if invalidParams.Len() > 0 {
453		return invalidParams
454	} else {
455		return nil
456	}
457}
458
459func validateOpBatchGetStreamKeyInput(v *BatchGetStreamKeyInput) error {
460	if v == nil {
461		return nil
462	}
463	invalidParams := smithy.InvalidParamsError{Context: "BatchGetStreamKeyInput"}
464	if v.Arns == nil {
465		invalidParams.Add(smithy.NewErrParamRequired("Arns"))
466	}
467	if invalidParams.Len() > 0 {
468		return invalidParams
469	} else {
470		return nil
471	}
472}
473
474func validateOpCreateStreamKeyInput(v *CreateStreamKeyInput) error {
475	if v == nil {
476		return nil
477	}
478	invalidParams := smithy.InvalidParamsError{Context: "CreateStreamKeyInput"}
479	if v.ChannelArn == nil {
480		invalidParams.Add(smithy.NewErrParamRequired("ChannelArn"))
481	}
482	if invalidParams.Len() > 0 {
483		return invalidParams
484	} else {
485		return nil
486	}
487}
488
489func validateOpDeleteChannelInput(v *DeleteChannelInput) error {
490	if v == nil {
491		return nil
492	}
493	invalidParams := smithy.InvalidParamsError{Context: "DeleteChannelInput"}
494	if v.Arn == nil {
495		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
496	}
497	if invalidParams.Len() > 0 {
498		return invalidParams
499	} else {
500		return nil
501	}
502}
503
504func validateOpDeletePlaybackKeyPairInput(v *DeletePlaybackKeyPairInput) error {
505	if v == nil {
506		return nil
507	}
508	invalidParams := smithy.InvalidParamsError{Context: "DeletePlaybackKeyPairInput"}
509	if v.Arn == nil {
510		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
511	}
512	if invalidParams.Len() > 0 {
513		return invalidParams
514	} else {
515		return nil
516	}
517}
518
519func validateOpDeleteStreamKeyInput(v *DeleteStreamKeyInput) error {
520	if v == nil {
521		return nil
522	}
523	invalidParams := smithy.InvalidParamsError{Context: "DeleteStreamKeyInput"}
524	if v.Arn == nil {
525		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
526	}
527	if invalidParams.Len() > 0 {
528		return invalidParams
529	} else {
530		return nil
531	}
532}
533
534func validateOpGetChannelInput(v *GetChannelInput) error {
535	if v == nil {
536		return nil
537	}
538	invalidParams := smithy.InvalidParamsError{Context: "GetChannelInput"}
539	if v.Arn == nil {
540		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
541	}
542	if invalidParams.Len() > 0 {
543		return invalidParams
544	} else {
545		return nil
546	}
547}
548
549func validateOpGetPlaybackKeyPairInput(v *GetPlaybackKeyPairInput) error {
550	if v == nil {
551		return nil
552	}
553	invalidParams := smithy.InvalidParamsError{Context: "GetPlaybackKeyPairInput"}
554	if v.Arn == nil {
555		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
556	}
557	if invalidParams.Len() > 0 {
558		return invalidParams
559	} else {
560		return nil
561	}
562}
563
564func validateOpGetStreamInput(v *GetStreamInput) error {
565	if v == nil {
566		return nil
567	}
568	invalidParams := smithy.InvalidParamsError{Context: "GetStreamInput"}
569	if v.ChannelArn == nil {
570		invalidParams.Add(smithy.NewErrParamRequired("ChannelArn"))
571	}
572	if invalidParams.Len() > 0 {
573		return invalidParams
574	} else {
575		return nil
576	}
577}
578
579func validateOpGetStreamKeyInput(v *GetStreamKeyInput) error {
580	if v == nil {
581		return nil
582	}
583	invalidParams := smithy.InvalidParamsError{Context: "GetStreamKeyInput"}
584	if v.Arn == nil {
585		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
586	}
587	if invalidParams.Len() > 0 {
588		return invalidParams
589	} else {
590		return nil
591	}
592}
593
594func validateOpImportPlaybackKeyPairInput(v *ImportPlaybackKeyPairInput) error {
595	if v == nil {
596		return nil
597	}
598	invalidParams := smithy.InvalidParamsError{Context: "ImportPlaybackKeyPairInput"}
599	if v.PublicKeyMaterial == nil {
600		invalidParams.Add(smithy.NewErrParamRequired("PublicKeyMaterial"))
601	}
602	if invalidParams.Len() > 0 {
603		return invalidParams
604	} else {
605		return nil
606	}
607}
608
609func validateOpListStreamKeysInput(v *ListStreamKeysInput) error {
610	if v == nil {
611		return nil
612	}
613	invalidParams := smithy.InvalidParamsError{Context: "ListStreamKeysInput"}
614	if v.ChannelArn == nil {
615		invalidParams.Add(smithy.NewErrParamRequired("ChannelArn"))
616	}
617	if invalidParams.Len() > 0 {
618		return invalidParams
619	} else {
620		return nil
621	}
622}
623
624func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
625	if v == nil {
626		return nil
627	}
628	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
629	if v.ResourceArn == nil {
630		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
631	}
632	if invalidParams.Len() > 0 {
633		return invalidParams
634	} else {
635		return nil
636	}
637}
638
639func validateOpPutMetadataInput(v *PutMetadataInput) error {
640	if v == nil {
641		return nil
642	}
643	invalidParams := smithy.InvalidParamsError{Context: "PutMetadataInput"}
644	if v.ChannelArn == nil {
645		invalidParams.Add(smithy.NewErrParamRequired("ChannelArn"))
646	}
647	if v.Metadata == nil {
648		invalidParams.Add(smithy.NewErrParamRequired("Metadata"))
649	}
650	if invalidParams.Len() > 0 {
651		return invalidParams
652	} else {
653		return nil
654	}
655}
656
657func validateOpStopStreamInput(v *StopStreamInput) error {
658	if v == nil {
659		return nil
660	}
661	invalidParams := smithy.InvalidParamsError{Context: "StopStreamInput"}
662	if v.ChannelArn == nil {
663		invalidParams.Add(smithy.NewErrParamRequired("ChannelArn"))
664	}
665	if invalidParams.Len() > 0 {
666		return invalidParams
667	} else {
668		return nil
669	}
670}
671
672func validateOpTagResourceInput(v *TagResourceInput) error {
673	if v == nil {
674		return nil
675	}
676	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
677	if v.ResourceArn == nil {
678		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
679	}
680	if v.Tags == nil {
681		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
682	}
683	if invalidParams.Len() > 0 {
684		return invalidParams
685	} else {
686		return nil
687	}
688}
689
690func validateOpUntagResourceInput(v *UntagResourceInput) error {
691	if v == nil {
692		return nil
693	}
694	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
695	if v.ResourceArn == nil {
696		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
697	}
698	if v.TagKeys == nil {
699		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
700	}
701	if invalidParams.Len() > 0 {
702		return invalidParams
703	} else {
704		return nil
705	}
706}
707
708func validateOpUpdateChannelInput(v *UpdateChannelInput) error {
709	if v == nil {
710		return nil
711	}
712	invalidParams := smithy.InvalidParamsError{Context: "UpdateChannelInput"}
713	if v.Arn == nil {
714		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
715	}
716	if invalidParams.Len() > 0 {
717		return invalidParams
718	} else {
719		return nil
720	}
721}
722