1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package route53domains
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/route53domains/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpAcceptDomainTransferFromAnotherAwsAccount struct {
14}
15
16func (*validateOpAcceptDomainTransferFromAnotherAwsAccount) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpAcceptDomainTransferFromAnotherAwsAccount) 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.(*AcceptDomainTransferFromAnotherAwsAccountInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpAcceptDomainTransferFromAnotherAwsAccountInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpCancelDomainTransferToAnotherAwsAccount struct {
34}
35
36func (*validateOpCancelDomainTransferToAnotherAwsAccount) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpCancelDomainTransferToAnotherAwsAccount) 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.(*CancelDomainTransferToAnotherAwsAccountInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpCancelDomainTransferToAnotherAwsAccountInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpCheckDomainAvailability struct {
54}
55
56func (*validateOpCheckDomainAvailability) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpCheckDomainAvailability) 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.(*CheckDomainAvailabilityInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpCheckDomainAvailabilityInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpCheckDomainTransferability struct {
74}
75
76func (*validateOpCheckDomainTransferability) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpCheckDomainTransferability) 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.(*CheckDomainTransferabilityInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpCheckDomainTransferabilityInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpDeleteTagsForDomain struct {
94}
95
96func (*validateOpDeleteTagsForDomain) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpDeleteTagsForDomain) 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.(*DeleteTagsForDomainInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpDeleteTagsForDomainInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpDisableDomainAutoRenew struct {
114}
115
116func (*validateOpDisableDomainAutoRenew) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpDisableDomainAutoRenew) 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.(*DisableDomainAutoRenewInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpDisableDomainAutoRenewInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpDisableDomainTransferLock struct {
134}
135
136func (*validateOpDisableDomainTransferLock) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpDisableDomainTransferLock) 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.(*DisableDomainTransferLockInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpDisableDomainTransferLockInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpEnableDomainAutoRenew struct {
154}
155
156func (*validateOpEnableDomainAutoRenew) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpEnableDomainAutoRenew) 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.(*EnableDomainAutoRenewInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpEnableDomainAutoRenewInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpEnableDomainTransferLock struct {
174}
175
176func (*validateOpEnableDomainTransferLock) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpEnableDomainTransferLock) 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.(*EnableDomainTransferLockInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpEnableDomainTransferLockInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpGetDomainDetail struct {
194}
195
196func (*validateOpGetDomainDetail) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpGetDomainDetail) 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.(*GetDomainDetailInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpGetDomainDetailInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpGetDomainSuggestions struct {
214}
215
216func (*validateOpGetDomainSuggestions) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpGetDomainSuggestions) 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.(*GetDomainSuggestionsInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpGetDomainSuggestionsInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpGetOperationDetail struct {
234}
235
236func (*validateOpGetOperationDetail) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpGetOperationDetail) 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.(*GetOperationDetailInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpGetOperationDetailInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpListTagsForDomain struct {
254}
255
256func (*validateOpListTagsForDomain) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpListTagsForDomain) 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.(*ListTagsForDomainInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpListTagsForDomainInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpRegisterDomain struct {
274}
275
276func (*validateOpRegisterDomain) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpRegisterDomain) 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.(*RegisterDomainInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpRegisterDomainInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpRejectDomainTransferFromAnotherAwsAccount struct {
294}
295
296func (*validateOpRejectDomainTransferFromAnotherAwsAccount) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpRejectDomainTransferFromAnotherAwsAccount) 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.(*RejectDomainTransferFromAnotherAwsAccountInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpRejectDomainTransferFromAnotherAwsAccountInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpRenewDomain struct {
314}
315
316func (*validateOpRenewDomain) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpRenewDomain) 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.(*RenewDomainInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpRenewDomainInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpRetrieveDomainAuthCode struct {
334}
335
336func (*validateOpRetrieveDomainAuthCode) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpRetrieveDomainAuthCode) 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.(*RetrieveDomainAuthCodeInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpRetrieveDomainAuthCodeInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpTransferDomain struct {
354}
355
356func (*validateOpTransferDomain) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpTransferDomain) 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.(*TransferDomainInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpTransferDomainInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpTransferDomainToAnotherAwsAccount struct {
374}
375
376func (*validateOpTransferDomainToAnotherAwsAccount) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpTransferDomainToAnotherAwsAccount) 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.(*TransferDomainToAnotherAwsAccountInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpTransferDomainToAnotherAwsAccountInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpUpdateDomainContact struct {
394}
395
396func (*validateOpUpdateDomainContact) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpUpdateDomainContact) 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.(*UpdateDomainContactInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpUpdateDomainContactInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpUpdateDomainContactPrivacy struct {
414}
415
416func (*validateOpUpdateDomainContactPrivacy) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpUpdateDomainContactPrivacy) 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.(*UpdateDomainContactPrivacyInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpUpdateDomainContactPrivacyInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpUpdateDomainNameservers struct {
434}
435
436func (*validateOpUpdateDomainNameservers) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpUpdateDomainNameservers) 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.(*UpdateDomainNameserversInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpUpdateDomainNameserversInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpUpdateTagsForDomain struct {
454}
455
456func (*validateOpUpdateTagsForDomain) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpUpdateTagsForDomain) 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.(*UpdateTagsForDomainInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpUpdateTagsForDomainInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473func addOpAcceptDomainTransferFromAnotherAwsAccountValidationMiddleware(stack *middleware.Stack) error {
474	return stack.Initialize.Add(&validateOpAcceptDomainTransferFromAnotherAwsAccount{}, middleware.After)
475}
476
477func addOpCancelDomainTransferToAnotherAwsAccountValidationMiddleware(stack *middleware.Stack) error {
478	return stack.Initialize.Add(&validateOpCancelDomainTransferToAnotherAwsAccount{}, middleware.After)
479}
480
481func addOpCheckDomainAvailabilityValidationMiddleware(stack *middleware.Stack) error {
482	return stack.Initialize.Add(&validateOpCheckDomainAvailability{}, middleware.After)
483}
484
485func addOpCheckDomainTransferabilityValidationMiddleware(stack *middleware.Stack) error {
486	return stack.Initialize.Add(&validateOpCheckDomainTransferability{}, middleware.After)
487}
488
489func addOpDeleteTagsForDomainValidationMiddleware(stack *middleware.Stack) error {
490	return stack.Initialize.Add(&validateOpDeleteTagsForDomain{}, middleware.After)
491}
492
493func addOpDisableDomainAutoRenewValidationMiddleware(stack *middleware.Stack) error {
494	return stack.Initialize.Add(&validateOpDisableDomainAutoRenew{}, middleware.After)
495}
496
497func addOpDisableDomainTransferLockValidationMiddleware(stack *middleware.Stack) error {
498	return stack.Initialize.Add(&validateOpDisableDomainTransferLock{}, middleware.After)
499}
500
501func addOpEnableDomainAutoRenewValidationMiddleware(stack *middleware.Stack) error {
502	return stack.Initialize.Add(&validateOpEnableDomainAutoRenew{}, middleware.After)
503}
504
505func addOpEnableDomainTransferLockValidationMiddleware(stack *middleware.Stack) error {
506	return stack.Initialize.Add(&validateOpEnableDomainTransferLock{}, middleware.After)
507}
508
509func addOpGetDomainDetailValidationMiddleware(stack *middleware.Stack) error {
510	return stack.Initialize.Add(&validateOpGetDomainDetail{}, middleware.After)
511}
512
513func addOpGetDomainSuggestionsValidationMiddleware(stack *middleware.Stack) error {
514	return stack.Initialize.Add(&validateOpGetDomainSuggestions{}, middleware.After)
515}
516
517func addOpGetOperationDetailValidationMiddleware(stack *middleware.Stack) error {
518	return stack.Initialize.Add(&validateOpGetOperationDetail{}, middleware.After)
519}
520
521func addOpListTagsForDomainValidationMiddleware(stack *middleware.Stack) error {
522	return stack.Initialize.Add(&validateOpListTagsForDomain{}, middleware.After)
523}
524
525func addOpRegisterDomainValidationMiddleware(stack *middleware.Stack) error {
526	return stack.Initialize.Add(&validateOpRegisterDomain{}, middleware.After)
527}
528
529func addOpRejectDomainTransferFromAnotherAwsAccountValidationMiddleware(stack *middleware.Stack) error {
530	return stack.Initialize.Add(&validateOpRejectDomainTransferFromAnotherAwsAccount{}, middleware.After)
531}
532
533func addOpRenewDomainValidationMiddleware(stack *middleware.Stack) error {
534	return stack.Initialize.Add(&validateOpRenewDomain{}, middleware.After)
535}
536
537func addOpRetrieveDomainAuthCodeValidationMiddleware(stack *middleware.Stack) error {
538	return stack.Initialize.Add(&validateOpRetrieveDomainAuthCode{}, middleware.After)
539}
540
541func addOpTransferDomainValidationMiddleware(stack *middleware.Stack) error {
542	return stack.Initialize.Add(&validateOpTransferDomain{}, middleware.After)
543}
544
545func addOpTransferDomainToAnotherAwsAccountValidationMiddleware(stack *middleware.Stack) error {
546	return stack.Initialize.Add(&validateOpTransferDomainToAnotherAwsAccount{}, middleware.After)
547}
548
549func addOpUpdateDomainContactValidationMiddleware(stack *middleware.Stack) error {
550	return stack.Initialize.Add(&validateOpUpdateDomainContact{}, middleware.After)
551}
552
553func addOpUpdateDomainContactPrivacyValidationMiddleware(stack *middleware.Stack) error {
554	return stack.Initialize.Add(&validateOpUpdateDomainContactPrivacy{}, middleware.After)
555}
556
557func addOpUpdateDomainNameserversValidationMiddleware(stack *middleware.Stack) error {
558	return stack.Initialize.Add(&validateOpUpdateDomainNameservers{}, middleware.After)
559}
560
561func addOpUpdateTagsForDomainValidationMiddleware(stack *middleware.Stack) error {
562	return stack.Initialize.Add(&validateOpUpdateTagsForDomain{}, middleware.After)
563}
564
565func validateContactDetail(v *types.ContactDetail) error {
566	if v == nil {
567		return nil
568	}
569	invalidParams := smithy.InvalidParamsError{Context: "ContactDetail"}
570	if v.ExtraParams != nil {
571		if err := validateExtraParamList(v.ExtraParams); err != nil {
572			invalidParams.AddNested("ExtraParams", err.(smithy.InvalidParamsError))
573		}
574	}
575	if invalidParams.Len() > 0 {
576		return invalidParams
577	} else {
578		return nil
579	}
580}
581
582func validateExtraParam(v *types.ExtraParam) error {
583	if v == nil {
584		return nil
585	}
586	invalidParams := smithy.InvalidParamsError{Context: "ExtraParam"}
587	if len(v.Name) == 0 {
588		invalidParams.Add(smithy.NewErrParamRequired("Name"))
589	}
590	if v.Value == nil {
591		invalidParams.Add(smithy.NewErrParamRequired("Value"))
592	}
593	if invalidParams.Len() > 0 {
594		return invalidParams
595	} else {
596		return nil
597	}
598}
599
600func validateExtraParamList(v []types.ExtraParam) error {
601	if v == nil {
602		return nil
603	}
604	invalidParams := smithy.InvalidParamsError{Context: "ExtraParamList"}
605	for i := range v {
606		if err := validateExtraParam(&v[i]); err != nil {
607			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
608		}
609	}
610	if invalidParams.Len() > 0 {
611		return invalidParams
612	} else {
613		return nil
614	}
615}
616
617func validateNameserver(v *types.Nameserver) error {
618	if v == nil {
619		return nil
620	}
621	invalidParams := smithy.InvalidParamsError{Context: "Nameserver"}
622	if v.Name == nil {
623		invalidParams.Add(smithy.NewErrParamRequired("Name"))
624	}
625	if invalidParams.Len() > 0 {
626		return invalidParams
627	} else {
628		return nil
629	}
630}
631
632func validateNameserverList(v []types.Nameserver) error {
633	if v == nil {
634		return nil
635	}
636	invalidParams := smithy.InvalidParamsError{Context: "NameserverList"}
637	for i := range v {
638		if err := validateNameserver(&v[i]); err != nil {
639			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
640		}
641	}
642	if invalidParams.Len() > 0 {
643		return invalidParams
644	} else {
645		return nil
646	}
647}
648
649func validateOpAcceptDomainTransferFromAnotherAwsAccountInput(v *AcceptDomainTransferFromAnotherAwsAccountInput) error {
650	if v == nil {
651		return nil
652	}
653	invalidParams := smithy.InvalidParamsError{Context: "AcceptDomainTransferFromAnotherAwsAccountInput"}
654	if v.DomainName == nil {
655		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
656	}
657	if v.Password == nil {
658		invalidParams.Add(smithy.NewErrParamRequired("Password"))
659	}
660	if invalidParams.Len() > 0 {
661		return invalidParams
662	} else {
663		return nil
664	}
665}
666
667func validateOpCancelDomainTransferToAnotherAwsAccountInput(v *CancelDomainTransferToAnotherAwsAccountInput) error {
668	if v == nil {
669		return nil
670	}
671	invalidParams := smithy.InvalidParamsError{Context: "CancelDomainTransferToAnotherAwsAccountInput"}
672	if v.DomainName == nil {
673		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
674	}
675	if invalidParams.Len() > 0 {
676		return invalidParams
677	} else {
678		return nil
679	}
680}
681
682func validateOpCheckDomainAvailabilityInput(v *CheckDomainAvailabilityInput) error {
683	if v == nil {
684		return nil
685	}
686	invalidParams := smithy.InvalidParamsError{Context: "CheckDomainAvailabilityInput"}
687	if v.DomainName == nil {
688		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
689	}
690	if invalidParams.Len() > 0 {
691		return invalidParams
692	} else {
693		return nil
694	}
695}
696
697func validateOpCheckDomainTransferabilityInput(v *CheckDomainTransferabilityInput) error {
698	if v == nil {
699		return nil
700	}
701	invalidParams := smithy.InvalidParamsError{Context: "CheckDomainTransferabilityInput"}
702	if v.DomainName == nil {
703		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
704	}
705	if invalidParams.Len() > 0 {
706		return invalidParams
707	} else {
708		return nil
709	}
710}
711
712func validateOpDeleteTagsForDomainInput(v *DeleteTagsForDomainInput) error {
713	if v == nil {
714		return nil
715	}
716	invalidParams := smithy.InvalidParamsError{Context: "DeleteTagsForDomainInput"}
717	if v.DomainName == nil {
718		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
719	}
720	if v.TagsToDelete == nil {
721		invalidParams.Add(smithy.NewErrParamRequired("TagsToDelete"))
722	}
723	if invalidParams.Len() > 0 {
724		return invalidParams
725	} else {
726		return nil
727	}
728}
729
730func validateOpDisableDomainAutoRenewInput(v *DisableDomainAutoRenewInput) error {
731	if v == nil {
732		return nil
733	}
734	invalidParams := smithy.InvalidParamsError{Context: "DisableDomainAutoRenewInput"}
735	if v.DomainName == nil {
736		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
737	}
738	if invalidParams.Len() > 0 {
739		return invalidParams
740	} else {
741		return nil
742	}
743}
744
745func validateOpDisableDomainTransferLockInput(v *DisableDomainTransferLockInput) error {
746	if v == nil {
747		return nil
748	}
749	invalidParams := smithy.InvalidParamsError{Context: "DisableDomainTransferLockInput"}
750	if v.DomainName == nil {
751		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
752	}
753	if invalidParams.Len() > 0 {
754		return invalidParams
755	} else {
756		return nil
757	}
758}
759
760func validateOpEnableDomainAutoRenewInput(v *EnableDomainAutoRenewInput) error {
761	if v == nil {
762		return nil
763	}
764	invalidParams := smithy.InvalidParamsError{Context: "EnableDomainAutoRenewInput"}
765	if v.DomainName == nil {
766		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
767	}
768	if invalidParams.Len() > 0 {
769		return invalidParams
770	} else {
771		return nil
772	}
773}
774
775func validateOpEnableDomainTransferLockInput(v *EnableDomainTransferLockInput) error {
776	if v == nil {
777		return nil
778	}
779	invalidParams := smithy.InvalidParamsError{Context: "EnableDomainTransferLockInput"}
780	if v.DomainName == nil {
781		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
782	}
783	if invalidParams.Len() > 0 {
784		return invalidParams
785	} else {
786		return nil
787	}
788}
789
790func validateOpGetDomainDetailInput(v *GetDomainDetailInput) error {
791	if v == nil {
792		return nil
793	}
794	invalidParams := smithy.InvalidParamsError{Context: "GetDomainDetailInput"}
795	if v.DomainName == nil {
796		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
797	}
798	if invalidParams.Len() > 0 {
799		return invalidParams
800	} else {
801		return nil
802	}
803}
804
805func validateOpGetDomainSuggestionsInput(v *GetDomainSuggestionsInput) error {
806	if v == nil {
807		return nil
808	}
809	invalidParams := smithy.InvalidParamsError{Context: "GetDomainSuggestionsInput"}
810	if v.DomainName == nil {
811		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
812	}
813	if v.OnlyAvailable == nil {
814		invalidParams.Add(smithy.NewErrParamRequired("OnlyAvailable"))
815	}
816	if invalidParams.Len() > 0 {
817		return invalidParams
818	} else {
819		return nil
820	}
821}
822
823func validateOpGetOperationDetailInput(v *GetOperationDetailInput) error {
824	if v == nil {
825		return nil
826	}
827	invalidParams := smithy.InvalidParamsError{Context: "GetOperationDetailInput"}
828	if v.OperationId == nil {
829		invalidParams.Add(smithy.NewErrParamRequired("OperationId"))
830	}
831	if invalidParams.Len() > 0 {
832		return invalidParams
833	} else {
834		return nil
835	}
836}
837
838func validateOpListTagsForDomainInput(v *ListTagsForDomainInput) error {
839	if v == nil {
840		return nil
841	}
842	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForDomainInput"}
843	if v.DomainName == nil {
844		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
845	}
846	if invalidParams.Len() > 0 {
847		return invalidParams
848	} else {
849		return nil
850	}
851}
852
853func validateOpRegisterDomainInput(v *RegisterDomainInput) error {
854	if v == nil {
855		return nil
856	}
857	invalidParams := smithy.InvalidParamsError{Context: "RegisterDomainInput"}
858	if v.DomainName == nil {
859		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
860	}
861	if v.DurationInYears == nil {
862		invalidParams.Add(smithy.NewErrParamRequired("DurationInYears"))
863	}
864	if v.AdminContact == nil {
865		invalidParams.Add(smithy.NewErrParamRequired("AdminContact"))
866	} else if v.AdminContact != nil {
867		if err := validateContactDetail(v.AdminContact); err != nil {
868			invalidParams.AddNested("AdminContact", err.(smithy.InvalidParamsError))
869		}
870	}
871	if v.RegistrantContact == nil {
872		invalidParams.Add(smithy.NewErrParamRequired("RegistrantContact"))
873	} else if v.RegistrantContact != nil {
874		if err := validateContactDetail(v.RegistrantContact); err != nil {
875			invalidParams.AddNested("RegistrantContact", err.(smithy.InvalidParamsError))
876		}
877	}
878	if v.TechContact == nil {
879		invalidParams.Add(smithy.NewErrParamRequired("TechContact"))
880	} else if v.TechContact != nil {
881		if err := validateContactDetail(v.TechContact); err != nil {
882			invalidParams.AddNested("TechContact", err.(smithy.InvalidParamsError))
883		}
884	}
885	if invalidParams.Len() > 0 {
886		return invalidParams
887	} else {
888		return nil
889	}
890}
891
892func validateOpRejectDomainTransferFromAnotherAwsAccountInput(v *RejectDomainTransferFromAnotherAwsAccountInput) error {
893	if v == nil {
894		return nil
895	}
896	invalidParams := smithy.InvalidParamsError{Context: "RejectDomainTransferFromAnotherAwsAccountInput"}
897	if v.DomainName == nil {
898		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
899	}
900	if invalidParams.Len() > 0 {
901		return invalidParams
902	} else {
903		return nil
904	}
905}
906
907func validateOpRenewDomainInput(v *RenewDomainInput) error {
908	if v == nil {
909		return nil
910	}
911	invalidParams := smithy.InvalidParamsError{Context: "RenewDomainInput"}
912	if v.DomainName == nil {
913		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
914	}
915	if invalidParams.Len() > 0 {
916		return invalidParams
917	} else {
918		return nil
919	}
920}
921
922func validateOpRetrieveDomainAuthCodeInput(v *RetrieveDomainAuthCodeInput) error {
923	if v == nil {
924		return nil
925	}
926	invalidParams := smithy.InvalidParamsError{Context: "RetrieveDomainAuthCodeInput"}
927	if v.DomainName == nil {
928		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
929	}
930	if invalidParams.Len() > 0 {
931		return invalidParams
932	} else {
933		return nil
934	}
935}
936
937func validateOpTransferDomainInput(v *TransferDomainInput) error {
938	if v == nil {
939		return nil
940	}
941	invalidParams := smithy.InvalidParamsError{Context: "TransferDomainInput"}
942	if v.DomainName == nil {
943		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
944	}
945	if v.DurationInYears == nil {
946		invalidParams.Add(smithy.NewErrParamRequired("DurationInYears"))
947	}
948	if v.Nameservers != nil {
949		if err := validateNameserverList(v.Nameservers); err != nil {
950			invalidParams.AddNested("Nameservers", err.(smithy.InvalidParamsError))
951		}
952	}
953	if v.AdminContact == nil {
954		invalidParams.Add(smithy.NewErrParamRequired("AdminContact"))
955	} else if v.AdminContact != nil {
956		if err := validateContactDetail(v.AdminContact); err != nil {
957			invalidParams.AddNested("AdminContact", err.(smithy.InvalidParamsError))
958		}
959	}
960	if v.RegistrantContact == nil {
961		invalidParams.Add(smithy.NewErrParamRequired("RegistrantContact"))
962	} else if v.RegistrantContact != nil {
963		if err := validateContactDetail(v.RegistrantContact); err != nil {
964			invalidParams.AddNested("RegistrantContact", err.(smithy.InvalidParamsError))
965		}
966	}
967	if v.TechContact == nil {
968		invalidParams.Add(smithy.NewErrParamRequired("TechContact"))
969	} else if v.TechContact != nil {
970		if err := validateContactDetail(v.TechContact); err != nil {
971			invalidParams.AddNested("TechContact", err.(smithy.InvalidParamsError))
972		}
973	}
974	if invalidParams.Len() > 0 {
975		return invalidParams
976	} else {
977		return nil
978	}
979}
980
981func validateOpTransferDomainToAnotherAwsAccountInput(v *TransferDomainToAnotherAwsAccountInput) error {
982	if v == nil {
983		return nil
984	}
985	invalidParams := smithy.InvalidParamsError{Context: "TransferDomainToAnotherAwsAccountInput"}
986	if v.DomainName == nil {
987		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
988	}
989	if v.AccountId == nil {
990		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
991	}
992	if invalidParams.Len() > 0 {
993		return invalidParams
994	} else {
995		return nil
996	}
997}
998
999func validateOpUpdateDomainContactInput(v *UpdateDomainContactInput) error {
1000	if v == nil {
1001		return nil
1002	}
1003	invalidParams := smithy.InvalidParamsError{Context: "UpdateDomainContactInput"}
1004	if v.DomainName == nil {
1005		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
1006	}
1007	if v.AdminContact != nil {
1008		if err := validateContactDetail(v.AdminContact); err != nil {
1009			invalidParams.AddNested("AdminContact", err.(smithy.InvalidParamsError))
1010		}
1011	}
1012	if v.RegistrantContact != nil {
1013		if err := validateContactDetail(v.RegistrantContact); err != nil {
1014			invalidParams.AddNested("RegistrantContact", err.(smithy.InvalidParamsError))
1015		}
1016	}
1017	if v.TechContact != nil {
1018		if err := validateContactDetail(v.TechContact); err != nil {
1019			invalidParams.AddNested("TechContact", err.(smithy.InvalidParamsError))
1020		}
1021	}
1022	if invalidParams.Len() > 0 {
1023		return invalidParams
1024	} else {
1025		return nil
1026	}
1027}
1028
1029func validateOpUpdateDomainContactPrivacyInput(v *UpdateDomainContactPrivacyInput) error {
1030	if v == nil {
1031		return nil
1032	}
1033	invalidParams := smithy.InvalidParamsError{Context: "UpdateDomainContactPrivacyInput"}
1034	if v.DomainName == nil {
1035		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
1036	}
1037	if invalidParams.Len() > 0 {
1038		return invalidParams
1039	} else {
1040		return nil
1041	}
1042}
1043
1044func validateOpUpdateDomainNameserversInput(v *UpdateDomainNameserversInput) error {
1045	if v == nil {
1046		return nil
1047	}
1048	invalidParams := smithy.InvalidParamsError{Context: "UpdateDomainNameserversInput"}
1049	if v.DomainName == nil {
1050		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
1051	}
1052	if v.Nameservers == nil {
1053		invalidParams.Add(smithy.NewErrParamRequired("Nameservers"))
1054	} else if v.Nameservers != nil {
1055		if err := validateNameserverList(v.Nameservers); err != nil {
1056			invalidParams.AddNested("Nameservers", err.(smithy.InvalidParamsError))
1057		}
1058	}
1059	if invalidParams.Len() > 0 {
1060		return invalidParams
1061	} else {
1062		return nil
1063	}
1064}
1065
1066func validateOpUpdateTagsForDomainInput(v *UpdateTagsForDomainInput) error {
1067	if v == nil {
1068		return nil
1069	}
1070	invalidParams := smithy.InvalidParamsError{Context: "UpdateTagsForDomainInput"}
1071	if v.DomainName == nil {
1072		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
1073	}
1074	if invalidParams.Len() > 0 {
1075		return invalidParams
1076	} else {
1077		return nil
1078	}
1079}
1080