1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package codestarconnections
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/codestarconnections/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpCreateConnection struct {
14}
15
16func (*validateOpCreateConnection) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpCreateConnection) 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.(*CreateConnectionInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpCreateConnectionInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpCreateHost struct {
34}
35
36func (*validateOpCreateHost) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpCreateHost) 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.(*CreateHostInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpCreateHostInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpDeleteConnection struct {
54}
55
56func (*validateOpDeleteConnection) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpDeleteConnection) 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.(*DeleteConnectionInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpDeleteConnectionInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpDeleteHost struct {
74}
75
76func (*validateOpDeleteHost) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpDeleteHost) 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.(*DeleteHostInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpDeleteHostInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpGetConnection struct {
94}
95
96func (*validateOpGetConnection) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpGetConnection) 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.(*GetConnectionInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpGetConnectionInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpGetHost struct {
114}
115
116func (*validateOpGetHost) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpGetHost) 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.(*GetHostInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpGetHostInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpListTagsForResource struct {
134}
135
136func (*validateOpListTagsForResource) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpListTagsForResourceInput(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
193type validateOpUpdateHost struct {
194}
195
196func (*validateOpUpdateHost) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpUpdateHost) 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.(*UpdateHostInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpUpdateHostInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213func addOpCreateConnectionValidationMiddleware(stack *middleware.Stack) error {
214	return stack.Initialize.Add(&validateOpCreateConnection{}, middleware.After)
215}
216
217func addOpCreateHostValidationMiddleware(stack *middleware.Stack) error {
218	return stack.Initialize.Add(&validateOpCreateHost{}, middleware.After)
219}
220
221func addOpDeleteConnectionValidationMiddleware(stack *middleware.Stack) error {
222	return stack.Initialize.Add(&validateOpDeleteConnection{}, middleware.After)
223}
224
225func addOpDeleteHostValidationMiddleware(stack *middleware.Stack) error {
226	return stack.Initialize.Add(&validateOpDeleteHost{}, middleware.After)
227}
228
229func addOpGetConnectionValidationMiddleware(stack *middleware.Stack) error {
230	return stack.Initialize.Add(&validateOpGetConnection{}, middleware.After)
231}
232
233func addOpGetHostValidationMiddleware(stack *middleware.Stack) error {
234	return stack.Initialize.Add(&validateOpGetHost{}, middleware.After)
235}
236
237func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
238	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
239}
240
241func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
242	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
243}
244
245func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
246	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
247}
248
249func addOpUpdateHostValidationMiddleware(stack *middleware.Stack) error {
250	return stack.Initialize.Add(&validateOpUpdateHost{}, middleware.After)
251}
252
253func validateTag(v *types.Tag) error {
254	if v == nil {
255		return nil
256	}
257	invalidParams := smithy.InvalidParamsError{Context: "Tag"}
258	if v.Key == nil {
259		invalidParams.Add(smithy.NewErrParamRequired("Key"))
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 validateTagList(v []types.Tag) error {
272	if v == nil {
273		return nil
274	}
275	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
276	for i := range v {
277		if err := validateTag(&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 validateVpcConfiguration(v *types.VpcConfiguration) error {
289	if v == nil {
290		return nil
291	}
292	invalidParams := smithy.InvalidParamsError{Context: "VpcConfiguration"}
293	if v.VpcId == nil {
294		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
295	}
296	if v.SubnetIds == nil {
297		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
298	}
299	if v.SecurityGroupIds == nil {
300		invalidParams.Add(smithy.NewErrParamRequired("SecurityGroupIds"))
301	}
302	if invalidParams.Len() > 0 {
303		return invalidParams
304	} else {
305		return nil
306	}
307}
308
309func validateOpCreateConnectionInput(v *CreateConnectionInput) error {
310	if v == nil {
311		return nil
312	}
313	invalidParams := smithy.InvalidParamsError{Context: "CreateConnectionInput"}
314	if v.ConnectionName == nil {
315		invalidParams.Add(smithy.NewErrParamRequired("ConnectionName"))
316	}
317	if v.Tags != nil {
318		if err := validateTagList(v.Tags); err != nil {
319			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
320		}
321	}
322	if invalidParams.Len() > 0 {
323		return invalidParams
324	} else {
325		return nil
326	}
327}
328
329func validateOpCreateHostInput(v *CreateHostInput) error {
330	if v == nil {
331		return nil
332	}
333	invalidParams := smithy.InvalidParamsError{Context: "CreateHostInput"}
334	if v.Name == nil {
335		invalidParams.Add(smithy.NewErrParamRequired("Name"))
336	}
337	if len(v.ProviderType) == 0 {
338		invalidParams.Add(smithy.NewErrParamRequired("ProviderType"))
339	}
340	if v.ProviderEndpoint == nil {
341		invalidParams.Add(smithy.NewErrParamRequired("ProviderEndpoint"))
342	}
343	if v.VpcConfiguration != nil {
344		if err := validateVpcConfiguration(v.VpcConfiguration); err != nil {
345			invalidParams.AddNested("VpcConfiguration", err.(smithy.InvalidParamsError))
346		}
347	}
348	if v.Tags != nil {
349		if err := validateTagList(v.Tags); err != nil {
350			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
351		}
352	}
353	if invalidParams.Len() > 0 {
354		return invalidParams
355	} else {
356		return nil
357	}
358}
359
360func validateOpDeleteConnectionInput(v *DeleteConnectionInput) error {
361	if v == nil {
362		return nil
363	}
364	invalidParams := smithy.InvalidParamsError{Context: "DeleteConnectionInput"}
365	if v.ConnectionArn == nil {
366		invalidParams.Add(smithy.NewErrParamRequired("ConnectionArn"))
367	}
368	if invalidParams.Len() > 0 {
369		return invalidParams
370	} else {
371		return nil
372	}
373}
374
375func validateOpDeleteHostInput(v *DeleteHostInput) error {
376	if v == nil {
377		return nil
378	}
379	invalidParams := smithy.InvalidParamsError{Context: "DeleteHostInput"}
380	if v.HostArn == nil {
381		invalidParams.Add(smithy.NewErrParamRequired("HostArn"))
382	}
383	if invalidParams.Len() > 0 {
384		return invalidParams
385	} else {
386		return nil
387	}
388}
389
390func validateOpGetConnectionInput(v *GetConnectionInput) error {
391	if v == nil {
392		return nil
393	}
394	invalidParams := smithy.InvalidParamsError{Context: "GetConnectionInput"}
395	if v.ConnectionArn == nil {
396		invalidParams.Add(smithy.NewErrParamRequired("ConnectionArn"))
397	}
398	if invalidParams.Len() > 0 {
399		return invalidParams
400	} else {
401		return nil
402	}
403}
404
405func validateOpGetHostInput(v *GetHostInput) error {
406	if v == nil {
407		return nil
408	}
409	invalidParams := smithy.InvalidParamsError{Context: "GetHostInput"}
410	if v.HostArn == nil {
411		invalidParams.Add(smithy.NewErrParamRequired("HostArn"))
412	}
413	if invalidParams.Len() > 0 {
414		return invalidParams
415	} else {
416		return nil
417	}
418}
419
420func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
421	if v == nil {
422		return nil
423	}
424	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
425	if v.ResourceArn == nil {
426		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
427	}
428	if invalidParams.Len() > 0 {
429		return invalidParams
430	} else {
431		return nil
432	}
433}
434
435func validateOpTagResourceInput(v *TagResourceInput) error {
436	if v == nil {
437		return nil
438	}
439	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
440	if v.ResourceArn == nil {
441		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
442	}
443	if v.Tags == nil {
444		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
445	} else if v.Tags != nil {
446		if err := validateTagList(v.Tags); err != nil {
447			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
448		}
449	}
450	if invalidParams.Len() > 0 {
451		return invalidParams
452	} else {
453		return nil
454	}
455}
456
457func validateOpUntagResourceInput(v *UntagResourceInput) error {
458	if v == nil {
459		return nil
460	}
461	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
462	if v.ResourceArn == nil {
463		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
464	}
465	if v.TagKeys == nil {
466		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
467	}
468	if invalidParams.Len() > 0 {
469		return invalidParams
470	} else {
471		return nil
472	}
473}
474
475func validateOpUpdateHostInput(v *UpdateHostInput) error {
476	if v == nil {
477		return nil
478	}
479	invalidParams := smithy.InvalidParamsError{Context: "UpdateHostInput"}
480	if v.HostArn == nil {
481		invalidParams.Add(smithy.NewErrParamRequired("HostArn"))
482	}
483	if v.VpcConfiguration != nil {
484		if err := validateVpcConfiguration(v.VpcConfiguration); err != nil {
485			invalidParams.AddNested("VpcConfiguration", err.(smithy.InvalidParamsError))
486		}
487	}
488	if invalidParams.Len() > 0 {
489		return invalidParams
490	} else {
491		return nil
492	}
493}
494