1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package greengrass
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/greengrass/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpAssociateRoleToGroup struct {
14}
15
16func (*validateOpAssociateRoleToGroup) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpAssociateRoleToGroup) 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.(*AssociateRoleToGroupInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpAssociateRoleToGroupInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpAssociateServiceRoleToAccount struct {
34}
35
36func (*validateOpAssociateServiceRoleToAccount) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpAssociateServiceRoleToAccount) 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.(*AssociateServiceRoleToAccountInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpAssociateServiceRoleToAccountInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpCreateConnectorDefinition struct {
54}
55
56func (*validateOpCreateConnectorDefinition) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpCreateConnectorDefinition) 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.(*CreateConnectorDefinitionInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpCreateConnectorDefinitionInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpCreateConnectorDefinitionVersion struct {
74}
75
76func (*validateOpCreateConnectorDefinitionVersion) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpCreateConnectorDefinitionVersion) 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.(*CreateConnectorDefinitionVersionInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpCreateConnectorDefinitionVersionInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpCreateCoreDefinition struct {
94}
95
96func (*validateOpCreateCoreDefinition) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpCreateCoreDefinition) 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.(*CreateCoreDefinitionInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpCreateCoreDefinitionInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpCreateCoreDefinitionVersion struct {
114}
115
116func (*validateOpCreateCoreDefinitionVersion) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpCreateCoreDefinitionVersion) 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.(*CreateCoreDefinitionVersionInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpCreateCoreDefinitionVersionInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpCreateDeployment struct {
134}
135
136func (*validateOpCreateDeployment) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpCreateDeployment) 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.(*CreateDeploymentInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpCreateDeploymentInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpCreateDeviceDefinition struct {
154}
155
156func (*validateOpCreateDeviceDefinition) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpCreateDeviceDefinition) 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.(*CreateDeviceDefinitionInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpCreateDeviceDefinitionInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpCreateDeviceDefinitionVersion struct {
174}
175
176func (*validateOpCreateDeviceDefinitionVersion) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpCreateDeviceDefinitionVersion) 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.(*CreateDeviceDefinitionVersionInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpCreateDeviceDefinitionVersionInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpCreateFunctionDefinition struct {
194}
195
196func (*validateOpCreateFunctionDefinition) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpCreateFunctionDefinition) 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.(*CreateFunctionDefinitionInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpCreateFunctionDefinitionInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpCreateFunctionDefinitionVersion struct {
214}
215
216func (*validateOpCreateFunctionDefinitionVersion) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpCreateFunctionDefinitionVersion) 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.(*CreateFunctionDefinitionVersionInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpCreateFunctionDefinitionVersionInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpCreateGroupCertificateAuthority struct {
234}
235
236func (*validateOpCreateGroupCertificateAuthority) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpCreateGroupCertificateAuthority) 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.(*CreateGroupCertificateAuthorityInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpCreateGroupCertificateAuthorityInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpCreateGroup struct {
254}
255
256func (*validateOpCreateGroup) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpCreateGroup) 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.(*CreateGroupInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpCreateGroupInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpCreateGroupVersion struct {
274}
275
276func (*validateOpCreateGroupVersion) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpCreateGroupVersion) 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.(*CreateGroupVersionInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpCreateGroupVersionInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpCreateLoggerDefinition struct {
294}
295
296func (*validateOpCreateLoggerDefinition) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpCreateLoggerDefinition) 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.(*CreateLoggerDefinitionInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpCreateLoggerDefinitionInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpCreateLoggerDefinitionVersion struct {
314}
315
316func (*validateOpCreateLoggerDefinitionVersion) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpCreateLoggerDefinitionVersion) 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.(*CreateLoggerDefinitionVersionInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpCreateLoggerDefinitionVersionInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpCreateResourceDefinition struct {
334}
335
336func (*validateOpCreateResourceDefinition) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpCreateResourceDefinition) 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.(*CreateResourceDefinitionInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpCreateResourceDefinitionInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpCreateResourceDefinitionVersion struct {
354}
355
356func (*validateOpCreateResourceDefinitionVersion) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpCreateResourceDefinitionVersion) 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.(*CreateResourceDefinitionVersionInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpCreateResourceDefinitionVersionInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpCreateSoftwareUpdateJob struct {
374}
375
376func (*validateOpCreateSoftwareUpdateJob) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpCreateSoftwareUpdateJob) 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.(*CreateSoftwareUpdateJobInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpCreateSoftwareUpdateJobInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpCreateSubscriptionDefinition struct {
394}
395
396func (*validateOpCreateSubscriptionDefinition) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpCreateSubscriptionDefinition) 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.(*CreateSubscriptionDefinitionInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpCreateSubscriptionDefinitionInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpCreateSubscriptionDefinitionVersion struct {
414}
415
416func (*validateOpCreateSubscriptionDefinitionVersion) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpCreateSubscriptionDefinitionVersion) 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.(*CreateSubscriptionDefinitionVersionInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpCreateSubscriptionDefinitionVersionInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpDeleteConnectorDefinition struct {
434}
435
436func (*validateOpDeleteConnectorDefinition) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpDeleteConnectorDefinition) 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.(*DeleteConnectorDefinitionInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpDeleteConnectorDefinitionInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpDeleteCoreDefinition struct {
454}
455
456func (*validateOpDeleteCoreDefinition) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpDeleteCoreDefinition) 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.(*DeleteCoreDefinitionInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpDeleteCoreDefinitionInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpDeleteDeviceDefinition struct {
474}
475
476func (*validateOpDeleteDeviceDefinition) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpDeleteDeviceDefinition) 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.(*DeleteDeviceDefinitionInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpDeleteDeviceDefinitionInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpDeleteFunctionDefinition struct {
494}
495
496func (*validateOpDeleteFunctionDefinition) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpDeleteFunctionDefinition) 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.(*DeleteFunctionDefinitionInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpDeleteFunctionDefinitionInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpDeleteGroup struct {
514}
515
516func (*validateOpDeleteGroup) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpDeleteGroup) 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.(*DeleteGroupInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpDeleteGroupInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpDeleteLoggerDefinition struct {
534}
535
536func (*validateOpDeleteLoggerDefinition) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpDeleteLoggerDefinition) 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.(*DeleteLoggerDefinitionInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpDeleteLoggerDefinitionInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpDeleteResourceDefinition struct {
554}
555
556func (*validateOpDeleteResourceDefinition) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpDeleteResourceDefinition) 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.(*DeleteResourceDefinitionInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpDeleteResourceDefinitionInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpDeleteSubscriptionDefinition struct {
574}
575
576func (*validateOpDeleteSubscriptionDefinition) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpDeleteSubscriptionDefinition) 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.(*DeleteSubscriptionDefinitionInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpDeleteSubscriptionDefinitionInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpDisassociateRoleFromGroup struct {
594}
595
596func (*validateOpDisassociateRoleFromGroup) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpDisassociateRoleFromGroup) 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.(*DisassociateRoleFromGroupInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpDisassociateRoleFromGroupInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpGetAssociatedRole struct {
614}
615
616func (*validateOpGetAssociatedRole) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpGetAssociatedRole) 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.(*GetAssociatedRoleInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpGetAssociatedRoleInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpGetBulkDeploymentStatus struct {
634}
635
636func (*validateOpGetBulkDeploymentStatus) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpGetBulkDeploymentStatus) 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.(*GetBulkDeploymentStatusInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpGetBulkDeploymentStatusInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653type validateOpGetConnectivityInfo struct {
654}
655
656func (*validateOpGetConnectivityInfo) ID() string {
657	return "OperationInputValidation"
658}
659
660func (m *validateOpGetConnectivityInfo) 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.(*GetConnectivityInfoInput)
664	if !ok {
665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666	}
667	if err := validateOpGetConnectivityInfoInput(input); err != nil {
668		return out, metadata, err
669	}
670	return next.HandleInitialize(ctx, in)
671}
672
673type validateOpGetConnectorDefinition struct {
674}
675
676func (*validateOpGetConnectorDefinition) ID() string {
677	return "OperationInputValidation"
678}
679
680func (m *validateOpGetConnectorDefinition) 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.(*GetConnectorDefinitionInput)
684	if !ok {
685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
686	}
687	if err := validateOpGetConnectorDefinitionInput(input); err != nil {
688		return out, metadata, err
689	}
690	return next.HandleInitialize(ctx, in)
691}
692
693type validateOpGetConnectorDefinitionVersion struct {
694}
695
696func (*validateOpGetConnectorDefinitionVersion) ID() string {
697	return "OperationInputValidation"
698}
699
700func (m *validateOpGetConnectorDefinitionVersion) 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.(*GetConnectorDefinitionVersionInput)
704	if !ok {
705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
706	}
707	if err := validateOpGetConnectorDefinitionVersionInput(input); err != nil {
708		return out, metadata, err
709	}
710	return next.HandleInitialize(ctx, in)
711}
712
713type validateOpGetCoreDefinition struct {
714}
715
716func (*validateOpGetCoreDefinition) ID() string {
717	return "OperationInputValidation"
718}
719
720func (m *validateOpGetCoreDefinition) 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.(*GetCoreDefinitionInput)
724	if !ok {
725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
726	}
727	if err := validateOpGetCoreDefinitionInput(input); err != nil {
728		return out, metadata, err
729	}
730	return next.HandleInitialize(ctx, in)
731}
732
733type validateOpGetCoreDefinitionVersion struct {
734}
735
736func (*validateOpGetCoreDefinitionVersion) ID() string {
737	return "OperationInputValidation"
738}
739
740func (m *validateOpGetCoreDefinitionVersion) 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.(*GetCoreDefinitionVersionInput)
744	if !ok {
745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
746	}
747	if err := validateOpGetCoreDefinitionVersionInput(input); err != nil {
748		return out, metadata, err
749	}
750	return next.HandleInitialize(ctx, in)
751}
752
753type validateOpGetDeploymentStatus struct {
754}
755
756func (*validateOpGetDeploymentStatus) ID() string {
757	return "OperationInputValidation"
758}
759
760func (m *validateOpGetDeploymentStatus) 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.(*GetDeploymentStatusInput)
764	if !ok {
765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
766	}
767	if err := validateOpGetDeploymentStatusInput(input); err != nil {
768		return out, metadata, err
769	}
770	return next.HandleInitialize(ctx, in)
771}
772
773type validateOpGetDeviceDefinition struct {
774}
775
776func (*validateOpGetDeviceDefinition) ID() string {
777	return "OperationInputValidation"
778}
779
780func (m *validateOpGetDeviceDefinition) 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.(*GetDeviceDefinitionInput)
784	if !ok {
785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
786	}
787	if err := validateOpGetDeviceDefinitionInput(input); err != nil {
788		return out, metadata, err
789	}
790	return next.HandleInitialize(ctx, in)
791}
792
793type validateOpGetDeviceDefinitionVersion struct {
794}
795
796func (*validateOpGetDeviceDefinitionVersion) ID() string {
797	return "OperationInputValidation"
798}
799
800func (m *validateOpGetDeviceDefinitionVersion) 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.(*GetDeviceDefinitionVersionInput)
804	if !ok {
805		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
806	}
807	if err := validateOpGetDeviceDefinitionVersionInput(input); err != nil {
808		return out, metadata, err
809	}
810	return next.HandleInitialize(ctx, in)
811}
812
813type validateOpGetFunctionDefinition struct {
814}
815
816func (*validateOpGetFunctionDefinition) ID() string {
817	return "OperationInputValidation"
818}
819
820func (m *validateOpGetFunctionDefinition) 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.(*GetFunctionDefinitionInput)
824	if !ok {
825		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
826	}
827	if err := validateOpGetFunctionDefinitionInput(input); err != nil {
828		return out, metadata, err
829	}
830	return next.HandleInitialize(ctx, in)
831}
832
833type validateOpGetFunctionDefinitionVersion struct {
834}
835
836func (*validateOpGetFunctionDefinitionVersion) ID() string {
837	return "OperationInputValidation"
838}
839
840func (m *validateOpGetFunctionDefinitionVersion) 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.(*GetFunctionDefinitionVersionInput)
844	if !ok {
845		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
846	}
847	if err := validateOpGetFunctionDefinitionVersionInput(input); err != nil {
848		return out, metadata, err
849	}
850	return next.HandleInitialize(ctx, in)
851}
852
853type validateOpGetGroupCertificateAuthority struct {
854}
855
856func (*validateOpGetGroupCertificateAuthority) ID() string {
857	return "OperationInputValidation"
858}
859
860func (m *validateOpGetGroupCertificateAuthority) 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.(*GetGroupCertificateAuthorityInput)
864	if !ok {
865		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
866	}
867	if err := validateOpGetGroupCertificateAuthorityInput(input); err != nil {
868		return out, metadata, err
869	}
870	return next.HandleInitialize(ctx, in)
871}
872
873type validateOpGetGroupCertificateConfiguration struct {
874}
875
876func (*validateOpGetGroupCertificateConfiguration) ID() string {
877	return "OperationInputValidation"
878}
879
880func (m *validateOpGetGroupCertificateConfiguration) 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.(*GetGroupCertificateConfigurationInput)
884	if !ok {
885		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
886	}
887	if err := validateOpGetGroupCertificateConfigurationInput(input); err != nil {
888		return out, metadata, err
889	}
890	return next.HandleInitialize(ctx, in)
891}
892
893type validateOpGetGroup struct {
894}
895
896func (*validateOpGetGroup) ID() string {
897	return "OperationInputValidation"
898}
899
900func (m *validateOpGetGroup) 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.(*GetGroupInput)
904	if !ok {
905		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
906	}
907	if err := validateOpGetGroupInput(input); err != nil {
908		return out, metadata, err
909	}
910	return next.HandleInitialize(ctx, in)
911}
912
913type validateOpGetGroupVersion struct {
914}
915
916func (*validateOpGetGroupVersion) ID() string {
917	return "OperationInputValidation"
918}
919
920func (m *validateOpGetGroupVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
921	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
922) {
923	input, ok := in.Parameters.(*GetGroupVersionInput)
924	if !ok {
925		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
926	}
927	if err := validateOpGetGroupVersionInput(input); err != nil {
928		return out, metadata, err
929	}
930	return next.HandleInitialize(ctx, in)
931}
932
933type validateOpGetLoggerDefinition struct {
934}
935
936func (*validateOpGetLoggerDefinition) ID() string {
937	return "OperationInputValidation"
938}
939
940func (m *validateOpGetLoggerDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
941	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
942) {
943	input, ok := in.Parameters.(*GetLoggerDefinitionInput)
944	if !ok {
945		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
946	}
947	if err := validateOpGetLoggerDefinitionInput(input); err != nil {
948		return out, metadata, err
949	}
950	return next.HandleInitialize(ctx, in)
951}
952
953type validateOpGetLoggerDefinitionVersion struct {
954}
955
956func (*validateOpGetLoggerDefinitionVersion) ID() string {
957	return "OperationInputValidation"
958}
959
960func (m *validateOpGetLoggerDefinitionVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
961	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
962) {
963	input, ok := in.Parameters.(*GetLoggerDefinitionVersionInput)
964	if !ok {
965		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
966	}
967	if err := validateOpGetLoggerDefinitionVersionInput(input); err != nil {
968		return out, metadata, err
969	}
970	return next.HandleInitialize(ctx, in)
971}
972
973type validateOpGetResourceDefinition struct {
974}
975
976func (*validateOpGetResourceDefinition) ID() string {
977	return "OperationInputValidation"
978}
979
980func (m *validateOpGetResourceDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
981	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
982) {
983	input, ok := in.Parameters.(*GetResourceDefinitionInput)
984	if !ok {
985		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
986	}
987	if err := validateOpGetResourceDefinitionInput(input); err != nil {
988		return out, metadata, err
989	}
990	return next.HandleInitialize(ctx, in)
991}
992
993type validateOpGetResourceDefinitionVersion struct {
994}
995
996func (*validateOpGetResourceDefinitionVersion) ID() string {
997	return "OperationInputValidation"
998}
999
1000func (m *validateOpGetResourceDefinitionVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1001	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1002) {
1003	input, ok := in.Parameters.(*GetResourceDefinitionVersionInput)
1004	if !ok {
1005		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1006	}
1007	if err := validateOpGetResourceDefinitionVersionInput(input); err != nil {
1008		return out, metadata, err
1009	}
1010	return next.HandleInitialize(ctx, in)
1011}
1012
1013type validateOpGetSubscriptionDefinition struct {
1014}
1015
1016func (*validateOpGetSubscriptionDefinition) ID() string {
1017	return "OperationInputValidation"
1018}
1019
1020func (m *validateOpGetSubscriptionDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1021	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1022) {
1023	input, ok := in.Parameters.(*GetSubscriptionDefinitionInput)
1024	if !ok {
1025		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1026	}
1027	if err := validateOpGetSubscriptionDefinitionInput(input); err != nil {
1028		return out, metadata, err
1029	}
1030	return next.HandleInitialize(ctx, in)
1031}
1032
1033type validateOpGetSubscriptionDefinitionVersion struct {
1034}
1035
1036func (*validateOpGetSubscriptionDefinitionVersion) ID() string {
1037	return "OperationInputValidation"
1038}
1039
1040func (m *validateOpGetSubscriptionDefinitionVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1041	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1042) {
1043	input, ok := in.Parameters.(*GetSubscriptionDefinitionVersionInput)
1044	if !ok {
1045		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1046	}
1047	if err := validateOpGetSubscriptionDefinitionVersionInput(input); err != nil {
1048		return out, metadata, err
1049	}
1050	return next.HandleInitialize(ctx, in)
1051}
1052
1053type validateOpGetThingRuntimeConfiguration struct {
1054}
1055
1056func (*validateOpGetThingRuntimeConfiguration) ID() string {
1057	return "OperationInputValidation"
1058}
1059
1060func (m *validateOpGetThingRuntimeConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1061	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1062) {
1063	input, ok := in.Parameters.(*GetThingRuntimeConfigurationInput)
1064	if !ok {
1065		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1066	}
1067	if err := validateOpGetThingRuntimeConfigurationInput(input); err != nil {
1068		return out, metadata, err
1069	}
1070	return next.HandleInitialize(ctx, in)
1071}
1072
1073type validateOpListBulkDeploymentDetailedReports struct {
1074}
1075
1076func (*validateOpListBulkDeploymentDetailedReports) ID() string {
1077	return "OperationInputValidation"
1078}
1079
1080func (m *validateOpListBulkDeploymentDetailedReports) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1081	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1082) {
1083	input, ok := in.Parameters.(*ListBulkDeploymentDetailedReportsInput)
1084	if !ok {
1085		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1086	}
1087	if err := validateOpListBulkDeploymentDetailedReportsInput(input); err != nil {
1088		return out, metadata, err
1089	}
1090	return next.HandleInitialize(ctx, in)
1091}
1092
1093type validateOpListConnectorDefinitionVersions struct {
1094}
1095
1096func (*validateOpListConnectorDefinitionVersions) ID() string {
1097	return "OperationInputValidation"
1098}
1099
1100func (m *validateOpListConnectorDefinitionVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1101	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1102) {
1103	input, ok := in.Parameters.(*ListConnectorDefinitionVersionsInput)
1104	if !ok {
1105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1106	}
1107	if err := validateOpListConnectorDefinitionVersionsInput(input); err != nil {
1108		return out, metadata, err
1109	}
1110	return next.HandleInitialize(ctx, in)
1111}
1112
1113type validateOpListCoreDefinitionVersions struct {
1114}
1115
1116func (*validateOpListCoreDefinitionVersions) ID() string {
1117	return "OperationInputValidation"
1118}
1119
1120func (m *validateOpListCoreDefinitionVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1121	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1122) {
1123	input, ok := in.Parameters.(*ListCoreDefinitionVersionsInput)
1124	if !ok {
1125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1126	}
1127	if err := validateOpListCoreDefinitionVersionsInput(input); err != nil {
1128		return out, metadata, err
1129	}
1130	return next.HandleInitialize(ctx, in)
1131}
1132
1133type validateOpListDeployments struct {
1134}
1135
1136func (*validateOpListDeployments) ID() string {
1137	return "OperationInputValidation"
1138}
1139
1140func (m *validateOpListDeployments) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1141	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1142) {
1143	input, ok := in.Parameters.(*ListDeploymentsInput)
1144	if !ok {
1145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1146	}
1147	if err := validateOpListDeploymentsInput(input); err != nil {
1148		return out, metadata, err
1149	}
1150	return next.HandleInitialize(ctx, in)
1151}
1152
1153type validateOpListDeviceDefinitionVersions struct {
1154}
1155
1156func (*validateOpListDeviceDefinitionVersions) ID() string {
1157	return "OperationInputValidation"
1158}
1159
1160func (m *validateOpListDeviceDefinitionVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1161	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1162) {
1163	input, ok := in.Parameters.(*ListDeviceDefinitionVersionsInput)
1164	if !ok {
1165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1166	}
1167	if err := validateOpListDeviceDefinitionVersionsInput(input); err != nil {
1168		return out, metadata, err
1169	}
1170	return next.HandleInitialize(ctx, in)
1171}
1172
1173type validateOpListFunctionDefinitionVersions struct {
1174}
1175
1176func (*validateOpListFunctionDefinitionVersions) ID() string {
1177	return "OperationInputValidation"
1178}
1179
1180func (m *validateOpListFunctionDefinitionVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1181	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1182) {
1183	input, ok := in.Parameters.(*ListFunctionDefinitionVersionsInput)
1184	if !ok {
1185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1186	}
1187	if err := validateOpListFunctionDefinitionVersionsInput(input); err != nil {
1188		return out, metadata, err
1189	}
1190	return next.HandleInitialize(ctx, in)
1191}
1192
1193type validateOpListGroupCertificateAuthorities struct {
1194}
1195
1196func (*validateOpListGroupCertificateAuthorities) ID() string {
1197	return "OperationInputValidation"
1198}
1199
1200func (m *validateOpListGroupCertificateAuthorities) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1201	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1202) {
1203	input, ok := in.Parameters.(*ListGroupCertificateAuthoritiesInput)
1204	if !ok {
1205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1206	}
1207	if err := validateOpListGroupCertificateAuthoritiesInput(input); err != nil {
1208		return out, metadata, err
1209	}
1210	return next.HandleInitialize(ctx, in)
1211}
1212
1213type validateOpListGroupVersions struct {
1214}
1215
1216func (*validateOpListGroupVersions) ID() string {
1217	return "OperationInputValidation"
1218}
1219
1220func (m *validateOpListGroupVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1221	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1222) {
1223	input, ok := in.Parameters.(*ListGroupVersionsInput)
1224	if !ok {
1225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1226	}
1227	if err := validateOpListGroupVersionsInput(input); err != nil {
1228		return out, metadata, err
1229	}
1230	return next.HandleInitialize(ctx, in)
1231}
1232
1233type validateOpListLoggerDefinitionVersions struct {
1234}
1235
1236func (*validateOpListLoggerDefinitionVersions) ID() string {
1237	return "OperationInputValidation"
1238}
1239
1240func (m *validateOpListLoggerDefinitionVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1241	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1242) {
1243	input, ok := in.Parameters.(*ListLoggerDefinitionVersionsInput)
1244	if !ok {
1245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1246	}
1247	if err := validateOpListLoggerDefinitionVersionsInput(input); err != nil {
1248		return out, metadata, err
1249	}
1250	return next.HandleInitialize(ctx, in)
1251}
1252
1253type validateOpListResourceDefinitionVersions struct {
1254}
1255
1256func (*validateOpListResourceDefinitionVersions) ID() string {
1257	return "OperationInputValidation"
1258}
1259
1260func (m *validateOpListResourceDefinitionVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1261	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1262) {
1263	input, ok := in.Parameters.(*ListResourceDefinitionVersionsInput)
1264	if !ok {
1265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1266	}
1267	if err := validateOpListResourceDefinitionVersionsInput(input); err != nil {
1268		return out, metadata, err
1269	}
1270	return next.HandleInitialize(ctx, in)
1271}
1272
1273type validateOpListSubscriptionDefinitionVersions struct {
1274}
1275
1276func (*validateOpListSubscriptionDefinitionVersions) ID() string {
1277	return "OperationInputValidation"
1278}
1279
1280func (m *validateOpListSubscriptionDefinitionVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1281	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1282) {
1283	input, ok := in.Parameters.(*ListSubscriptionDefinitionVersionsInput)
1284	if !ok {
1285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1286	}
1287	if err := validateOpListSubscriptionDefinitionVersionsInput(input); err != nil {
1288		return out, metadata, err
1289	}
1290	return next.HandleInitialize(ctx, in)
1291}
1292
1293type validateOpListTagsForResource struct {
1294}
1295
1296func (*validateOpListTagsForResource) ID() string {
1297	return "OperationInputValidation"
1298}
1299
1300func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1301	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1302) {
1303	input, ok := in.Parameters.(*ListTagsForResourceInput)
1304	if !ok {
1305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1306	}
1307	if err := validateOpListTagsForResourceInput(input); err != nil {
1308		return out, metadata, err
1309	}
1310	return next.HandleInitialize(ctx, in)
1311}
1312
1313type validateOpResetDeployments struct {
1314}
1315
1316func (*validateOpResetDeployments) ID() string {
1317	return "OperationInputValidation"
1318}
1319
1320func (m *validateOpResetDeployments) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1321	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1322) {
1323	input, ok := in.Parameters.(*ResetDeploymentsInput)
1324	if !ok {
1325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1326	}
1327	if err := validateOpResetDeploymentsInput(input); err != nil {
1328		return out, metadata, err
1329	}
1330	return next.HandleInitialize(ctx, in)
1331}
1332
1333type validateOpStartBulkDeployment struct {
1334}
1335
1336func (*validateOpStartBulkDeployment) ID() string {
1337	return "OperationInputValidation"
1338}
1339
1340func (m *validateOpStartBulkDeployment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1341	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1342) {
1343	input, ok := in.Parameters.(*StartBulkDeploymentInput)
1344	if !ok {
1345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1346	}
1347	if err := validateOpStartBulkDeploymentInput(input); err != nil {
1348		return out, metadata, err
1349	}
1350	return next.HandleInitialize(ctx, in)
1351}
1352
1353type validateOpStopBulkDeployment struct {
1354}
1355
1356func (*validateOpStopBulkDeployment) ID() string {
1357	return "OperationInputValidation"
1358}
1359
1360func (m *validateOpStopBulkDeployment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1361	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1362) {
1363	input, ok := in.Parameters.(*StopBulkDeploymentInput)
1364	if !ok {
1365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1366	}
1367	if err := validateOpStopBulkDeploymentInput(input); err != nil {
1368		return out, metadata, err
1369	}
1370	return next.HandleInitialize(ctx, in)
1371}
1372
1373type validateOpTagResource struct {
1374}
1375
1376func (*validateOpTagResource) ID() string {
1377	return "OperationInputValidation"
1378}
1379
1380func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1381	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1382) {
1383	input, ok := in.Parameters.(*TagResourceInput)
1384	if !ok {
1385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1386	}
1387	if err := validateOpTagResourceInput(input); err != nil {
1388		return out, metadata, err
1389	}
1390	return next.HandleInitialize(ctx, in)
1391}
1392
1393type validateOpUntagResource struct {
1394}
1395
1396func (*validateOpUntagResource) ID() string {
1397	return "OperationInputValidation"
1398}
1399
1400func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1401	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1402) {
1403	input, ok := in.Parameters.(*UntagResourceInput)
1404	if !ok {
1405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1406	}
1407	if err := validateOpUntagResourceInput(input); err != nil {
1408		return out, metadata, err
1409	}
1410	return next.HandleInitialize(ctx, in)
1411}
1412
1413type validateOpUpdateConnectivityInfo struct {
1414}
1415
1416func (*validateOpUpdateConnectivityInfo) ID() string {
1417	return "OperationInputValidation"
1418}
1419
1420func (m *validateOpUpdateConnectivityInfo) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1421	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1422) {
1423	input, ok := in.Parameters.(*UpdateConnectivityInfoInput)
1424	if !ok {
1425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1426	}
1427	if err := validateOpUpdateConnectivityInfoInput(input); err != nil {
1428		return out, metadata, err
1429	}
1430	return next.HandleInitialize(ctx, in)
1431}
1432
1433type validateOpUpdateConnectorDefinition struct {
1434}
1435
1436func (*validateOpUpdateConnectorDefinition) ID() string {
1437	return "OperationInputValidation"
1438}
1439
1440func (m *validateOpUpdateConnectorDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1441	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1442) {
1443	input, ok := in.Parameters.(*UpdateConnectorDefinitionInput)
1444	if !ok {
1445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1446	}
1447	if err := validateOpUpdateConnectorDefinitionInput(input); err != nil {
1448		return out, metadata, err
1449	}
1450	return next.HandleInitialize(ctx, in)
1451}
1452
1453type validateOpUpdateCoreDefinition struct {
1454}
1455
1456func (*validateOpUpdateCoreDefinition) ID() string {
1457	return "OperationInputValidation"
1458}
1459
1460func (m *validateOpUpdateCoreDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1461	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1462) {
1463	input, ok := in.Parameters.(*UpdateCoreDefinitionInput)
1464	if !ok {
1465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1466	}
1467	if err := validateOpUpdateCoreDefinitionInput(input); err != nil {
1468		return out, metadata, err
1469	}
1470	return next.HandleInitialize(ctx, in)
1471}
1472
1473type validateOpUpdateDeviceDefinition struct {
1474}
1475
1476func (*validateOpUpdateDeviceDefinition) ID() string {
1477	return "OperationInputValidation"
1478}
1479
1480func (m *validateOpUpdateDeviceDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1481	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1482) {
1483	input, ok := in.Parameters.(*UpdateDeviceDefinitionInput)
1484	if !ok {
1485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1486	}
1487	if err := validateOpUpdateDeviceDefinitionInput(input); err != nil {
1488		return out, metadata, err
1489	}
1490	return next.HandleInitialize(ctx, in)
1491}
1492
1493type validateOpUpdateFunctionDefinition struct {
1494}
1495
1496func (*validateOpUpdateFunctionDefinition) ID() string {
1497	return "OperationInputValidation"
1498}
1499
1500func (m *validateOpUpdateFunctionDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1501	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1502) {
1503	input, ok := in.Parameters.(*UpdateFunctionDefinitionInput)
1504	if !ok {
1505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1506	}
1507	if err := validateOpUpdateFunctionDefinitionInput(input); err != nil {
1508		return out, metadata, err
1509	}
1510	return next.HandleInitialize(ctx, in)
1511}
1512
1513type validateOpUpdateGroupCertificateConfiguration struct {
1514}
1515
1516func (*validateOpUpdateGroupCertificateConfiguration) ID() string {
1517	return "OperationInputValidation"
1518}
1519
1520func (m *validateOpUpdateGroupCertificateConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1521	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1522) {
1523	input, ok := in.Parameters.(*UpdateGroupCertificateConfigurationInput)
1524	if !ok {
1525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1526	}
1527	if err := validateOpUpdateGroupCertificateConfigurationInput(input); err != nil {
1528		return out, metadata, err
1529	}
1530	return next.HandleInitialize(ctx, in)
1531}
1532
1533type validateOpUpdateGroup struct {
1534}
1535
1536func (*validateOpUpdateGroup) ID() string {
1537	return "OperationInputValidation"
1538}
1539
1540func (m *validateOpUpdateGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1541	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1542) {
1543	input, ok := in.Parameters.(*UpdateGroupInput)
1544	if !ok {
1545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1546	}
1547	if err := validateOpUpdateGroupInput(input); err != nil {
1548		return out, metadata, err
1549	}
1550	return next.HandleInitialize(ctx, in)
1551}
1552
1553type validateOpUpdateLoggerDefinition struct {
1554}
1555
1556func (*validateOpUpdateLoggerDefinition) ID() string {
1557	return "OperationInputValidation"
1558}
1559
1560func (m *validateOpUpdateLoggerDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1561	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1562) {
1563	input, ok := in.Parameters.(*UpdateLoggerDefinitionInput)
1564	if !ok {
1565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1566	}
1567	if err := validateOpUpdateLoggerDefinitionInput(input); err != nil {
1568		return out, metadata, err
1569	}
1570	return next.HandleInitialize(ctx, in)
1571}
1572
1573type validateOpUpdateResourceDefinition struct {
1574}
1575
1576func (*validateOpUpdateResourceDefinition) ID() string {
1577	return "OperationInputValidation"
1578}
1579
1580func (m *validateOpUpdateResourceDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1581	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1582) {
1583	input, ok := in.Parameters.(*UpdateResourceDefinitionInput)
1584	if !ok {
1585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1586	}
1587	if err := validateOpUpdateResourceDefinitionInput(input); err != nil {
1588		return out, metadata, err
1589	}
1590	return next.HandleInitialize(ctx, in)
1591}
1592
1593type validateOpUpdateSubscriptionDefinition struct {
1594}
1595
1596func (*validateOpUpdateSubscriptionDefinition) ID() string {
1597	return "OperationInputValidation"
1598}
1599
1600func (m *validateOpUpdateSubscriptionDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1601	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1602) {
1603	input, ok := in.Parameters.(*UpdateSubscriptionDefinitionInput)
1604	if !ok {
1605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1606	}
1607	if err := validateOpUpdateSubscriptionDefinitionInput(input); err != nil {
1608		return out, metadata, err
1609	}
1610	return next.HandleInitialize(ctx, in)
1611}
1612
1613type validateOpUpdateThingRuntimeConfiguration struct {
1614}
1615
1616func (*validateOpUpdateThingRuntimeConfiguration) ID() string {
1617	return "OperationInputValidation"
1618}
1619
1620func (m *validateOpUpdateThingRuntimeConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1621	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1622) {
1623	input, ok := in.Parameters.(*UpdateThingRuntimeConfigurationInput)
1624	if !ok {
1625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1626	}
1627	if err := validateOpUpdateThingRuntimeConfigurationInput(input); err != nil {
1628		return out, metadata, err
1629	}
1630	return next.HandleInitialize(ctx, in)
1631}
1632
1633func addOpAssociateRoleToGroupValidationMiddleware(stack *middleware.Stack) error {
1634	return stack.Initialize.Add(&validateOpAssociateRoleToGroup{}, middleware.After)
1635}
1636
1637func addOpAssociateServiceRoleToAccountValidationMiddleware(stack *middleware.Stack) error {
1638	return stack.Initialize.Add(&validateOpAssociateServiceRoleToAccount{}, middleware.After)
1639}
1640
1641func addOpCreateConnectorDefinitionValidationMiddleware(stack *middleware.Stack) error {
1642	return stack.Initialize.Add(&validateOpCreateConnectorDefinition{}, middleware.After)
1643}
1644
1645func addOpCreateConnectorDefinitionVersionValidationMiddleware(stack *middleware.Stack) error {
1646	return stack.Initialize.Add(&validateOpCreateConnectorDefinitionVersion{}, middleware.After)
1647}
1648
1649func addOpCreateCoreDefinitionValidationMiddleware(stack *middleware.Stack) error {
1650	return stack.Initialize.Add(&validateOpCreateCoreDefinition{}, middleware.After)
1651}
1652
1653func addOpCreateCoreDefinitionVersionValidationMiddleware(stack *middleware.Stack) error {
1654	return stack.Initialize.Add(&validateOpCreateCoreDefinitionVersion{}, middleware.After)
1655}
1656
1657func addOpCreateDeploymentValidationMiddleware(stack *middleware.Stack) error {
1658	return stack.Initialize.Add(&validateOpCreateDeployment{}, middleware.After)
1659}
1660
1661func addOpCreateDeviceDefinitionValidationMiddleware(stack *middleware.Stack) error {
1662	return stack.Initialize.Add(&validateOpCreateDeviceDefinition{}, middleware.After)
1663}
1664
1665func addOpCreateDeviceDefinitionVersionValidationMiddleware(stack *middleware.Stack) error {
1666	return stack.Initialize.Add(&validateOpCreateDeviceDefinitionVersion{}, middleware.After)
1667}
1668
1669func addOpCreateFunctionDefinitionValidationMiddleware(stack *middleware.Stack) error {
1670	return stack.Initialize.Add(&validateOpCreateFunctionDefinition{}, middleware.After)
1671}
1672
1673func addOpCreateFunctionDefinitionVersionValidationMiddleware(stack *middleware.Stack) error {
1674	return stack.Initialize.Add(&validateOpCreateFunctionDefinitionVersion{}, middleware.After)
1675}
1676
1677func addOpCreateGroupCertificateAuthorityValidationMiddleware(stack *middleware.Stack) error {
1678	return stack.Initialize.Add(&validateOpCreateGroupCertificateAuthority{}, middleware.After)
1679}
1680
1681func addOpCreateGroupValidationMiddleware(stack *middleware.Stack) error {
1682	return stack.Initialize.Add(&validateOpCreateGroup{}, middleware.After)
1683}
1684
1685func addOpCreateGroupVersionValidationMiddleware(stack *middleware.Stack) error {
1686	return stack.Initialize.Add(&validateOpCreateGroupVersion{}, middleware.After)
1687}
1688
1689func addOpCreateLoggerDefinitionValidationMiddleware(stack *middleware.Stack) error {
1690	return stack.Initialize.Add(&validateOpCreateLoggerDefinition{}, middleware.After)
1691}
1692
1693func addOpCreateLoggerDefinitionVersionValidationMiddleware(stack *middleware.Stack) error {
1694	return stack.Initialize.Add(&validateOpCreateLoggerDefinitionVersion{}, middleware.After)
1695}
1696
1697func addOpCreateResourceDefinitionValidationMiddleware(stack *middleware.Stack) error {
1698	return stack.Initialize.Add(&validateOpCreateResourceDefinition{}, middleware.After)
1699}
1700
1701func addOpCreateResourceDefinitionVersionValidationMiddleware(stack *middleware.Stack) error {
1702	return stack.Initialize.Add(&validateOpCreateResourceDefinitionVersion{}, middleware.After)
1703}
1704
1705func addOpCreateSoftwareUpdateJobValidationMiddleware(stack *middleware.Stack) error {
1706	return stack.Initialize.Add(&validateOpCreateSoftwareUpdateJob{}, middleware.After)
1707}
1708
1709func addOpCreateSubscriptionDefinitionValidationMiddleware(stack *middleware.Stack) error {
1710	return stack.Initialize.Add(&validateOpCreateSubscriptionDefinition{}, middleware.After)
1711}
1712
1713func addOpCreateSubscriptionDefinitionVersionValidationMiddleware(stack *middleware.Stack) error {
1714	return stack.Initialize.Add(&validateOpCreateSubscriptionDefinitionVersion{}, middleware.After)
1715}
1716
1717func addOpDeleteConnectorDefinitionValidationMiddleware(stack *middleware.Stack) error {
1718	return stack.Initialize.Add(&validateOpDeleteConnectorDefinition{}, middleware.After)
1719}
1720
1721func addOpDeleteCoreDefinitionValidationMiddleware(stack *middleware.Stack) error {
1722	return stack.Initialize.Add(&validateOpDeleteCoreDefinition{}, middleware.After)
1723}
1724
1725func addOpDeleteDeviceDefinitionValidationMiddleware(stack *middleware.Stack) error {
1726	return stack.Initialize.Add(&validateOpDeleteDeviceDefinition{}, middleware.After)
1727}
1728
1729func addOpDeleteFunctionDefinitionValidationMiddleware(stack *middleware.Stack) error {
1730	return stack.Initialize.Add(&validateOpDeleteFunctionDefinition{}, middleware.After)
1731}
1732
1733func addOpDeleteGroupValidationMiddleware(stack *middleware.Stack) error {
1734	return stack.Initialize.Add(&validateOpDeleteGroup{}, middleware.After)
1735}
1736
1737func addOpDeleteLoggerDefinitionValidationMiddleware(stack *middleware.Stack) error {
1738	return stack.Initialize.Add(&validateOpDeleteLoggerDefinition{}, middleware.After)
1739}
1740
1741func addOpDeleteResourceDefinitionValidationMiddleware(stack *middleware.Stack) error {
1742	return stack.Initialize.Add(&validateOpDeleteResourceDefinition{}, middleware.After)
1743}
1744
1745func addOpDeleteSubscriptionDefinitionValidationMiddleware(stack *middleware.Stack) error {
1746	return stack.Initialize.Add(&validateOpDeleteSubscriptionDefinition{}, middleware.After)
1747}
1748
1749func addOpDisassociateRoleFromGroupValidationMiddleware(stack *middleware.Stack) error {
1750	return stack.Initialize.Add(&validateOpDisassociateRoleFromGroup{}, middleware.After)
1751}
1752
1753func addOpGetAssociatedRoleValidationMiddleware(stack *middleware.Stack) error {
1754	return stack.Initialize.Add(&validateOpGetAssociatedRole{}, middleware.After)
1755}
1756
1757func addOpGetBulkDeploymentStatusValidationMiddleware(stack *middleware.Stack) error {
1758	return stack.Initialize.Add(&validateOpGetBulkDeploymentStatus{}, middleware.After)
1759}
1760
1761func addOpGetConnectivityInfoValidationMiddleware(stack *middleware.Stack) error {
1762	return stack.Initialize.Add(&validateOpGetConnectivityInfo{}, middleware.After)
1763}
1764
1765func addOpGetConnectorDefinitionValidationMiddleware(stack *middleware.Stack) error {
1766	return stack.Initialize.Add(&validateOpGetConnectorDefinition{}, middleware.After)
1767}
1768
1769func addOpGetConnectorDefinitionVersionValidationMiddleware(stack *middleware.Stack) error {
1770	return stack.Initialize.Add(&validateOpGetConnectorDefinitionVersion{}, middleware.After)
1771}
1772
1773func addOpGetCoreDefinitionValidationMiddleware(stack *middleware.Stack) error {
1774	return stack.Initialize.Add(&validateOpGetCoreDefinition{}, middleware.After)
1775}
1776
1777func addOpGetCoreDefinitionVersionValidationMiddleware(stack *middleware.Stack) error {
1778	return stack.Initialize.Add(&validateOpGetCoreDefinitionVersion{}, middleware.After)
1779}
1780
1781func addOpGetDeploymentStatusValidationMiddleware(stack *middleware.Stack) error {
1782	return stack.Initialize.Add(&validateOpGetDeploymentStatus{}, middleware.After)
1783}
1784
1785func addOpGetDeviceDefinitionValidationMiddleware(stack *middleware.Stack) error {
1786	return stack.Initialize.Add(&validateOpGetDeviceDefinition{}, middleware.After)
1787}
1788
1789func addOpGetDeviceDefinitionVersionValidationMiddleware(stack *middleware.Stack) error {
1790	return stack.Initialize.Add(&validateOpGetDeviceDefinitionVersion{}, middleware.After)
1791}
1792
1793func addOpGetFunctionDefinitionValidationMiddleware(stack *middleware.Stack) error {
1794	return stack.Initialize.Add(&validateOpGetFunctionDefinition{}, middleware.After)
1795}
1796
1797func addOpGetFunctionDefinitionVersionValidationMiddleware(stack *middleware.Stack) error {
1798	return stack.Initialize.Add(&validateOpGetFunctionDefinitionVersion{}, middleware.After)
1799}
1800
1801func addOpGetGroupCertificateAuthorityValidationMiddleware(stack *middleware.Stack) error {
1802	return stack.Initialize.Add(&validateOpGetGroupCertificateAuthority{}, middleware.After)
1803}
1804
1805func addOpGetGroupCertificateConfigurationValidationMiddleware(stack *middleware.Stack) error {
1806	return stack.Initialize.Add(&validateOpGetGroupCertificateConfiguration{}, middleware.After)
1807}
1808
1809func addOpGetGroupValidationMiddleware(stack *middleware.Stack) error {
1810	return stack.Initialize.Add(&validateOpGetGroup{}, middleware.After)
1811}
1812
1813func addOpGetGroupVersionValidationMiddleware(stack *middleware.Stack) error {
1814	return stack.Initialize.Add(&validateOpGetGroupVersion{}, middleware.After)
1815}
1816
1817func addOpGetLoggerDefinitionValidationMiddleware(stack *middleware.Stack) error {
1818	return stack.Initialize.Add(&validateOpGetLoggerDefinition{}, middleware.After)
1819}
1820
1821func addOpGetLoggerDefinitionVersionValidationMiddleware(stack *middleware.Stack) error {
1822	return stack.Initialize.Add(&validateOpGetLoggerDefinitionVersion{}, middleware.After)
1823}
1824
1825func addOpGetResourceDefinitionValidationMiddleware(stack *middleware.Stack) error {
1826	return stack.Initialize.Add(&validateOpGetResourceDefinition{}, middleware.After)
1827}
1828
1829func addOpGetResourceDefinitionVersionValidationMiddleware(stack *middleware.Stack) error {
1830	return stack.Initialize.Add(&validateOpGetResourceDefinitionVersion{}, middleware.After)
1831}
1832
1833func addOpGetSubscriptionDefinitionValidationMiddleware(stack *middleware.Stack) error {
1834	return stack.Initialize.Add(&validateOpGetSubscriptionDefinition{}, middleware.After)
1835}
1836
1837func addOpGetSubscriptionDefinitionVersionValidationMiddleware(stack *middleware.Stack) error {
1838	return stack.Initialize.Add(&validateOpGetSubscriptionDefinitionVersion{}, middleware.After)
1839}
1840
1841func addOpGetThingRuntimeConfigurationValidationMiddleware(stack *middleware.Stack) error {
1842	return stack.Initialize.Add(&validateOpGetThingRuntimeConfiguration{}, middleware.After)
1843}
1844
1845func addOpListBulkDeploymentDetailedReportsValidationMiddleware(stack *middleware.Stack) error {
1846	return stack.Initialize.Add(&validateOpListBulkDeploymentDetailedReports{}, middleware.After)
1847}
1848
1849func addOpListConnectorDefinitionVersionsValidationMiddleware(stack *middleware.Stack) error {
1850	return stack.Initialize.Add(&validateOpListConnectorDefinitionVersions{}, middleware.After)
1851}
1852
1853func addOpListCoreDefinitionVersionsValidationMiddleware(stack *middleware.Stack) error {
1854	return stack.Initialize.Add(&validateOpListCoreDefinitionVersions{}, middleware.After)
1855}
1856
1857func addOpListDeploymentsValidationMiddleware(stack *middleware.Stack) error {
1858	return stack.Initialize.Add(&validateOpListDeployments{}, middleware.After)
1859}
1860
1861func addOpListDeviceDefinitionVersionsValidationMiddleware(stack *middleware.Stack) error {
1862	return stack.Initialize.Add(&validateOpListDeviceDefinitionVersions{}, middleware.After)
1863}
1864
1865func addOpListFunctionDefinitionVersionsValidationMiddleware(stack *middleware.Stack) error {
1866	return stack.Initialize.Add(&validateOpListFunctionDefinitionVersions{}, middleware.After)
1867}
1868
1869func addOpListGroupCertificateAuthoritiesValidationMiddleware(stack *middleware.Stack) error {
1870	return stack.Initialize.Add(&validateOpListGroupCertificateAuthorities{}, middleware.After)
1871}
1872
1873func addOpListGroupVersionsValidationMiddleware(stack *middleware.Stack) error {
1874	return stack.Initialize.Add(&validateOpListGroupVersions{}, middleware.After)
1875}
1876
1877func addOpListLoggerDefinitionVersionsValidationMiddleware(stack *middleware.Stack) error {
1878	return stack.Initialize.Add(&validateOpListLoggerDefinitionVersions{}, middleware.After)
1879}
1880
1881func addOpListResourceDefinitionVersionsValidationMiddleware(stack *middleware.Stack) error {
1882	return stack.Initialize.Add(&validateOpListResourceDefinitionVersions{}, middleware.After)
1883}
1884
1885func addOpListSubscriptionDefinitionVersionsValidationMiddleware(stack *middleware.Stack) error {
1886	return stack.Initialize.Add(&validateOpListSubscriptionDefinitionVersions{}, middleware.After)
1887}
1888
1889func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
1890	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
1891}
1892
1893func addOpResetDeploymentsValidationMiddleware(stack *middleware.Stack) error {
1894	return stack.Initialize.Add(&validateOpResetDeployments{}, middleware.After)
1895}
1896
1897func addOpStartBulkDeploymentValidationMiddleware(stack *middleware.Stack) error {
1898	return stack.Initialize.Add(&validateOpStartBulkDeployment{}, middleware.After)
1899}
1900
1901func addOpStopBulkDeploymentValidationMiddleware(stack *middleware.Stack) error {
1902	return stack.Initialize.Add(&validateOpStopBulkDeployment{}, middleware.After)
1903}
1904
1905func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
1906	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
1907}
1908
1909func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
1910	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
1911}
1912
1913func addOpUpdateConnectivityInfoValidationMiddleware(stack *middleware.Stack) error {
1914	return stack.Initialize.Add(&validateOpUpdateConnectivityInfo{}, middleware.After)
1915}
1916
1917func addOpUpdateConnectorDefinitionValidationMiddleware(stack *middleware.Stack) error {
1918	return stack.Initialize.Add(&validateOpUpdateConnectorDefinition{}, middleware.After)
1919}
1920
1921func addOpUpdateCoreDefinitionValidationMiddleware(stack *middleware.Stack) error {
1922	return stack.Initialize.Add(&validateOpUpdateCoreDefinition{}, middleware.After)
1923}
1924
1925func addOpUpdateDeviceDefinitionValidationMiddleware(stack *middleware.Stack) error {
1926	return stack.Initialize.Add(&validateOpUpdateDeviceDefinition{}, middleware.After)
1927}
1928
1929func addOpUpdateFunctionDefinitionValidationMiddleware(stack *middleware.Stack) error {
1930	return stack.Initialize.Add(&validateOpUpdateFunctionDefinition{}, middleware.After)
1931}
1932
1933func addOpUpdateGroupCertificateConfigurationValidationMiddleware(stack *middleware.Stack) error {
1934	return stack.Initialize.Add(&validateOpUpdateGroupCertificateConfiguration{}, middleware.After)
1935}
1936
1937func addOpUpdateGroupValidationMiddleware(stack *middleware.Stack) error {
1938	return stack.Initialize.Add(&validateOpUpdateGroup{}, middleware.After)
1939}
1940
1941func addOpUpdateLoggerDefinitionValidationMiddleware(stack *middleware.Stack) error {
1942	return stack.Initialize.Add(&validateOpUpdateLoggerDefinition{}, middleware.After)
1943}
1944
1945func addOpUpdateResourceDefinitionValidationMiddleware(stack *middleware.Stack) error {
1946	return stack.Initialize.Add(&validateOpUpdateResourceDefinition{}, middleware.After)
1947}
1948
1949func addOpUpdateSubscriptionDefinitionValidationMiddleware(stack *middleware.Stack) error {
1950	return stack.Initialize.Add(&validateOpUpdateSubscriptionDefinition{}, middleware.After)
1951}
1952
1953func addOpUpdateThingRuntimeConfigurationValidationMiddleware(stack *middleware.Stack) error {
1954	return stack.Initialize.Add(&validateOpUpdateThingRuntimeConfiguration{}, middleware.After)
1955}
1956
1957func validate__listOfConnector(v []types.Connector) error {
1958	if v == nil {
1959		return nil
1960	}
1961	invalidParams := smithy.InvalidParamsError{Context: "ListOfConnector"}
1962	for i := range v {
1963		if err := validateConnector(&v[i]); err != nil {
1964			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1965		}
1966	}
1967	if invalidParams.Len() > 0 {
1968		return invalidParams
1969	} else {
1970		return nil
1971	}
1972}
1973
1974func validate__listOfCore(v []types.Core) error {
1975	if v == nil {
1976		return nil
1977	}
1978	invalidParams := smithy.InvalidParamsError{Context: "ListOfCore"}
1979	for i := range v {
1980		if err := validateCore(&v[i]); err != nil {
1981			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1982		}
1983	}
1984	if invalidParams.Len() > 0 {
1985		return invalidParams
1986	} else {
1987		return nil
1988	}
1989}
1990
1991func validate__listOfDevice(v []types.Device) error {
1992	if v == nil {
1993		return nil
1994	}
1995	invalidParams := smithy.InvalidParamsError{Context: "ListOfDevice"}
1996	for i := range v {
1997		if err := validateDevice(&v[i]); err != nil {
1998			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1999		}
2000	}
2001	if invalidParams.Len() > 0 {
2002		return invalidParams
2003	} else {
2004		return nil
2005	}
2006}
2007
2008func validate__listOfFunction(v []types.Function) error {
2009	if v == nil {
2010		return nil
2011	}
2012	invalidParams := smithy.InvalidParamsError{Context: "ListOfFunction"}
2013	for i := range v {
2014		if err := validateFunction(&v[i]); err != nil {
2015			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2016		}
2017	}
2018	if invalidParams.Len() > 0 {
2019		return invalidParams
2020	} else {
2021		return nil
2022	}
2023}
2024
2025func validate__listOfLogger(v []types.Logger) error {
2026	if v == nil {
2027		return nil
2028	}
2029	invalidParams := smithy.InvalidParamsError{Context: "ListOfLogger"}
2030	for i := range v {
2031		if err := validateLogger(&v[i]); err != nil {
2032			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2033		}
2034	}
2035	if invalidParams.Len() > 0 {
2036		return invalidParams
2037	} else {
2038		return nil
2039	}
2040}
2041
2042func validate__listOfResource(v []types.Resource) error {
2043	if v == nil {
2044		return nil
2045	}
2046	invalidParams := smithy.InvalidParamsError{Context: "ListOfResource"}
2047	for i := range v {
2048		if err := validateResource(&v[i]); err != nil {
2049			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2050		}
2051	}
2052	if invalidParams.Len() > 0 {
2053		return invalidParams
2054	} else {
2055		return nil
2056	}
2057}
2058
2059func validate__listOfResourceAccessPolicy(v []types.ResourceAccessPolicy) error {
2060	if v == nil {
2061		return nil
2062	}
2063	invalidParams := smithy.InvalidParamsError{Context: "ListOfResourceAccessPolicy"}
2064	for i := range v {
2065		if err := validateResourceAccessPolicy(&v[i]); err != nil {
2066			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2067		}
2068	}
2069	if invalidParams.Len() > 0 {
2070		return invalidParams
2071	} else {
2072		return nil
2073	}
2074}
2075
2076func validate__listOfSubscription(v []types.Subscription) error {
2077	if v == nil {
2078		return nil
2079	}
2080	invalidParams := smithy.InvalidParamsError{Context: "ListOfSubscription"}
2081	for i := range v {
2082		if err := validateSubscription(&v[i]); err != nil {
2083			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2084		}
2085	}
2086	if invalidParams.Len() > 0 {
2087		return invalidParams
2088	} else {
2089		return nil
2090	}
2091}
2092
2093func validateConnector(v *types.Connector) error {
2094	if v == nil {
2095		return nil
2096	}
2097	invalidParams := smithy.InvalidParamsError{Context: "Connector"}
2098	if v.ConnectorArn == nil {
2099		invalidParams.Add(smithy.NewErrParamRequired("ConnectorArn"))
2100	}
2101	if v.Id == nil {
2102		invalidParams.Add(smithy.NewErrParamRequired("Id"))
2103	}
2104	if invalidParams.Len() > 0 {
2105		return invalidParams
2106	} else {
2107		return nil
2108	}
2109}
2110
2111func validateConnectorDefinitionVersion(v *types.ConnectorDefinitionVersion) error {
2112	if v == nil {
2113		return nil
2114	}
2115	invalidParams := smithy.InvalidParamsError{Context: "ConnectorDefinitionVersion"}
2116	if v.Connectors != nil {
2117		if err := validate__listOfConnector(v.Connectors); err != nil {
2118			invalidParams.AddNested("Connectors", err.(smithy.InvalidParamsError))
2119		}
2120	}
2121	if invalidParams.Len() > 0 {
2122		return invalidParams
2123	} else {
2124		return nil
2125	}
2126}
2127
2128func validateCore(v *types.Core) error {
2129	if v == nil {
2130		return nil
2131	}
2132	invalidParams := smithy.InvalidParamsError{Context: "Core"}
2133	if v.CertificateArn == nil {
2134		invalidParams.Add(smithy.NewErrParamRequired("CertificateArn"))
2135	}
2136	if v.Id == nil {
2137		invalidParams.Add(smithy.NewErrParamRequired("Id"))
2138	}
2139	if v.ThingArn == nil {
2140		invalidParams.Add(smithy.NewErrParamRequired("ThingArn"))
2141	}
2142	if invalidParams.Len() > 0 {
2143		return invalidParams
2144	} else {
2145		return nil
2146	}
2147}
2148
2149func validateCoreDefinitionVersion(v *types.CoreDefinitionVersion) error {
2150	if v == nil {
2151		return nil
2152	}
2153	invalidParams := smithy.InvalidParamsError{Context: "CoreDefinitionVersion"}
2154	if v.Cores != nil {
2155		if err := validate__listOfCore(v.Cores); err != nil {
2156			invalidParams.AddNested("Cores", err.(smithy.InvalidParamsError))
2157		}
2158	}
2159	if invalidParams.Len() > 0 {
2160		return invalidParams
2161	} else {
2162		return nil
2163	}
2164}
2165
2166func validateDevice(v *types.Device) error {
2167	if v == nil {
2168		return nil
2169	}
2170	invalidParams := smithy.InvalidParamsError{Context: "Device"}
2171	if v.CertificateArn == nil {
2172		invalidParams.Add(smithy.NewErrParamRequired("CertificateArn"))
2173	}
2174	if v.Id == nil {
2175		invalidParams.Add(smithy.NewErrParamRequired("Id"))
2176	}
2177	if v.ThingArn == nil {
2178		invalidParams.Add(smithy.NewErrParamRequired("ThingArn"))
2179	}
2180	if invalidParams.Len() > 0 {
2181		return invalidParams
2182	} else {
2183		return nil
2184	}
2185}
2186
2187func validateDeviceDefinitionVersion(v *types.DeviceDefinitionVersion) error {
2188	if v == nil {
2189		return nil
2190	}
2191	invalidParams := smithy.InvalidParamsError{Context: "DeviceDefinitionVersion"}
2192	if v.Devices != nil {
2193		if err := validate__listOfDevice(v.Devices); err != nil {
2194			invalidParams.AddNested("Devices", err.(smithy.InvalidParamsError))
2195		}
2196	}
2197	if invalidParams.Len() > 0 {
2198		return invalidParams
2199	} else {
2200		return nil
2201	}
2202}
2203
2204func validateFunction(v *types.Function) error {
2205	if v == nil {
2206		return nil
2207	}
2208	invalidParams := smithy.InvalidParamsError{Context: "Function"}
2209	if v.FunctionConfiguration != nil {
2210		if err := validateFunctionConfiguration(v.FunctionConfiguration); err != nil {
2211			invalidParams.AddNested("FunctionConfiguration", err.(smithy.InvalidParamsError))
2212		}
2213	}
2214	if v.Id == nil {
2215		invalidParams.Add(smithy.NewErrParamRequired("Id"))
2216	}
2217	if invalidParams.Len() > 0 {
2218		return invalidParams
2219	} else {
2220		return nil
2221	}
2222}
2223
2224func validateFunctionConfiguration(v *types.FunctionConfiguration) error {
2225	if v == nil {
2226		return nil
2227	}
2228	invalidParams := smithy.InvalidParamsError{Context: "FunctionConfiguration"}
2229	if v.Environment != nil {
2230		if err := validateFunctionConfigurationEnvironment(v.Environment); err != nil {
2231			invalidParams.AddNested("Environment", err.(smithy.InvalidParamsError))
2232		}
2233	}
2234	if invalidParams.Len() > 0 {
2235		return invalidParams
2236	} else {
2237		return nil
2238	}
2239}
2240
2241func validateFunctionConfigurationEnvironment(v *types.FunctionConfigurationEnvironment) error {
2242	if v == nil {
2243		return nil
2244	}
2245	invalidParams := smithy.InvalidParamsError{Context: "FunctionConfigurationEnvironment"}
2246	if v.ResourceAccessPolicies != nil {
2247		if err := validate__listOfResourceAccessPolicy(v.ResourceAccessPolicies); err != nil {
2248			invalidParams.AddNested("ResourceAccessPolicies", err.(smithy.InvalidParamsError))
2249		}
2250	}
2251	if invalidParams.Len() > 0 {
2252		return invalidParams
2253	} else {
2254		return nil
2255	}
2256}
2257
2258func validateFunctionDefinitionVersion(v *types.FunctionDefinitionVersion) error {
2259	if v == nil {
2260		return nil
2261	}
2262	invalidParams := smithy.InvalidParamsError{Context: "FunctionDefinitionVersion"}
2263	if v.Functions != nil {
2264		if err := validate__listOfFunction(v.Functions); err != nil {
2265			invalidParams.AddNested("Functions", err.(smithy.InvalidParamsError))
2266		}
2267	}
2268	if invalidParams.Len() > 0 {
2269		return invalidParams
2270	} else {
2271		return nil
2272	}
2273}
2274
2275func validateLogger(v *types.Logger) error {
2276	if v == nil {
2277		return nil
2278	}
2279	invalidParams := smithy.InvalidParamsError{Context: "Logger"}
2280	if len(v.Component) == 0 {
2281		invalidParams.Add(smithy.NewErrParamRequired("Component"))
2282	}
2283	if v.Id == nil {
2284		invalidParams.Add(smithy.NewErrParamRequired("Id"))
2285	}
2286	if len(v.Level) == 0 {
2287		invalidParams.Add(smithy.NewErrParamRequired("Level"))
2288	}
2289	if len(v.Type) == 0 {
2290		invalidParams.Add(smithy.NewErrParamRequired("Type"))
2291	}
2292	if invalidParams.Len() > 0 {
2293		return invalidParams
2294	} else {
2295		return nil
2296	}
2297}
2298
2299func validateLoggerDefinitionVersion(v *types.LoggerDefinitionVersion) error {
2300	if v == nil {
2301		return nil
2302	}
2303	invalidParams := smithy.InvalidParamsError{Context: "LoggerDefinitionVersion"}
2304	if v.Loggers != nil {
2305		if err := validate__listOfLogger(v.Loggers); err != nil {
2306			invalidParams.AddNested("Loggers", err.(smithy.InvalidParamsError))
2307		}
2308	}
2309	if invalidParams.Len() > 0 {
2310		return invalidParams
2311	} else {
2312		return nil
2313	}
2314}
2315
2316func validateResource(v *types.Resource) error {
2317	if v == nil {
2318		return nil
2319	}
2320	invalidParams := smithy.InvalidParamsError{Context: "Resource"}
2321	if v.Id == nil {
2322		invalidParams.Add(smithy.NewErrParamRequired("Id"))
2323	}
2324	if v.Name == nil {
2325		invalidParams.Add(smithy.NewErrParamRequired("Name"))
2326	}
2327	if v.ResourceDataContainer == nil {
2328		invalidParams.Add(smithy.NewErrParamRequired("ResourceDataContainer"))
2329	} else if v.ResourceDataContainer != nil {
2330		if err := validateResourceDataContainer(v.ResourceDataContainer); err != nil {
2331			invalidParams.AddNested("ResourceDataContainer", err.(smithy.InvalidParamsError))
2332		}
2333	}
2334	if invalidParams.Len() > 0 {
2335		return invalidParams
2336	} else {
2337		return nil
2338	}
2339}
2340
2341func validateResourceAccessPolicy(v *types.ResourceAccessPolicy) error {
2342	if v == nil {
2343		return nil
2344	}
2345	invalidParams := smithy.InvalidParamsError{Context: "ResourceAccessPolicy"}
2346	if v.ResourceId == nil {
2347		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
2348	}
2349	if invalidParams.Len() > 0 {
2350		return invalidParams
2351	} else {
2352		return nil
2353	}
2354}
2355
2356func validateResourceDataContainer(v *types.ResourceDataContainer) error {
2357	if v == nil {
2358		return nil
2359	}
2360	invalidParams := smithy.InvalidParamsError{Context: "ResourceDataContainer"}
2361	if v.S3MachineLearningModelResourceData != nil {
2362		if err := validateS3MachineLearningModelResourceData(v.S3MachineLearningModelResourceData); err != nil {
2363			invalidParams.AddNested("S3MachineLearningModelResourceData", err.(smithy.InvalidParamsError))
2364		}
2365	}
2366	if v.SageMakerMachineLearningModelResourceData != nil {
2367		if err := validateSageMakerMachineLearningModelResourceData(v.SageMakerMachineLearningModelResourceData); err != nil {
2368			invalidParams.AddNested("SageMakerMachineLearningModelResourceData", err.(smithy.InvalidParamsError))
2369		}
2370	}
2371	if invalidParams.Len() > 0 {
2372		return invalidParams
2373	} else {
2374		return nil
2375	}
2376}
2377
2378func validateResourceDefinitionVersion(v *types.ResourceDefinitionVersion) error {
2379	if v == nil {
2380		return nil
2381	}
2382	invalidParams := smithy.InvalidParamsError{Context: "ResourceDefinitionVersion"}
2383	if v.Resources != nil {
2384		if err := validate__listOfResource(v.Resources); err != nil {
2385			invalidParams.AddNested("Resources", err.(smithy.InvalidParamsError))
2386		}
2387	}
2388	if invalidParams.Len() > 0 {
2389		return invalidParams
2390	} else {
2391		return nil
2392	}
2393}
2394
2395func validateResourceDownloadOwnerSetting(v *types.ResourceDownloadOwnerSetting) error {
2396	if v == nil {
2397		return nil
2398	}
2399	invalidParams := smithy.InvalidParamsError{Context: "ResourceDownloadOwnerSetting"}
2400	if v.GroupOwner == nil {
2401		invalidParams.Add(smithy.NewErrParamRequired("GroupOwner"))
2402	}
2403	if len(v.GroupPermission) == 0 {
2404		invalidParams.Add(smithy.NewErrParamRequired("GroupPermission"))
2405	}
2406	if invalidParams.Len() > 0 {
2407		return invalidParams
2408	} else {
2409		return nil
2410	}
2411}
2412
2413func validateS3MachineLearningModelResourceData(v *types.S3MachineLearningModelResourceData) error {
2414	if v == nil {
2415		return nil
2416	}
2417	invalidParams := smithy.InvalidParamsError{Context: "S3MachineLearningModelResourceData"}
2418	if v.OwnerSetting != nil {
2419		if err := validateResourceDownloadOwnerSetting(v.OwnerSetting); err != nil {
2420			invalidParams.AddNested("OwnerSetting", err.(smithy.InvalidParamsError))
2421		}
2422	}
2423	if invalidParams.Len() > 0 {
2424		return invalidParams
2425	} else {
2426		return nil
2427	}
2428}
2429
2430func validateSageMakerMachineLearningModelResourceData(v *types.SageMakerMachineLearningModelResourceData) error {
2431	if v == nil {
2432		return nil
2433	}
2434	invalidParams := smithy.InvalidParamsError{Context: "SageMakerMachineLearningModelResourceData"}
2435	if v.OwnerSetting != nil {
2436		if err := validateResourceDownloadOwnerSetting(v.OwnerSetting); err != nil {
2437			invalidParams.AddNested("OwnerSetting", err.(smithy.InvalidParamsError))
2438		}
2439	}
2440	if invalidParams.Len() > 0 {
2441		return invalidParams
2442	} else {
2443		return nil
2444	}
2445}
2446
2447func validateSubscription(v *types.Subscription) error {
2448	if v == nil {
2449		return nil
2450	}
2451	invalidParams := smithy.InvalidParamsError{Context: "Subscription"}
2452	if v.Id == nil {
2453		invalidParams.Add(smithy.NewErrParamRequired("Id"))
2454	}
2455	if v.Source == nil {
2456		invalidParams.Add(smithy.NewErrParamRequired("Source"))
2457	}
2458	if v.Subject == nil {
2459		invalidParams.Add(smithy.NewErrParamRequired("Subject"))
2460	}
2461	if v.Target == nil {
2462		invalidParams.Add(smithy.NewErrParamRequired("Target"))
2463	}
2464	if invalidParams.Len() > 0 {
2465		return invalidParams
2466	} else {
2467		return nil
2468	}
2469}
2470
2471func validateSubscriptionDefinitionVersion(v *types.SubscriptionDefinitionVersion) error {
2472	if v == nil {
2473		return nil
2474	}
2475	invalidParams := smithy.InvalidParamsError{Context: "SubscriptionDefinitionVersion"}
2476	if v.Subscriptions != nil {
2477		if err := validate__listOfSubscription(v.Subscriptions); err != nil {
2478			invalidParams.AddNested("Subscriptions", err.(smithy.InvalidParamsError))
2479		}
2480	}
2481	if invalidParams.Len() > 0 {
2482		return invalidParams
2483	} else {
2484		return nil
2485	}
2486}
2487
2488func validateTelemetryConfigurationUpdate(v *types.TelemetryConfigurationUpdate) error {
2489	if v == nil {
2490		return nil
2491	}
2492	invalidParams := smithy.InvalidParamsError{Context: "TelemetryConfigurationUpdate"}
2493	if len(v.Telemetry) == 0 {
2494		invalidParams.Add(smithy.NewErrParamRequired("Telemetry"))
2495	}
2496	if invalidParams.Len() > 0 {
2497		return invalidParams
2498	} else {
2499		return nil
2500	}
2501}
2502
2503func validateOpAssociateRoleToGroupInput(v *AssociateRoleToGroupInput) error {
2504	if v == nil {
2505		return nil
2506	}
2507	invalidParams := smithy.InvalidParamsError{Context: "AssociateRoleToGroupInput"}
2508	if v.GroupId == nil {
2509		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
2510	}
2511	if v.RoleArn == nil {
2512		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
2513	}
2514	if invalidParams.Len() > 0 {
2515		return invalidParams
2516	} else {
2517		return nil
2518	}
2519}
2520
2521func validateOpAssociateServiceRoleToAccountInput(v *AssociateServiceRoleToAccountInput) error {
2522	if v == nil {
2523		return nil
2524	}
2525	invalidParams := smithy.InvalidParamsError{Context: "AssociateServiceRoleToAccountInput"}
2526	if v.RoleArn == nil {
2527		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
2528	}
2529	if invalidParams.Len() > 0 {
2530		return invalidParams
2531	} else {
2532		return nil
2533	}
2534}
2535
2536func validateOpCreateConnectorDefinitionInput(v *CreateConnectorDefinitionInput) error {
2537	if v == nil {
2538		return nil
2539	}
2540	invalidParams := smithy.InvalidParamsError{Context: "CreateConnectorDefinitionInput"}
2541	if v.InitialVersion != nil {
2542		if err := validateConnectorDefinitionVersion(v.InitialVersion); err != nil {
2543			invalidParams.AddNested("InitialVersion", err.(smithy.InvalidParamsError))
2544		}
2545	}
2546	if invalidParams.Len() > 0 {
2547		return invalidParams
2548	} else {
2549		return nil
2550	}
2551}
2552
2553func validateOpCreateConnectorDefinitionVersionInput(v *CreateConnectorDefinitionVersionInput) error {
2554	if v == nil {
2555		return nil
2556	}
2557	invalidParams := smithy.InvalidParamsError{Context: "CreateConnectorDefinitionVersionInput"}
2558	if v.ConnectorDefinitionId == nil {
2559		invalidParams.Add(smithy.NewErrParamRequired("ConnectorDefinitionId"))
2560	}
2561	if v.Connectors != nil {
2562		if err := validate__listOfConnector(v.Connectors); err != nil {
2563			invalidParams.AddNested("Connectors", err.(smithy.InvalidParamsError))
2564		}
2565	}
2566	if invalidParams.Len() > 0 {
2567		return invalidParams
2568	} else {
2569		return nil
2570	}
2571}
2572
2573func validateOpCreateCoreDefinitionInput(v *CreateCoreDefinitionInput) error {
2574	if v == nil {
2575		return nil
2576	}
2577	invalidParams := smithy.InvalidParamsError{Context: "CreateCoreDefinitionInput"}
2578	if v.InitialVersion != nil {
2579		if err := validateCoreDefinitionVersion(v.InitialVersion); err != nil {
2580			invalidParams.AddNested("InitialVersion", err.(smithy.InvalidParamsError))
2581		}
2582	}
2583	if invalidParams.Len() > 0 {
2584		return invalidParams
2585	} else {
2586		return nil
2587	}
2588}
2589
2590func validateOpCreateCoreDefinitionVersionInput(v *CreateCoreDefinitionVersionInput) error {
2591	if v == nil {
2592		return nil
2593	}
2594	invalidParams := smithy.InvalidParamsError{Context: "CreateCoreDefinitionVersionInput"}
2595	if v.CoreDefinitionId == nil {
2596		invalidParams.Add(smithy.NewErrParamRequired("CoreDefinitionId"))
2597	}
2598	if v.Cores != nil {
2599		if err := validate__listOfCore(v.Cores); err != nil {
2600			invalidParams.AddNested("Cores", err.(smithy.InvalidParamsError))
2601		}
2602	}
2603	if invalidParams.Len() > 0 {
2604		return invalidParams
2605	} else {
2606		return nil
2607	}
2608}
2609
2610func validateOpCreateDeploymentInput(v *CreateDeploymentInput) error {
2611	if v == nil {
2612		return nil
2613	}
2614	invalidParams := smithy.InvalidParamsError{Context: "CreateDeploymentInput"}
2615	if len(v.DeploymentType) == 0 {
2616		invalidParams.Add(smithy.NewErrParamRequired("DeploymentType"))
2617	}
2618	if v.GroupId == nil {
2619		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
2620	}
2621	if invalidParams.Len() > 0 {
2622		return invalidParams
2623	} else {
2624		return nil
2625	}
2626}
2627
2628func validateOpCreateDeviceDefinitionInput(v *CreateDeviceDefinitionInput) error {
2629	if v == nil {
2630		return nil
2631	}
2632	invalidParams := smithy.InvalidParamsError{Context: "CreateDeviceDefinitionInput"}
2633	if v.InitialVersion != nil {
2634		if err := validateDeviceDefinitionVersion(v.InitialVersion); err != nil {
2635			invalidParams.AddNested("InitialVersion", err.(smithy.InvalidParamsError))
2636		}
2637	}
2638	if invalidParams.Len() > 0 {
2639		return invalidParams
2640	} else {
2641		return nil
2642	}
2643}
2644
2645func validateOpCreateDeviceDefinitionVersionInput(v *CreateDeviceDefinitionVersionInput) error {
2646	if v == nil {
2647		return nil
2648	}
2649	invalidParams := smithy.InvalidParamsError{Context: "CreateDeviceDefinitionVersionInput"}
2650	if v.DeviceDefinitionId == nil {
2651		invalidParams.Add(smithy.NewErrParamRequired("DeviceDefinitionId"))
2652	}
2653	if v.Devices != nil {
2654		if err := validate__listOfDevice(v.Devices); err != nil {
2655			invalidParams.AddNested("Devices", err.(smithy.InvalidParamsError))
2656		}
2657	}
2658	if invalidParams.Len() > 0 {
2659		return invalidParams
2660	} else {
2661		return nil
2662	}
2663}
2664
2665func validateOpCreateFunctionDefinitionInput(v *CreateFunctionDefinitionInput) error {
2666	if v == nil {
2667		return nil
2668	}
2669	invalidParams := smithy.InvalidParamsError{Context: "CreateFunctionDefinitionInput"}
2670	if v.InitialVersion != nil {
2671		if err := validateFunctionDefinitionVersion(v.InitialVersion); err != nil {
2672			invalidParams.AddNested("InitialVersion", err.(smithy.InvalidParamsError))
2673		}
2674	}
2675	if invalidParams.Len() > 0 {
2676		return invalidParams
2677	} else {
2678		return nil
2679	}
2680}
2681
2682func validateOpCreateFunctionDefinitionVersionInput(v *CreateFunctionDefinitionVersionInput) error {
2683	if v == nil {
2684		return nil
2685	}
2686	invalidParams := smithy.InvalidParamsError{Context: "CreateFunctionDefinitionVersionInput"}
2687	if v.FunctionDefinitionId == nil {
2688		invalidParams.Add(smithy.NewErrParamRequired("FunctionDefinitionId"))
2689	}
2690	if v.Functions != nil {
2691		if err := validate__listOfFunction(v.Functions); err != nil {
2692			invalidParams.AddNested("Functions", err.(smithy.InvalidParamsError))
2693		}
2694	}
2695	if invalidParams.Len() > 0 {
2696		return invalidParams
2697	} else {
2698		return nil
2699	}
2700}
2701
2702func validateOpCreateGroupCertificateAuthorityInput(v *CreateGroupCertificateAuthorityInput) error {
2703	if v == nil {
2704		return nil
2705	}
2706	invalidParams := smithy.InvalidParamsError{Context: "CreateGroupCertificateAuthorityInput"}
2707	if v.GroupId == nil {
2708		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
2709	}
2710	if invalidParams.Len() > 0 {
2711		return invalidParams
2712	} else {
2713		return nil
2714	}
2715}
2716
2717func validateOpCreateGroupInput(v *CreateGroupInput) error {
2718	if v == nil {
2719		return nil
2720	}
2721	invalidParams := smithy.InvalidParamsError{Context: "CreateGroupInput"}
2722	if v.Name == nil {
2723		invalidParams.Add(smithy.NewErrParamRequired("Name"))
2724	}
2725	if invalidParams.Len() > 0 {
2726		return invalidParams
2727	} else {
2728		return nil
2729	}
2730}
2731
2732func validateOpCreateGroupVersionInput(v *CreateGroupVersionInput) error {
2733	if v == nil {
2734		return nil
2735	}
2736	invalidParams := smithy.InvalidParamsError{Context: "CreateGroupVersionInput"}
2737	if v.GroupId == nil {
2738		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
2739	}
2740	if invalidParams.Len() > 0 {
2741		return invalidParams
2742	} else {
2743		return nil
2744	}
2745}
2746
2747func validateOpCreateLoggerDefinitionInput(v *CreateLoggerDefinitionInput) error {
2748	if v == nil {
2749		return nil
2750	}
2751	invalidParams := smithy.InvalidParamsError{Context: "CreateLoggerDefinitionInput"}
2752	if v.InitialVersion != nil {
2753		if err := validateLoggerDefinitionVersion(v.InitialVersion); err != nil {
2754			invalidParams.AddNested("InitialVersion", err.(smithy.InvalidParamsError))
2755		}
2756	}
2757	if invalidParams.Len() > 0 {
2758		return invalidParams
2759	} else {
2760		return nil
2761	}
2762}
2763
2764func validateOpCreateLoggerDefinitionVersionInput(v *CreateLoggerDefinitionVersionInput) error {
2765	if v == nil {
2766		return nil
2767	}
2768	invalidParams := smithy.InvalidParamsError{Context: "CreateLoggerDefinitionVersionInput"}
2769	if v.LoggerDefinitionId == nil {
2770		invalidParams.Add(smithy.NewErrParamRequired("LoggerDefinitionId"))
2771	}
2772	if v.Loggers != nil {
2773		if err := validate__listOfLogger(v.Loggers); err != nil {
2774			invalidParams.AddNested("Loggers", err.(smithy.InvalidParamsError))
2775		}
2776	}
2777	if invalidParams.Len() > 0 {
2778		return invalidParams
2779	} else {
2780		return nil
2781	}
2782}
2783
2784func validateOpCreateResourceDefinitionInput(v *CreateResourceDefinitionInput) error {
2785	if v == nil {
2786		return nil
2787	}
2788	invalidParams := smithy.InvalidParamsError{Context: "CreateResourceDefinitionInput"}
2789	if v.InitialVersion != nil {
2790		if err := validateResourceDefinitionVersion(v.InitialVersion); err != nil {
2791			invalidParams.AddNested("InitialVersion", err.(smithy.InvalidParamsError))
2792		}
2793	}
2794	if invalidParams.Len() > 0 {
2795		return invalidParams
2796	} else {
2797		return nil
2798	}
2799}
2800
2801func validateOpCreateResourceDefinitionVersionInput(v *CreateResourceDefinitionVersionInput) error {
2802	if v == nil {
2803		return nil
2804	}
2805	invalidParams := smithy.InvalidParamsError{Context: "CreateResourceDefinitionVersionInput"}
2806	if v.ResourceDefinitionId == nil {
2807		invalidParams.Add(smithy.NewErrParamRequired("ResourceDefinitionId"))
2808	}
2809	if v.Resources != nil {
2810		if err := validate__listOfResource(v.Resources); err != nil {
2811			invalidParams.AddNested("Resources", err.(smithy.InvalidParamsError))
2812		}
2813	}
2814	if invalidParams.Len() > 0 {
2815		return invalidParams
2816	} else {
2817		return nil
2818	}
2819}
2820
2821func validateOpCreateSoftwareUpdateJobInput(v *CreateSoftwareUpdateJobInput) error {
2822	if v == nil {
2823		return nil
2824	}
2825	invalidParams := smithy.InvalidParamsError{Context: "CreateSoftwareUpdateJobInput"}
2826	if v.S3UrlSignerRole == nil {
2827		invalidParams.Add(smithy.NewErrParamRequired("S3UrlSignerRole"))
2828	}
2829	if len(v.SoftwareToUpdate) == 0 {
2830		invalidParams.Add(smithy.NewErrParamRequired("SoftwareToUpdate"))
2831	}
2832	if v.UpdateTargets == nil {
2833		invalidParams.Add(smithy.NewErrParamRequired("UpdateTargets"))
2834	}
2835	if len(v.UpdateTargetsArchitecture) == 0 {
2836		invalidParams.Add(smithy.NewErrParamRequired("UpdateTargetsArchitecture"))
2837	}
2838	if len(v.UpdateTargetsOperatingSystem) == 0 {
2839		invalidParams.Add(smithy.NewErrParamRequired("UpdateTargetsOperatingSystem"))
2840	}
2841	if invalidParams.Len() > 0 {
2842		return invalidParams
2843	} else {
2844		return nil
2845	}
2846}
2847
2848func validateOpCreateSubscriptionDefinitionInput(v *CreateSubscriptionDefinitionInput) error {
2849	if v == nil {
2850		return nil
2851	}
2852	invalidParams := smithy.InvalidParamsError{Context: "CreateSubscriptionDefinitionInput"}
2853	if v.InitialVersion != nil {
2854		if err := validateSubscriptionDefinitionVersion(v.InitialVersion); err != nil {
2855			invalidParams.AddNested("InitialVersion", err.(smithy.InvalidParamsError))
2856		}
2857	}
2858	if invalidParams.Len() > 0 {
2859		return invalidParams
2860	} else {
2861		return nil
2862	}
2863}
2864
2865func validateOpCreateSubscriptionDefinitionVersionInput(v *CreateSubscriptionDefinitionVersionInput) error {
2866	if v == nil {
2867		return nil
2868	}
2869	invalidParams := smithy.InvalidParamsError{Context: "CreateSubscriptionDefinitionVersionInput"}
2870	if v.SubscriptionDefinitionId == nil {
2871		invalidParams.Add(smithy.NewErrParamRequired("SubscriptionDefinitionId"))
2872	}
2873	if v.Subscriptions != nil {
2874		if err := validate__listOfSubscription(v.Subscriptions); err != nil {
2875			invalidParams.AddNested("Subscriptions", err.(smithy.InvalidParamsError))
2876		}
2877	}
2878	if invalidParams.Len() > 0 {
2879		return invalidParams
2880	} else {
2881		return nil
2882	}
2883}
2884
2885func validateOpDeleteConnectorDefinitionInput(v *DeleteConnectorDefinitionInput) error {
2886	if v == nil {
2887		return nil
2888	}
2889	invalidParams := smithy.InvalidParamsError{Context: "DeleteConnectorDefinitionInput"}
2890	if v.ConnectorDefinitionId == nil {
2891		invalidParams.Add(smithy.NewErrParamRequired("ConnectorDefinitionId"))
2892	}
2893	if invalidParams.Len() > 0 {
2894		return invalidParams
2895	} else {
2896		return nil
2897	}
2898}
2899
2900func validateOpDeleteCoreDefinitionInput(v *DeleteCoreDefinitionInput) error {
2901	if v == nil {
2902		return nil
2903	}
2904	invalidParams := smithy.InvalidParamsError{Context: "DeleteCoreDefinitionInput"}
2905	if v.CoreDefinitionId == nil {
2906		invalidParams.Add(smithy.NewErrParamRequired("CoreDefinitionId"))
2907	}
2908	if invalidParams.Len() > 0 {
2909		return invalidParams
2910	} else {
2911		return nil
2912	}
2913}
2914
2915func validateOpDeleteDeviceDefinitionInput(v *DeleteDeviceDefinitionInput) error {
2916	if v == nil {
2917		return nil
2918	}
2919	invalidParams := smithy.InvalidParamsError{Context: "DeleteDeviceDefinitionInput"}
2920	if v.DeviceDefinitionId == nil {
2921		invalidParams.Add(smithy.NewErrParamRequired("DeviceDefinitionId"))
2922	}
2923	if invalidParams.Len() > 0 {
2924		return invalidParams
2925	} else {
2926		return nil
2927	}
2928}
2929
2930func validateOpDeleteFunctionDefinitionInput(v *DeleteFunctionDefinitionInput) error {
2931	if v == nil {
2932		return nil
2933	}
2934	invalidParams := smithy.InvalidParamsError{Context: "DeleteFunctionDefinitionInput"}
2935	if v.FunctionDefinitionId == nil {
2936		invalidParams.Add(smithy.NewErrParamRequired("FunctionDefinitionId"))
2937	}
2938	if invalidParams.Len() > 0 {
2939		return invalidParams
2940	} else {
2941		return nil
2942	}
2943}
2944
2945func validateOpDeleteGroupInput(v *DeleteGroupInput) error {
2946	if v == nil {
2947		return nil
2948	}
2949	invalidParams := smithy.InvalidParamsError{Context: "DeleteGroupInput"}
2950	if v.GroupId == nil {
2951		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
2952	}
2953	if invalidParams.Len() > 0 {
2954		return invalidParams
2955	} else {
2956		return nil
2957	}
2958}
2959
2960func validateOpDeleteLoggerDefinitionInput(v *DeleteLoggerDefinitionInput) error {
2961	if v == nil {
2962		return nil
2963	}
2964	invalidParams := smithy.InvalidParamsError{Context: "DeleteLoggerDefinitionInput"}
2965	if v.LoggerDefinitionId == nil {
2966		invalidParams.Add(smithy.NewErrParamRequired("LoggerDefinitionId"))
2967	}
2968	if invalidParams.Len() > 0 {
2969		return invalidParams
2970	} else {
2971		return nil
2972	}
2973}
2974
2975func validateOpDeleteResourceDefinitionInput(v *DeleteResourceDefinitionInput) error {
2976	if v == nil {
2977		return nil
2978	}
2979	invalidParams := smithy.InvalidParamsError{Context: "DeleteResourceDefinitionInput"}
2980	if v.ResourceDefinitionId == nil {
2981		invalidParams.Add(smithy.NewErrParamRequired("ResourceDefinitionId"))
2982	}
2983	if invalidParams.Len() > 0 {
2984		return invalidParams
2985	} else {
2986		return nil
2987	}
2988}
2989
2990func validateOpDeleteSubscriptionDefinitionInput(v *DeleteSubscriptionDefinitionInput) error {
2991	if v == nil {
2992		return nil
2993	}
2994	invalidParams := smithy.InvalidParamsError{Context: "DeleteSubscriptionDefinitionInput"}
2995	if v.SubscriptionDefinitionId == nil {
2996		invalidParams.Add(smithy.NewErrParamRequired("SubscriptionDefinitionId"))
2997	}
2998	if invalidParams.Len() > 0 {
2999		return invalidParams
3000	} else {
3001		return nil
3002	}
3003}
3004
3005func validateOpDisassociateRoleFromGroupInput(v *DisassociateRoleFromGroupInput) error {
3006	if v == nil {
3007		return nil
3008	}
3009	invalidParams := smithy.InvalidParamsError{Context: "DisassociateRoleFromGroupInput"}
3010	if v.GroupId == nil {
3011		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
3012	}
3013	if invalidParams.Len() > 0 {
3014		return invalidParams
3015	} else {
3016		return nil
3017	}
3018}
3019
3020func validateOpGetAssociatedRoleInput(v *GetAssociatedRoleInput) error {
3021	if v == nil {
3022		return nil
3023	}
3024	invalidParams := smithy.InvalidParamsError{Context: "GetAssociatedRoleInput"}
3025	if v.GroupId == nil {
3026		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
3027	}
3028	if invalidParams.Len() > 0 {
3029		return invalidParams
3030	} else {
3031		return nil
3032	}
3033}
3034
3035func validateOpGetBulkDeploymentStatusInput(v *GetBulkDeploymentStatusInput) error {
3036	if v == nil {
3037		return nil
3038	}
3039	invalidParams := smithy.InvalidParamsError{Context: "GetBulkDeploymentStatusInput"}
3040	if v.BulkDeploymentId == nil {
3041		invalidParams.Add(smithy.NewErrParamRequired("BulkDeploymentId"))
3042	}
3043	if invalidParams.Len() > 0 {
3044		return invalidParams
3045	} else {
3046		return nil
3047	}
3048}
3049
3050func validateOpGetConnectivityInfoInput(v *GetConnectivityInfoInput) error {
3051	if v == nil {
3052		return nil
3053	}
3054	invalidParams := smithy.InvalidParamsError{Context: "GetConnectivityInfoInput"}
3055	if v.ThingName == nil {
3056		invalidParams.Add(smithy.NewErrParamRequired("ThingName"))
3057	}
3058	if invalidParams.Len() > 0 {
3059		return invalidParams
3060	} else {
3061		return nil
3062	}
3063}
3064
3065func validateOpGetConnectorDefinitionInput(v *GetConnectorDefinitionInput) error {
3066	if v == nil {
3067		return nil
3068	}
3069	invalidParams := smithy.InvalidParamsError{Context: "GetConnectorDefinitionInput"}
3070	if v.ConnectorDefinitionId == nil {
3071		invalidParams.Add(smithy.NewErrParamRequired("ConnectorDefinitionId"))
3072	}
3073	if invalidParams.Len() > 0 {
3074		return invalidParams
3075	} else {
3076		return nil
3077	}
3078}
3079
3080func validateOpGetConnectorDefinitionVersionInput(v *GetConnectorDefinitionVersionInput) error {
3081	if v == nil {
3082		return nil
3083	}
3084	invalidParams := smithy.InvalidParamsError{Context: "GetConnectorDefinitionVersionInput"}
3085	if v.ConnectorDefinitionId == nil {
3086		invalidParams.Add(smithy.NewErrParamRequired("ConnectorDefinitionId"))
3087	}
3088	if v.ConnectorDefinitionVersionId == nil {
3089		invalidParams.Add(smithy.NewErrParamRequired("ConnectorDefinitionVersionId"))
3090	}
3091	if invalidParams.Len() > 0 {
3092		return invalidParams
3093	} else {
3094		return nil
3095	}
3096}
3097
3098func validateOpGetCoreDefinitionInput(v *GetCoreDefinitionInput) error {
3099	if v == nil {
3100		return nil
3101	}
3102	invalidParams := smithy.InvalidParamsError{Context: "GetCoreDefinitionInput"}
3103	if v.CoreDefinitionId == nil {
3104		invalidParams.Add(smithy.NewErrParamRequired("CoreDefinitionId"))
3105	}
3106	if invalidParams.Len() > 0 {
3107		return invalidParams
3108	} else {
3109		return nil
3110	}
3111}
3112
3113func validateOpGetCoreDefinitionVersionInput(v *GetCoreDefinitionVersionInput) error {
3114	if v == nil {
3115		return nil
3116	}
3117	invalidParams := smithy.InvalidParamsError{Context: "GetCoreDefinitionVersionInput"}
3118	if v.CoreDefinitionId == nil {
3119		invalidParams.Add(smithy.NewErrParamRequired("CoreDefinitionId"))
3120	}
3121	if v.CoreDefinitionVersionId == nil {
3122		invalidParams.Add(smithy.NewErrParamRequired("CoreDefinitionVersionId"))
3123	}
3124	if invalidParams.Len() > 0 {
3125		return invalidParams
3126	} else {
3127		return nil
3128	}
3129}
3130
3131func validateOpGetDeploymentStatusInput(v *GetDeploymentStatusInput) error {
3132	if v == nil {
3133		return nil
3134	}
3135	invalidParams := smithy.InvalidParamsError{Context: "GetDeploymentStatusInput"}
3136	if v.DeploymentId == nil {
3137		invalidParams.Add(smithy.NewErrParamRequired("DeploymentId"))
3138	}
3139	if v.GroupId == nil {
3140		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
3141	}
3142	if invalidParams.Len() > 0 {
3143		return invalidParams
3144	} else {
3145		return nil
3146	}
3147}
3148
3149func validateOpGetDeviceDefinitionInput(v *GetDeviceDefinitionInput) error {
3150	if v == nil {
3151		return nil
3152	}
3153	invalidParams := smithy.InvalidParamsError{Context: "GetDeviceDefinitionInput"}
3154	if v.DeviceDefinitionId == nil {
3155		invalidParams.Add(smithy.NewErrParamRequired("DeviceDefinitionId"))
3156	}
3157	if invalidParams.Len() > 0 {
3158		return invalidParams
3159	} else {
3160		return nil
3161	}
3162}
3163
3164func validateOpGetDeviceDefinitionVersionInput(v *GetDeviceDefinitionVersionInput) error {
3165	if v == nil {
3166		return nil
3167	}
3168	invalidParams := smithy.InvalidParamsError{Context: "GetDeviceDefinitionVersionInput"}
3169	if v.DeviceDefinitionId == nil {
3170		invalidParams.Add(smithy.NewErrParamRequired("DeviceDefinitionId"))
3171	}
3172	if v.DeviceDefinitionVersionId == nil {
3173		invalidParams.Add(smithy.NewErrParamRequired("DeviceDefinitionVersionId"))
3174	}
3175	if invalidParams.Len() > 0 {
3176		return invalidParams
3177	} else {
3178		return nil
3179	}
3180}
3181
3182func validateOpGetFunctionDefinitionInput(v *GetFunctionDefinitionInput) error {
3183	if v == nil {
3184		return nil
3185	}
3186	invalidParams := smithy.InvalidParamsError{Context: "GetFunctionDefinitionInput"}
3187	if v.FunctionDefinitionId == nil {
3188		invalidParams.Add(smithy.NewErrParamRequired("FunctionDefinitionId"))
3189	}
3190	if invalidParams.Len() > 0 {
3191		return invalidParams
3192	} else {
3193		return nil
3194	}
3195}
3196
3197func validateOpGetFunctionDefinitionVersionInput(v *GetFunctionDefinitionVersionInput) error {
3198	if v == nil {
3199		return nil
3200	}
3201	invalidParams := smithy.InvalidParamsError{Context: "GetFunctionDefinitionVersionInput"}
3202	if v.FunctionDefinitionId == nil {
3203		invalidParams.Add(smithy.NewErrParamRequired("FunctionDefinitionId"))
3204	}
3205	if v.FunctionDefinitionVersionId == nil {
3206		invalidParams.Add(smithy.NewErrParamRequired("FunctionDefinitionVersionId"))
3207	}
3208	if invalidParams.Len() > 0 {
3209		return invalidParams
3210	} else {
3211		return nil
3212	}
3213}
3214
3215func validateOpGetGroupCertificateAuthorityInput(v *GetGroupCertificateAuthorityInput) error {
3216	if v == nil {
3217		return nil
3218	}
3219	invalidParams := smithy.InvalidParamsError{Context: "GetGroupCertificateAuthorityInput"}
3220	if v.CertificateAuthorityId == nil {
3221		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityId"))
3222	}
3223	if v.GroupId == nil {
3224		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
3225	}
3226	if invalidParams.Len() > 0 {
3227		return invalidParams
3228	} else {
3229		return nil
3230	}
3231}
3232
3233func validateOpGetGroupCertificateConfigurationInput(v *GetGroupCertificateConfigurationInput) error {
3234	if v == nil {
3235		return nil
3236	}
3237	invalidParams := smithy.InvalidParamsError{Context: "GetGroupCertificateConfigurationInput"}
3238	if v.GroupId == nil {
3239		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
3240	}
3241	if invalidParams.Len() > 0 {
3242		return invalidParams
3243	} else {
3244		return nil
3245	}
3246}
3247
3248func validateOpGetGroupInput(v *GetGroupInput) error {
3249	if v == nil {
3250		return nil
3251	}
3252	invalidParams := smithy.InvalidParamsError{Context: "GetGroupInput"}
3253	if v.GroupId == nil {
3254		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
3255	}
3256	if invalidParams.Len() > 0 {
3257		return invalidParams
3258	} else {
3259		return nil
3260	}
3261}
3262
3263func validateOpGetGroupVersionInput(v *GetGroupVersionInput) error {
3264	if v == nil {
3265		return nil
3266	}
3267	invalidParams := smithy.InvalidParamsError{Context: "GetGroupVersionInput"}
3268	if v.GroupId == nil {
3269		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
3270	}
3271	if v.GroupVersionId == nil {
3272		invalidParams.Add(smithy.NewErrParamRequired("GroupVersionId"))
3273	}
3274	if invalidParams.Len() > 0 {
3275		return invalidParams
3276	} else {
3277		return nil
3278	}
3279}
3280
3281func validateOpGetLoggerDefinitionInput(v *GetLoggerDefinitionInput) error {
3282	if v == nil {
3283		return nil
3284	}
3285	invalidParams := smithy.InvalidParamsError{Context: "GetLoggerDefinitionInput"}
3286	if v.LoggerDefinitionId == nil {
3287		invalidParams.Add(smithy.NewErrParamRequired("LoggerDefinitionId"))
3288	}
3289	if invalidParams.Len() > 0 {
3290		return invalidParams
3291	} else {
3292		return nil
3293	}
3294}
3295
3296func validateOpGetLoggerDefinitionVersionInput(v *GetLoggerDefinitionVersionInput) error {
3297	if v == nil {
3298		return nil
3299	}
3300	invalidParams := smithy.InvalidParamsError{Context: "GetLoggerDefinitionVersionInput"}
3301	if v.LoggerDefinitionId == nil {
3302		invalidParams.Add(smithy.NewErrParamRequired("LoggerDefinitionId"))
3303	}
3304	if v.LoggerDefinitionVersionId == nil {
3305		invalidParams.Add(smithy.NewErrParamRequired("LoggerDefinitionVersionId"))
3306	}
3307	if invalidParams.Len() > 0 {
3308		return invalidParams
3309	} else {
3310		return nil
3311	}
3312}
3313
3314func validateOpGetResourceDefinitionInput(v *GetResourceDefinitionInput) error {
3315	if v == nil {
3316		return nil
3317	}
3318	invalidParams := smithy.InvalidParamsError{Context: "GetResourceDefinitionInput"}
3319	if v.ResourceDefinitionId == nil {
3320		invalidParams.Add(smithy.NewErrParamRequired("ResourceDefinitionId"))
3321	}
3322	if invalidParams.Len() > 0 {
3323		return invalidParams
3324	} else {
3325		return nil
3326	}
3327}
3328
3329func validateOpGetResourceDefinitionVersionInput(v *GetResourceDefinitionVersionInput) error {
3330	if v == nil {
3331		return nil
3332	}
3333	invalidParams := smithy.InvalidParamsError{Context: "GetResourceDefinitionVersionInput"}
3334	if v.ResourceDefinitionId == nil {
3335		invalidParams.Add(smithy.NewErrParamRequired("ResourceDefinitionId"))
3336	}
3337	if v.ResourceDefinitionVersionId == nil {
3338		invalidParams.Add(smithy.NewErrParamRequired("ResourceDefinitionVersionId"))
3339	}
3340	if invalidParams.Len() > 0 {
3341		return invalidParams
3342	} else {
3343		return nil
3344	}
3345}
3346
3347func validateOpGetSubscriptionDefinitionInput(v *GetSubscriptionDefinitionInput) error {
3348	if v == nil {
3349		return nil
3350	}
3351	invalidParams := smithy.InvalidParamsError{Context: "GetSubscriptionDefinitionInput"}
3352	if v.SubscriptionDefinitionId == nil {
3353		invalidParams.Add(smithy.NewErrParamRequired("SubscriptionDefinitionId"))
3354	}
3355	if invalidParams.Len() > 0 {
3356		return invalidParams
3357	} else {
3358		return nil
3359	}
3360}
3361
3362func validateOpGetSubscriptionDefinitionVersionInput(v *GetSubscriptionDefinitionVersionInput) error {
3363	if v == nil {
3364		return nil
3365	}
3366	invalidParams := smithy.InvalidParamsError{Context: "GetSubscriptionDefinitionVersionInput"}
3367	if v.SubscriptionDefinitionId == nil {
3368		invalidParams.Add(smithy.NewErrParamRequired("SubscriptionDefinitionId"))
3369	}
3370	if v.SubscriptionDefinitionVersionId == nil {
3371		invalidParams.Add(smithy.NewErrParamRequired("SubscriptionDefinitionVersionId"))
3372	}
3373	if invalidParams.Len() > 0 {
3374		return invalidParams
3375	} else {
3376		return nil
3377	}
3378}
3379
3380func validateOpGetThingRuntimeConfigurationInput(v *GetThingRuntimeConfigurationInput) error {
3381	if v == nil {
3382		return nil
3383	}
3384	invalidParams := smithy.InvalidParamsError{Context: "GetThingRuntimeConfigurationInput"}
3385	if v.ThingName == nil {
3386		invalidParams.Add(smithy.NewErrParamRequired("ThingName"))
3387	}
3388	if invalidParams.Len() > 0 {
3389		return invalidParams
3390	} else {
3391		return nil
3392	}
3393}
3394
3395func validateOpListBulkDeploymentDetailedReportsInput(v *ListBulkDeploymentDetailedReportsInput) error {
3396	if v == nil {
3397		return nil
3398	}
3399	invalidParams := smithy.InvalidParamsError{Context: "ListBulkDeploymentDetailedReportsInput"}
3400	if v.BulkDeploymentId == nil {
3401		invalidParams.Add(smithy.NewErrParamRequired("BulkDeploymentId"))
3402	}
3403	if invalidParams.Len() > 0 {
3404		return invalidParams
3405	} else {
3406		return nil
3407	}
3408}
3409
3410func validateOpListConnectorDefinitionVersionsInput(v *ListConnectorDefinitionVersionsInput) error {
3411	if v == nil {
3412		return nil
3413	}
3414	invalidParams := smithy.InvalidParamsError{Context: "ListConnectorDefinitionVersionsInput"}
3415	if v.ConnectorDefinitionId == nil {
3416		invalidParams.Add(smithy.NewErrParamRequired("ConnectorDefinitionId"))
3417	}
3418	if invalidParams.Len() > 0 {
3419		return invalidParams
3420	} else {
3421		return nil
3422	}
3423}
3424
3425func validateOpListCoreDefinitionVersionsInput(v *ListCoreDefinitionVersionsInput) error {
3426	if v == nil {
3427		return nil
3428	}
3429	invalidParams := smithy.InvalidParamsError{Context: "ListCoreDefinitionVersionsInput"}
3430	if v.CoreDefinitionId == nil {
3431		invalidParams.Add(smithy.NewErrParamRequired("CoreDefinitionId"))
3432	}
3433	if invalidParams.Len() > 0 {
3434		return invalidParams
3435	} else {
3436		return nil
3437	}
3438}
3439
3440func validateOpListDeploymentsInput(v *ListDeploymentsInput) error {
3441	if v == nil {
3442		return nil
3443	}
3444	invalidParams := smithy.InvalidParamsError{Context: "ListDeploymentsInput"}
3445	if v.GroupId == nil {
3446		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
3447	}
3448	if invalidParams.Len() > 0 {
3449		return invalidParams
3450	} else {
3451		return nil
3452	}
3453}
3454
3455func validateOpListDeviceDefinitionVersionsInput(v *ListDeviceDefinitionVersionsInput) error {
3456	if v == nil {
3457		return nil
3458	}
3459	invalidParams := smithy.InvalidParamsError{Context: "ListDeviceDefinitionVersionsInput"}
3460	if v.DeviceDefinitionId == nil {
3461		invalidParams.Add(smithy.NewErrParamRequired("DeviceDefinitionId"))
3462	}
3463	if invalidParams.Len() > 0 {
3464		return invalidParams
3465	} else {
3466		return nil
3467	}
3468}
3469
3470func validateOpListFunctionDefinitionVersionsInput(v *ListFunctionDefinitionVersionsInput) error {
3471	if v == nil {
3472		return nil
3473	}
3474	invalidParams := smithy.InvalidParamsError{Context: "ListFunctionDefinitionVersionsInput"}
3475	if v.FunctionDefinitionId == nil {
3476		invalidParams.Add(smithy.NewErrParamRequired("FunctionDefinitionId"))
3477	}
3478	if invalidParams.Len() > 0 {
3479		return invalidParams
3480	} else {
3481		return nil
3482	}
3483}
3484
3485func validateOpListGroupCertificateAuthoritiesInput(v *ListGroupCertificateAuthoritiesInput) error {
3486	if v == nil {
3487		return nil
3488	}
3489	invalidParams := smithy.InvalidParamsError{Context: "ListGroupCertificateAuthoritiesInput"}
3490	if v.GroupId == nil {
3491		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
3492	}
3493	if invalidParams.Len() > 0 {
3494		return invalidParams
3495	} else {
3496		return nil
3497	}
3498}
3499
3500func validateOpListGroupVersionsInput(v *ListGroupVersionsInput) error {
3501	if v == nil {
3502		return nil
3503	}
3504	invalidParams := smithy.InvalidParamsError{Context: "ListGroupVersionsInput"}
3505	if v.GroupId == nil {
3506		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
3507	}
3508	if invalidParams.Len() > 0 {
3509		return invalidParams
3510	} else {
3511		return nil
3512	}
3513}
3514
3515func validateOpListLoggerDefinitionVersionsInput(v *ListLoggerDefinitionVersionsInput) error {
3516	if v == nil {
3517		return nil
3518	}
3519	invalidParams := smithy.InvalidParamsError{Context: "ListLoggerDefinitionVersionsInput"}
3520	if v.LoggerDefinitionId == nil {
3521		invalidParams.Add(smithy.NewErrParamRequired("LoggerDefinitionId"))
3522	}
3523	if invalidParams.Len() > 0 {
3524		return invalidParams
3525	} else {
3526		return nil
3527	}
3528}
3529
3530func validateOpListResourceDefinitionVersionsInput(v *ListResourceDefinitionVersionsInput) error {
3531	if v == nil {
3532		return nil
3533	}
3534	invalidParams := smithy.InvalidParamsError{Context: "ListResourceDefinitionVersionsInput"}
3535	if v.ResourceDefinitionId == nil {
3536		invalidParams.Add(smithy.NewErrParamRequired("ResourceDefinitionId"))
3537	}
3538	if invalidParams.Len() > 0 {
3539		return invalidParams
3540	} else {
3541		return nil
3542	}
3543}
3544
3545func validateOpListSubscriptionDefinitionVersionsInput(v *ListSubscriptionDefinitionVersionsInput) error {
3546	if v == nil {
3547		return nil
3548	}
3549	invalidParams := smithy.InvalidParamsError{Context: "ListSubscriptionDefinitionVersionsInput"}
3550	if v.SubscriptionDefinitionId == nil {
3551		invalidParams.Add(smithy.NewErrParamRequired("SubscriptionDefinitionId"))
3552	}
3553	if invalidParams.Len() > 0 {
3554		return invalidParams
3555	} else {
3556		return nil
3557	}
3558}
3559
3560func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
3561	if v == nil {
3562		return nil
3563	}
3564	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
3565	if v.ResourceArn == nil {
3566		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
3567	}
3568	if invalidParams.Len() > 0 {
3569		return invalidParams
3570	} else {
3571		return nil
3572	}
3573}
3574
3575func validateOpResetDeploymentsInput(v *ResetDeploymentsInput) error {
3576	if v == nil {
3577		return nil
3578	}
3579	invalidParams := smithy.InvalidParamsError{Context: "ResetDeploymentsInput"}
3580	if v.GroupId == nil {
3581		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
3582	}
3583	if invalidParams.Len() > 0 {
3584		return invalidParams
3585	} else {
3586		return nil
3587	}
3588}
3589
3590func validateOpStartBulkDeploymentInput(v *StartBulkDeploymentInput) error {
3591	if v == nil {
3592		return nil
3593	}
3594	invalidParams := smithy.InvalidParamsError{Context: "StartBulkDeploymentInput"}
3595	if v.ExecutionRoleArn == nil {
3596		invalidParams.Add(smithy.NewErrParamRequired("ExecutionRoleArn"))
3597	}
3598	if v.InputFileUri == nil {
3599		invalidParams.Add(smithy.NewErrParamRequired("InputFileUri"))
3600	}
3601	if invalidParams.Len() > 0 {
3602		return invalidParams
3603	} else {
3604		return nil
3605	}
3606}
3607
3608func validateOpStopBulkDeploymentInput(v *StopBulkDeploymentInput) error {
3609	if v == nil {
3610		return nil
3611	}
3612	invalidParams := smithy.InvalidParamsError{Context: "StopBulkDeploymentInput"}
3613	if v.BulkDeploymentId == nil {
3614		invalidParams.Add(smithy.NewErrParamRequired("BulkDeploymentId"))
3615	}
3616	if invalidParams.Len() > 0 {
3617		return invalidParams
3618	} else {
3619		return nil
3620	}
3621}
3622
3623func validateOpTagResourceInput(v *TagResourceInput) error {
3624	if v == nil {
3625		return nil
3626	}
3627	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
3628	if v.ResourceArn == nil {
3629		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
3630	}
3631	if invalidParams.Len() > 0 {
3632		return invalidParams
3633	} else {
3634		return nil
3635	}
3636}
3637
3638func validateOpUntagResourceInput(v *UntagResourceInput) error {
3639	if v == nil {
3640		return nil
3641	}
3642	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
3643	if v.ResourceArn == nil {
3644		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
3645	}
3646	if v.TagKeys == nil {
3647		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
3648	}
3649	if invalidParams.Len() > 0 {
3650		return invalidParams
3651	} else {
3652		return nil
3653	}
3654}
3655
3656func validateOpUpdateConnectivityInfoInput(v *UpdateConnectivityInfoInput) error {
3657	if v == nil {
3658		return nil
3659	}
3660	invalidParams := smithy.InvalidParamsError{Context: "UpdateConnectivityInfoInput"}
3661	if v.ThingName == nil {
3662		invalidParams.Add(smithy.NewErrParamRequired("ThingName"))
3663	}
3664	if invalidParams.Len() > 0 {
3665		return invalidParams
3666	} else {
3667		return nil
3668	}
3669}
3670
3671func validateOpUpdateConnectorDefinitionInput(v *UpdateConnectorDefinitionInput) error {
3672	if v == nil {
3673		return nil
3674	}
3675	invalidParams := smithy.InvalidParamsError{Context: "UpdateConnectorDefinitionInput"}
3676	if v.ConnectorDefinitionId == nil {
3677		invalidParams.Add(smithy.NewErrParamRequired("ConnectorDefinitionId"))
3678	}
3679	if invalidParams.Len() > 0 {
3680		return invalidParams
3681	} else {
3682		return nil
3683	}
3684}
3685
3686func validateOpUpdateCoreDefinitionInput(v *UpdateCoreDefinitionInput) error {
3687	if v == nil {
3688		return nil
3689	}
3690	invalidParams := smithy.InvalidParamsError{Context: "UpdateCoreDefinitionInput"}
3691	if v.CoreDefinitionId == nil {
3692		invalidParams.Add(smithy.NewErrParamRequired("CoreDefinitionId"))
3693	}
3694	if invalidParams.Len() > 0 {
3695		return invalidParams
3696	} else {
3697		return nil
3698	}
3699}
3700
3701func validateOpUpdateDeviceDefinitionInput(v *UpdateDeviceDefinitionInput) error {
3702	if v == nil {
3703		return nil
3704	}
3705	invalidParams := smithy.InvalidParamsError{Context: "UpdateDeviceDefinitionInput"}
3706	if v.DeviceDefinitionId == nil {
3707		invalidParams.Add(smithy.NewErrParamRequired("DeviceDefinitionId"))
3708	}
3709	if invalidParams.Len() > 0 {
3710		return invalidParams
3711	} else {
3712		return nil
3713	}
3714}
3715
3716func validateOpUpdateFunctionDefinitionInput(v *UpdateFunctionDefinitionInput) error {
3717	if v == nil {
3718		return nil
3719	}
3720	invalidParams := smithy.InvalidParamsError{Context: "UpdateFunctionDefinitionInput"}
3721	if v.FunctionDefinitionId == nil {
3722		invalidParams.Add(smithy.NewErrParamRequired("FunctionDefinitionId"))
3723	}
3724	if invalidParams.Len() > 0 {
3725		return invalidParams
3726	} else {
3727		return nil
3728	}
3729}
3730
3731func validateOpUpdateGroupCertificateConfigurationInput(v *UpdateGroupCertificateConfigurationInput) error {
3732	if v == nil {
3733		return nil
3734	}
3735	invalidParams := smithy.InvalidParamsError{Context: "UpdateGroupCertificateConfigurationInput"}
3736	if v.GroupId == nil {
3737		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
3738	}
3739	if invalidParams.Len() > 0 {
3740		return invalidParams
3741	} else {
3742		return nil
3743	}
3744}
3745
3746func validateOpUpdateGroupInput(v *UpdateGroupInput) error {
3747	if v == nil {
3748		return nil
3749	}
3750	invalidParams := smithy.InvalidParamsError{Context: "UpdateGroupInput"}
3751	if v.GroupId == nil {
3752		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
3753	}
3754	if invalidParams.Len() > 0 {
3755		return invalidParams
3756	} else {
3757		return nil
3758	}
3759}
3760
3761func validateOpUpdateLoggerDefinitionInput(v *UpdateLoggerDefinitionInput) error {
3762	if v == nil {
3763		return nil
3764	}
3765	invalidParams := smithy.InvalidParamsError{Context: "UpdateLoggerDefinitionInput"}
3766	if v.LoggerDefinitionId == nil {
3767		invalidParams.Add(smithy.NewErrParamRequired("LoggerDefinitionId"))
3768	}
3769	if invalidParams.Len() > 0 {
3770		return invalidParams
3771	} else {
3772		return nil
3773	}
3774}
3775
3776func validateOpUpdateResourceDefinitionInput(v *UpdateResourceDefinitionInput) error {
3777	if v == nil {
3778		return nil
3779	}
3780	invalidParams := smithy.InvalidParamsError{Context: "UpdateResourceDefinitionInput"}
3781	if v.ResourceDefinitionId == nil {
3782		invalidParams.Add(smithy.NewErrParamRequired("ResourceDefinitionId"))
3783	}
3784	if invalidParams.Len() > 0 {
3785		return invalidParams
3786	} else {
3787		return nil
3788	}
3789}
3790
3791func validateOpUpdateSubscriptionDefinitionInput(v *UpdateSubscriptionDefinitionInput) error {
3792	if v == nil {
3793		return nil
3794	}
3795	invalidParams := smithy.InvalidParamsError{Context: "UpdateSubscriptionDefinitionInput"}
3796	if v.SubscriptionDefinitionId == nil {
3797		invalidParams.Add(smithy.NewErrParamRequired("SubscriptionDefinitionId"))
3798	}
3799	if invalidParams.Len() > 0 {
3800		return invalidParams
3801	} else {
3802		return nil
3803	}
3804}
3805
3806func validateOpUpdateThingRuntimeConfigurationInput(v *UpdateThingRuntimeConfigurationInput) error {
3807	if v == nil {
3808		return nil
3809	}
3810	invalidParams := smithy.InvalidParamsError{Context: "UpdateThingRuntimeConfigurationInput"}
3811	if v.TelemetryConfiguration != nil {
3812		if err := validateTelemetryConfigurationUpdate(v.TelemetryConfiguration); err != nil {
3813			invalidParams.AddNested("TelemetryConfiguration", err.(smithy.InvalidParamsError))
3814		}
3815	}
3816	if v.ThingName == nil {
3817		invalidParams.Add(smithy.NewErrParamRequired("ThingName"))
3818	}
3819	if invalidParams.Len() > 0 {
3820		return invalidParams
3821	} else {
3822		return nil
3823	}
3824}
3825