1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package ioteventsdata
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/ioteventsdata/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpBatchPutMessage struct {
14}
15
16func (*validateOpBatchPutMessage) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpBatchPutMessage) 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.(*BatchPutMessageInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpBatchPutMessageInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpBatchUpdateDetector struct {
34}
35
36func (*validateOpBatchUpdateDetector) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpBatchUpdateDetector) 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.(*BatchUpdateDetectorInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpBatchUpdateDetectorInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpDescribeDetector struct {
54}
55
56func (*validateOpDescribeDetector) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpDescribeDetector) 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.(*DescribeDetectorInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpDescribeDetectorInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpListDetectors struct {
74}
75
76func (*validateOpListDetectors) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpListDetectors) 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.(*ListDetectorsInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpListDetectorsInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93func addOpBatchPutMessageValidationMiddleware(stack *middleware.Stack) error {
94	return stack.Initialize.Add(&validateOpBatchPutMessage{}, middleware.After)
95}
96
97func addOpBatchUpdateDetectorValidationMiddleware(stack *middleware.Stack) error {
98	return stack.Initialize.Add(&validateOpBatchUpdateDetector{}, middleware.After)
99}
100
101func addOpDescribeDetectorValidationMiddleware(stack *middleware.Stack) error {
102	return stack.Initialize.Add(&validateOpDescribeDetector{}, middleware.After)
103}
104
105func addOpListDetectorsValidationMiddleware(stack *middleware.Stack) error {
106	return stack.Initialize.Add(&validateOpListDetectors{}, middleware.After)
107}
108
109func validateDetectorStateDefinition(v *types.DetectorStateDefinition) error {
110	if v == nil {
111		return nil
112	}
113	invalidParams := smithy.InvalidParamsError{Context: "DetectorStateDefinition"}
114	if v.StateName == nil {
115		invalidParams.Add(smithy.NewErrParamRequired("StateName"))
116	}
117	if v.Variables == nil {
118		invalidParams.Add(smithy.NewErrParamRequired("Variables"))
119	} else if v.Variables != nil {
120		if err := validateVariableDefinitions(v.Variables); err != nil {
121			invalidParams.AddNested("Variables", err.(smithy.InvalidParamsError))
122		}
123	}
124	if v.Timers == nil {
125		invalidParams.Add(smithy.NewErrParamRequired("Timers"))
126	} else if v.Timers != nil {
127		if err := validateTimerDefinitions(v.Timers); err != nil {
128			invalidParams.AddNested("Timers", err.(smithy.InvalidParamsError))
129		}
130	}
131	if invalidParams.Len() > 0 {
132		return invalidParams
133	} else {
134		return nil
135	}
136}
137
138func validateMessage(v *types.Message) error {
139	if v == nil {
140		return nil
141	}
142	invalidParams := smithy.InvalidParamsError{Context: "Message"}
143	if v.MessageId == nil {
144		invalidParams.Add(smithy.NewErrParamRequired("MessageId"))
145	}
146	if v.InputName == nil {
147		invalidParams.Add(smithy.NewErrParamRequired("InputName"))
148	}
149	if v.Payload == nil {
150		invalidParams.Add(smithy.NewErrParamRequired("Payload"))
151	}
152	if invalidParams.Len() > 0 {
153		return invalidParams
154	} else {
155		return nil
156	}
157}
158
159func validateMessages(v []types.Message) error {
160	if v == nil {
161		return nil
162	}
163	invalidParams := smithy.InvalidParamsError{Context: "Messages"}
164	for i := range v {
165		if err := validateMessage(&v[i]); err != nil {
166			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
167		}
168	}
169	if invalidParams.Len() > 0 {
170		return invalidParams
171	} else {
172		return nil
173	}
174}
175
176func validateTimerDefinition(v *types.TimerDefinition) error {
177	if v == nil {
178		return nil
179	}
180	invalidParams := smithy.InvalidParamsError{Context: "TimerDefinition"}
181	if v.Name == nil {
182		invalidParams.Add(smithy.NewErrParamRequired("Name"))
183	}
184	if v.Seconds == nil {
185		invalidParams.Add(smithy.NewErrParamRequired("Seconds"))
186	}
187	if invalidParams.Len() > 0 {
188		return invalidParams
189	} else {
190		return nil
191	}
192}
193
194func validateTimerDefinitions(v []types.TimerDefinition) error {
195	if v == nil {
196		return nil
197	}
198	invalidParams := smithy.InvalidParamsError{Context: "TimerDefinitions"}
199	for i := range v {
200		if err := validateTimerDefinition(&v[i]); err != nil {
201			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
202		}
203	}
204	if invalidParams.Len() > 0 {
205		return invalidParams
206	} else {
207		return nil
208	}
209}
210
211func validateUpdateDetectorRequest(v *types.UpdateDetectorRequest) error {
212	if v == nil {
213		return nil
214	}
215	invalidParams := smithy.InvalidParamsError{Context: "UpdateDetectorRequest"}
216	if v.MessageId == nil {
217		invalidParams.Add(smithy.NewErrParamRequired("MessageId"))
218	}
219	if v.DetectorModelName == nil {
220		invalidParams.Add(smithy.NewErrParamRequired("DetectorModelName"))
221	}
222	if v.State == nil {
223		invalidParams.Add(smithy.NewErrParamRequired("State"))
224	} else if v.State != nil {
225		if err := validateDetectorStateDefinition(v.State); err != nil {
226			invalidParams.AddNested("State", err.(smithy.InvalidParamsError))
227		}
228	}
229	if invalidParams.Len() > 0 {
230		return invalidParams
231	} else {
232		return nil
233	}
234}
235
236func validateUpdateDetectorRequests(v []types.UpdateDetectorRequest) error {
237	if v == nil {
238		return nil
239	}
240	invalidParams := smithy.InvalidParamsError{Context: "UpdateDetectorRequests"}
241	for i := range v {
242		if err := validateUpdateDetectorRequest(&v[i]); err != nil {
243			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
244		}
245	}
246	if invalidParams.Len() > 0 {
247		return invalidParams
248	} else {
249		return nil
250	}
251}
252
253func validateVariableDefinition(v *types.VariableDefinition) error {
254	if v == nil {
255		return nil
256	}
257	invalidParams := smithy.InvalidParamsError{Context: "VariableDefinition"}
258	if v.Name == nil {
259		invalidParams.Add(smithy.NewErrParamRequired("Name"))
260	}
261	if v.Value == nil {
262		invalidParams.Add(smithy.NewErrParamRequired("Value"))
263	}
264	if invalidParams.Len() > 0 {
265		return invalidParams
266	} else {
267		return nil
268	}
269}
270
271func validateVariableDefinitions(v []types.VariableDefinition) error {
272	if v == nil {
273		return nil
274	}
275	invalidParams := smithy.InvalidParamsError{Context: "VariableDefinitions"}
276	for i := range v {
277		if err := validateVariableDefinition(&v[i]); err != nil {
278			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
279		}
280	}
281	if invalidParams.Len() > 0 {
282		return invalidParams
283	} else {
284		return nil
285	}
286}
287
288func validateOpBatchPutMessageInput(v *BatchPutMessageInput) error {
289	if v == nil {
290		return nil
291	}
292	invalidParams := smithy.InvalidParamsError{Context: "BatchPutMessageInput"}
293	if v.Messages == nil {
294		invalidParams.Add(smithy.NewErrParamRequired("Messages"))
295	} else if v.Messages != nil {
296		if err := validateMessages(v.Messages); err != nil {
297			invalidParams.AddNested("Messages", err.(smithy.InvalidParamsError))
298		}
299	}
300	if invalidParams.Len() > 0 {
301		return invalidParams
302	} else {
303		return nil
304	}
305}
306
307func validateOpBatchUpdateDetectorInput(v *BatchUpdateDetectorInput) error {
308	if v == nil {
309		return nil
310	}
311	invalidParams := smithy.InvalidParamsError{Context: "BatchUpdateDetectorInput"}
312	if v.Detectors == nil {
313		invalidParams.Add(smithy.NewErrParamRequired("Detectors"))
314	} else if v.Detectors != nil {
315		if err := validateUpdateDetectorRequests(v.Detectors); err != nil {
316			invalidParams.AddNested("Detectors", err.(smithy.InvalidParamsError))
317		}
318	}
319	if invalidParams.Len() > 0 {
320		return invalidParams
321	} else {
322		return nil
323	}
324}
325
326func validateOpDescribeDetectorInput(v *DescribeDetectorInput) error {
327	if v == nil {
328		return nil
329	}
330	invalidParams := smithy.InvalidParamsError{Context: "DescribeDetectorInput"}
331	if v.DetectorModelName == nil {
332		invalidParams.Add(smithy.NewErrParamRequired("DetectorModelName"))
333	}
334	if invalidParams.Len() > 0 {
335		return invalidParams
336	} else {
337		return nil
338	}
339}
340
341func validateOpListDetectorsInput(v *ListDetectorsInput) error {
342	if v == nil {
343		return nil
344	}
345	invalidParams := smithy.InvalidParamsError{Context: "ListDetectorsInput"}
346	if v.DetectorModelName == nil {
347		invalidParams.Add(smithy.NewErrParamRequired("DetectorModelName"))
348	}
349	if invalidParams.Len() > 0 {
350		return invalidParams
351	} else {
352		return nil
353	}
354}
355