1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package iotsitewise
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/iotsitewise/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpAssociateAssets struct {
14}
15
16func (*validateOpAssociateAssets) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpAssociateAssets) 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.(*AssociateAssetsInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpAssociateAssetsInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpBatchAssociateProjectAssets struct {
34}
35
36func (*validateOpBatchAssociateProjectAssets) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpBatchAssociateProjectAssets) 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.(*BatchAssociateProjectAssetsInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpBatchAssociateProjectAssetsInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpBatchDisassociateProjectAssets struct {
54}
55
56func (*validateOpBatchDisassociateProjectAssets) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpBatchDisassociateProjectAssets) 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.(*BatchDisassociateProjectAssetsInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpBatchDisassociateProjectAssetsInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpBatchPutAssetPropertyValue struct {
74}
75
76func (*validateOpBatchPutAssetPropertyValue) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpBatchPutAssetPropertyValue) 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.(*BatchPutAssetPropertyValueInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpBatchPutAssetPropertyValueInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpCreateAccessPolicy struct {
94}
95
96func (*validateOpCreateAccessPolicy) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpCreateAccessPolicy) 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.(*CreateAccessPolicyInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpCreateAccessPolicyInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpCreateAsset struct {
114}
115
116func (*validateOpCreateAsset) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpCreateAsset) 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.(*CreateAssetInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpCreateAssetInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpCreateAssetModel struct {
134}
135
136func (*validateOpCreateAssetModel) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpCreateAssetModel) 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.(*CreateAssetModelInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpCreateAssetModelInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpCreateDashboard struct {
154}
155
156func (*validateOpCreateDashboard) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpCreateDashboard) 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.(*CreateDashboardInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpCreateDashboardInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpCreateGateway struct {
174}
175
176func (*validateOpCreateGateway) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpCreateGateway) 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.(*CreateGatewayInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpCreateGatewayInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpCreatePortal struct {
194}
195
196func (*validateOpCreatePortal) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpCreatePortal) 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.(*CreatePortalInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpCreatePortalInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpCreateProject struct {
214}
215
216func (*validateOpCreateProject) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpCreateProject) 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.(*CreateProjectInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpCreateProjectInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpDeleteAccessPolicy struct {
234}
235
236func (*validateOpDeleteAccessPolicy) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpDeleteAccessPolicy) 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.(*DeleteAccessPolicyInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpDeleteAccessPolicyInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpDeleteAsset struct {
254}
255
256func (*validateOpDeleteAsset) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpDeleteAsset) 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.(*DeleteAssetInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpDeleteAssetInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpDeleteAssetModel struct {
274}
275
276func (*validateOpDeleteAssetModel) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpDeleteAssetModel) 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.(*DeleteAssetModelInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpDeleteAssetModelInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpDeleteDashboard struct {
294}
295
296func (*validateOpDeleteDashboard) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpDeleteDashboard) 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.(*DeleteDashboardInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpDeleteDashboardInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpDeleteGateway struct {
314}
315
316func (*validateOpDeleteGateway) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpDeleteGateway) 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.(*DeleteGatewayInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpDeleteGatewayInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpDeletePortal struct {
334}
335
336func (*validateOpDeletePortal) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpDeletePortal) 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.(*DeletePortalInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpDeletePortalInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpDeleteProject struct {
354}
355
356func (*validateOpDeleteProject) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpDeleteProject) 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.(*DeleteProjectInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpDeleteProjectInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpDescribeAccessPolicy struct {
374}
375
376func (*validateOpDescribeAccessPolicy) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpDescribeAccessPolicy) 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.(*DescribeAccessPolicyInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpDescribeAccessPolicyInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpDescribeAsset struct {
394}
395
396func (*validateOpDescribeAsset) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpDescribeAsset) 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.(*DescribeAssetInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpDescribeAssetInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpDescribeAssetModel struct {
414}
415
416func (*validateOpDescribeAssetModel) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpDescribeAssetModel) 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.(*DescribeAssetModelInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpDescribeAssetModelInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpDescribeAssetProperty struct {
434}
435
436func (*validateOpDescribeAssetProperty) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpDescribeAssetProperty) 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.(*DescribeAssetPropertyInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpDescribeAssetPropertyInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpDescribeDashboard struct {
454}
455
456func (*validateOpDescribeDashboard) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpDescribeDashboard) 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.(*DescribeDashboardInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpDescribeDashboardInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpDescribeGatewayCapabilityConfiguration struct {
474}
475
476func (*validateOpDescribeGatewayCapabilityConfiguration) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpDescribeGatewayCapabilityConfiguration) 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.(*DescribeGatewayCapabilityConfigurationInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpDescribeGatewayCapabilityConfigurationInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpDescribeGateway struct {
494}
495
496func (*validateOpDescribeGateway) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpDescribeGateway) 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.(*DescribeGatewayInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpDescribeGatewayInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpDescribePortal struct {
514}
515
516func (*validateOpDescribePortal) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpDescribePortal) 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.(*DescribePortalInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpDescribePortalInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpDescribeProject struct {
534}
535
536func (*validateOpDescribeProject) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpDescribeProject) 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.(*DescribeProjectInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpDescribeProjectInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpDisassociateAssets struct {
554}
555
556func (*validateOpDisassociateAssets) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpDisassociateAssets) 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.(*DisassociateAssetsInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpDisassociateAssetsInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpGetAssetPropertyAggregates struct {
574}
575
576func (*validateOpGetAssetPropertyAggregates) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpGetAssetPropertyAggregates) 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.(*GetAssetPropertyAggregatesInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpGetAssetPropertyAggregatesInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpListAssetRelationships struct {
594}
595
596func (*validateOpListAssetRelationships) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpListAssetRelationships) 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.(*ListAssetRelationshipsInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpListAssetRelationshipsInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpListAssociatedAssets struct {
614}
615
616func (*validateOpListAssociatedAssets) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpListAssociatedAssets) 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.(*ListAssociatedAssetsInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpListAssociatedAssetsInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpListDashboards struct {
634}
635
636func (*validateOpListDashboards) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpListDashboards) 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.(*ListDashboardsInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpListDashboardsInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653type validateOpListProjectAssets struct {
654}
655
656func (*validateOpListProjectAssets) ID() string {
657	return "OperationInputValidation"
658}
659
660func (m *validateOpListProjectAssets) 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.(*ListProjectAssetsInput)
664	if !ok {
665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666	}
667	if err := validateOpListProjectAssetsInput(input); err != nil {
668		return out, metadata, err
669	}
670	return next.HandleInitialize(ctx, in)
671}
672
673type validateOpListProjects struct {
674}
675
676func (*validateOpListProjects) ID() string {
677	return "OperationInputValidation"
678}
679
680func (m *validateOpListProjects) 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.(*ListProjectsInput)
684	if !ok {
685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
686	}
687	if err := validateOpListProjectsInput(input); err != nil {
688		return out, metadata, err
689	}
690	return next.HandleInitialize(ctx, in)
691}
692
693type validateOpListTagsForResource struct {
694}
695
696func (*validateOpListTagsForResource) ID() string {
697	return "OperationInputValidation"
698}
699
700func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput)
704	if !ok {
705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
706	}
707	if err := validateOpListTagsForResourceInput(input); err != nil {
708		return out, metadata, err
709	}
710	return next.HandleInitialize(ctx, in)
711}
712
713type validateOpPutDefaultEncryptionConfiguration struct {
714}
715
716func (*validateOpPutDefaultEncryptionConfiguration) ID() string {
717	return "OperationInputValidation"
718}
719
720func (m *validateOpPutDefaultEncryptionConfiguration) 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.(*PutDefaultEncryptionConfigurationInput)
724	if !ok {
725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
726	}
727	if err := validateOpPutDefaultEncryptionConfigurationInput(input); err != nil {
728		return out, metadata, err
729	}
730	return next.HandleInitialize(ctx, in)
731}
732
733type validateOpPutLoggingOptions struct {
734}
735
736func (*validateOpPutLoggingOptions) ID() string {
737	return "OperationInputValidation"
738}
739
740func (m *validateOpPutLoggingOptions) 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.(*PutLoggingOptionsInput)
744	if !ok {
745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
746	}
747	if err := validateOpPutLoggingOptionsInput(input); err != nil {
748		return out, metadata, err
749	}
750	return next.HandleInitialize(ctx, in)
751}
752
753type validateOpTagResource struct {
754}
755
756func (*validateOpTagResource) ID() string {
757	return "OperationInputValidation"
758}
759
760func (m *validateOpTagResource) 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.(*TagResourceInput)
764	if !ok {
765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
766	}
767	if err := validateOpTagResourceInput(input); err != nil {
768		return out, metadata, err
769	}
770	return next.HandleInitialize(ctx, in)
771}
772
773type validateOpUntagResource struct {
774}
775
776func (*validateOpUntagResource) ID() string {
777	return "OperationInputValidation"
778}
779
780func (m *validateOpUntagResource) 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.(*UntagResourceInput)
784	if !ok {
785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
786	}
787	if err := validateOpUntagResourceInput(input); err != nil {
788		return out, metadata, err
789	}
790	return next.HandleInitialize(ctx, in)
791}
792
793type validateOpUpdateAccessPolicy struct {
794}
795
796func (*validateOpUpdateAccessPolicy) ID() string {
797	return "OperationInputValidation"
798}
799
800func (m *validateOpUpdateAccessPolicy) 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.(*UpdateAccessPolicyInput)
804	if !ok {
805		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
806	}
807	if err := validateOpUpdateAccessPolicyInput(input); err != nil {
808		return out, metadata, err
809	}
810	return next.HandleInitialize(ctx, in)
811}
812
813type validateOpUpdateAsset struct {
814}
815
816func (*validateOpUpdateAsset) ID() string {
817	return "OperationInputValidation"
818}
819
820func (m *validateOpUpdateAsset) 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.(*UpdateAssetInput)
824	if !ok {
825		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
826	}
827	if err := validateOpUpdateAssetInput(input); err != nil {
828		return out, metadata, err
829	}
830	return next.HandleInitialize(ctx, in)
831}
832
833type validateOpUpdateAssetModel struct {
834}
835
836func (*validateOpUpdateAssetModel) ID() string {
837	return "OperationInputValidation"
838}
839
840func (m *validateOpUpdateAssetModel) 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.(*UpdateAssetModelInput)
844	if !ok {
845		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
846	}
847	if err := validateOpUpdateAssetModelInput(input); err != nil {
848		return out, metadata, err
849	}
850	return next.HandleInitialize(ctx, in)
851}
852
853type validateOpUpdateAssetProperty struct {
854}
855
856func (*validateOpUpdateAssetProperty) ID() string {
857	return "OperationInputValidation"
858}
859
860func (m *validateOpUpdateAssetProperty) 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.(*UpdateAssetPropertyInput)
864	if !ok {
865		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
866	}
867	if err := validateOpUpdateAssetPropertyInput(input); err != nil {
868		return out, metadata, err
869	}
870	return next.HandleInitialize(ctx, in)
871}
872
873type validateOpUpdateDashboard struct {
874}
875
876func (*validateOpUpdateDashboard) ID() string {
877	return "OperationInputValidation"
878}
879
880func (m *validateOpUpdateDashboard) 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.(*UpdateDashboardInput)
884	if !ok {
885		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
886	}
887	if err := validateOpUpdateDashboardInput(input); err != nil {
888		return out, metadata, err
889	}
890	return next.HandleInitialize(ctx, in)
891}
892
893type validateOpUpdateGatewayCapabilityConfiguration struct {
894}
895
896func (*validateOpUpdateGatewayCapabilityConfiguration) ID() string {
897	return "OperationInputValidation"
898}
899
900func (m *validateOpUpdateGatewayCapabilityConfiguration) 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.(*UpdateGatewayCapabilityConfigurationInput)
904	if !ok {
905		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
906	}
907	if err := validateOpUpdateGatewayCapabilityConfigurationInput(input); err != nil {
908		return out, metadata, err
909	}
910	return next.HandleInitialize(ctx, in)
911}
912
913type validateOpUpdateGateway struct {
914}
915
916func (*validateOpUpdateGateway) ID() string {
917	return "OperationInputValidation"
918}
919
920func (m *validateOpUpdateGateway) 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.(*UpdateGatewayInput)
924	if !ok {
925		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
926	}
927	if err := validateOpUpdateGatewayInput(input); err != nil {
928		return out, metadata, err
929	}
930	return next.HandleInitialize(ctx, in)
931}
932
933type validateOpUpdatePortal struct {
934}
935
936func (*validateOpUpdatePortal) ID() string {
937	return "OperationInputValidation"
938}
939
940func (m *validateOpUpdatePortal) 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.(*UpdatePortalInput)
944	if !ok {
945		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
946	}
947	if err := validateOpUpdatePortalInput(input); err != nil {
948		return out, metadata, err
949	}
950	return next.HandleInitialize(ctx, in)
951}
952
953type validateOpUpdateProject struct {
954}
955
956func (*validateOpUpdateProject) ID() string {
957	return "OperationInputValidation"
958}
959
960func (m *validateOpUpdateProject) 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.(*UpdateProjectInput)
964	if !ok {
965		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
966	}
967	if err := validateOpUpdateProjectInput(input); err != nil {
968		return out, metadata, err
969	}
970	return next.HandleInitialize(ctx, in)
971}
972
973func addOpAssociateAssetsValidationMiddleware(stack *middleware.Stack) error {
974	return stack.Initialize.Add(&validateOpAssociateAssets{}, middleware.After)
975}
976
977func addOpBatchAssociateProjectAssetsValidationMiddleware(stack *middleware.Stack) error {
978	return stack.Initialize.Add(&validateOpBatchAssociateProjectAssets{}, middleware.After)
979}
980
981func addOpBatchDisassociateProjectAssetsValidationMiddleware(stack *middleware.Stack) error {
982	return stack.Initialize.Add(&validateOpBatchDisassociateProjectAssets{}, middleware.After)
983}
984
985func addOpBatchPutAssetPropertyValueValidationMiddleware(stack *middleware.Stack) error {
986	return stack.Initialize.Add(&validateOpBatchPutAssetPropertyValue{}, middleware.After)
987}
988
989func addOpCreateAccessPolicyValidationMiddleware(stack *middleware.Stack) error {
990	return stack.Initialize.Add(&validateOpCreateAccessPolicy{}, middleware.After)
991}
992
993func addOpCreateAssetValidationMiddleware(stack *middleware.Stack) error {
994	return stack.Initialize.Add(&validateOpCreateAsset{}, middleware.After)
995}
996
997func addOpCreateAssetModelValidationMiddleware(stack *middleware.Stack) error {
998	return stack.Initialize.Add(&validateOpCreateAssetModel{}, middleware.After)
999}
1000
1001func addOpCreateDashboardValidationMiddleware(stack *middleware.Stack) error {
1002	return stack.Initialize.Add(&validateOpCreateDashboard{}, middleware.After)
1003}
1004
1005func addOpCreateGatewayValidationMiddleware(stack *middleware.Stack) error {
1006	return stack.Initialize.Add(&validateOpCreateGateway{}, middleware.After)
1007}
1008
1009func addOpCreatePortalValidationMiddleware(stack *middleware.Stack) error {
1010	return stack.Initialize.Add(&validateOpCreatePortal{}, middleware.After)
1011}
1012
1013func addOpCreateProjectValidationMiddleware(stack *middleware.Stack) error {
1014	return stack.Initialize.Add(&validateOpCreateProject{}, middleware.After)
1015}
1016
1017func addOpDeleteAccessPolicyValidationMiddleware(stack *middleware.Stack) error {
1018	return stack.Initialize.Add(&validateOpDeleteAccessPolicy{}, middleware.After)
1019}
1020
1021func addOpDeleteAssetValidationMiddleware(stack *middleware.Stack) error {
1022	return stack.Initialize.Add(&validateOpDeleteAsset{}, middleware.After)
1023}
1024
1025func addOpDeleteAssetModelValidationMiddleware(stack *middleware.Stack) error {
1026	return stack.Initialize.Add(&validateOpDeleteAssetModel{}, middleware.After)
1027}
1028
1029func addOpDeleteDashboardValidationMiddleware(stack *middleware.Stack) error {
1030	return stack.Initialize.Add(&validateOpDeleteDashboard{}, middleware.After)
1031}
1032
1033func addOpDeleteGatewayValidationMiddleware(stack *middleware.Stack) error {
1034	return stack.Initialize.Add(&validateOpDeleteGateway{}, middleware.After)
1035}
1036
1037func addOpDeletePortalValidationMiddleware(stack *middleware.Stack) error {
1038	return stack.Initialize.Add(&validateOpDeletePortal{}, middleware.After)
1039}
1040
1041func addOpDeleteProjectValidationMiddleware(stack *middleware.Stack) error {
1042	return stack.Initialize.Add(&validateOpDeleteProject{}, middleware.After)
1043}
1044
1045func addOpDescribeAccessPolicyValidationMiddleware(stack *middleware.Stack) error {
1046	return stack.Initialize.Add(&validateOpDescribeAccessPolicy{}, middleware.After)
1047}
1048
1049func addOpDescribeAssetValidationMiddleware(stack *middleware.Stack) error {
1050	return stack.Initialize.Add(&validateOpDescribeAsset{}, middleware.After)
1051}
1052
1053func addOpDescribeAssetModelValidationMiddleware(stack *middleware.Stack) error {
1054	return stack.Initialize.Add(&validateOpDescribeAssetModel{}, middleware.After)
1055}
1056
1057func addOpDescribeAssetPropertyValidationMiddleware(stack *middleware.Stack) error {
1058	return stack.Initialize.Add(&validateOpDescribeAssetProperty{}, middleware.After)
1059}
1060
1061func addOpDescribeDashboardValidationMiddleware(stack *middleware.Stack) error {
1062	return stack.Initialize.Add(&validateOpDescribeDashboard{}, middleware.After)
1063}
1064
1065func addOpDescribeGatewayCapabilityConfigurationValidationMiddleware(stack *middleware.Stack) error {
1066	return stack.Initialize.Add(&validateOpDescribeGatewayCapabilityConfiguration{}, middleware.After)
1067}
1068
1069func addOpDescribeGatewayValidationMiddleware(stack *middleware.Stack) error {
1070	return stack.Initialize.Add(&validateOpDescribeGateway{}, middleware.After)
1071}
1072
1073func addOpDescribePortalValidationMiddleware(stack *middleware.Stack) error {
1074	return stack.Initialize.Add(&validateOpDescribePortal{}, middleware.After)
1075}
1076
1077func addOpDescribeProjectValidationMiddleware(stack *middleware.Stack) error {
1078	return stack.Initialize.Add(&validateOpDescribeProject{}, middleware.After)
1079}
1080
1081func addOpDisassociateAssetsValidationMiddleware(stack *middleware.Stack) error {
1082	return stack.Initialize.Add(&validateOpDisassociateAssets{}, middleware.After)
1083}
1084
1085func addOpGetAssetPropertyAggregatesValidationMiddleware(stack *middleware.Stack) error {
1086	return stack.Initialize.Add(&validateOpGetAssetPropertyAggregates{}, middleware.After)
1087}
1088
1089func addOpListAssetRelationshipsValidationMiddleware(stack *middleware.Stack) error {
1090	return stack.Initialize.Add(&validateOpListAssetRelationships{}, middleware.After)
1091}
1092
1093func addOpListAssociatedAssetsValidationMiddleware(stack *middleware.Stack) error {
1094	return stack.Initialize.Add(&validateOpListAssociatedAssets{}, middleware.After)
1095}
1096
1097func addOpListDashboardsValidationMiddleware(stack *middleware.Stack) error {
1098	return stack.Initialize.Add(&validateOpListDashboards{}, middleware.After)
1099}
1100
1101func addOpListProjectAssetsValidationMiddleware(stack *middleware.Stack) error {
1102	return stack.Initialize.Add(&validateOpListProjectAssets{}, middleware.After)
1103}
1104
1105func addOpListProjectsValidationMiddleware(stack *middleware.Stack) error {
1106	return stack.Initialize.Add(&validateOpListProjects{}, middleware.After)
1107}
1108
1109func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
1110	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
1111}
1112
1113func addOpPutDefaultEncryptionConfigurationValidationMiddleware(stack *middleware.Stack) error {
1114	return stack.Initialize.Add(&validateOpPutDefaultEncryptionConfiguration{}, middleware.After)
1115}
1116
1117func addOpPutLoggingOptionsValidationMiddleware(stack *middleware.Stack) error {
1118	return stack.Initialize.Add(&validateOpPutLoggingOptions{}, middleware.After)
1119}
1120
1121func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
1122	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
1123}
1124
1125func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
1126	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
1127}
1128
1129func addOpUpdateAccessPolicyValidationMiddleware(stack *middleware.Stack) error {
1130	return stack.Initialize.Add(&validateOpUpdateAccessPolicy{}, middleware.After)
1131}
1132
1133func addOpUpdateAssetValidationMiddleware(stack *middleware.Stack) error {
1134	return stack.Initialize.Add(&validateOpUpdateAsset{}, middleware.After)
1135}
1136
1137func addOpUpdateAssetModelValidationMiddleware(stack *middleware.Stack) error {
1138	return stack.Initialize.Add(&validateOpUpdateAssetModel{}, middleware.After)
1139}
1140
1141func addOpUpdateAssetPropertyValidationMiddleware(stack *middleware.Stack) error {
1142	return stack.Initialize.Add(&validateOpUpdateAssetProperty{}, middleware.After)
1143}
1144
1145func addOpUpdateDashboardValidationMiddleware(stack *middleware.Stack) error {
1146	return stack.Initialize.Add(&validateOpUpdateDashboard{}, middleware.After)
1147}
1148
1149func addOpUpdateGatewayCapabilityConfigurationValidationMiddleware(stack *middleware.Stack) error {
1150	return stack.Initialize.Add(&validateOpUpdateGatewayCapabilityConfiguration{}, middleware.After)
1151}
1152
1153func addOpUpdateGatewayValidationMiddleware(stack *middleware.Stack) error {
1154	return stack.Initialize.Add(&validateOpUpdateGateway{}, middleware.After)
1155}
1156
1157func addOpUpdatePortalValidationMiddleware(stack *middleware.Stack) error {
1158	return stack.Initialize.Add(&validateOpUpdatePortal{}, middleware.After)
1159}
1160
1161func addOpUpdateProjectValidationMiddleware(stack *middleware.Stack) error {
1162	return stack.Initialize.Add(&validateOpUpdateProject{}, middleware.After)
1163}
1164
1165func validateAssetModelCompositeModel(v *types.AssetModelCompositeModel) error {
1166	if v == nil {
1167		return nil
1168	}
1169	invalidParams := smithy.InvalidParamsError{Context: "AssetModelCompositeModel"}
1170	if v.Name == nil {
1171		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1172	}
1173	if v.Type == nil {
1174		invalidParams.Add(smithy.NewErrParamRequired("Type"))
1175	}
1176	if v.Properties != nil {
1177		if err := validateAssetModelProperties(v.Properties); err != nil {
1178			invalidParams.AddNested("Properties", err.(smithy.InvalidParamsError))
1179		}
1180	}
1181	if invalidParams.Len() > 0 {
1182		return invalidParams
1183	} else {
1184		return nil
1185	}
1186}
1187
1188func validateAssetModelCompositeModelDefinition(v *types.AssetModelCompositeModelDefinition) error {
1189	if v == nil {
1190		return nil
1191	}
1192	invalidParams := smithy.InvalidParamsError{Context: "AssetModelCompositeModelDefinition"}
1193	if v.Name == nil {
1194		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1195	}
1196	if v.Type == nil {
1197		invalidParams.Add(smithy.NewErrParamRequired("Type"))
1198	}
1199	if v.Properties != nil {
1200		if err := validateAssetModelPropertyDefinitions(v.Properties); err != nil {
1201			invalidParams.AddNested("Properties", err.(smithy.InvalidParamsError))
1202		}
1203	}
1204	if invalidParams.Len() > 0 {
1205		return invalidParams
1206	} else {
1207		return nil
1208	}
1209}
1210
1211func validateAssetModelCompositeModelDefinitions(v []types.AssetModelCompositeModelDefinition) error {
1212	if v == nil {
1213		return nil
1214	}
1215	invalidParams := smithy.InvalidParamsError{Context: "AssetModelCompositeModelDefinitions"}
1216	for i := range v {
1217		if err := validateAssetModelCompositeModelDefinition(&v[i]); err != nil {
1218			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1219		}
1220	}
1221	if invalidParams.Len() > 0 {
1222		return invalidParams
1223	} else {
1224		return nil
1225	}
1226}
1227
1228func validateAssetModelCompositeModels(v []types.AssetModelCompositeModel) error {
1229	if v == nil {
1230		return nil
1231	}
1232	invalidParams := smithy.InvalidParamsError{Context: "AssetModelCompositeModels"}
1233	for i := range v {
1234		if err := validateAssetModelCompositeModel(&v[i]); err != nil {
1235			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1236		}
1237	}
1238	if invalidParams.Len() > 0 {
1239		return invalidParams
1240	} else {
1241		return nil
1242	}
1243}
1244
1245func validateAssetModelHierarchies(v []types.AssetModelHierarchy) error {
1246	if v == nil {
1247		return nil
1248	}
1249	invalidParams := smithy.InvalidParamsError{Context: "AssetModelHierarchies"}
1250	for i := range v {
1251		if err := validateAssetModelHierarchy(&v[i]); err != nil {
1252			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1253		}
1254	}
1255	if invalidParams.Len() > 0 {
1256		return invalidParams
1257	} else {
1258		return nil
1259	}
1260}
1261
1262func validateAssetModelHierarchy(v *types.AssetModelHierarchy) error {
1263	if v == nil {
1264		return nil
1265	}
1266	invalidParams := smithy.InvalidParamsError{Context: "AssetModelHierarchy"}
1267	if v.Name == nil {
1268		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1269	}
1270	if v.ChildAssetModelId == nil {
1271		invalidParams.Add(smithy.NewErrParamRequired("ChildAssetModelId"))
1272	}
1273	if invalidParams.Len() > 0 {
1274		return invalidParams
1275	} else {
1276		return nil
1277	}
1278}
1279
1280func validateAssetModelHierarchyDefinition(v *types.AssetModelHierarchyDefinition) error {
1281	if v == nil {
1282		return nil
1283	}
1284	invalidParams := smithy.InvalidParamsError{Context: "AssetModelHierarchyDefinition"}
1285	if v.Name == nil {
1286		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1287	}
1288	if v.ChildAssetModelId == nil {
1289		invalidParams.Add(smithy.NewErrParamRequired("ChildAssetModelId"))
1290	}
1291	if invalidParams.Len() > 0 {
1292		return invalidParams
1293	} else {
1294		return nil
1295	}
1296}
1297
1298func validateAssetModelHierarchyDefinitions(v []types.AssetModelHierarchyDefinition) error {
1299	if v == nil {
1300		return nil
1301	}
1302	invalidParams := smithy.InvalidParamsError{Context: "AssetModelHierarchyDefinitions"}
1303	for i := range v {
1304		if err := validateAssetModelHierarchyDefinition(&v[i]); err != nil {
1305			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1306		}
1307	}
1308	if invalidParams.Len() > 0 {
1309		return invalidParams
1310	} else {
1311		return nil
1312	}
1313}
1314
1315func validateAssetModelProperties(v []types.AssetModelProperty) error {
1316	if v == nil {
1317		return nil
1318	}
1319	invalidParams := smithy.InvalidParamsError{Context: "AssetModelProperties"}
1320	for i := range v {
1321		if err := validateAssetModelProperty(&v[i]); err != nil {
1322			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1323		}
1324	}
1325	if invalidParams.Len() > 0 {
1326		return invalidParams
1327	} else {
1328		return nil
1329	}
1330}
1331
1332func validateAssetModelProperty(v *types.AssetModelProperty) error {
1333	if v == nil {
1334		return nil
1335	}
1336	invalidParams := smithy.InvalidParamsError{Context: "AssetModelProperty"}
1337	if v.Name == nil {
1338		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1339	}
1340	if len(v.DataType) == 0 {
1341		invalidParams.Add(smithy.NewErrParamRequired("DataType"))
1342	}
1343	if v.Type == nil {
1344		invalidParams.Add(smithy.NewErrParamRequired("Type"))
1345	} else if v.Type != nil {
1346		if err := validatePropertyType(v.Type); err != nil {
1347			invalidParams.AddNested("Type", err.(smithy.InvalidParamsError))
1348		}
1349	}
1350	if invalidParams.Len() > 0 {
1351		return invalidParams
1352	} else {
1353		return nil
1354	}
1355}
1356
1357func validateAssetModelPropertyDefinition(v *types.AssetModelPropertyDefinition) error {
1358	if v == nil {
1359		return nil
1360	}
1361	invalidParams := smithy.InvalidParamsError{Context: "AssetModelPropertyDefinition"}
1362	if v.Name == nil {
1363		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1364	}
1365	if len(v.DataType) == 0 {
1366		invalidParams.Add(smithy.NewErrParamRequired("DataType"))
1367	}
1368	if v.Type == nil {
1369		invalidParams.Add(smithy.NewErrParamRequired("Type"))
1370	} else if v.Type != nil {
1371		if err := validatePropertyType(v.Type); err != nil {
1372			invalidParams.AddNested("Type", err.(smithy.InvalidParamsError))
1373		}
1374	}
1375	if invalidParams.Len() > 0 {
1376		return invalidParams
1377	} else {
1378		return nil
1379	}
1380}
1381
1382func validateAssetModelPropertyDefinitions(v []types.AssetModelPropertyDefinition) error {
1383	if v == nil {
1384		return nil
1385	}
1386	invalidParams := smithy.InvalidParamsError{Context: "AssetModelPropertyDefinitions"}
1387	for i := range v {
1388		if err := validateAssetModelPropertyDefinition(&v[i]); err != nil {
1389			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1390		}
1391	}
1392	if invalidParams.Len() > 0 {
1393		return invalidParams
1394	} else {
1395		return nil
1396	}
1397}
1398
1399func validateAssetPropertyValue(v *types.AssetPropertyValue) error {
1400	if v == nil {
1401		return nil
1402	}
1403	invalidParams := smithy.InvalidParamsError{Context: "AssetPropertyValue"}
1404	if v.Value == nil {
1405		invalidParams.Add(smithy.NewErrParamRequired("Value"))
1406	}
1407	if v.Timestamp == nil {
1408		invalidParams.Add(smithy.NewErrParamRequired("Timestamp"))
1409	} else if v.Timestamp != nil {
1410		if err := validateTimeInNanos(v.Timestamp); err != nil {
1411			invalidParams.AddNested("Timestamp", err.(smithy.InvalidParamsError))
1412		}
1413	}
1414	if invalidParams.Len() > 0 {
1415		return invalidParams
1416	} else {
1417		return nil
1418	}
1419}
1420
1421func validateAssetPropertyValues(v []types.AssetPropertyValue) error {
1422	if v == nil {
1423		return nil
1424	}
1425	invalidParams := smithy.InvalidParamsError{Context: "AssetPropertyValues"}
1426	for i := range v {
1427		if err := validateAssetPropertyValue(&v[i]); err != nil {
1428			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1429		}
1430	}
1431	if invalidParams.Len() > 0 {
1432		return invalidParams
1433	} else {
1434		return nil
1435	}
1436}
1437
1438func validateExpressionVariable(v *types.ExpressionVariable) error {
1439	if v == nil {
1440		return nil
1441	}
1442	invalidParams := smithy.InvalidParamsError{Context: "ExpressionVariable"}
1443	if v.Name == nil {
1444		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1445	}
1446	if v.Value == nil {
1447		invalidParams.Add(smithy.NewErrParamRequired("Value"))
1448	} else if v.Value != nil {
1449		if err := validateVariableValue(v.Value); err != nil {
1450			invalidParams.AddNested("Value", err.(smithy.InvalidParamsError))
1451		}
1452	}
1453	if invalidParams.Len() > 0 {
1454		return invalidParams
1455	} else {
1456		return nil
1457	}
1458}
1459
1460func validateExpressionVariables(v []types.ExpressionVariable) error {
1461	if v == nil {
1462		return nil
1463	}
1464	invalidParams := smithy.InvalidParamsError{Context: "ExpressionVariables"}
1465	for i := range v {
1466		if err := validateExpressionVariable(&v[i]); err != nil {
1467			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1468		}
1469	}
1470	if invalidParams.Len() > 0 {
1471		return invalidParams
1472	} else {
1473		return nil
1474	}
1475}
1476
1477func validateGatewayPlatform(v *types.GatewayPlatform) error {
1478	if v == nil {
1479		return nil
1480	}
1481	invalidParams := smithy.InvalidParamsError{Context: "GatewayPlatform"}
1482	if v.Greengrass == nil {
1483		invalidParams.Add(smithy.NewErrParamRequired("Greengrass"))
1484	} else if v.Greengrass != nil {
1485		if err := validateGreengrass(v.Greengrass); err != nil {
1486			invalidParams.AddNested("Greengrass", err.(smithy.InvalidParamsError))
1487		}
1488	}
1489	if invalidParams.Len() > 0 {
1490		return invalidParams
1491	} else {
1492		return nil
1493	}
1494}
1495
1496func validateGreengrass(v *types.Greengrass) error {
1497	if v == nil {
1498		return nil
1499	}
1500	invalidParams := smithy.InvalidParamsError{Context: "Greengrass"}
1501	if v.GroupArn == nil {
1502		invalidParams.Add(smithy.NewErrParamRequired("GroupArn"))
1503	}
1504	if invalidParams.Len() > 0 {
1505		return invalidParams
1506	} else {
1507		return nil
1508	}
1509}
1510
1511func validateGroupIdentity(v *types.GroupIdentity) error {
1512	if v == nil {
1513		return nil
1514	}
1515	invalidParams := smithy.InvalidParamsError{Context: "GroupIdentity"}
1516	if v.Id == nil {
1517		invalidParams.Add(smithy.NewErrParamRequired("Id"))
1518	}
1519	if invalidParams.Len() > 0 {
1520		return invalidParams
1521	} else {
1522		return nil
1523	}
1524}
1525
1526func validateIAMRoleIdentity(v *types.IAMRoleIdentity) error {
1527	if v == nil {
1528		return nil
1529	}
1530	invalidParams := smithy.InvalidParamsError{Context: "IAMRoleIdentity"}
1531	if v.Arn == nil {
1532		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
1533	}
1534	if invalidParams.Len() > 0 {
1535		return invalidParams
1536	} else {
1537		return nil
1538	}
1539}
1540
1541func validateIAMUserIdentity(v *types.IAMUserIdentity) error {
1542	if v == nil {
1543		return nil
1544	}
1545	invalidParams := smithy.InvalidParamsError{Context: "IAMUserIdentity"}
1546	if v.Arn == nil {
1547		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
1548	}
1549	if invalidParams.Len() > 0 {
1550		return invalidParams
1551	} else {
1552		return nil
1553	}
1554}
1555
1556func validateIdentity(v *types.Identity) error {
1557	if v == nil {
1558		return nil
1559	}
1560	invalidParams := smithy.InvalidParamsError{Context: "Identity"}
1561	if v.User != nil {
1562		if err := validateUserIdentity(v.User); err != nil {
1563			invalidParams.AddNested("User", err.(smithy.InvalidParamsError))
1564		}
1565	}
1566	if v.Group != nil {
1567		if err := validateGroupIdentity(v.Group); err != nil {
1568			invalidParams.AddNested("Group", err.(smithy.InvalidParamsError))
1569		}
1570	}
1571	if v.IamUser != nil {
1572		if err := validateIAMUserIdentity(v.IamUser); err != nil {
1573			invalidParams.AddNested("IamUser", err.(smithy.InvalidParamsError))
1574		}
1575	}
1576	if v.IamRole != nil {
1577		if err := validateIAMRoleIdentity(v.IamRole); err != nil {
1578			invalidParams.AddNested("IamRole", err.(smithy.InvalidParamsError))
1579		}
1580	}
1581	if invalidParams.Len() > 0 {
1582		return invalidParams
1583	} else {
1584		return nil
1585	}
1586}
1587
1588func validateImage(v *types.Image) error {
1589	if v == nil {
1590		return nil
1591	}
1592	invalidParams := smithy.InvalidParamsError{Context: "Image"}
1593	if v.File != nil {
1594		if err := validateImageFile(v.File); err != nil {
1595			invalidParams.AddNested("File", err.(smithy.InvalidParamsError))
1596		}
1597	}
1598	if invalidParams.Len() > 0 {
1599		return invalidParams
1600	} else {
1601		return nil
1602	}
1603}
1604
1605func validateImageFile(v *types.ImageFile) error {
1606	if v == nil {
1607		return nil
1608	}
1609	invalidParams := smithy.InvalidParamsError{Context: "ImageFile"}
1610	if v.Data == nil {
1611		invalidParams.Add(smithy.NewErrParamRequired("Data"))
1612	}
1613	if len(v.Type) == 0 {
1614		invalidParams.Add(smithy.NewErrParamRequired("Type"))
1615	}
1616	if invalidParams.Len() > 0 {
1617		return invalidParams
1618	} else {
1619		return nil
1620	}
1621}
1622
1623func validateLoggingOptions(v *types.LoggingOptions) error {
1624	if v == nil {
1625		return nil
1626	}
1627	invalidParams := smithy.InvalidParamsError{Context: "LoggingOptions"}
1628	if len(v.Level) == 0 {
1629		invalidParams.Add(smithy.NewErrParamRequired("Level"))
1630	}
1631	if invalidParams.Len() > 0 {
1632		return invalidParams
1633	} else {
1634		return nil
1635	}
1636}
1637
1638func validateMetric(v *types.Metric) error {
1639	if v == nil {
1640		return nil
1641	}
1642	invalidParams := smithy.InvalidParamsError{Context: "Metric"}
1643	if v.Expression == nil {
1644		invalidParams.Add(smithy.NewErrParamRequired("Expression"))
1645	}
1646	if v.Variables == nil {
1647		invalidParams.Add(smithy.NewErrParamRequired("Variables"))
1648	} else if v.Variables != nil {
1649		if err := validateExpressionVariables(v.Variables); err != nil {
1650			invalidParams.AddNested("Variables", err.(smithy.InvalidParamsError))
1651		}
1652	}
1653	if v.Window == nil {
1654		invalidParams.Add(smithy.NewErrParamRequired("Window"))
1655	} else if v.Window != nil {
1656		if err := validateMetricWindow(v.Window); err != nil {
1657			invalidParams.AddNested("Window", err.(smithy.InvalidParamsError))
1658		}
1659	}
1660	if invalidParams.Len() > 0 {
1661		return invalidParams
1662	} else {
1663		return nil
1664	}
1665}
1666
1667func validateMetricWindow(v *types.MetricWindow) error {
1668	if v == nil {
1669		return nil
1670	}
1671	invalidParams := smithy.InvalidParamsError{Context: "MetricWindow"}
1672	if v.Tumbling != nil {
1673		if err := validateTumblingWindow(v.Tumbling); err != nil {
1674			invalidParams.AddNested("Tumbling", err.(smithy.InvalidParamsError))
1675		}
1676	}
1677	if invalidParams.Len() > 0 {
1678		return invalidParams
1679	} else {
1680		return nil
1681	}
1682}
1683
1684func validatePortalResource(v *types.PortalResource) error {
1685	if v == nil {
1686		return nil
1687	}
1688	invalidParams := smithy.InvalidParamsError{Context: "PortalResource"}
1689	if v.Id == nil {
1690		invalidParams.Add(smithy.NewErrParamRequired("Id"))
1691	}
1692	if invalidParams.Len() > 0 {
1693		return invalidParams
1694	} else {
1695		return nil
1696	}
1697}
1698
1699func validateProjectResource(v *types.ProjectResource) error {
1700	if v == nil {
1701		return nil
1702	}
1703	invalidParams := smithy.InvalidParamsError{Context: "ProjectResource"}
1704	if v.Id == nil {
1705		invalidParams.Add(smithy.NewErrParamRequired("Id"))
1706	}
1707	if invalidParams.Len() > 0 {
1708		return invalidParams
1709	} else {
1710		return nil
1711	}
1712}
1713
1714func validatePropertyType(v *types.PropertyType) error {
1715	if v == nil {
1716		return nil
1717	}
1718	invalidParams := smithy.InvalidParamsError{Context: "PropertyType"}
1719	if v.Transform != nil {
1720		if err := validateTransform(v.Transform); err != nil {
1721			invalidParams.AddNested("Transform", err.(smithy.InvalidParamsError))
1722		}
1723	}
1724	if v.Metric != nil {
1725		if err := validateMetric(v.Metric); err != nil {
1726			invalidParams.AddNested("Metric", err.(smithy.InvalidParamsError))
1727		}
1728	}
1729	if invalidParams.Len() > 0 {
1730		return invalidParams
1731	} else {
1732		return nil
1733	}
1734}
1735
1736func validatePutAssetPropertyValueEntries(v []types.PutAssetPropertyValueEntry) error {
1737	if v == nil {
1738		return nil
1739	}
1740	invalidParams := smithy.InvalidParamsError{Context: "PutAssetPropertyValueEntries"}
1741	for i := range v {
1742		if err := validatePutAssetPropertyValueEntry(&v[i]); err != nil {
1743			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1744		}
1745	}
1746	if invalidParams.Len() > 0 {
1747		return invalidParams
1748	} else {
1749		return nil
1750	}
1751}
1752
1753func validatePutAssetPropertyValueEntry(v *types.PutAssetPropertyValueEntry) error {
1754	if v == nil {
1755		return nil
1756	}
1757	invalidParams := smithy.InvalidParamsError{Context: "PutAssetPropertyValueEntry"}
1758	if v.EntryId == nil {
1759		invalidParams.Add(smithy.NewErrParamRequired("EntryId"))
1760	}
1761	if v.PropertyValues == nil {
1762		invalidParams.Add(smithy.NewErrParamRequired("PropertyValues"))
1763	} else if v.PropertyValues != nil {
1764		if err := validateAssetPropertyValues(v.PropertyValues); err != nil {
1765			invalidParams.AddNested("PropertyValues", err.(smithy.InvalidParamsError))
1766		}
1767	}
1768	if invalidParams.Len() > 0 {
1769		return invalidParams
1770	} else {
1771		return nil
1772	}
1773}
1774
1775func validateResource(v *types.Resource) error {
1776	if v == nil {
1777		return nil
1778	}
1779	invalidParams := smithy.InvalidParamsError{Context: "Resource"}
1780	if v.Portal != nil {
1781		if err := validatePortalResource(v.Portal); err != nil {
1782			invalidParams.AddNested("Portal", err.(smithy.InvalidParamsError))
1783		}
1784	}
1785	if v.Project != nil {
1786		if err := validateProjectResource(v.Project); err != nil {
1787			invalidParams.AddNested("Project", err.(smithy.InvalidParamsError))
1788		}
1789	}
1790	if invalidParams.Len() > 0 {
1791		return invalidParams
1792	} else {
1793		return nil
1794	}
1795}
1796
1797func validateTimeInNanos(v *types.TimeInNanos) error {
1798	if v == nil {
1799		return nil
1800	}
1801	invalidParams := smithy.InvalidParamsError{Context: "TimeInNanos"}
1802	if v.TimeInSeconds == nil {
1803		invalidParams.Add(smithy.NewErrParamRequired("TimeInSeconds"))
1804	}
1805	if invalidParams.Len() > 0 {
1806		return invalidParams
1807	} else {
1808		return nil
1809	}
1810}
1811
1812func validateTransform(v *types.Transform) error {
1813	if v == nil {
1814		return nil
1815	}
1816	invalidParams := smithy.InvalidParamsError{Context: "Transform"}
1817	if v.Expression == nil {
1818		invalidParams.Add(smithy.NewErrParamRequired("Expression"))
1819	}
1820	if v.Variables == nil {
1821		invalidParams.Add(smithy.NewErrParamRequired("Variables"))
1822	} else if v.Variables != nil {
1823		if err := validateExpressionVariables(v.Variables); err != nil {
1824			invalidParams.AddNested("Variables", err.(smithy.InvalidParamsError))
1825		}
1826	}
1827	if invalidParams.Len() > 0 {
1828		return invalidParams
1829	} else {
1830		return nil
1831	}
1832}
1833
1834func validateTumblingWindow(v *types.TumblingWindow) error {
1835	if v == nil {
1836		return nil
1837	}
1838	invalidParams := smithy.InvalidParamsError{Context: "TumblingWindow"}
1839	if v.Interval == nil {
1840		invalidParams.Add(smithy.NewErrParamRequired("Interval"))
1841	}
1842	if invalidParams.Len() > 0 {
1843		return invalidParams
1844	} else {
1845		return nil
1846	}
1847}
1848
1849func validateUserIdentity(v *types.UserIdentity) error {
1850	if v == nil {
1851		return nil
1852	}
1853	invalidParams := smithy.InvalidParamsError{Context: "UserIdentity"}
1854	if v.Id == nil {
1855		invalidParams.Add(smithy.NewErrParamRequired("Id"))
1856	}
1857	if invalidParams.Len() > 0 {
1858		return invalidParams
1859	} else {
1860		return nil
1861	}
1862}
1863
1864func validateVariableValue(v *types.VariableValue) error {
1865	if v == nil {
1866		return nil
1867	}
1868	invalidParams := smithy.InvalidParamsError{Context: "VariableValue"}
1869	if v.PropertyId == nil {
1870		invalidParams.Add(smithy.NewErrParamRequired("PropertyId"))
1871	}
1872	if invalidParams.Len() > 0 {
1873		return invalidParams
1874	} else {
1875		return nil
1876	}
1877}
1878
1879func validateOpAssociateAssetsInput(v *AssociateAssetsInput) error {
1880	if v == nil {
1881		return nil
1882	}
1883	invalidParams := smithy.InvalidParamsError{Context: "AssociateAssetsInput"}
1884	if v.AssetId == nil {
1885		invalidParams.Add(smithy.NewErrParamRequired("AssetId"))
1886	}
1887	if v.HierarchyId == nil {
1888		invalidParams.Add(smithy.NewErrParamRequired("HierarchyId"))
1889	}
1890	if v.ChildAssetId == nil {
1891		invalidParams.Add(smithy.NewErrParamRequired("ChildAssetId"))
1892	}
1893	if invalidParams.Len() > 0 {
1894		return invalidParams
1895	} else {
1896		return nil
1897	}
1898}
1899
1900func validateOpBatchAssociateProjectAssetsInput(v *BatchAssociateProjectAssetsInput) error {
1901	if v == nil {
1902		return nil
1903	}
1904	invalidParams := smithy.InvalidParamsError{Context: "BatchAssociateProjectAssetsInput"}
1905	if v.ProjectId == nil {
1906		invalidParams.Add(smithy.NewErrParamRequired("ProjectId"))
1907	}
1908	if v.AssetIds == nil {
1909		invalidParams.Add(smithy.NewErrParamRequired("AssetIds"))
1910	}
1911	if invalidParams.Len() > 0 {
1912		return invalidParams
1913	} else {
1914		return nil
1915	}
1916}
1917
1918func validateOpBatchDisassociateProjectAssetsInput(v *BatchDisassociateProjectAssetsInput) error {
1919	if v == nil {
1920		return nil
1921	}
1922	invalidParams := smithy.InvalidParamsError{Context: "BatchDisassociateProjectAssetsInput"}
1923	if v.ProjectId == nil {
1924		invalidParams.Add(smithy.NewErrParamRequired("ProjectId"))
1925	}
1926	if v.AssetIds == nil {
1927		invalidParams.Add(smithy.NewErrParamRequired("AssetIds"))
1928	}
1929	if invalidParams.Len() > 0 {
1930		return invalidParams
1931	} else {
1932		return nil
1933	}
1934}
1935
1936func validateOpBatchPutAssetPropertyValueInput(v *BatchPutAssetPropertyValueInput) error {
1937	if v == nil {
1938		return nil
1939	}
1940	invalidParams := smithy.InvalidParamsError{Context: "BatchPutAssetPropertyValueInput"}
1941	if v.Entries == nil {
1942		invalidParams.Add(smithy.NewErrParamRequired("Entries"))
1943	} else if v.Entries != nil {
1944		if err := validatePutAssetPropertyValueEntries(v.Entries); err != nil {
1945			invalidParams.AddNested("Entries", err.(smithy.InvalidParamsError))
1946		}
1947	}
1948	if invalidParams.Len() > 0 {
1949		return invalidParams
1950	} else {
1951		return nil
1952	}
1953}
1954
1955func validateOpCreateAccessPolicyInput(v *CreateAccessPolicyInput) error {
1956	if v == nil {
1957		return nil
1958	}
1959	invalidParams := smithy.InvalidParamsError{Context: "CreateAccessPolicyInput"}
1960	if v.AccessPolicyIdentity == nil {
1961		invalidParams.Add(smithy.NewErrParamRequired("AccessPolicyIdentity"))
1962	} else if v.AccessPolicyIdentity != nil {
1963		if err := validateIdentity(v.AccessPolicyIdentity); err != nil {
1964			invalidParams.AddNested("AccessPolicyIdentity", err.(smithy.InvalidParamsError))
1965		}
1966	}
1967	if v.AccessPolicyResource == nil {
1968		invalidParams.Add(smithy.NewErrParamRequired("AccessPolicyResource"))
1969	} else if v.AccessPolicyResource != nil {
1970		if err := validateResource(v.AccessPolicyResource); err != nil {
1971			invalidParams.AddNested("AccessPolicyResource", err.(smithy.InvalidParamsError))
1972		}
1973	}
1974	if len(v.AccessPolicyPermission) == 0 {
1975		invalidParams.Add(smithy.NewErrParamRequired("AccessPolicyPermission"))
1976	}
1977	if invalidParams.Len() > 0 {
1978		return invalidParams
1979	} else {
1980		return nil
1981	}
1982}
1983
1984func validateOpCreateAssetInput(v *CreateAssetInput) error {
1985	if v == nil {
1986		return nil
1987	}
1988	invalidParams := smithy.InvalidParamsError{Context: "CreateAssetInput"}
1989	if v.AssetName == nil {
1990		invalidParams.Add(smithy.NewErrParamRequired("AssetName"))
1991	}
1992	if v.AssetModelId == nil {
1993		invalidParams.Add(smithy.NewErrParamRequired("AssetModelId"))
1994	}
1995	if invalidParams.Len() > 0 {
1996		return invalidParams
1997	} else {
1998		return nil
1999	}
2000}
2001
2002func validateOpCreateAssetModelInput(v *CreateAssetModelInput) error {
2003	if v == nil {
2004		return nil
2005	}
2006	invalidParams := smithy.InvalidParamsError{Context: "CreateAssetModelInput"}
2007	if v.AssetModelName == nil {
2008		invalidParams.Add(smithy.NewErrParamRequired("AssetModelName"))
2009	}
2010	if v.AssetModelProperties != nil {
2011		if err := validateAssetModelPropertyDefinitions(v.AssetModelProperties); err != nil {
2012			invalidParams.AddNested("AssetModelProperties", err.(smithy.InvalidParamsError))
2013		}
2014	}
2015	if v.AssetModelHierarchies != nil {
2016		if err := validateAssetModelHierarchyDefinitions(v.AssetModelHierarchies); err != nil {
2017			invalidParams.AddNested("AssetModelHierarchies", err.(smithy.InvalidParamsError))
2018		}
2019	}
2020	if v.AssetModelCompositeModels != nil {
2021		if err := validateAssetModelCompositeModelDefinitions(v.AssetModelCompositeModels); err != nil {
2022			invalidParams.AddNested("AssetModelCompositeModels", err.(smithy.InvalidParamsError))
2023		}
2024	}
2025	if invalidParams.Len() > 0 {
2026		return invalidParams
2027	} else {
2028		return nil
2029	}
2030}
2031
2032func validateOpCreateDashboardInput(v *CreateDashboardInput) error {
2033	if v == nil {
2034		return nil
2035	}
2036	invalidParams := smithy.InvalidParamsError{Context: "CreateDashboardInput"}
2037	if v.ProjectId == nil {
2038		invalidParams.Add(smithy.NewErrParamRequired("ProjectId"))
2039	}
2040	if v.DashboardName == nil {
2041		invalidParams.Add(smithy.NewErrParamRequired("DashboardName"))
2042	}
2043	if v.DashboardDefinition == nil {
2044		invalidParams.Add(smithy.NewErrParamRequired("DashboardDefinition"))
2045	}
2046	if invalidParams.Len() > 0 {
2047		return invalidParams
2048	} else {
2049		return nil
2050	}
2051}
2052
2053func validateOpCreateGatewayInput(v *CreateGatewayInput) error {
2054	if v == nil {
2055		return nil
2056	}
2057	invalidParams := smithy.InvalidParamsError{Context: "CreateGatewayInput"}
2058	if v.GatewayName == nil {
2059		invalidParams.Add(smithy.NewErrParamRequired("GatewayName"))
2060	}
2061	if v.GatewayPlatform == nil {
2062		invalidParams.Add(smithy.NewErrParamRequired("GatewayPlatform"))
2063	} else if v.GatewayPlatform != nil {
2064		if err := validateGatewayPlatform(v.GatewayPlatform); err != nil {
2065			invalidParams.AddNested("GatewayPlatform", err.(smithy.InvalidParamsError))
2066		}
2067	}
2068	if invalidParams.Len() > 0 {
2069		return invalidParams
2070	} else {
2071		return nil
2072	}
2073}
2074
2075func validateOpCreatePortalInput(v *CreatePortalInput) error {
2076	if v == nil {
2077		return nil
2078	}
2079	invalidParams := smithy.InvalidParamsError{Context: "CreatePortalInput"}
2080	if v.PortalName == nil {
2081		invalidParams.Add(smithy.NewErrParamRequired("PortalName"))
2082	}
2083	if v.PortalContactEmail == nil {
2084		invalidParams.Add(smithy.NewErrParamRequired("PortalContactEmail"))
2085	}
2086	if v.PortalLogoImageFile != nil {
2087		if err := validateImageFile(v.PortalLogoImageFile); err != nil {
2088			invalidParams.AddNested("PortalLogoImageFile", err.(smithy.InvalidParamsError))
2089		}
2090	}
2091	if v.RoleArn == nil {
2092		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
2093	}
2094	if invalidParams.Len() > 0 {
2095		return invalidParams
2096	} else {
2097		return nil
2098	}
2099}
2100
2101func validateOpCreateProjectInput(v *CreateProjectInput) error {
2102	if v == nil {
2103		return nil
2104	}
2105	invalidParams := smithy.InvalidParamsError{Context: "CreateProjectInput"}
2106	if v.PortalId == nil {
2107		invalidParams.Add(smithy.NewErrParamRequired("PortalId"))
2108	}
2109	if v.ProjectName == nil {
2110		invalidParams.Add(smithy.NewErrParamRequired("ProjectName"))
2111	}
2112	if invalidParams.Len() > 0 {
2113		return invalidParams
2114	} else {
2115		return nil
2116	}
2117}
2118
2119func validateOpDeleteAccessPolicyInput(v *DeleteAccessPolicyInput) error {
2120	if v == nil {
2121		return nil
2122	}
2123	invalidParams := smithy.InvalidParamsError{Context: "DeleteAccessPolicyInput"}
2124	if v.AccessPolicyId == nil {
2125		invalidParams.Add(smithy.NewErrParamRequired("AccessPolicyId"))
2126	}
2127	if invalidParams.Len() > 0 {
2128		return invalidParams
2129	} else {
2130		return nil
2131	}
2132}
2133
2134func validateOpDeleteAssetInput(v *DeleteAssetInput) error {
2135	if v == nil {
2136		return nil
2137	}
2138	invalidParams := smithy.InvalidParamsError{Context: "DeleteAssetInput"}
2139	if v.AssetId == nil {
2140		invalidParams.Add(smithy.NewErrParamRequired("AssetId"))
2141	}
2142	if invalidParams.Len() > 0 {
2143		return invalidParams
2144	} else {
2145		return nil
2146	}
2147}
2148
2149func validateOpDeleteAssetModelInput(v *DeleteAssetModelInput) error {
2150	if v == nil {
2151		return nil
2152	}
2153	invalidParams := smithy.InvalidParamsError{Context: "DeleteAssetModelInput"}
2154	if v.AssetModelId == nil {
2155		invalidParams.Add(smithy.NewErrParamRequired("AssetModelId"))
2156	}
2157	if invalidParams.Len() > 0 {
2158		return invalidParams
2159	} else {
2160		return nil
2161	}
2162}
2163
2164func validateOpDeleteDashboardInput(v *DeleteDashboardInput) error {
2165	if v == nil {
2166		return nil
2167	}
2168	invalidParams := smithy.InvalidParamsError{Context: "DeleteDashboardInput"}
2169	if v.DashboardId == nil {
2170		invalidParams.Add(smithy.NewErrParamRequired("DashboardId"))
2171	}
2172	if invalidParams.Len() > 0 {
2173		return invalidParams
2174	} else {
2175		return nil
2176	}
2177}
2178
2179func validateOpDeleteGatewayInput(v *DeleteGatewayInput) error {
2180	if v == nil {
2181		return nil
2182	}
2183	invalidParams := smithy.InvalidParamsError{Context: "DeleteGatewayInput"}
2184	if v.GatewayId == nil {
2185		invalidParams.Add(smithy.NewErrParamRequired("GatewayId"))
2186	}
2187	if invalidParams.Len() > 0 {
2188		return invalidParams
2189	} else {
2190		return nil
2191	}
2192}
2193
2194func validateOpDeletePortalInput(v *DeletePortalInput) error {
2195	if v == nil {
2196		return nil
2197	}
2198	invalidParams := smithy.InvalidParamsError{Context: "DeletePortalInput"}
2199	if v.PortalId == nil {
2200		invalidParams.Add(smithy.NewErrParamRequired("PortalId"))
2201	}
2202	if invalidParams.Len() > 0 {
2203		return invalidParams
2204	} else {
2205		return nil
2206	}
2207}
2208
2209func validateOpDeleteProjectInput(v *DeleteProjectInput) error {
2210	if v == nil {
2211		return nil
2212	}
2213	invalidParams := smithy.InvalidParamsError{Context: "DeleteProjectInput"}
2214	if v.ProjectId == nil {
2215		invalidParams.Add(smithy.NewErrParamRequired("ProjectId"))
2216	}
2217	if invalidParams.Len() > 0 {
2218		return invalidParams
2219	} else {
2220		return nil
2221	}
2222}
2223
2224func validateOpDescribeAccessPolicyInput(v *DescribeAccessPolicyInput) error {
2225	if v == nil {
2226		return nil
2227	}
2228	invalidParams := smithy.InvalidParamsError{Context: "DescribeAccessPolicyInput"}
2229	if v.AccessPolicyId == nil {
2230		invalidParams.Add(smithy.NewErrParamRequired("AccessPolicyId"))
2231	}
2232	if invalidParams.Len() > 0 {
2233		return invalidParams
2234	} else {
2235		return nil
2236	}
2237}
2238
2239func validateOpDescribeAssetInput(v *DescribeAssetInput) error {
2240	if v == nil {
2241		return nil
2242	}
2243	invalidParams := smithy.InvalidParamsError{Context: "DescribeAssetInput"}
2244	if v.AssetId == nil {
2245		invalidParams.Add(smithy.NewErrParamRequired("AssetId"))
2246	}
2247	if invalidParams.Len() > 0 {
2248		return invalidParams
2249	} else {
2250		return nil
2251	}
2252}
2253
2254func validateOpDescribeAssetModelInput(v *DescribeAssetModelInput) error {
2255	if v == nil {
2256		return nil
2257	}
2258	invalidParams := smithy.InvalidParamsError{Context: "DescribeAssetModelInput"}
2259	if v.AssetModelId == nil {
2260		invalidParams.Add(smithy.NewErrParamRequired("AssetModelId"))
2261	}
2262	if invalidParams.Len() > 0 {
2263		return invalidParams
2264	} else {
2265		return nil
2266	}
2267}
2268
2269func validateOpDescribeAssetPropertyInput(v *DescribeAssetPropertyInput) error {
2270	if v == nil {
2271		return nil
2272	}
2273	invalidParams := smithy.InvalidParamsError{Context: "DescribeAssetPropertyInput"}
2274	if v.AssetId == nil {
2275		invalidParams.Add(smithy.NewErrParamRequired("AssetId"))
2276	}
2277	if v.PropertyId == nil {
2278		invalidParams.Add(smithy.NewErrParamRequired("PropertyId"))
2279	}
2280	if invalidParams.Len() > 0 {
2281		return invalidParams
2282	} else {
2283		return nil
2284	}
2285}
2286
2287func validateOpDescribeDashboardInput(v *DescribeDashboardInput) error {
2288	if v == nil {
2289		return nil
2290	}
2291	invalidParams := smithy.InvalidParamsError{Context: "DescribeDashboardInput"}
2292	if v.DashboardId == nil {
2293		invalidParams.Add(smithy.NewErrParamRequired("DashboardId"))
2294	}
2295	if invalidParams.Len() > 0 {
2296		return invalidParams
2297	} else {
2298		return nil
2299	}
2300}
2301
2302func validateOpDescribeGatewayCapabilityConfigurationInput(v *DescribeGatewayCapabilityConfigurationInput) error {
2303	if v == nil {
2304		return nil
2305	}
2306	invalidParams := smithy.InvalidParamsError{Context: "DescribeGatewayCapabilityConfigurationInput"}
2307	if v.GatewayId == nil {
2308		invalidParams.Add(smithy.NewErrParamRequired("GatewayId"))
2309	}
2310	if v.CapabilityNamespace == nil {
2311		invalidParams.Add(smithy.NewErrParamRequired("CapabilityNamespace"))
2312	}
2313	if invalidParams.Len() > 0 {
2314		return invalidParams
2315	} else {
2316		return nil
2317	}
2318}
2319
2320func validateOpDescribeGatewayInput(v *DescribeGatewayInput) error {
2321	if v == nil {
2322		return nil
2323	}
2324	invalidParams := smithy.InvalidParamsError{Context: "DescribeGatewayInput"}
2325	if v.GatewayId == nil {
2326		invalidParams.Add(smithy.NewErrParamRequired("GatewayId"))
2327	}
2328	if invalidParams.Len() > 0 {
2329		return invalidParams
2330	} else {
2331		return nil
2332	}
2333}
2334
2335func validateOpDescribePortalInput(v *DescribePortalInput) error {
2336	if v == nil {
2337		return nil
2338	}
2339	invalidParams := smithy.InvalidParamsError{Context: "DescribePortalInput"}
2340	if v.PortalId == nil {
2341		invalidParams.Add(smithy.NewErrParamRequired("PortalId"))
2342	}
2343	if invalidParams.Len() > 0 {
2344		return invalidParams
2345	} else {
2346		return nil
2347	}
2348}
2349
2350func validateOpDescribeProjectInput(v *DescribeProjectInput) error {
2351	if v == nil {
2352		return nil
2353	}
2354	invalidParams := smithy.InvalidParamsError{Context: "DescribeProjectInput"}
2355	if v.ProjectId == nil {
2356		invalidParams.Add(smithy.NewErrParamRequired("ProjectId"))
2357	}
2358	if invalidParams.Len() > 0 {
2359		return invalidParams
2360	} else {
2361		return nil
2362	}
2363}
2364
2365func validateOpDisassociateAssetsInput(v *DisassociateAssetsInput) error {
2366	if v == nil {
2367		return nil
2368	}
2369	invalidParams := smithy.InvalidParamsError{Context: "DisassociateAssetsInput"}
2370	if v.AssetId == nil {
2371		invalidParams.Add(smithy.NewErrParamRequired("AssetId"))
2372	}
2373	if v.HierarchyId == nil {
2374		invalidParams.Add(smithy.NewErrParamRequired("HierarchyId"))
2375	}
2376	if v.ChildAssetId == nil {
2377		invalidParams.Add(smithy.NewErrParamRequired("ChildAssetId"))
2378	}
2379	if invalidParams.Len() > 0 {
2380		return invalidParams
2381	} else {
2382		return nil
2383	}
2384}
2385
2386func validateOpGetAssetPropertyAggregatesInput(v *GetAssetPropertyAggregatesInput) error {
2387	if v == nil {
2388		return nil
2389	}
2390	invalidParams := smithy.InvalidParamsError{Context: "GetAssetPropertyAggregatesInput"}
2391	if v.AggregateTypes == nil {
2392		invalidParams.Add(smithy.NewErrParamRequired("AggregateTypes"))
2393	}
2394	if v.Resolution == nil {
2395		invalidParams.Add(smithy.NewErrParamRequired("Resolution"))
2396	}
2397	if v.StartDate == nil {
2398		invalidParams.Add(smithy.NewErrParamRequired("StartDate"))
2399	}
2400	if v.EndDate == nil {
2401		invalidParams.Add(smithy.NewErrParamRequired("EndDate"))
2402	}
2403	if invalidParams.Len() > 0 {
2404		return invalidParams
2405	} else {
2406		return nil
2407	}
2408}
2409
2410func validateOpListAssetRelationshipsInput(v *ListAssetRelationshipsInput) error {
2411	if v == nil {
2412		return nil
2413	}
2414	invalidParams := smithy.InvalidParamsError{Context: "ListAssetRelationshipsInput"}
2415	if v.AssetId == nil {
2416		invalidParams.Add(smithy.NewErrParamRequired("AssetId"))
2417	}
2418	if len(v.TraversalType) == 0 {
2419		invalidParams.Add(smithy.NewErrParamRequired("TraversalType"))
2420	}
2421	if invalidParams.Len() > 0 {
2422		return invalidParams
2423	} else {
2424		return nil
2425	}
2426}
2427
2428func validateOpListAssociatedAssetsInput(v *ListAssociatedAssetsInput) error {
2429	if v == nil {
2430		return nil
2431	}
2432	invalidParams := smithy.InvalidParamsError{Context: "ListAssociatedAssetsInput"}
2433	if v.AssetId == nil {
2434		invalidParams.Add(smithy.NewErrParamRequired("AssetId"))
2435	}
2436	if invalidParams.Len() > 0 {
2437		return invalidParams
2438	} else {
2439		return nil
2440	}
2441}
2442
2443func validateOpListDashboardsInput(v *ListDashboardsInput) error {
2444	if v == nil {
2445		return nil
2446	}
2447	invalidParams := smithy.InvalidParamsError{Context: "ListDashboardsInput"}
2448	if v.ProjectId == nil {
2449		invalidParams.Add(smithy.NewErrParamRequired("ProjectId"))
2450	}
2451	if invalidParams.Len() > 0 {
2452		return invalidParams
2453	} else {
2454		return nil
2455	}
2456}
2457
2458func validateOpListProjectAssetsInput(v *ListProjectAssetsInput) error {
2459	if v == nil {
2460		return nil
2461	}
2462	invalidParams := smithy.InvalidParamsError{Context: "ListProjectAssetsInput"}
2463	if v.ProjectId == nil {
2464		invalidParams.Add(smithy.NewErrParamRequired("ProjectId"))
2465	}
2466	if invalidParams.Len() > 0 {
2467		return invalidParams
2468	} else {
2469		return nil
2470	}
2471}
2472
2473func validateOpListProjectsInput(v *ListProjectsInput) error {
2474	if v == nil {
2475		return nil
2476	}
2477	invalidParams := smithy.InvalidParamsError{Context: "ListProjectsInput"}
2478	if v.PortalId == nil {
2479		invalidParams.Add(smithy.NewErrParamRequired("PortalId"))
2480	}
2481	if invalidParams.Len() > 0 {
2482		return invalidParams
2483	} else {
2484		return nil
2485	}
2486}
2487
2488func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
2489	if v == nil {
2490		return nil
2491	}
2492	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
2493	if v.ResourceArn == nil {
2494		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
2495	}
2496	if invalidParams.Len() > 0 {
2497		return invalidParams
2498	} else {
2499		return nil
2500	}
2501}
2502
2503func validateOpPutDefaultEncryptionConfigurationInput(v *PutDefaultEncryptionConfigurationInput) error {
2504	if v == nil {
2505		return nil
2506	}
2507	invalidParams := smithy.InvalidParamsError{Context: "PutDefaultEncryptionConfigurationInput"}
2508	if len(v.EncryptionType) == 0 {
2509		invalidParams.Add(smithy.NewErrParamRequired("EncryptionType"))
2510	}
2511	if invalidParams.Len() > 0 {
2512		return invalidParams
2513	} else {
2514		return nil
2515	}
2516}
2517
2518func validateOpPutLoggingOptionsInput(v *PutLoggingOptionsInput) error {
2519	if v == nil {
2520		return nil
2521	}
2522	invalidParams := smithy.InvalidParamsError{Context: "PutLoggingOptionsInput"}
2523	if v.LoggingOptions == nil {
2524		invalidParams.Add(smithy.NewErrParamRequired("LoggingOptions"))
2525	} else if v.LoggingOptions != nil {
2526		if err := validateLoggingOptions(v.LoggingOptions); err != nil {
2527			invalidParams.AddNested("LoggingOptions", err.(smithy.InvalidParamsError))
2528		}
2529	}
2530	if invalidParams.Len() > 0 {
2531		return invalidParams
2532	} else {
2533		return nil
2534	}
2535}
2536
2537func validateOpTagResourceInput(v *TagResourceInput) error {
2538	if v == nil {
2539		return nil
2540	}
2541	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
2542	if v.ResourceArn == nil {
2543		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
2544	}
2545	if v.Tags == nil {
2546		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
2547	}
2548	if invalidParams.Len() > 0 {
2549		return invalidParams
2550	} else {
2551		return nil
2552	}
2553}
2554
2555func validateOpUntagResourceInput(v *UntagResourceInput) error {
2556	if v == nil {
2557		return nil
2558	}
2559	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
2560	if v.ResourceArn == nil {
2561		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
2562	}
2563	if v.TagKeys == nil {
2564		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
2565	}
2566	if invalidParams.Len() > 0 {
2567		return invalidParams
2568	} else {
2569		return nil
2570	}
2571}
2572
2573func validateOpUpdateAccessPolicyInput(v *UpdateAccessPolicyInput) error {
2574	if v == nil {
2575		return nil
2576	}
2577	invalidParams := smithy.InvalidParamsError{Context: "UpdateAccessPolicyInput"}
2578	if v.AccessPolicyId == nil {
2579		invalidParams.Add(smithy.NewErrParamRequired("AccessPolicyId"))
2580	}
2581	if v.AccessPolicyIdentity == nil {
2582		invalidParams.Add(smithy.NewErrParamRequired("AccessPolicyIdentity"))
2583	} else if v.AccessPolicyIdentity != nil {
2584		if err := validateIdentity(v.AccessPolicyIdentity); err != nil {
2585			invalidParams.AddNested("AccessPolicyIdentity", err.(smithy.InvalidParamsError))
2586		}
2587	}
2588	if v.AccessPolicyResource == nil {
2589		invalidParams.Add(smithy.NewErrParamRequired("AccessPolicyResource"))
2590	} else if v.AccessPolicyResource != nil {
2591		if err := validateResource(v.AccessPolicyResource); err != nil {
2592			invalidParams.AddNested("AccessPolicyResource", err.(smithy.InvalidParamsError))
2593		}
2594	}
2595	if len(v.AccessPolicyPermission) == 0 {
2596		invalidParams.Add(smithy.NewErrParamRequired("AccessPolicyPermission"))
2597	}
2598	if invalidParams.Len() > 0 {
2599		return invalidParams
2600	} else {
2601		return nil
2602	}
2603}
2604
2605func validateOpUpdateAssetInput(v *UpdateAssetInput) error {
2606	if v == nil {
2607		return nil
2608	}
2609	invalidParams := smithy.InvalidParamsError{Context: "UpdateAssetInput"}
2610	if v.AssetId == nil {
2611		invalidParams.Add(smithy.NewErrParamRequired("AssetId"))
2612	}
2613	if v.AssetName == nil {
2614		invalidParams.Add(smithy.NewErrParamRequired("AssetName"))
2615	}
2616	if invalidParams.Len() > 0 {
2617		return invalidParams
2618	} else {
2619		return nil
2620	}
2621}
2622
2623func validateOpUpdateAssetModelInput(v *UpdateAssetModelInput) error {
2624	if v == nil {
2625		return nil
2626	}
2627	invalidParams := smithy.InvalidParamsError{Context: "UpdateAssetModelInput"}
2628	if v.AssetModelId == nil {
2629		invalidParams.Add(smithy.NewErrParamRequired("AssetModelId"))
2630	}
2631	if v.AssetModelName == nil {
2632		invalidParams.Add(smithy.NewErrParamRequired("AssetModelName"))
2633	}
2634	if v.AssetModelProperties != nil {
2635		if err := validateAssetModelProperties(v.AssetModelProperties); err != nil {
2636			invalidParams.AddNested("AssetModelProperties", err.(smithy.InvalidParamsError))
2637		}
2638	}
2639	if v.AssetModelHierarchies != nil {
2640		if err := validateAssetModelHierarchies(v.AssetModelHierarchies); err != nil {
2641			invalidParams.AddNested("AssetModelHierarchies", err.(smithy.InvalidParamsError))
2642		}
2643	}
2644	if v.AssetModelCompositeModels != nil {
2645		if err := validateAssetModelCompositeModels(v.AssetModelCompositeModels); err != nil {
2646			invalidParams.AddNested("AssetModelCompositeModels", err.(smithy.InvalidParamsError))
2647		}
2648	}
2649	if invalidParams.Len() > 0 {
2650		return invalidParams
2651	} else {
2652		return nil
2653	}
2654}
2655
2656func validateOpUpdateAssetPropertyInput(v *UpdateAssetPropertyInput) error {
2657	if v == nil {
2658		return nil
2659	}
2660	invalidParams := smithy.InvalidParamsError{Context: "UpdateAssetPropertyInput"}
2661	if v.AssetId == nil {
2662		invalidParams.Add(smithy.NewErrParamRequired("AssetId"))
2663	}
2664	if v.PropertyId == nil {
2665		invalidParams.Add(smithy.NewErrParamRequired("PropertyId"))
2666	}
2667	if invalidParams.Len() > 0 {
2668		return invalidParams
2669	} else {
2670		return nil
2671	}
2672}
2673
2674func validateOpUpdateDashboardInput(v *UpdateDashboardInput) error {
2675	if v == nil {
2676		return nil
2677	}
2678	invalidParams := smithy.InvalidParamsError{Context: "UpdateDashboardInput"}
2679	if v.DashboardId == nil {
2680		invalidParams.Add(smithy.NewErrParamRequired("DashboardId"))
2681	}
2682	if v.DashboardName == nil {
2683		invalidParams.Add(smithy.NewErrParamRequired("DashboardName"))
2684	}
2685	if v.DashboardDefinition == nil {
2686		invalidParams.Add(smithy.NewErrParamRequired("DashboardDefinition"))
2687	}
2688	if invalidParams.Len() > 0 {
2689		return invalidParams
2690	} else {
2691		return nil
2692	}
2693}
2694
2695func validateOpUpdateGatewayCapabilityConfigurationInput(v *UpdateGatewayCapabilityConfigurationInput) error {
2696	if v == nil {
2697		return nil
2698	}
2699	invalidParams := smithy.InvalidParamsError{Context: "UpdateGatewayCapabilityConfigurationInput"}
2700	if v.GatewayId == nil {
2701		invalidParams.Add(smithy.NewErrParamRequired("GatewayId"))
2702	}
2703	if v.CapabilityNamespace == nil {
2704		invalidParams.Add(smithy.NewErrParamRequired("CapabilityNamespace"))
2705	}
2706	if v.CapabilityConfiguration == nil {
2707		invalidParams.Add(smithy.NewErrParamRequired("CapabilityConfiguration"))
2708	}
2709	if invalidParams.Len() > 0 {
2710		return invalidParams
2711	} else {
2712		return nil
2713	}
2714}
2715
2716func validateOpUpdateGatewayInput(v *UpdateGatewayInput) error {
2717	if v == nil {
2718		return nil
2719	}
2720	invalidParams := smithy.InvalidParamsError{Context: "UpdateGatewayInput"}
2721	if v.GatewayId == nil {
2722		invalidParams.Add(smithy.NewErrParamRequired("GatewayId"))
2723	}
2724	if v.GatewayName == nil {
2725		invalidParams.Add(smithy.NewErrParamRequired("GatewayName"))
2726	}
2727	if invalidParams.Len() > 0 {
2728		return invalidParams
2729	} else {
2730		return nil
2731	}
2732}
2733
2734func validateOpUpdatePortalInput(v *UpdatePortalInput) error {
2735	if v == nil {
2736		return nil
2737	}
2738	invalidParams := smithy.InvalidParamsError{Context: "UpdatePortalInput"}
2739	if v.PortalId == nil {
2740		invalidParams.Add(smithy.NewErrParamRequired("PortalId"))
2741	}
2742	if v.PortalName == nil {
2743		invalidParams.Add(smithy.NewErrParamRequired("PortalName"))
2744	}
2745	if v.PortalContactEmail == nil {
2746		invalidParams.Add(smithy.NewErrParamRequired("PortalContactEmail"))
2747	}
2748	if v.PortalLogoImage != nil {
2749		if err := validateImage(v.PortalLogoImage); err != nil {
2750			invalidParams.AddNested("PortalLogoImage", err.(smithy.InvalidParamsError))
2751		}
2752	}
2753	if v.RoleArn == nil {
2754		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
2755	}
2756	if invalidParams.Len() > 0 {
2757		return invalidParams
2758	} else {
2759		return nil
2760	}
2761}
2762
2763func validateOpUpdateProjectInput(v *UpdateProjectInput) error {
2764	if v == nil {
2765		return nil
2766	}
2767	invalidParams := smithy.InvalidParamsError{Context: "UpdateProjectInput"}
2768	if v.ProjectId == nil {
2769		invalidParams.Add(smithy.NewErrParamRequired("ProjectId"))
2770	}
2771	if v.ProjectName == nil {
2772		invalidParams.Add(smithy.NewErrParamRequired("ProjectName"))
2773	}
2774	if invalidParams.Len() > 0 {
2775		return invalidParams
2776	} else {
2777		return nil
2778	}
2779}
2780