1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package worklink
4
5import (
6	"context"
7	"fmt"
8	smithy "github.com/aws/smithy-go"
9	"github.com/aws/smithy-go/middleware"
10)
11
12type validateOpAssociateDomain struct {
13}
14
15func (*validateOpAssociateDomain) ID() string {
16	return "OperationInputValidation"
17}
18
19func (m *validateOpAssociateDomain) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
20	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
21) {
22	input, ok := in.Parameters.(*AssociateDomainInput)
23	if !ok {
24		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
25	}
26	if err := validateOpAssociateDomainInput(input); err != nil {
27		return out, metadata, err
28	}
29	return next.HandleInitialize(ctx, in)
30}
31
32type validateOpAssociateWebsiteAuthorizationProvider struct {
33}
34
35func (*validateOpAssociateWebsiteAuthorizationProvider) ID() string {
36	return "OperationInputValidation"
37}
38
39func (m *validateOpAssociateWebsiteAuthorizationProvider) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
40	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
41) {
42	input, ok := in.Parameters.(*AssociateWebsiteAuthorizationProviderInput)
43	if !ok {
44		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
45	}
46	if err := validateOpAssociateWebsiteAuthorizationProviderInput(input); err != nil {
47		return out, metadata, err
48	}
49	return next.HandleInitialize(ctx, in)
50}
51
52type validateOpAssociateWebsiteCertificateAuthority struct {
53}
54
55func (*validateOpAssociateWebsiteCertificateAuthority) ID() string {
56	return "OperationInputValidation"
57}
58
59func (m *validateOpAssociateWebsiteCertificateAuthority) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
60	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
61) {
62	input, ok := in.Parameters.(*AssociateWebsiteCertificateAuthorityInput)
63	if !ok {
64		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
65	}
66	if err := validateOpAssociateWebsiteCertificateAuthorityInput(input); err != nil {
67		return out, metadata, err
68	}
69	return next.HandleInitialize(ctx, in)
70}
71
72type validateOpCreateFleet struct {
73}
74
75func (*validateOpCreateFleet) ID() string {
76	return "OperationInputValidation"
77}
78
79func (m *validateOpCreateFleet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
80	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
81) {
82	input, ok := in.Parameters.(*CreateFleetInput)
83	if !ok {
84		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
85	}
86	if err := validateOpCreateFleetInput(input); err != nil {
87		return out, metadata, err
88	}
89	return next.HandleInitialize(ctx, in)
90}
91
92type validateOpDeleteFleet struct {
93}
94
95func (*validateOpDeleteFleet) ID() string {
96	return "OperationInputValidation"
97}
98
99func (m *validateOpDeleteFleet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
100	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
101) {
102	input, ok := in.Parameters.(*DeleteFleetInput)
103	if !ok {
104		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
105	}
106	if err := validateOpDeleteFleetInput(input); err != nil {
107		return out, metadata, err
108	}
109	return next.HandleInitialize(ctx, in)
110}
111
112type validateOpDescribeAuditStreamConfiguration struct {
113}
114
115func (*validateOpDescribeAuditStreamConfiguration) ID() string {
116	return "OperationInputValidation"
117}
118
119func (m *validateOpDescribeAuditStreamConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
120	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
121) {
122	input, ok := in.Parameters.(*DescribeAuditStreamConfigurationInput)
123	if !ok {
124		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
125	}
126	if err := validateOpDescribeAuditStreamConfigurationInput(input); err != nil {
127		return out, metadata, err
128	}
129	return next.HandleInitialize(ctx, in)
130}
131
132type validateOpDescribeCompanyNetworkConfiguration struct {
133}
134
135func (*validateOpDescribeCompanyNetworkConfiguration) ID() string {
136	return "OperationInputValidation"
137}
138
139func (m *validateOpDescribeCompanyNetworkConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
140	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
141) {
142	input, ok := in.Parameters.(*DescribeCompanyNetworkConfigurationInput)
143	if !ok {
144		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
145	}
146	if err := validateOpDescribeCompanyNetworkConfigurationInput(input); err != nil {
147		return out, metadata, err
148	}
149	return next.HandleInitialize(ctx, in)
150}
151
152type validateOpDescribeDevice struct {
153}
154
155func (*validateOpDescribeDevice) ID() string {
156	return "OperationInputValidation"
157}
158
159func (m *validateOpDescribeDevice) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
160	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
161) {
162	input, ok := in.Parameters.(*DescribeDeviceInput)
163	if !ok {
164		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
165	}
166	if err := validateOpDescribeDeviceInput(input); err != nil {
167		return out, metadata, err
168	}
169	return next.HandleInitialize(ctx, in)
170}
171
172type validateOpDescribeDevicePolicyConfiguration struct {
173}
174
175func (*validateOpDescribeDevicePolicyConfiguration) ID() string {
176	return "OperationInputValidation"
177}
178
179func (m *validateOpDescribeDevicePolicyConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
180	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
181) {
182	input, ok := in.Parameters.(*DescribeDevicePolicyConfigurationInput)
183	if !ok {
184		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
185	}
186	if err := validateOpDescribeDevicePolicyConfigurationInput(input); err != nil {
187		return out, metadata, err
188	}
189	return next.HandleInitialize(ctx, in)
190}
191
192type validateOpDescribeDomain struct {
193}
194
195func (*validateOpDescribeDomain) ID() string {
196	return "OperationInputValidation"
197}
198
199func (m *validateOpDescribeDomain) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
200	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
201) {
202	input, ok := in.Parameters.(*DescribeDomainInput)
203	if !ok {
204		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
205	}
206	if err := validateOpDescribeDomainInput(input); err != nil {
207		return out, metadata, err
208	}
209	return next.HandleInitialize(ctx, in)
210}
211
212type validateOpDescribeFleetMetadata struct {
213}
214
215func (*validateOpDescribeFleetMetadata) ID() string {
216	return "OperationInputValidation"
217}
218
219func (m *validateOpDescribeFleetMetadata) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
220	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
221) {
222	input, ok := in.Parameters.(*DescribeFleetMetadataInput)
223	if !ok {
224		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
225	}
226	if err := validateOpDescribeFleetMetadataInput(input); err != nil {
227		return out, metadata, err
228	}
229	return next.HandleInitialize(ctx, in)
230}
231
232type validateOpDescribeIdentityProviderConfiguration struct {
233}
234
235func (*validateOpDescribeIdentityProviderConfiguration) ID() string {
236	return "OperationInputValidation"
237}
238
239func (m *validateOpDescribeIdentityProviderConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
240	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
241) {
242	input, ok := in.Parameters.(*DescribeIdentityProviderConfigurationInput)
243	if !ok {
244		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
245	}
246	if err := validateOpDescribeIdentityProviderConfigurationInput(input); err != nil {
247		return out, metadata, err
248	}
249	return next.HandleInitialize(ctx, in)
250}
251
252type validateOpDescribeWebsiteCertificateAuthority struct {
253}
254
255func (*validateOpDescribeWebsiteCertificateAuthority) ID() string {
256	return "OperationInputValidation"
257}
258
259func (m *validateOpDescribeWebsiteCertificateAuthority) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
260	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
261) {
262	input, ok := in.Parameters.(*DescribeWebsiteCertificateAuthorityInput)
263	if !ok {
264		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
265	}
266	if err := validateOpDescribeWebsiteCertificateAuthorityInput(input); err != nil {
267		return out, metadata, err
268	}
269	return next.HandleInitialize(ctx, in)
270}
271
272type validateOpDisassociateDomain struct {
273}
274
275func (*validateOpDisassociateDomain) ID() string {
276	return "OperationInputValidation"
277}
278
279func (m *validateOpDisassociateDomain) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
280	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
281) {
282	input, ok := in.Parameters.(*DisassociateDomainInput)
283	if !ok {
284		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
285	}
286	if err := validateOpDisassociateDomainInput(input); err != nil {
287		return out, metadata, err
288	}
289	return next.HandleInitialize(ctx, in)
290}
291
292type validateOpDisassociateWebsiteAuthorizationProvider struct {
293}
294
295func (*validateOpDisassociateWebsiteAuthorizationProvider) ID() string {
296	return "OperationInputValidation"
297}
298
299func (m *validateOpDisassociateWebsiteAuthorizationProvider) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
300	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
301) {
302	input, ok := in.Parameters.(*DisassociateWebsiteAuthorizationProviderInput)
303	if !ok {
304		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
305	}
306	if err := validateOpDisassociateWebsiteAuthorizationProviderInput(input); err != nil {
307		return out, metadata, err
308	}
309	return next.HandleInitialize(ctx, in)
310}
311
312type validateOpDisassociateWebsiteCertificateAuthority struct {
313}
314
315func (*validateOpDisassociateWebsiteCertificateAuthority) ID() string {
316	return "OperationInputValidation"
317}
318
319func (m *validateOpDisassociateWebsiteCertificateAuthority) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
320	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
321) {
322	input, ok := in.Parameters.(*DisassociateWebsiteCertificateAuthorityInput)
323	if !ok {
324		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
325	}
326	if err := validateOpDisassociateWebsiteCertificateAuthorityInput(input); err != nil {
327		return out, metadata, err
328	}
329	return next.HandleInitialize(ctx, in)
330}
331
332type validateOpListDevices struct {
333}
334
335func (*validateOpListDevices) ID() string {
336	return "OperationInputValidation"
337}
338
339func (m *validateOpListDevices) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
340	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
341) {
342	input, ok := in.Parameters.(*ListDevicesInput)
343	if !ok {
344		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
345	}
346	if err := validateOpListDevicesInput(input); err != nil {
347		return out, metadata, err
348	}
349	return next.HandleInitialize(ctx, in)
350}
351
352type validateOpListDomains struct {
353}
354
355func (*validateOpListDomains) ID() string {
356	return "OperationInputValidation"
357}
358
359func (m *validateOpListDomains) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
360	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
361) {
362	input, ok := in.Parameters.(*ListDomainsInput)
363	if !ok {
364		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
365	}
366	if err := validateOpListDomainsInput(input); err != nil {
367		return out, metadata, err
368	}
369	return next.HandleInitialize(ctx, in)
370}
371
372type validateOpListTagsForResource struct {
373}
374
375func (*validateOpListTagsForResource) ID() string {
376	return "OperationInputValidation"
377}
378
379func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
380	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
381) {
382	input, ok := in.Parameters.(*ListTagsForResourceInput)
383	if !ok {
384		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
385	}
386	if err := validateOpListTagsForResourceInput(input); err != nil {
387		return out, metadata, err
388	}
389	return next.HandleInitialize(ctx, in)
390}
391
392type validateOpListWebsiteAuthorizationProviders struct {
393}
394
395func (*validateOpListWebsiteAuthorizationProviders) ID() string {
396	return "OperationInputValidation"
397}
398
399func (m *validateOpListWebsiteAuthorizationProviders) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
400	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
401) {
402	input, ok := in.Parameters.(*ListWebsiteAuthorizationProvidersInput)
403	if !ok {
404		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
405	}
406	if err := validateOpListWebsiteAuthorizationProvidersInput(input); err != nil {
407		return out, metadata, err
408	}
409	return next.HandleInitialize(ctx, in)
410}
411
412type validateOpListWebsiteCertificateAuthorities struct {
413}
414
415func (*validateOpListWebsiteCertificateAuthorities) ID() string {
416	return "OperationInputValidation"
417}
418
419func (m *validateOpListWebsiteCertificateAuthorities) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
420	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
421) {
422	input, ok := in.Parameters.(*ListWebsiteCertificateAuthoritiesInput)
423	if !ok {
424		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
425	}
426	if err := validateOpListWebsiteCertificateAuthoritiesInput(input); err != nil {
427		return out, metadata, err
428	}
429	return next.HandleInitialize(ctx, in)
430}
431
432type validateOpRestoreDomainAccess struct {
433}
434
435func (*validateOpRestoreDomainAccess) ID() string {
436	return "OperationInputValidation"
437}
438
439func (m *validateOpRestoreDomainAccess) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
440	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
441) {
442	input, ok := in.Parameters.(*RestoreDomainAccessInput)
443	if !ok {
444		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
445	}
446	if err := validateOpRestoreDomainAccessInput(input); err != nil {
447		return out, metadata, err
448	}
449	return next.HandleInitialize(ctx, in)
450}
451
452type validateOpRevokeDomainAccess struct {
453}
454
455func (*validateOpRevokeDomainAccess) ID() string {
456	return "OperationInputValidation"
457}
458
459func (m *validateOpRevokeDomainAccess) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
460	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
461) {
462	input, ok := in.Parameters.(*RevokeDomainAccessInput)
463	if !ok {
464		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
465	}
466	if err := validateOpRevokeDomainAccessInput(input); err != nil {
467		return out, metadata, err
468	}
469	return next.HandleInitialize(ctx, in)
470}
471
472type validateOpSignOutUser struct {
473}
474
475func (*validateOpSignOutUser) ID() string {
476	return "OperationInputValidation"
477}
478
479func (m *validateOpSignOutUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
480	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
481) {
482	input, ok := in.Parameters.(*SignOutUserInput)
483	if !ok {
484		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
485	}
486	if err := validateOpSignOutUserInput(input); err != nil {
487		return out, metadata, err
488	}
489	return next.HandleInitialize(ctx, in)
490}
491
492type validateOpTagResource struct {
493}
494
495func (*validateOpTagResource) ID() string {
496	return "OperationInputValidation"
497}
498
499func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
500	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
501) {
502	input, ok := in.Parameters.(*TagResourceInput)
503	if !ok {
504		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
505	}
506	if err := validateOpTagResourceInput(input); err != nil {
507		return out, metadata, err
508	}
509	return next.HandleInitialize(ctx, in)
510}
511
512type validateOpUntagResource struct {
513}
514
515func (*validateOpUntagResource) ID() string {
516	return "OperationInputValidation"
517}
518
519func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
520	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
521) {
522	input, ok := in.Parameters.(*UntagResourceInput)
523	if !ok {
524		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
525	}
526	if err := validateOpUntagResourceInput(input); err != nil {
527		return out, metadata, err
528	}
529	return next.HandleInitialize(ctx, in)
530}
531
532type validateOpUpdateAuditStreamConfiguration struct {
533}
534
535func (*validateOpUpdateAuditStreamConfiguration) ID() string {
536	return "OperationInputValidation"
537}
538
539func (m *validateOpUpdateAuditStreamConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
540	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
541) {
542	input, ok := in.Parameters.(*UpdateAuditStreamConfigurationInput)
543	if !ok {
544		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
545	}
546	if err := validateOpUpdateAuditStreamConfigurationInput(input); err != nil {
547		return out, metadata, err
548	}
549	return next.HandleInitialize(ctx, in)
550}
551
552type validateOpUpdateCompanyNetworkConfiguration struct {
553}
554
555func (*validateOpUpdateCompanyNetworkConfiguration) ID() string {
556	return "OperationInputValidation"
557}
558
559func (m *validateOpUpdateCompanyNetworkConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
560	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
561) {
562	input, ok := in.Parameters.(*UpdateCompanyNetworkConfigurationInput)
563	if !ok {
564		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
565	}
566	if err := validateOpUpdateCompanyNetworkConfigurationInput(input); err != nil {
567		return out, metadata, err
568	}
569	return next.HandleInitialize(ctx, in)
570}
571
572type validateOpUpdateDevicePolicyConfiguration struct {
573}
574
575func (*validateOpUpdateDevicePolicyConfiguration) ID() string {
576	return "OperationInputValidation"
577}
578
579func (m *validateOpUpdateDevicePolicyConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
580	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
581) {
582	input, ok := in.Parameters.(*UpdateDevicePolicyConfigurationInput)
583	if !ok {
584		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
585	}
586	if err := validateOpUpdateDevicePolicyConfigurationInput(input); err != nil {
587		return out, metadata, err
588	}
589	return next.HandleInitialize(ctx, in)
590}
591
592type validateOpUpdateDomainMetadata struct {
593}
594
595func (*validateOpUpdateDomainMetadata) ID() string {
596	return "OperationInputValidation"
597}
598
599func (m *validateOpUpdateDomainMetadata) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
600	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
601) {
602	input, ok := in.Parameters.(*UpdateDomainMetadataInput)
603	if !ok {
604		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
605	}
606	if err := validateOpUpdateDomainMetadataInput(input); err != nil {
607		return out, metadata, err
608	}
609	return next.HandleInitialize(ctx, in)
610}
611
612type validateOpUpdateFleetMetadata struct {
613}
614
615func (*validateOpUpdateFleetMetadata) ID() string {
616	return "OperationInputValidation"
617}
618
619func (m *validateOpUpdateFleetMetadata) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
620	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
621) {
622	input, ok := in.Parameters.(*UpdateFleetMetadataInput)
623	if !ok {
624		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
625	}
626	if err := validateOpUpdateFleetMetadataInput(input); err != nil {
627		return out, metadata, err
628	}
629	return next.HandleInitialize(ctx, in)
630}
631
632type validateOpUpdateIdentityProviderConfiguration struct {
633}
634
635func (*validateOpUpdateIdentityProviderConfiguration) ID() string {
636	return "OperationInputValidation"
637}
638
639func (m *validateOpUpdateIdentityProviderConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
640	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
641) {
642	input, ok := in.Parameters.(*UpdateIdentityProviderConfigurationInput)
643	if !ok {
644		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
645	}
646	if err := validateOpUpdateIdentityProviderConfigurationInput(input); err != nil {
647		return out, metadata, err
648	}
649	return next.HandleInitialize(ctx, in)
650}
651
652func addOpAssociateDomainValidationMiddleware(stack *middleware.Stack) error {
653	return stack.Initialize.Add(&validateOpAssociateDomain{}, middleware.After)
654}
655
656func addOpAssociateWebsiteAuthorizationProviderValidationMiddleware(stack *middleware.Stack) error {
657	return stack.Initialize.Add(&validateOpAssociateWebsiteAuthorizationProvider{}, middleware.After)
658}
659
660func addOpAssociateWebsiteCertificateAuthorityValidationMiddleware(stack *middleware.Stack) error {
661	return stack.Initialize.Add(&validateOpAssociateWebsiteCertificateAuthority{}, middleware.After)
662}
663
664func addOpCreateFleetValidationMiddleware(stack *middleware.Stack) error {
665	return stack.Initialize.Add(&validateOpCreateFleet{}, middleware.After)
666}
667
668func addOpDeleteFleetValidationMiddleware(stack *middleware.Stack) error {
669	return stack.Initialize.Add(&validateOpDeleteFleet{}, middleware.After)
670}
671
672func addOpDescribeAuditStreamConfigurationValidationMiddleware(stack *middleware.Stack) error {
673	return stack.Initialize.Add(&validateOpDescribeAuditStreamConfiguration{}, middleware.After)
674}
675
676func addOpDescribeCompanyNetworkConfigurationValidationMiddleware(stack *middleware.Stack) error {
677	return stack.Initialize.Add(&validateOpDescribeCompanyNetworkConfiguration{}, middleware.After)
678}
679
680func addOpDescribeDeviceValidationMiddleware(stack *middleware.Stack) error {
681	return stack.Initialize.Add(&validateOpDescribeDevice{}, middleware.After)
682}
683
684func addOpDescribeDevicePolicyConfigurationValidationMiddleware(stack *middleware.Stack) error {
685	return stack.Initialize.Add(&validateOpDescribeDevicePolicyConfiguration{}, middleware.After)
686}
687
688func addOpDescribeDomainValidationMiddleware(stack *middleware.Stack) error {
689	return stack.Initialize.Add(&validateOpDescribeDomain{}, middleware.After)
690}
691
692func addOpDescribeFleetMetadataValidationMiddleware(stack *middleware.Stack) error {
693	return stack.Initialize.Add(&validateOpDescribeFleetMetadata{}, middleware.After)
694}
695
696func addOpDescribeIdentityProviderConfigurationValidationMiddleware(stack *middleware.Stack) error {
697	return stack.Initialize.Add(&validateOpDescribeIdentityProviderConfiguration{}, middleware.After)
698}
699
700func addOpDescribeWebsiteCertificateAuthorityValidationMiddleware(stack *middleware.Stack) error {
701	return stack.Initialize.Add(&validateOpDescribeWebsiteCertificateAuthority{}, middleware.After)
702}
703
704func addOpDisassociateDomainValidationMiddleware(stack *middleware.Stack) error {
705	return stack.Initialize.Add(&validateOpDisassociateDomain{}, middleware.After)
706}
707
708func addOpDisassociateWebsiteAuthorizationProviderValidationMiddleware(stack *middleware.Stack) error {
709	return stack.Initialize.Add(&validateOpDisassociateWebsiteAuthorizationProvider{}, middleware.After)
710}
711
712func addOpDisassociateWebsiteCertificateAuthorityValidationMiddleware(stack *middleware.Stack) error {
713	return stack.Initialize.Add(&validateOpDisassociateWebsiteCertificateAuthority{}, middleware.After)
714}
715
716func addOpListDevicesValidationMiddleware(stack *middleware.Stack) error {
717	return stack.Initialize.Add(&validateOpListDevices{}, middleware.After)
718}
719
720func addOpListDomainsValidationMiddleware(stack *middleware.Stack) error {
721	return stack.Initialize.Add(&validateOpListDomains{}, middleware.After)
722}
723
724func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
725	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
726}
727
728func addOpListWebsiteAuthorizationProvidersValidationMiddleware(stack *middleware.Stack) error {
729	return stack.Initialize.Add(&validateOpListWebsiteAuthorizationProviders{}, middleware.After)
730}
731
732func addOpListWebsiteCertificateAuthoritiesValidationMiddleware(stack *middleware.Stack) error {
733	return stack.Initialize.Add(&validateOpListWebsiteCertificateAuthorities{}, middleware.After)
734}
735
736func addOpRestoreDomainAccessValidationMiddleware(stack *middleware.Stack) error {
737	return stack.Initialize.Add(&validateOpRestoreDomainAccess{}, middleware.After)
738}
739
740func addOpRevokeDomainAccessValidationMiddleware(stack *middleware.Stack) error {
741	return stack.Initialize.Add(&validateOpRevokeDomainAccess{}, middleware.After)
742}
743
744func addOpSignOutUserValidationMiddleware(stack *middleware.Stack) error {
745	return stack.Initialize.Add(&validateOpSignOutUser{}, middleware.After)
746}
747
748func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
749	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
750}
751
752func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
753	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
754}
755
756func addOpUpdateAuditStreamConfigurationValidationMiddleware(stack *middleware.Stack) error {
757	return stack.Initialize.Add(&validateOpUpdateAuditStreamConfiguration{}, middleware.After)
758}
759
760func addOpUpdateCompanyNetworkConfigurationValidationMiddleware(stack *middleware.Stack) error {
761	return stack.Initialize.Add(&validateOpUpdateCompanyNetworkConfiguration{}, middleware.After)
762}
763
764func addOpUpdateDevicePolicyConfigurationValidationMiddleware(stack *middleware.Stack) error {
765	return stack.Initialize.Add(&validateOpUpdateDevicePolicyConfiguration{}, middleware.After)
766}
767
768func addOpUpdateDomainMetadataValidationMiddleware(stack *middleware.Stack) error {
769	return stack.Initialize.Add(&validateOpUpdateDomainMetadata{}, middleware.After)
770}
771
772func addOpUpdateFleetMetadataValidationMiddleware(stack *middleware.Stack) error {
773	return stack.Initialize.Add(&validateOpUpdateFleetMetadata{}, middleware.After)
774}
775
776func addOpUpdateIdentityProviderConfigurationValidationMiddleware(stack *middleware.Stack) error {
777	return stack.Initialize.Add(&validateOpUpdateIdentityProviderConfiguration{}, middleware.After)
778}
779
780func validateOpAssociateDomainInput(v *AssociateDomainInput) error {
781	if v == nil {
782		return nil
783	}
784	invalidParams := smithy.InvalidParamsError{Context: "AssociateDomainInput"}
785	if v.FleetArn == nil {
786		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
787	}
788	if v.DomainName == nil {
789		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
790	}
791	if v.AcmCertificateArn == nil {
792		invalidParams.Add(smithy.NewErrParamRequired("AcmCertificateArn"))
793	}
794	if invalidParams.Len() > 0 {
795		return invalidParams
796	} else {
797		return nil
798	}
799}
800
801func validateOpAssociateWebsiteAuthorizationProviderInput(v *AssociateWebsiteAuthorizationProviderInput) error {
802	if v == nil {
803		return nil
804	}
805	invalidParams := smithy.InvalidParamsError{Context: "AssociateWebsiteAuthorizationProviderInput"}
806	if v.FleetArn == nil {
807		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
808	}
809	if len(v.AuthorizationProviderType) == 0 {
810		invalidParams.Add(smithy.NewErrParamRequired("AuthorizationProviderType"))
811	}
812	if invalidParams.Len() > 0 {
813		return invalidParams
814	} else {
815		return nil
816	}
817}
818
819func validateOpAssociateWebsiteCertificateAuthorityInput(v *AssociateWebsiteCertificateAuthorityInput) error {
820	if v == nil {
821		return nil
822	}
823	invalidParams := smithy.InvalidParamsError{Context: "AssociateWebsiteCertificateAuthorityInput"}
824	if v.FleetArn == nil {
825		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
826	}
827	if v.Certificate == nil {
828		invalidParams.Add(smithy.NewErrParamRequired("Certificate"))
829	}
830	if invalidParams.Len() > 0 {
831		return invalidParams
832	} else {
833		return nil
834	}
835}
836
837func validateOpCreateFleetInput(v *CreateFleetInput) error {
838	if v == nil {
839		return nil
840	}
841	invalidParams := smithy.InvalidParamsError{Context: "CreateFleetInput"}
842	if v.FleetName == nil {
843		invalidParams.Add(smithy.NewErrParamRequired("FleetName"))
844	}
845	if invalidParams.Len() > 0 {
846		return invalidParams
847	} else {
848		return nil
849	}
850}
851
852func validateOpDeleteFleetInput(v *DeleteFleetInput) error {
853	if v == nil {
854		return nil
855	}
856	invalidParams := smithy.InvalidParamsError{Context: "DeleteFleetInput"}
857	if v.FleetArn == nil {
858		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
859	}
860	if invalidParams.Len() > 0 {
861		return invalidParams
862	} else {
863		return nil
864	}
865}
866
867func validateOpDescribeAuditStreamConfigurationInput(v *DescribeAuditStreamConfigurationInput) error {
868	if v == nil {
869		return nil
870	}
871	invalidParams := smithy.InvalidParamsError{Context: "DescribeAuditStreamConfigurationInput"}
872	if v.FleetArn == nil {
873		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
874	}
875	if invalidParams.Len() > 0 {
876		return invalidParams
877	} else {
878		return nil
879	}
880}
881
882func validateOpDescribeCompanyNetworkConfigurationInput(v *DescribeCompanyNetworkConfigurationInput) error {
883	if v == nil {
884		return nil
885	}
886	invalidParams := smithy.InvalidParamsError{Context: "DescribeCompanyNetworkConfigurationInput"}
887	if v.FleetArn == nil {
888		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
889	}
890	if invalidParams.Len() > 0 {
891		return invalidParams
892	} else {
893		return nil
894	}
895}
896
897func validateOpDescribeDeviceInput(v *DescribeDeviceInput) error {
898	if v == nil {
899		return nil
900	}
901	invalidParams := smithy.InvalidParamsError{Context: "DescribeDeviceInput"}
902	if v.FleetArn == nil {
903		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
904	}
905	if v.DeviceId == nil {
906		invalidParams.Add(smithy.NewErrParamRequired("DeviceId"))
907	}
908	if invalidParams.Len() > 0 {
909		return invalidParams
910	} else {
911		return nil
912	}
913}
914
915func validateOpDescribeDevicePolicyConfigurationInput(v *DescribeDevicePolicyConfigurationInput) error {
916	if v == nil {
917		return nil
918	}
919	invalidParams := smithy.InvalidParamsError{Context: "DescribeDevicePolicyConfigurationInput"}
920	if v.FleetArn == nil {
921		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
922	}
923	if invalidParams.Len() > 0 {
924		return invalidParams
925	} else {
926		return nil
927	}
928}
929
930func validateOpDescribeDomainInput(v *DescribeDomainInput) error {
931	if v == nil {
932		return nil
933	}
934	invalidParams := smithy.InvalidParamsError{Context: "DescribeDomainInput"}
935	if v.FleetArn == nil {
936		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
937	}
938	if v.DomainName == nil {
939		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
940	}
941	if invalidParams.Len() > 0 {
942		return invalidParams
943	} else {
944		return nil
945	}
946}
947
948func validateOpDescribeFleetMetadataInput(v *DescribeFleetMetadataInput) error {
949	if v == nil {
950		return nil
951	}
952	invalidParams := smithy.InvalidParamsError{Context: "DescribeFleetMetadataInput"}
953	if v.FleetArn == nil {
954		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
955	}
956	if invalidParams.Len() > 0 {
957		return invalidParams
958	} else {
959		return nil
960	}
961}
962
963func validateOpDescribeIdentityProviderConfigurationInput(v *DescribeIdentityProviderConfigurationInput) error {
964	if v == nil {
965		return nil
966	}
967	invalidParams := smithy.InvalidParamsError{Context: "DescribeIdentityProviderConfigurationInput"}
968	if v.FleetArn == nil {
969		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
970	}
971	if invalidParams.Len() > 0 {
972		return invalidParams
973	} else {
974		return nil
975	}
976}
977
978func validateOpDescribeWebsiteCertificateAuthorityInput(v *DescribeWebsiteCertificateAuthorityInput) error {
979	if v == nil {
980		return nil
981	}
982	invalidParams := smithy.InvalidParamsError{Context: "DescribeWebsiteCertificateAuthorityInput"}
983	if v.FleetArn == nil {
984		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
985	}
986	if v.WebsiteCaId == nil {
987		invalidParams.Add(smithy.NewErrParamRequired("WebsiteCaId"))
988	}
989	if invalidParams.Len() > 0 {
990		return invalidParams
991	} else {
992		return nil
993	}
994}
995
996func validateOpDisassociateDomainInput(v *DisassociateDomainInput) error {
997	if v == nil {
998		return nil
999	}
1000	invalidParams := smithy.InvalidParamsError{Context: "DisassociateDomainInput"}
1001	if v.FleetArn == nil {
1002		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
1003	}
1004	if v.DomainName == nil {
1005		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
1006	}
1007	if invalidParams.Len() > 0 {
1008		return invalidParams
1009	} else {
1010		return nil
1011	}
1012}
1013
1014func validateOpDisassociateWebsiteAuthorizationProviderInput(v *DisassociateWebsiteAuthorizationProviderInput) error {
1015	if v == nil {
1016		return nil
1017	}
1018	invalidParams := smithy.InvalidParamsError{Context: "DisassociateWebsiteAuthorizationProviderInput"}
1019	if v.FleetArn == nil {
1020		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
1021	}
1022	if v.AuthorizationProviderId == nil {
1023		invalidParams.Add(smithy.NewErrParamRequired("AuthorizationProviderId"))
1024	}
1025	if invalidParams.Len() > 0 {
1026		return invalidParams
1027	} else {
1028		return nil
1029	}
1030}
1031
1032func validateOpDisassociateWebsiteCertificateAuthorityInput(v *DisassociateWebsiteCertificateAuthorityInput) error {
1033	if v == nil {
1034		return nil
1035	}
1036	invalidParams := smithy.InvalidParamsError{Context: "DisassociateWebsiteCertificateAuthorityInput"}
1037	if v.FleetArn == nil {
1038		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
1039	}
1040	if v.WebsiteCaId == nil {
1041		invalidParams.Add(smithy.NewErrParamRequired("WebsiteCaId"))
1042	}
1043	if invalidParams.Len() > 0 {
1044		return invalidParams
1045	} else {
1046		return nil
1047	}
1048}
1049
1050func validateOpListDevicesInput(v *ListDevicesInput) error {
1051	if v == nil {
1052		return nil
1053	}
1054	invalidParams := smithy.InvalidParamsError{Context: "ListDevicesInput"}
1055	if v.FleetArn == nil {
1056		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
1057	}
1058	if invalidParams.Len() > 0 {
1059		return invalidParams
1060	} else {
1061		return nil
1062	}
1063}
1064
1065func validateOpListDomainsInput(v *ListDomainsInput) error {
1066	if v == nil {
1067		return nil
1068	}
1069	invalidParams := smithy.InvalidParamsError{Context: "ListDomainsInput"}
1070	if v.FleetArn == nil {
1071		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
1072	}
1073	if invalidParams.Len() > 0 {
1074		return invalidParams
1075	} else {
1076		return nil
1077	}
1078}
1079
1080func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
1081	if v == nil {
1082		return nil
1083	}
1084	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
1085	if v.ResourceArn == nil {
1086		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1087	}
1088	if invalidParams.Len() > 0 {
1089		return invalidParams
1090	} else {
1091		return nil
1092	}
1093}
1094
1095func validateOpListWebsiteAuthorizationProvidersInput(v *ListWebsiteAuthorizationProvidersInput) error {
1096	if v == nil {
1097		return nil
1098	}
1099	invalidParams := smithy.InvalidParamsError{Context: "ListWebsiteAuthorizationProvidersInput"}
1100	if v.FleetArn == nil {
1101		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
1102	}
1103	if invalidParams.Len() > 0 {
1104		return invalidParams
1105	} else {
1106		return nil
1107	}
1108}
1109
1110func validateOpListWebsiteCertificateAuthoritiesInput(v *ListWebsiteCertificateAuthoritiesInput) error {
1111	if v == nil {
1112		return nil
1113	}
1114	invalidParams := smithy.InvalidParamsError{Context: "ListWebsiteCertificateAuthoritiesInput"}
1115	if v.FleetArn == nil {
1116		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
1117	}
1118	if invalidParams.Len() > 0 {
1119		return invalidParams
1120	} else {
1121		return nil
1122	}
1123}
1124
1125func validateOpRestoreDomainAccessInput(v *RestoreDomainAccessInput) error {
1126	if v == nil {
1127		return nil
1128	}
1129	invalidParams := smithy.InvalidParamsError{Context: "RestoreDomainAccessInput"}
1130	if v.FleetArn == nil {
1131		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
1132	}
1133	if v.DomainName == nil {
1134		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
1135	}
1136	if invalidParams.Len() > 0 {
1137		return invalidParams
1138	} else {
1139		return nil
1140	}
1141}
1142
1143func validateOpRevokeDomainAccessInput(v *RevokeDomainAccessInput) error {
1144	if v == nil {
1145		return nil
1146	}
1147	invalidParams := smithy.InvalidParamsError{Context: "RevokeDomainAccessInput"}
1148	if v.FleetArn == nil {
1149		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
1150	}
1151	if v.DomainName == nil {
1152		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
1153	}
1154	if invalidParams.Len() > 0 {
1155		return invalidParams
1156	} else {
1157		return nil
1158	}
1159}
1160
1161func validateOpSignOutUserInput(v *SignOutUserInput) error {
1162	if v == nil {
1163		return nil
1164	}
1165	invalidParams := smithy.InvalidParamsError{Context: "SignOutUserInput"}
1166	if v.FleetArn == nil {
1167		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
1168	}
1169	if v.Username == nil {
1170		invalidParams.Add(smithy.NewErrParamRequired("Username"))
1171	}
1172	if invalidParams.Len() > 0 {
1173		return invalidParams
1174	} else {
1175		return nil
1176	}
1177}
1178
1179func validateOpTagResourceInput(v *TagResourceInput) error {
1180	if v == nil {
1181		return nil
1182	}
1183	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
1184	if v.ResourceArn == nil {
1185		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1186	}
1187	if v.Tags == nil {
1188		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
1189	}
1190	if invalidParams.Len() > 0 {
1191		return invalidParams
1192	} else {
1193		return nil
1194	}
1195}
1196
1197func validateOpUntagResourceInput(v *UntagResourceInput) error {
1198	if v == nil {
1199		return nil
1200	}
1201	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
1202	if v.ResourceArn == nil {
1203		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1204	}
1205	if v.TagKeys == nil {
1206		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
1207	}
1208	if invalidParams.Len() > 0 {
1209		return invalidParams
1210	} else {
1211		return nil
1212	}
1213}
1214
1215func validateOpUpdateAuditStreamConfigurationInput(v *UpdateAuditStreamConfigurationInput) error {
1216	if v == nil {
1217		return nil
1218	}
1219	invalidParams := smithy.InvalidParamsError{Context: "UpdateAuditStreamConfigurationInput"}
1220	if v.FleetArn == nil {
1221		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
1222	}
1223	if invalidParams.Len() > 0 {
1224		return invalidParams
1225	} else {
1226		return nil
1227	}
1228}
1229
1230func validateOpUpdateCompanyNetworkConfigurationInput(v *UpdateCompanyNetworkConfigurationInput) error {
1231	if v == nil {
1232		return nil
1233	}
1234	invalidParams := smithy.InvalidParamsError{Context: "UpdateCompanyNetworkConfigurationInput"}
1235	if v.FleetArn == nil {
1236		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
1237	}
1238	if v.VpcId == nil {
1239		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
1240	}
1241	if v.SubnetIds == nil {
1242		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
1243	}
1244	if v.SecurityGroupIds == nil {
1245		invalidParams.Add(smithy.NewErrParamRequired("SecurityGroupIds"))
1246	}
1247	if invalidParams.Len() > 0 {
1248		return invalidParams
1249	} else {
1250		return nil
1251	}
1252}
1253
1254func validateOpUpdateDevicePolicyConfigurationInput(v *UpdateDevicePolicyConfigurationInput) error {
1255	if v == nil {
1256		return nil
1257	}
1258	invalidParams := smithy.InvalidParamsError{Context: "UpdateDevicePolicyConfigurationInput"}
1259	if v.FleetArn == nil {
1260		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
1261	}
1262	if invalidParams.Len() > 0 {
1263		return invalidParams
1264	} else {
1265		return nil
1266	}
1267}
1268
1269func validateOpUpdateDomainMetadataInput(v *UpdateDomainMetadataInput) error {
1270	if v == nil {
1271		return nil
1272	}
1273	invalidParams := smithy.InvalidParamsError{Context: "UpdateDomainMetadataInput"}
1274	if v.FleetArn == nil {
1275		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
1276	}
1277	if v.DomainName == nil {
1278		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
1279	}
1280	if invalidParams.Len() > 0 {
1281		return invalidParams
1282	} else {
1283		return nil
1284	}
1285}
1286
1287func validateOpUpdateFleetMetadataInput(v *UpdateFleetMetadataInput) error {
1288	if v == nil {
1289		return nil
1290	}
1291	invalidParams := smithy.InvalidParamsError{Context: "UpdateFleetMetadataInput"}
1292	if v.FleetArn == nil {
1293		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
1294	}
1295	if invalidParams.Len() > 0 {
1296		return invalidParams
1297	} else {
1298		return nil
1299	}
1300}
1301
1302func validateOpUpdateIdentityProviderConfigurationInput(v *UpdateIdentityProviderConfigurationInput) error {
1303	if v == nil {
1304		return nil
1305	}
1306	invalidParams := smithy.InvalidParamsError{Context: "UpdateIdentityProviderConfigurationInput"}
1307	if v.FleetArn == nil {
1308		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
1309	}
1310	if len(v.IdentityProviderType) == 0 {
1311		invalidParams.Add(smithy.NewErrParamRequired("IdentityProviderType"))
1312	}
1313	if invalidParams.Len() > 0 {
1314		return invalidParams
1315	} else {
1316		return nil
1317	}
1318}
1319