1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package braket
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/braket/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpCancelQuantumTask struct {
14}
15
16func (*validateOpCancelQuantumTask) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpCancelQuantumTask) 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.(*CancelQuantumTaskInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpCancelQuantumTaskInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpCreateQuantumTask struct {
34}
35
36func (*validateOpCreateQuantumTask) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpCreateQuantumTask) 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.(*CreateQuantumTaskInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpCreateQuantumTaskInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpGetDevice struct {
54}
55
56func (*validateOpGetDevice) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpGetDevice) 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.(*GetDeviceInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpGetDeviceInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpGetQuantumTask struct {
74}
75
76func (*validateOpGetQuantumTask) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpGetQuantumTask) 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.(*GetQuantumTaskInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpGetQuantumTaskInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpListTagsForResource struct {
94}
95
96func (*validateOpListTagsForResource) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpListTagsForResourceInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpSearchDevices struct {
114}
115
116func (*validateOpSearchDevices) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpSearchDevices) 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.(*SearchDevicesInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpSearchDevicesInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpSearchQuantumTasks struct {
134}
135
136func (*validateOpSearchQuantumTasks) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpSearchQuantumTasks) 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.(*SearchQuantumTasksInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpSearchQuantumTasksInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpTagResource struct {
154}
155
156func (*validateOpTagResource) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpTagResource) 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.(*TagResourceInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpTagResourceInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpUntagResource struct {
174}
175
176func (*validateOpUntagResource) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpUntagResource) 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.(*UntagResourceInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpUntagResourceInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193func addOpCancelQuantumTaskValidationMiddleware(stack *middleware.Stack) error {
194	return stack.Initialize.Add(&validateOpCancelQuantumTask{}, middleware.After)
195}
196
197func addOpCreateQuantumTaskValidationMiddleware(stack *middleware.Stack) error {
198	return stack.Initialize.Add(&validateOpCreateQuantumTask{}, middleware.After)
199}
200
201func addOpGetDeviceValidationMiddleware(stack *middleware.Stack) error {
202	return stack.Initialize.Add(&validateOpGetDevice{}, middleware.After)
203}
204
205func addOpGetQuantumTaskValidationMiddleware(stack *middleware.Stack) error {
206	return stack.Initialize.Add(&validateOpGetQuantumTask{}, middleware.After)
207}
208
209func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
210	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
211}
212
213func addOpSearchDevicesValidationMiddleware(stack *middleware.Stack) error {
214	return stack.Initialize.Add(&validateOpSearchDevices{}, middleware.After)
215}
216
217func addOpSearchQuantumTasksValidationMiddleware(stack *middleware.Stack) error {
218	return stack.Initialize.Add(&validateOpSearchQuantumTasks{}, middleware.After)
219}
220
221func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
222	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
223}
224
225func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
226	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
227}
228
229func validateSearchDevicesFilter(v *types.SearchDevicesFilter) error {
230	if v == nil {
231		return nil
232	}
233	invalidParams := smithy.InvalidParamsError{Context: "SearchDevicesFilter"}
234	if v.Name == nil {
235		invalidParams.Add(smithy.NewErrParamRequired("Name"))
236	}
237	if v.Values == nil {
238		invalidParams.Add(smithy.NewErrParamRequired("Values"))
239	}
240	if invalidParams.Len() > 0 {
241		return invalidParams
242	} else {
243		return nil
244	}
245}
246
247func validateSearchDevicesFilterList(v []types.SearchDevicesFilter) error {
248	if v == nil {
249		return nil
250	}
251	invalidParams := smithy.InvalidParamsError{Context: "SearchDevicesFilterList"}
252	for i := range v {
253		if err := validateSearchDevicesFilter(&v[i]); err != nil {
254			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
255		}
256	}
257	if invalidParams.Len() > 0 {
258		return invalidParams
259	} else {
260		return nil
261	}
262}
263
264func validateSearchQuantumTasksFilter(v *types.SearchQuantumTasksFilter) error {
265	if v == nil {
266		return nil
267	}
268	invalidParams := smithy.InvalidParamsError{Context: "SearchQuantumTasksFilter"}
269	if v.Name == nil {
270		invalidParams.Add(smithy.NewErrParamRequired("Name"))
271	}
272	if v.Values == nil {
273		invalidParams.Add(smithy.NewErrParamRequired("Values"))
274	}
275	if len(v.Operator) == 0 {
276		invalidParams.Add(smithy.NewErrParamRequired("Operator"))
277	}
278	if invalidParams.Len() > 0 {
279		return invalidParams
280	} else {
281		return nil
282	}
283}
284
285func validateSearchQuantumTasksFilterList(v []types.SearchQuantumTasksFilter) error {
286	if v == nil {
287		return nil
288	}
289	invalidParams := smithy.InvalidParamsError{Context: "SearchQuantumTasksFilterList"}
290	for i := range v {
291		if err := validateSearchQuantumTasksFilter(&v[i]); err != nil {
292			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
293		}
294	}
295	if invalidParams.Len() > 0 {
296		return invalidParams
297	} else {
298		return nil
299	}
300}
301
302func validateOpCancelQuantumTaskInput(v *CancelQuantumTaskInput) error {
303	if v == nil {
304		return nil
305	}
306	invalidParams := smithy.InvalidParamsError{Context: "CancelQuantumTaskInput"}
307	if v.QuantumTaskArn == nil {
308		invalidParams.Add(smithy.NewErrParamRequired("QuantumTaskArn"))
309	}
310	if v.ClientToken == nil {
311		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
312	}
313	if invalidParams.Len() > 0 {
314		return invalidParams
315	} else {
316		return nil
317	}
318}
319
320func validateOpCreateQuantumTaskInput(v *CreateQuantumTaskInput) error {
321	if v == nil {
322		return nil
323	}
324	invalidParams := smithy.InvalidParamsError{Context: "CreateQuantumTaskInput"}
325	if v.ClientToken == nil {
326		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
327	}
328	if v.DeviceArn == nil {
329		invalidParams.Add(smithy.NewErrParamRequired("DeviceArn"))
330	}
331	if v.Shots == nil {
332		invalidParams.Add(smithy.NewErrParamRequired("Shots"))
333	}
334	if v.OutputS3Bucket == nil {
335		invalidParams.Add(smithy.NewErrParamRequired("OutputS3Bucket"))
336	}
337	if v.OutputS3KeyPrefix == nil {
338		invalidParams.Add(smithy.NewErrParamRequired("OutputS3KeyPrefix"))
339	}
340	if v.Action == nil {
341		invalidParams.Add(smithy.NewErrParamRequired("Action"))
342	}
343	if invalidParams.Len() > 0 {
344		return invalidParams
345	} else {
346		return nil
347	}
348}
349
350func validateOpGetDeviceInput(v *GetDeviceInput) error {
351	if v == nil {
352		return nil
353	}
354	invalidParams := smithy.InvalidParamsError{Context: "GetDeviceInput"}
355	if v.DeviceArn == nil {
356		invalidParams.Add(smithy.NewErrParamRequired("DeviceArn"))
357	}
358	if invalidParams.Len() > 0 {
359		return invalidParams
360	} else {
361		return nil
362	}
363}
364
365func validateOpGetQuantumTaskInput(v *GetQuantumTaskInput) error {
366	if v == nil {
367		return nil
368	}
369	invalidParams := smithy.InvalidParamsError{Context: "GetQuantumTaskInput"}
370	if v.QuantumTaskArn == nil {
371		invalidParams.Add(smithy.NewErrParamRequired("QuantumTaskArn"))
372	}
373	if invalidParams.Len() > 0 {
374		return invalidParams
375	} else {
376		return nil
377	}
378}
379
380func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
381	if v == nil {
382		return nil
383	}
384	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
385	if v.ResourceArn == nil {
386		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
387	}
388	if invalidParams.Len() > 0 {
389		return invalidParams
390	} else {
391		return nil
392	}
393}
394
395func validateOpSearchDevicesInput(v *SearchDevicesInput) error {
396	if v == nil {
397		return nil
398	}
399	invalidParams := smithy.InvalidParamsError{Context: "SearchDevicesInput"}
400	if v.Filters == nil {
401		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
402	} else if v.Filters != nil {
403		if err := validateSearchDevicesFilterList(v.Filters); err != nil {
404			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
405		}
406	}
407	if invalidParams.Len() > 0 {
408		return invalidParams
409	} else {
410		return nil
411	}
412}
413
414func validateOpSearchQuantumTasksInput(v *SearchQuantumTasksInput) error {
415	if v == nil {
416		return nil
417	}
418	invalidParams := smithy.InvalidParamsError{Context: "SearchQuantumTasksInput"}
419	if v.Filters == nil {
420		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
421	} else if v.Filters != nil {
422		if err := validateSearchQuantumTasksFilterList(v.Filters); err != nil {
423			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
424		}
425	}
426	if invalidParams.Len() > 0 {
427		return invalidParams
428	} else {
429		return nil
430	}
431}
432
433func validateOpTagResourceInput(v *TagResourceInput) error {
434	if v == nil {
435		return nil
436	}
437	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
438	if v.ResourceArn == nil {
439		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
440	}
441	if v.Tags == nil {
442		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
443	}
444	if invalidParams.Len() > 0 {
445		return invalidParams
446	} else {
447		return nil
448	}
449}
450
451func validateOpUntagResourceInput(v *UntagResourceInput) error {
452	if v == nil {
453		return nil
454	}
455	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
456	if v.ResourceArn == nil {
457		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
458	}
459	if v.TagKeys == nil {
460		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
461	}
462	if invalidParams.Len() > 0 {
463		return invalidParams
464	} else {
465		return nil
466	}
467}
468