1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package iotthingsgraph
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/iotthingsgraph/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpAssociateEntityToThing struct {
14}
15
16func (*validateOpAssociateEntityToThing) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpAssociateEntityToThing) 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.(*AssociateEntityToThingInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpAssociateEntityToThingInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpCreateFlowTemplate struct {
34}
35
36func (*validateOpCreateFlowTemplate) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpCreateFlowTemplate) 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.(*CreateFlowTemplateInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpCreateFlowTemplateInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpCreateSystemInstance struct {
54}
55
56func (*validateOpCreateSystemInstance) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpCreateSystemInstance) 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.(*CreateSystemInstanceInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpCreateSystemInstanceInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpCreateSystemTemplate struct {
74}
75
76func (*validateOpCreateSystemTemplate) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpCreateSystemTemplate) 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.(*CreateSystemTemplateInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpCreateSystemTemplateInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpDeleteFlowTemplate struct {
94}
95
96func (*validateOpDeleteFlowTemplate) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpDeleteFlowTemplate) 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.(*DeleteFlowTemplateInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpDeleteFlowTemplateInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpDeleteSystemTemplate struct {
114}
115
116func (*validateOpDeleteSystemTemplate) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpDeleteSystemTemplate) 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.(*DeleteSystemTemplateInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpDeleteSystemTemplateInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpDeprecateFlowTemplate struct {
134}
135
136func (*validateOpDeprecateFlowTemplate) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpDeprecateFlowTemplate) 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.(*DeprecateFlowTemplateInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpDeprecateFlowTemplateInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpDeprecateSystemTemplate struct {
154}
155
156func (*validateOpDeprecateSystemTemplate) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpDeprecateSystemTemplate) 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.(*DeprecateSystemTemplateInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpDeprecateSystemTemplateInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpDissociateEntityFromThing struct {
174}
175
176func (*validateOpDissociateEntityFromThing) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpDissociateEntityFromThing) 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.(*DissociateEntityFromThingInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpDissociateEntityFromThingInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpGetEntities struct {
194}
195
196func (*validateOpGetEntities) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpGetEntities) 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.(*GetEntitiesInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpGetEntitiesInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpGetFlowTemplate struct {
214}
215
216func (*validateOpGetFlowTemplate) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpGetFlowTemplate) 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.(*GetFlowTemplateInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpGetFlowTemplateInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpGetFlowTemplateRevisions struct {
234}
235
236func (*validateOpGetFlowTemplateRevisions) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpGetFlowTemplateRevisions) 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.(*GetFlowTemplateRevisionsInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpGetFlowTemplateRevisionsInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpGetSystemInstance struct {
254}
255
256func (*validateOpGetSystemInstance) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpGetSystemInstance) 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.(*GetSystemInstanceInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpGetSystemInstanceInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpGetSystemTemplate struct {
274}
275
276func (*validateOpGetSystemTemplate) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpGetSystemTemplate) 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.(*GetSystemTemplateInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpGetSystemTemplateInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpGetSystemTemplateRevisions struct {
294}
295
296func (*validateOpGetSystemTemplateRevisions) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpGetSystemTemplateRevisions) 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.(*GetSystemTemplateRevisionsInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpGetSystemTemplateRevisionsInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpGetUploadStatus struct {
314}
315
316func (*validateOpGetUploadStatus) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpGetUploadStatus) 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.(*GetUploadStatusInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpGetUploadStatusInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpListFlowExecutionMessages struct {
334}
335
336func (*validateOpListFlowExecutionMessages) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpListFlowExecutionMessages) 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.(*ListFlowExecutionMessagesInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpListFlowExecutionMessagesInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpListTagsForResource struct {
354}
355
356func (*validateOpListTagsForResource) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpListTagsForResourceInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpSearchEntities struct {
374}
375
376func (*validateOpSearchEntities) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpSearchEntities) 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.(*SearchEntitiesInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpSearchEntitiesInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpSearchFlowExecutions struct {
394}
395
396func (*validateOpSearchFlowExecutions) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpSearchFlowExecutions) 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.(*SearchFlowExecutionsInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpSearchFlowExecutionsInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpSearchFlowTemplates struct {
414}
415
416func (*validateOpSearchFlowTemplates) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpSearchFlowTemplates) 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.(*SearchFlowTemplatesInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpSearchFlowTemplatesInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpSearchSystemTemplates struct {
434}
435
436func (*validateOpSearchSystemTemplates) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpSearchSystemTemplates) 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.(*SearchSystemTemplatesInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpSearchSystemTemplatesInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpSearchThings struct {
454}
455
456func (*validateOpSearchThings) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpSearchThings) 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.(*SearchThingsInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpSearchThingsInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpTagResource struct {
474}
475
476func (*validateOpTagResource) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpTagResource) 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.(*TagResourceInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpTagResourceInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpUntagResource struct {
494}
495
496func (*validateOpUntagResource) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpUntagResource) 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.(*UntagResourceInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpUntagResourceInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpUpdateFlowTemplate struct {
514}
515
516func (*validateOpUpdateFlowTemplate) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpUpdateFlowTemplate) 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.(*UpdateFlowTemplateInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpUpdateFlowTemplateInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpUpdateSystemTemplate struct {
534}
535
536func (*validateOpUpdateSystemTemplate) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpUpdateSystemTemplate) 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.(*UpdateSystemTemplateInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpUpdateSystemTemplateInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpUploadEntityDefinitions struct {
554}
555
556func (*validateOpUploadEntityDefinitions) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpUploadEntityDefinitions) 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.(*UploadEntityDefinitionsInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpUploadEntityDefinitionsInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573func addOpAssociateEntityToThingValidationMiddleware(stack *middleware.Stack) error {
574	return stack.Initialize.Add(&validateOpAssociateEntityToThing{}, middleware.After)
575}
576
577func addOpCreateFlowTemplateValidationMiddleware(stack *middleware.Stack) error {
578	return stack.Initialize.Add(&validateOpCreateFlowTemplate{}, middleware.After)
579}
580
581func addOpCreateSystemInstanceValidationMiddleware(stack *middleware.Stack) error {
582	return stack.Initialize.Add(&validateOpCreateSystemInstance{}, middleware.After)
583}
584
585func addOpCreateSystemTemplateValidationMiddleware(stack *middleware.Stack) error {
586	return stack.Initialize.Add(&validateOpCreateSystemTemplate{}, middleware.After)
587}
588
589func addOpDeleteFlowTemplateValidationMiddleware(stack *middleware.Stack) error {
590	return stack.Initialize.Add(&validateOpDeleteFlowTemplate{}, middleware.After)
591}
592
593func addOpDeleteSystemTemplateValidationMiddleware(stack *middleware.Stack) error {
594	return stack.Initialize.Add(&validateOpDeleteSystemTemplate{}, middleware.After)
595}
596
597func addOpDeprecateFlowTemplateValidationMiddleware(stack *middleware.Stack) error {
598	return stack.Initialize.Add(&validateOpDeprecateFlowTemplate{}, middleware.After)
599}
600
601func addOpDeprecateSystemTemplateValidationMiddleware(stack *middleware.Stack) error {
602	return stack.Initialize.Add(&validateOpDeprecateSystemTemplate{}, middleware.After)
603}
604
605func addOpDissociateEntityFromThingValidationMiddleware(stack *middleware.Stack) error {
606	return stack.Initialize.Add(&validateOpDissociateEntityFromThing{}, middleware.After)
607}
608
609func addOpGetEntitiesValidationMiddleware(stack *middleware.Stack) error {
610	return stack.Initialize.Add(&validateOpGetEntities{}, middleware.After)
611}
612
613func addOpGetFlowTemplateValidationMiddleware(stack *middleware.Stack) error {
614	return stack.Initialize.Add(&validateOpGetFlowTemplate{}, middleware.After)
615}
616
617func addOpGetFlowTemplateRevisionsValidationMiddleware(stack *middleware.Stack) error {
618	return stack.Initialize.Add(&validateOpGetFlowTemplateRevisions{}, middleware.After)
619}
620
621func addOpGetSystemInstanceValidationMiddleware(stack *middleware.Stack) error {
622	return stack.Initialize.Add(&validateOpGetSystemInstance{}, middleware.After)
623}
624
625func addOpGetSystemTemplateValidationMiddleware(stack *middleware.Stack) error {
626	return stack.Initialize.Add(&validateOpGetSystemTemplate{}, middleware.After)
627}
628
629func addOpGetSystemTemplateRevisionsValidationMiddleware(stack *middleware.Stack) error {
630	return stack.Initialize.Add(&validateOpGetSystemTemplateRevisions{}, middleware.After)
631}
632
633func addOpGetUploadStatusValidationMiddleware(stack *middleware.Stack) error {
634	return stack.Initialize.Add(&validateOpGetUploadStatus{}, middleware.After)
635}
636
637func addOpListFlowExecutionMessagesValidationMiddleware(stack *middleware.Stack) error {
638	return stack.Initialize.Add(&validateOpListFlowExecutionMessages{}, middleware.After)
639}
640
641func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
642	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
643}
644
645func addOpSearchEntitiesValidationMiddleware(stack *middleware.Stack) error {
646	return stack.Initialize.Add(&validateOpSearchEntities{}, middleware.After)
647}
648
649func addOpSearchFlowExecutionsValidationMiddleware(stack *middleware.Stack) error {
650	return stack.Initialize.Add(&validateOpSearchFlowExecutions{}, middleware.After)
651}
652
653func addOpSearchFlowTemplatesValidationMiddleware(stack *middleware.Stack) error {
654	return stack.Initialize.Add(&validateOpSearchFlowTemplates{}, middleware.After)
655}
656
657func addOpSearchSystemTemplatesValidationMiddleware(stack *middleware.Stack) error {
658	return stack.Initialize.Add(&validateOpSearchSystemTemplates{}, middleware.After)
659}
660
661func addOpSearchThingsValidationMiddleware(stack *middleware.Stack) error {
662	return stack.Initialize.Add(&validateOpSearchThings{}, middleware.After)
663}
664
665func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
666	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
667}
668
669func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
670	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
671}
672
673func addOpUpdateFlowTemplateValidationMiddleware(stack *middleware.Stack) error {
674	return stack.Initialize.Add(&validateOpUpdateFlowTemplate{}, middleware.After)
675}
676
677func addOpUpdateSystemTemplateValidationMiddleware(stack *middleware.Stack) error {
678	return stack.Initialize.Add(&validateOpUpdateSystemTemplate{}, middleware.After)
679}
680
681func addOpUploadEntityDefinitionsValidationMiddleware(stack *middleware.Stack) error {
682	return stack.Initialize.Add(&validateOpUploadEntityDefinitions{}, middleware.After)
683}
684
685func validateDefinitionDocument(v *types.DefinitionDocument) error {
686	if v == nil {
687		return nil
688	}
689	invalidParams := smithy.InvalidParamsError{Context: "DefinitionDocument"}
690	if len(v.Language) == 0 {
691		invalidParams.Add(smithy.NewErrParamRequired("Language"))
692	}
693	if v.Text == nil {
694		invalidParams.Add(smithy.NewErrParamRequired("Text"))
695	}
696	if invalidParams.Len() > 0 {
697		return invalidParams
698	} else {
699		return nil
700	}
701}
702
703func validateFlowTemplateFilter(v *types.FlowTemplateFilter) error {
704	if v == nil {
705		return nil
706	}
707	invalidParams := smithy.InvalidParamsError{Context: "FlowTemplateFilter"}
708	if len(v.Name) == 0 {
709		invalidParams.Add(smithy.NewErrParamRequired("Name"))
710	}
711	if v.Value == nil {
712		invalidParams.Add(smithy.NewErrParamRequired("Value"))
713	}
714	if invalidParams.Len() > 0 {
715		return invalidParams
716	} else {
717		return nil
718	}
719}
720
721func validateFlowTemplateFilters(v []types.FlowTemplateFilter) error {
722	if v == nil {
723		return nil
724	}
725	invalidParams := smithy.InvalidParamsError{Context: "FlowTemplateFilters"}
726	for i := range v {
727		if err := validateFlowTemplateFilter(&v[i]); err != nil {
728			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
729		}
730	}
731	if invalidParams.Len() > 0 {
732		return invalidParams
733	} else {
734		return nil
735	}
736}
737
738func validateSystemTemplateFilter(v *types.SystemTemplateFilter) error {
739	if v == nil {
740		return nil
741	}
742	invalidParams := smithy.InvalidParamsError{Context: "SystemTemplateFilter"}
743	if len(v.Name) == 0 {
744		invalidParams.Add(smithy.NewErrParamRequired("Name"))
745	}
746	if v.Value == nil {
747		invalidParams.Add(smithy.NewErrParamRequired("Value"))
748	}
749	if invalidParams.Len() > 0 {
750		return invalidParams
751	} else {
752		return nil
753	}
754}
755
756func validateSystemTemplateFilters(v []types.SystemTemplateFilter) error {
757	if v == nil {
758		return nil
759	}
760	invalidParams := smithy.InvalidParamsError{Context: "SystemTemplateFilters"}
761	for i := range v {
762		if err := validateSystemTemplateFilter(&v[i]); err != nil {
763			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
764		}
765	}
766	if invalidParams.Len() > 0 {
767		return invalidParams
768	} else {
769		return nil
770	}
771}
772
773func validateTag(v *types.Tag) error {
774	if v == nil {
775		return nil
776	}
777	invalidParams := smithy.InvalidParamsError{Context: "Tag"}
778	if v.Key == nil {
779		invalidParams.Add(smithy.NewErrParamRequired("Key"))
780	}
781	if v.Value == nil {
782		invalidParams.Add(smithy.NewErrParamRequired("Value"))
783	}
784	if invalidParams.Len() > 0 {
785		return invalidParams
786	} else {
787		return nil
788	}
789}
790
791func validateTagList(v []types.Tag) error {
792	if v == nil {
793		return nil
794	}
795	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
796	for i := range v {
797		if err := validateTag(&v[i]); err != nil {
798			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
799		}
800	}
801	if invalidParams.Len() > 0 {
802		return invalidParams
803	} else {
804		return nil
805	}
806}
807
808func validateOpAssociateEntityToThingInput(v *AssociateEntityToThingInput) error {
809	if v == nil {
810		return nil
811	}
812	invalidParams := smithy.InvalidParamsError{Context: "AssociateEntityToThingInput"}
813	if v.ThingName == nil {
814		invalidParams.Add(smithy.NewErrParamRequired("ThingName"))
815	}
816	if v.EntityId == nil {
817		invalidParams.Add(smithy.NewErrParamRequired("EntityId"))
818	}
819	if invalidParams.Len() > 0 {
820		return invalidParams
821	} else {
822		return nil
823	}
824}
825
826func validateOpCreateFlowTemplateInput(v *CreateFlowTemplateInput) error {
827	if v == nil {
828		return nil
829	}
830	invalidParams := smithy.InvalidParamsError{Context: "CreateFlowTemplateInput"}
831	if v.Definition == nil {
832		invalidParams.Add(smithy.NewErrParamRequired("Definition"))
833	} else if v.Definition != nil {
834		if err := validateDefinitionDocument(v.Definition); err != nil {
835			invalidParams.AddNested("Definition", err.(smithy.InvalidParamsError))
836		}
837	}
838	if invalidParams.Len() > 0 {
839		return invalidParams
840	} else {
841		return nil
842	}
843}
844
845func validateOpCreateSystemInstanceInput(v *CreateSystemInstanceInput) error {
846	if v == nil {
847		return nil
848	}
849	invalidParams := smithy.InvalidParamsError{Context: "CreateSystemInstanceInput"}
850	if v.Tags != nil {
851		if err := validateTagList(v.Tags); err != nil {
852			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
853		}
854	}
855	if v.Definition == nil {
856		invalidParams.Add(smithy.NewErrParamRequired("Definition"))
857	} else if v.Definition != nil {
858		if err := validateDefinitionDocument(v.Definition); err != nil {
859			invalidParams.AddNested("Definition", err.(smithy.InvalidParamsError))
860		}
861	}
862	if len(v.Target) == 0 {
863		invalidParams.Add(smithy.NewErrParamRequired("Target"))
864	}
865	if invalidParams.Len() > 0 {
866		return invalidParams
867	} else {
868		return nil
869	}
870}
871
872func validateOpCreateSystemTemplateInput(v *CreateSystemTemplateInput) error {
873	if v == nil {
874		return nil
875	}
876	invalidParams := smithy.InvalidParamsError{Context: "CreateSystemTemplateInput"}
877	if v.Definition == nil {
878		invalidParams.Add(smithy.NewErrParamRequired("Definition"))
879	} else if v.Definition != nil {
880		if err := validateDefinitionDocument(v.Definition); err != nil {
881			invalidParams.AddNested("Definition", err.(smithy.InvalidParamsError))
882		}
883	}
884	if invalidParams.Len() > 0 {
885		return invalidParams
886	} else {
887		return nil
888	}
889}
890
891func validateOpDeleteFlowTemplateInput(v *DeleteFlowTemplateInput) error {
892	if v == nil {
893		return nil
894	}
895	invalidParams := smithy.InvalidParamsError{Context: "DeleteFlowTemplateInput"}
896	if v.Id == nil {
897		invalidParams.Add(smithy.NewErrParamRequired("Id"))
898	}
899	if invalidParams.Len() > 0 {
900		return invalidParams
901	} else {
902		return nil
903	}
904}
905
906func validateOpDeleteSystemTemplateInput(v *DeleteSystemTemplateInput) error {
907	if v == nil {
908		return nil
909	}
910	invalidParams := smithy.InvalidParamsError{Context: "DeleteSystemTemplateInput"}
911	if v.Id == nil {
912		invalidParams.Add(smithy.NewErrParamRequired("Id"))
913	}
914	if invalidParams.Len() > 0 {
915		return invalidParams
916	} else {
917		return nil
918	}
919}
920
921func validateOpDeprecateFlowTemplateInput(v *DeprecateFlowTemplateInput) error {
922	if v == nil {
923		return nil
924	}
925	invalidParams := smithy.InvalidParamsError{Context: "DeprecateFlowTemplateInput"}
926	if v.Id == nil {
927		invalidParams.Add(smithy.NewErrParamRequired("Id"))
928	}
929	if invalidParams.Len() > 0 {
930		return invalidParams
931	} else {
932		return nil
933	}
934}
935
936func validateOpDeprecateSystemTemplateInput(v *DeprecateSystemTemplateInput) error {
937	if v == nil {
938		return nil
939	}
940	invalidParams := smithy.InvalidParamsError{Context: "DeprecateSystemTemplateInput"}
941	if v.Id == nil {
942		invalidParams.Add(smithy.NewErrParamRequired("Id"))
943	}
944	if invalidParams.Len() > 0 {
945		return invalidParams
946	} else {
947		return nil
948	}
949}
950
951func validateOpDissociateEntityFromThingInput(v *DissociateEntityFromThingInput) error {
952	if v == nil {
953		return nil
954	}
955	invalidParams := smithy.InvalidParamsError{Context: "DissociateEntityFromThingInput"}
956	if v.ThingName == nil {
957		invalidParams.Add(smithy.NewErrParamRequired("ThingName"))
958	}
959	if len(v.EntityType) == 0 {
960		invalidParams.Add(smithy.NewErrParamRequired("EntityType"))
961	}
962	if invalidParams.Len() > 0 {
963		return invalidParams
964	} else {
965		return nil
966	}
967}
968
969func validateOpGetEntitiesInput(v *GetEntitiesInput) error {
970	if v == nil {
971		return nil
972	}
973	invalidParams := smithy.InvalidParamsError{Context: "GetEntitiesInput"}
974	if v.Ids == nil {
975		invalidParams.Add(smithy.NewErrParamRequired("Ids"))
976	}
977	if invalidParams.Len() > 0 {
978		return invalidParams
979	} else {
980		return nil
981	}
982}
983
984func validateOpGetFlowTemplateInput(v *GetFlowTemplateInput) error {
985	if v == nil {
986		return nil
987	}
988	invalidParams := smithy.InvalidParamsError{Context: "GetFlowTemplateInput"}
989	if v.Id == nil {
990		invalidParams.Add(smithy.NewErrParamRequired("Id"))
991	}
992	if invalidParams.Len() > 0 {
993		return invalidParams
994	} else {
995		return nil
996	}
997}
998
999func validateOpGetFlowTemplateRevisionsInput(v *GetFlowTemplateRevisionsInput) error {
1000	if v == nil {
1001		return nil
1002	}
1003	invalidParams := smithy.InvalidParamsError{Context: "GetFlowTemplateRevisionsInput"}
1004	if v.Id == nil {
1005		invalidParams.Add(smithy.NewErrParamRequired("Id"))
1006	}
1007	if invalidParams.Len() > 0 {
1008		return invalidParams
1009	} else {
1010		return nil
1011	}
1012}
1013
1014func validateOpGetSystemInstanceInput(v *GetSystemInstanceInput) error {
1015	if v == nil {
1016		return nil
1017	}
1018	invalidParams := smithy.InvalidParamsError{Context: "GetSystemInstanceInput"}
1019	if v.Id == nil {
1020		invalidParams.Add(smithy.NewErrParamRequired("Id"))
1021	}
1022	if invalidParams.Len() > 0 {
1023		return invalidParams
1024	} else {
1025		return nil
1026	}
1027}
1028
1029func validateOpGetSystemTemplateInput(v *GetSystemTemplateInput) error {
1030	if v == nil {
1031		return nil
1032	}
1033	invalidParams := smithy.InvalidParamsError{Context: "GetSystemTemplateInput"}
1034	if v.Id == nil {
1035		invalidParams.Add(smithy.NewErrParamRequired("Id"))
1036	}
1037	if invalidParams.Len() > 0 {
1038		return invalidParams
1039	} else {
1040		return nil
1041	}
1042}
1043
1044func validateOpGetSystemTemplateRevisionsInput(v *GetSystemTemplateRevisionsInput) error {
1045	if v == nil {
1046		return nil
1047	}
1048	invalidParams := smithy.InvalidParamsError{Context: "GetSystemTemplateRevisionsInput"}
1049	if v.Id == nil {
1050		invalidParams.Add(smithy.NewErrParamRequired("Id"))
1051	}
1052	if invalidParams.Len() > 0 {
1053		return invalidParams
1054	} else {
1055		return nil
1056	}
1057}
1058
1059func validateOpGetUploadStatusInput(v *GetUploadStatusInput) error {
1060	if v == nil {
1061		return nil
1062	}
1063	invalidParams := smithy.InvalidParamsError{Context: "GetUploadStatusInput"}
1064	if v.UploadId == nil {
1065		invalidParams.Add(smithy.NewErrParamRequired("UploadId"))
1066	}
1067	if invalidParams.Len() > 0 {
1068		return invalidParams
1069	} else {
1070		return nil
1071	}
1072}
1073
1074func validateOpListFlowExecutionMessagesInput(v *ListFlowExecutionMessagesInput) error {
1075	if v == nil {
1076		return nil
1077	}
1078	invalidParams := smithy.InvalidParamsError{Context: "ListFlowExecutionMessagesInput"}
1079	if v.FlowExecutionId == nil {
1080		invalidParams.Add(smithy.NewErrParamRequired("FlowExecutionId"))
1081	}
1082	if invalidParams.Len() > 0 {
1083		return invalidParams
1084	} else {
1085		return nil
1086	}
1087}
1088
1089func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
1090	if v == nil {
1091		return nil
1092	}
1093	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
1094	if v.ResourceArn == nil {
1095		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1096	}
1097	if invalidParams.Len() > 0 {
1098		return invalidParams
1099	} else {
1100		return nil
1101	}
1102}
1103
1104func validateOpSearchEntitiesInput(v *SearchEntitiesInput) error {
1105	if v == nil {
1106		return nil
1107	}
1108	invalidParams := smithy.InvalidParamsError{Context: "SearchEntitiesInput"}
1109	if v.EntityTypes == nil {
1110		invalidParams.Add(smithy.NewErrParamRequired("EntityTypes"))
1111	}
1112	if invalidParams.Len() > 0 {
1113		return invalidParams
1114	} else {
1115		return nil
1116	}
1117}
1118
1119func validateOpSearchFlowExecutionsInput(v *SearchFlowExecutionsInput) error {
1120	if v == nil {
1121		return nil
1122	}
1123	invalidParams := smithy.InvalidParamsError{Context: "SearchFlowExecutionsInput"}
1124	if v.SystemInstanceId == nil {
1125		invalidParams.Add(smithy.NewErrParamRequired("SystemInstanceId"))
1126	}
1127	if invalidParams.Len() > 0 {
1128		return invalidParams
1129	} else {
1130		return nil
1131	}
1132}
1133
1134func validateOpSearchFlowTemplatesInput(v *SearchFlowTemplatesInput) error {
1135	if v == nil {
1136		return nil
1137	}
1138	invalidParams := smithy.InvalidParamsError{Context: "SearchFlowTemplatesInput"}
1139	if v.Filters != nil {
1140		if err := validateFlowTemplateFilters(v.Filters); err != nil {
1141			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
1142		}
1143	}
1144	if invalidParams.Len() > 0 {
1145		return invalidParams
1146	} else {
1147		return nil
1148	}
1149}
1150
1151func validateOpSearchSystemTemplatesInput(v *SearchSystemTemplatesInput) error {
1152	if v == nil {
1153		return nil
1154	}
1155	invalidParams := smithy.InvalidParamsError{Context: "SearchSystemTemplatesInput"}
1156	if v.Filters != nil {
1157		if err := validateSystemTemplateFilters(v.Filters); err != nil {
1158			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
1159		}
1160	}
1161	if invalidParams.Len() > 0 {
1162		return invalidParams
1163	} else {
1164		return nil
1165	}
1166}
1167
1168func validateOpSearchThingsInput(v *SearchThingsInput) error {
1169	if v == nil {
1170		return nil
1171	}
1172	invalidParams := smithy.InvalidParamsError{Context: "SearchThingsInput"}
1173	if v.EntityId == nil {
1174		invalidParams.Add(smithy.NewErrParamRequired("EntityId"))
1175	}
1176	if invalidParams.Len() > 0 {
1177		return invalidParams
1178	} else {
1179		return nil
1180	}
1181}
1182
1183func validateOpTagResourceInput(v *TagResourceInput) error {
1184	if v == nil {
1185		return nil
1186	}
1187	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
1188	if v.ResourceArn == nil {
1189		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1190	}
1191	if v.Tags == nil {
1192		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
1193	} else if v.Tags != nil {
1194		if err := validateTagList(v.Tags); err != nil {
1195			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1196		}
1197	}
1198	if invalidParams.Len() > 0 {
1199		return invalidParams
1200	} else {
1201		return nil
1202	}
1203}
1204
1205func validateOpUntagResourceInput(v *UntagResourceInput) error {
1206	if v == nil {
1207		return nil
1208	}
1209	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
1210	if v.ResourceArn == nil {
1211		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1212	}
1213	if v.TagKeys == nil {
1214		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
1215	}
1216	if invalidParams.Len() > 0 {
1217		return invalidParams
1218	} else {
1219		return nil
1220	}
1221}
1222
1223func validateOpUpdateFlowTemplateInput(v *UpdateFlowTemplateInput) error {
1224	if v == nil {
1225		return nil
1226	}
1227	invalidParams := smithy.InvalidParamsError{Context: "UpdateFlowTemplateInput"}
1228	if v.Id == nil {
1229		invalidParams.Add(smithy.NewErrParamRequired("Id"))
1230	}
1231	if v.Definition == nil {
1232		invalidParams.Add(smithy.NewErrParamRequired("Definition"))
1233	} else if v.Definition != nil {
1234		if err := validateDefinitionDocument(v.Definition); err != nil {
1235			invalidParams.AddNested("Definition", err.(smithy.InvalidParamsError))
1236		}
1237	}
1238	if invalidParams.Len() > 0 {
1239		return invalidParams
1240	} else {
1241		return nil
1242	}
1243}
1244
1245func validateOpUpdateSystemTemplateInput(v *UpdateSystemTemplateInput) error {
1246	if v == nil {
1247		return nil
1248	}
1249	invalidParams := smithy.InvalidParamsError{Context: "UpdateSystemTemplateInput"}
1250	if v.Id == nil {
1251		invalidParams.Add(smithy.NewErrParamRequired("Id"))
1252	}
1253	if v.Definition == nil {
1254		invalidParams.Add(smithy.NewErrParamRequired("Definition"))
1255	} else if v.Definition != nil {
1256		if err := validateDefinitionDocument(v.Definition); err != nil {
1257			invalidParams.AddNested("Definition", err.(smithy.InvalidParamsError))
1258		}
1259	}
1260	if invalidParams.Len() > 0 {
1261		return invalidParams
1262	} else {
1263		return nil
1264	}
1265}
1266
1267func validateOpUploadEntityDefinitionsInput(v *UploadEntityDefinitionsInput) error {
1268	if v == nil {
1269		return nil
1270	}
1271	invalidParams := smithy.InvalidParamsError{Context: "UploadEntityDefinitionsInput"}
1272	if v.Document != nil {
1273		if err := validateDefinitionDocument(v.Document); err != nil {
1274			invalidParams.AddNested("Document", err.(smithy.InvalidParamsError))
1275		}
1276	}
1277	if invalidParams.Len() > 0 {
1278		return invalidParams
1279	} else {
1280		return nil
1281	}
1282}
1283