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 validateOpSearchDevices struct {
94}
95
96func (*validateOpSearchDevices) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpSearchDevices) 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.(*SearchDevicesInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpSearchDevicesInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpSearchQuantumTasks struct {
114}
115
116func (*validateOpSearchQuantumTasks) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpSearchQuantumTasks) 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.(*SearchQuantumTasksInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpSearchQuantumTasksInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133func addOpCancelQuantumTaskValidationMiddleware(stack *middleware.Stack) error {
134	return stack.Initialize.Add(&validateOpCancelQuantumTask{}, middleware.After)
135}
136
137func addOpCreateQuantumTaskValidationMiddleware(stack *middleware.Stack) error {
138	return stack.Initialize.Add(&validateOpCreateQuantumTask{}, middleware.After)
139}
140
141func addOpGetDeviceValidationMiddleware(stack *middleware.Stack) error {
142	return stack.Initialize.Add(&validateOpGetDevice{}, middleware.After)
143}
144
145func addOpGetQuantumTaskValidationMiddleware(stack *middleware.Stack) error {
146	return stack.Initialize.Add(&validateOpGetQuantumTask{}, middleware.After)
147}
148
149func addOpSearchDevicesValidationMiddleware(stack *middleware.Stack) error {
150	return stack.Initialize.Add(&validateOpSearchDevices{}, middleware.After)
151}
152
153func addOpSearchQuantumTasksValidationMiddleware(stack *middleware.Stack) error {
154	return stack.Initialize.Add(&validateOpSearchQuantumTasks{}, middleware.After)
155}
156
157func validateSearchDevicesFilter(v *types.SearchDevicesFilter) error {
158	if v == nil {
159		return nil
160	}
161	invalidParams := smithy.InvalidParamsError{Context: "SearchDevicesFilter"}
162	if v.Name == nil {
163		invalidParams.Add(smithy.NewErrParamRequired("Name"))
164	}
165	if v.Values == nil {
166		invalidParams.Add(smithy.NewErrParamRequired("Values"))
167	}
168	if invalidParams.Len() > 0 {
169		return invalidParams
170	} else {
171		return nil
172	}
173}
174
175func validateSearchDevicesFilterList(v []types.SearchDevicesFilter) error {
176	if v == nil {
177		return nil
178	}
179	invalidParams := smithy.InvalidParamsError{Context: "SearchDevicesFilterList"}
180	for i := range v {
181		if err := validateSearchDevicesFilter(&v[i]); err != nil {
182			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
183		}
184	}
185	if invalidParams.Len() > 0 {
186		return invalidParams
187	} else {
188		return nil
189	}
190}
191
192func validateSearchQuantumTasksFilter(v *types.SearchQuantumTasksFilter) error {
193	if v == nil {
194		return nil
195	}
196	invalidParams := smithy.InvalidParamsError{Context: "SearchQuantumTasksFilter"}
197	if v.Name == nil {
198		invalidParams.Add(smithy.NewErrParamRequired("Name"))
199	}
200	if v.Values == nil {
201		invalidParams.Add(smithy.NewErrParamRequired("Values"))
202	}
203	if len(v.Operator) == 0 {
204		invalidParams.Add(smithy.NewErrParamRequired("Operator"))
205	}
206	if invalidParams.Len() > 0 {
207		return invalidParams
208	} else {
209		return nil
210	}
211}
212
213func validateSearchQuantumTasksFilterList(v []types.SearchQuantumTasksFilter) error {
214	if v == nil {
215		return nil
216	}
217	invalidParams := smithy.InvalidParamsError{Context: "SearchQuantumTasksFilterList"}
218	for i := range v {
219		if err := validateSearchQuantumTasksFilter(&v[i]); err != nil {
220			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
221		}
222	}
223	if invalidParams.Len() > 0 {
224		return invalidParams
225	} else {
226		return nil
227	}
228}
229
230func validateOpCancelQuantumTaskInput(v *CancelQuantumTaskInput) error {
231	if v == nil {
232		return nil
233	}
234	invalidParams := smithy.InvalidParamsError{Context: "CancelQuantumTaskInput"}
235	if v.QuantumTaskArn == nil {
236		invalidParams.Add(smithy.NewErrParamRequired("QuantumTaskArn"))
237	}
238	if v.ClientToken == nil {
239		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
240	}
241	if invalidParams.Len() > 0 {
242		return invalidParams
243	} else {
244		return nil
245	}
246}
247
248func validateOpCreateQuantumTaskInput(v *CreateQuantumTaskInput) error {
249	if v == nil {
250		return nil
251	}
252	invalidParams := smithy.InvalidParamsError{Context: "CreateQuantumTaskInput"}
253	if v.ClientToken == nil {
254		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
255	}
256	if v.DeviceArn == nil {
257		invalidParams.Add(smithy.NewErrParamRequired("DeviceArn"))
258	}
259	if v.Shots == nil {
260		invalidParams.Add(smithy.NewErrParamRequired("Shots"))
261	}
262	if v.OutputS3Bucket == nil {
263		invalidParams.Add(smithy.NewErrParamRequired("OutputS3Bucket"))
264	}
265	if v.OutputS3KeyPrefix == nil {
266		invalidParams.Add(smithy.NewErrParamRequired("OutputS3KeyPrefix"))
267	}
268	if v.Action == nil {
269		invalidParams.Add(smithy.NewErrParamRequired("Action"))
270	}
271	if invalidParams.Len() > 0 {
272		return invalidParams
273	} else {
274		return nil
275	}
276}
277
278func validateOpGetDeviceInput(v *GetDeviceInput) error {
279	if v == nil {
280		return nil
281	}
282	invalidParams := smithy.InvalidParamsError{Context: "GetDeviceInput"}
283	if v.DeviceArn == nil {
284		invalidParams.Add(smithy.NewErrParamRequired("DeviceArn"))
285	}
286	if invalidParams.Len() > 0 {
287		return invalidParams
288	} else {
289		return nil
290	}
291}
292
293func validateOpGetQuantumTaskInput(v *GetQuantumTaskInput) error {
294	if v == nil {
295		return nil
296	}
297	invalidParams := smithy.InvalidParamsError{Context: "GetQuantumTaskInput"}
298	if v.QuantumTaskArn == nil {
299		invalidParams.Add(smithy.NewErrParamRequired("QuantumTaskArn"))
300	}
301	if invalidParams.Len() > 0 {
302		return invalidParams
303	} else {
304		return nil
305	}
306}
307
308func validateOpSearchDevicesInput(v *SearchDevicesInput) error {
309	if v == nil {
310		return nil
311	}
312	invalidParams := smithy.InvalidParamsError{Context: "SearchDevicesInput"}
313	if v.Filters == nil {
314		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
315	} else if v.Filters != nil {
316		if err := validateSearchDevicesFilterList(v.Filters); err != nil {
317			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
318		}
319	}
320	if invalidParams.Len() > 0 {
321		return invalidParams
322	} else {
323		return nil
324	}
325}
326
327func validateOpSearchQuantumTasksInput(v *SearchQuantumTasksInput) error {
328	if v == nil {
329		return nil
330	}
331	invalidParams := smithy.InvalidParamsError{Context: "SearchQuantumTasksInput"}
332	if v.Filters == nil {
333		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
334	} else if v.Filters != nil {
335		if err := validateSearchQuantumTasksFilterList(v.Filters); err != nil {
336			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
337		}
338	}
339	if invalidParams.Len() > 0 {
340		return invalidParams
341	} else {
342		return nil
343	}
344}
345