1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package connect
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/connect/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpAssociateApprovedOrigin struct {
14}
15
16func (*validateOpAssociateApprovedOrigin) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpAssociateApprovedOrigin) 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.(*AssociateApprovedOriginInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpAssociateApprovedOriginInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpAssociateInstanceStorageConfig struct {
34}
35
36func (*validateOpAssociateInstanceStorageConfig) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpAssociateInstanceStorageConfig) 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.(*AssociateInstanceStorageConfigInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpAssociateInstanceStorageConfigInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpAssociateLambdaFunction struct {
54}
55
56func (*validateOpAssociateLambdaFunction) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpAssociateLambdaFunction) 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.(*AssociateLambdaFunctionInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpAssociateLambdaFunctionInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpAssociateLexBot struct {
74}
75
76func (*validateOpAssociateLexBot) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpAssociateLexBot) 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.(*AssociateLexBotInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpAssociateLexBotInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpAssociateQueueQuickConnects struct {
94}
95
96func (*validateOpAssociateQueueQuickConnects) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpAssociateQueueQuickConnects) 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.(*AssociateQueueQuickConnectsInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpAssociateQueueQuickConnectsInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpAssociateRoutingProfileQueues struct {
114}
115
116func (*validateOpAssociateRoutingProfileQueues) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpAssociateRoutingProfileQueues) 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.(*AssociateRoutingProfileQueuesInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpAssociateRoutingProfileQueuesInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpAssociateSecurityKey struct {
134}
135
136func (*validateOpAssociateSecurityKey) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpAssociateSecurityKey) 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.(*AssociateSecurityKeyInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpAssociateSecurityKeyInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpCreateContactFlow struct {
154}
155
156func (*validateOpCreateContactFlow) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpCreateContactFlow) 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.(*CreateContactFlowInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpCreateContactFlowInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpCreateInstance struct {
174}
175
176func (*validateOpCreateInstance) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpCreateInstance) 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.(*CreateInstanceInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpCreateInstanceInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpCreateIntegrationAssociation struct {
194}
195
196func (*validateOpCreateIntegrationAssociation) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpCreateIntegrationAssociation) 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.(*CreateIntegrationAssociationInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpCreateIntegrationAssociationInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpCreateQueue struct {
214}
215
216func (*validateOpCreateQueue) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpCreateQueue) 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.(*CreateQueueInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpCreateQueueInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpCreateQuickConnect struct {
234}
235
236func (*validateOpCreateQuickConnect) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpCreateQuickConnect) 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.(*CreateQuickConnectInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpCreateQuickConnectInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpCreateRoutingProfile struct {
254}
255
256func (*validateOpCreateRoutingProfile) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpCreateRoutingProfile) 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.(*CreateRoutingProfileInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpCreateRoutingProfileInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpCreateUseCase struct {
274}
275
276func (*validateOpCreateUseCase) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpCreateUseCase) 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.(*CreateUseCaseInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpCreateUseCaseInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpCreateUserHierarchyGroup struct {
294}
295
296func (*validateOpCreateUserHierarchyGroup) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpCreateUserHierarchyGroup) 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.(*CreateUserHierarchyGroupInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpCreateUserHierarchyGroupInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpCreateUser struct {
314}
315
316func (*validateOpCreateUser) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpCreateUser) 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.(*CreateUserInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpCreateUserInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpDeleteInstance struct {
334}
335
336func (*validateOpDeleteInstance) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpDeleteInstance) 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.(*DeleteInstanceInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpDeleteInstanceInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpDeleteIntegrationAssociation struct {
354}
355
356func (*validateOpDeleteIntegrationAssociation) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpDeleteIntegrationAssociation) 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.(*DeleteIntegrationAssociationInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpDeleteIntegrationAssociationInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpDeleteQuickConnect struct {
374}
375
376func (*validateOpDeleteQuickConnect) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpDeleteQuickConnect) 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.(*DeleteQuickConnectInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpDeleteQuickConnectInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpDeleteUseCase struct {
394}
395
396func (*validateOpDeleteUseCase) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpDeleteUseCase) 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.(*DeleteUseCaseInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpDeleteUseCaseInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpDeleteUserHierarchyGroup struct {
414}
415
416func (*validateOpDeleteUserHierarchyGroup) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpDeleteUserHierarchyGroup) 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.(*DeleteUserHierarchyGroupInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpDeleteUserHierarchyGroupInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpDeleteUser struct {
434}
435
436func (*validateOpDeleteUser) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpDeleteUser) 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.(*DeleteUserInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpDeleteUserInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpDescribeContactFlow struct {
454}
455
456func (*validateOpDescribeContactFlow) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpDescribeContactFlow) 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.(*DescribeContactFlowInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpDescribeContactFlowInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpDescribeHoursOfOperation struct {
474}
475
476func (*validateOpDescribeHoursOfOperation) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpDescribeHoursOfOperation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
481	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
482) {
483	input, ok := in.Parameters.(*DescribeHoursOfOperationInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpDescribeHoursOfOperationInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpDescribeInstanceAttribute struct {
494}
495
496func (*validateOpDescribeInstanceAttribute) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpDescribeInstanceAttribute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
501	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
502) {
503	input, ok := in.Parameters.(*DescribeInstanceAttributeInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpDescribeInstanceAttributeInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpDescribeInstance struct {
514}
515
516func (*validateOpDescribeInstance) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpDescribeInstance) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
521	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
522) {
523	input, ok := in.Parameters.(*DescribeInstanceInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpDescribeInstanceInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpDescribeInstanceStorageConfig struct {
534}
535
536func (*validateOpDescribeInstanceStorageConfig) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpDescribeInstanceStorageConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
541	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
542) {
543	input, ok := in.Parameters.(*DescribeInstanceStorageConfigInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpDescribeInstanceStorageConfigInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpDescribeQueue struct {
554}
555
556func (*validateOpDescribeQueue) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpDescribeQueue) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
561	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
562) {
563	input, ok := in.Parameters.(*DescribeQueueInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpDescribeQueueInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpDescribeQuickConnect struct {
574}
575
576func (*validateOpDescribeQuickConnect) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpDescribeQuickConnect) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
581	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
582) {
583	input, ok := in.Parameters.(*DescribeQuickConnectInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpDescribeQuickConnectInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpDescribeRoutingProfile struct {
594}
595
596func (*validateOpDescribeRoutingProfile) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpDescribeRoutingProfile) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
601	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
602) {
603	input, ok := in.Parameters.(*DescribeRoutingProfileInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpDescribeRoutingProfileInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpDescribeUserHierarchyGroup struct {
614}
615
616func (*validateOpDescribeUserHierarchyGroup) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpDescribeUserHierarchyGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
621	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
622) {
623	input, ok := in.Parameters.(*DescribeUserHierarchyGroupInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpDescribeUserHierarchyGroupInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpDescribeUserHierarchyStructure struct {
634}
635
636func (*validateOpDescribeUserHierarchyStructure) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpDescribeUserHierarchyStructure) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
641	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
642) {
643	input, ok := in.Parameters.(*DescribeUserHierarchyStructureInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpDescribeUserHierarchyStructureInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653type validateOpDescribeUser struct {
654}
655
656func (*validateOpDescribeUser) ID() string {
657	return "OperationInputValidation"
658}
659
660func (m *validateOpDescribeUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
661	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
662) {
663	input, ok := in.Parameters.(*DescribeUserInput)
664	if !ok {
665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666	}
667	if err := validateOpDescribeUserInput(input); err != nil {
668		return out, metadata, err
669	}
670	return next.HandleInitialize(ctx, in)
671}
672
673type validateOpDisassociateApprovedOrigin struct {
674}
675
676func (*validateOpDisassociateApprovedOrigin) ID() string {
677	return "OperationInputValidation"
678}
679
680func (m *validateOpDisassociateApprovedOrigin) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
681	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
682) {
683	input, ok := in.Parameters.(*DisassociateApprovedOriginInput)
684	if !ok {
685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
686	}
687	if err := validateOpDisassociateApprovedOriginInput(input); err != nil {
688		return out, metadata, err
689	}
690	return next.HandleInitialize(ctx, in)
691}
692
693type validateOpDisassociateInstanceStorageConfig struct {
694}
695
696func (*validateOpDisassociateInstanceStorageConfig) ID() string {
697	return "OperationInputValidation"
698}
699
700func (m *validateOpDisassociateInstanceStorageConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
701	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
702) {
703	input, ok := in.Parameters.(*DisassociateInstanceStorageConfigInput)
704	if !ok {
705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
706	}
707	if err := validateOpDisassociateInstanceStorageConfigInput(input); err != nil {
708		return out, metadata, err
709	}
710	return next.HandleInitialize(ctx, in)
711}
712
713type validateOpDisassociateLambdaFunction struct {
714}
715
716func (*validateOpDisassociateLambdaFunction) ID() string {
717	return "OperationInputValidation"
718}
719
720func (m *validateOpDisassociateLambdaFunction) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
721	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
722) {
723	input, ok := in.Parameters.(*DisassociateLambdaFunctionInput)
724	if !ok {
725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
726	}
727	if err := validateOpDisassociateLambdaFunctionInput(input); err != nil {
728		return out, metadata, err
729	}
730	return next.HandleInitialize(ctx, in)
731}
732
733type validateOpDisassociateLexBot struct {
734}
735
736func (*validateOpDisassociateLexBot) ID() string {
737	return "OperationInputValidation"
738}
739
740func (m *validateOpDisassociateLexBot) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
741	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
742) {
743	input, ok := in.Parameters.(*DisassociateLexBotInput)
744	if !ok {
745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
746	}
747	if err := validateOpDisassociateLexBotInput(input); err != nil {
748		return out, metadata, err
749	}
750	return next.HandleInitialize(ctx, in)
751}
752
753type validateOpDisassociateQueueQuickConnects struct {
754}
755
756func (*validateOpDisassociateQueueQuickConnects) ID() string {
757	return "OperationInputValidation"
758}
759
760func (m *validateOpDisassociateQueueQuickConnects) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
761	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
762) {
763	input, ok := in.Parameters.(*DisassociateQueueQuickConnectsInput)
764	if !ok {
765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
766	}
767	if err := validateOpDisassociateQueueQuickConnectsInput(input); err != nil {
768		return out, metadata, err
769	}
770	return next.HandleInitialize(ctx, in)
771}
772
773type validateOpDisassociateRoutingProfileQueues struct {
774}
775
776func (*validateOpDisassociateRoutingProfileQueues) ID() string {
777	return "OperationInputValidation"
778}
779
780func (m *validateOpDisassociateRoutingProfileQueues) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
781	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
782) {
783	input, ok := in.Parameters.(*DisassociateRoutingProfileQueuesInput)
784	if !ok {
785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
786	}
787	if err := validateOpDisassociateRoutingProfileQueuesInput(input); err != nil {
788		return out, metadata, err
789	}
790	return next.HandleInitialize(ctx, in)
791}
792
793type validateOpDisassociateSecurityKey struct {
794}
795
796func (*validateOpDisassociateSecurityKey) ID() string {
797	return "OperationInputValidation"
798}
799
800func (m *validateOpDisassociateSecurityKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
801	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
802) {
803	input, ok := in.Parameters.(*DisassociateSecurityKeyInput)
804	if !ok {
805		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
806	}
807	if err := validateOpDisassociateSecurityKeyInput(input); err != nil {
808		return out, metadata, err
809	}
810	return next.HandleInitialize(ctx, in)
811}
812
813type validateOpGetContactAttributes struct {
814}
815
816func (*validateOpGetContactAttributes) ID() string {
817	return "OperationInputValidation"
818}
819
820func (m *validateOpGetContactAttributes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
821	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
822) {
823	input, ok := in.Parameters.(*GetContactAttributesInput)
824	if !ok {
825		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
826	}
827	if err := validateOpGetContactAttributesInput(input); err != nil {
828		return out, metadata, err
829	}
830	return next.HandleInitialize(ctx, in)
831}
832
833type validateOpGetCurrentMetricData struct {
834}
835
836func (*validateOpGetCurrentMetricData) ID() string {
837	return "OperationInputValidation"
838}
839
840func (m *validateOpGetCurrentMetricData) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
841	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
842) {
843	input, ok := in.Parameters.(*GetCurrentMetricDataInput)
844	if !ok {
845		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
846	}
847	if err := validateOpGetCurrentMetricDataInput(input); err != nil {
848		return out, metadata, err
849	}
850	return next.HandleInitialize(ctx, in)
851}
852
853type validateOpGetFederationToken struct {
854}
855
856func (*validateOpGetFederationToken) ID() string {
857	return "OperationInputValidation"
858}
859
860func (m *validateOpGetFederationToken) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
861	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
862) {
863	input, ok := in.Parameters.(*GetFederationTokenInput)
864	if !ok {
865		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
866	}
867	if err := validateOpGetFederationTokenInput(input); err != nil {
868		return out, metadata, err
869	}
870	return next.HandleInitialize(ctx, in)
871}
872
873type validateOpGetMetricData struct {
874}
875
876func (*validateOpGetMetricData) ID() string {
877	return "OperationInputValidation"
878}
879
880func (m *validateOpGetMetricData) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
881	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
882) {
883	input, ok := in.Parameters.(*GetMetricDataInput)
884	if !ok {
885		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
886	}
887	if err := validateOpGetMetricDataInput(input); err != nil {
888		return out, metadata, err
889	}
890	return next.HandleInitialize(ctx, in)
891}
892
893type validateOpListApprovedOrigins struct {
894}
895
896func (*validateOpListApprovedOrigins) ID() string {
897	return "OperationInputValidation"
898}
899
900func (m *validateOpListApprovedOrigins) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
901	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
902) {
903	input, ok := in.Parameters.(*ListApprovedOriginsInput)
904	if !ok {
905		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
906	}
907	if err := validateOpListApprovedOriginsInput(input); err != nil {
908		return out, metadata, err
909	}
910	return next.HandleInitialize(ctx, in)
911}
912
913type validateOpListContactFlows struct {
914}
915
916func (*validateOpListContactFlows) ID() string {
917	return "OperationInputValidation"
918}
919
920func (m *validateOpListContactFlows) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
921	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
922) {
923	input, ok := in.Parameters.(*ListContactFlowsInput)
924	if !ok {
925		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
926	}
927	if err := validateOpListContactFlowsInput(input); err != nil {
928		return out, metadata, err
929	}
930	return next.HandleInitialize(ctx, in)
931}
932
933type validateOpListHoursOfOperations struct {
934}
935
936func (*validateOpListHoursOfOperations) ID() string {
937	return "OperationInputValidation"
938}
939
940func (m *validateOpListHoursOfOperations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
941	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
942) {
943	input, ok := in.Parameters.(*ListHoursOfOperationsInput)
944	if !ok {
945		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
946	}
947	if err := validateOpListHoursOfOperationsInput(input); err != nil {
948		return out, metadata, err
949	}
950	return next.HandleInitialize(ctx, in)
951}
952
953type validateOpListInstanceAttributes struct {
954}
955
956func (*validateOpListInstanceAttributes) ID() string {
957	return "OperationInputValidation"
958}
959
960func (m *validateOpListInstanceAttributes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
961	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
962) {
963	input, ok := in.Parameters.(*ListInstanceAttributesInput)
964	if !ok {
965		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
966	}
967	if err := validateOpListInstanceAttributesInput(input); err != nil {
968		return out, metadata, err
969	}
970	return next.HandleInitialize(ctx, in)
971}
972
973type validateOpListInstanceStorageConfigs struct {
974}
975
976func (*validateOpListInstanceStorageConfigs) ID() string {
977	return "OperationInputValidation"
978}
979
980func (m *validateOpListInstanceStorageConfigs) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
981	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
982) {
983	input, ok := in.Parameters.(*ListInstanceStorageConfigsInput)
984	if !ok {
985		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
986	}
987	if err := validateOpListInstanceStorageConfigsInput(input); err != nil {
988		return out, metadata, err
989	}
990	return next.HandleInitialize(ctx, in)
991}
992
993type validateOpListIntegrationAssociations struct {
994}
995
996func (*validateOpListIntegrationAssociations) ID() string {
997	return "OperationInputValidation"
998}
999
1000func (m *validateOpListIntegrationAssociations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1001	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1002) {
1003	input, ok := in.Parameters.(*ListIntegrationAssociationsInput)
1004	if !ok {
1005		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1006	}
1007	if err := validateOpListIntegrationAssociationsInput(input); err != nil {
1008		return out, metadata, err
1009	}
1010	return next.HandleInitialize(ctx, in)
1011}
1012
1013type validateOpListLambdaFunctions struct {
1014}
1015
1016func (*validateOpListLambdaFunctions) ID() string {
1017	return "OperationInputValidation"
1018}
1019
1020func (m *validateOpListLambdaFunctions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1021	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1022) {
1023	input, ok := in.Parameters.(*ListLambdaFunctionsInput)
1024	if !ok {
1025		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1026	}
1027	if err := validateOpListLambdaFunctionsInput(input); err != nil {
1028		return out, metadata, err
1029	}
1030	return next.HandleInitialize(ctx, in)
1031}
1032
1033type validateOpListLexBots struct {
1034}
1035
1036func (*validateOpListLexBots) ID() string {
1037	return "OperationInputValidation"
1038}
1039
1040func (m *validateOpListLexBots) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1041	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1042) {
1043	input, ok := in.Parameters.(*ListLexBotsInput)
1044	if !ok {
1045		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1046	}
1047	if err := validateOpListLexBotsInput(input); err != nil {
1048		return out, metadata, err
1049	}
1050	return next.HandleInitialize(ctx, in)
1051}
1052
1053type validateOpListPhoneNumbers struct {
1054}
1055
1056func (*validateOpListPhoneNumbers) ID() string {
1057	return "OperationInputValidation"
1058}
1059
1060func (m *validateOpListPhoneNumbers) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1061	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1062) {
1063	input, ok := in.Parameters.(*ListPhoneNumbersInput)
1064	if !ok {
1065		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1066	}
1067	if err := validateOpListPhoneNumbersInput(input); err != nil {
1068		return out, metadata, err
1069	}
1070	return next.HandleInitialize(ctx, in)
1071}
1072
1073type validateOpListPrompts struct {
1074}
1075
1076func (*validateOpListPrompts) ID() string {
1077	return "OperationInputValidation"
1078}
1079
1080func (m *validateOpListPrompts) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1081	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1082) {
1083	input, ok := in.Parameters.(*ListPromptsInput)
1084	if !ok {
1085		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1086	}
1087	if err := validateOpListPromptsInput(input); err != nil {
1088		return out, metadata, err
1089	}
1090	return next.HandleInitialize(ctx, in)
1091}
1092
1093type validateOpListQueueQuickConnects struct {
1094}
1095
1096func (*validateOpListQueueQuickConnects) ID() string {
1097	return "OperationInputValidation"
1098}
1099
1100func (m *validateOpListQueueQuickConnects) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1101	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1102) {
1103	input, ok := in.Parameters.(*ListQueueQuickConnectsInput)
1104	if !ok {
1105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1106	}
1107	if err := validateOpListQueueQuickConnectsInput(input); err != nil {
1108		return out, metadata, err
1109	}
1110	return next.HandleInitialize(ctx, in)
1111}
1112
1113type validateOpListQueues struct {
1114}
1115
1116func (*validateOpListQueues) ID() string {
1117	return "OperationInputValidation"
1118}
1119
1120func (m *validateOpListQueues) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1121	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1122) {
1123	input, ok := in.Parameters.(*ListQueuesInput)
1124	if !ok {
1125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1126	}
1127	if err := validateOpListQueuesInput(input); err != nil {
1128		return out, metadata, err
1129	}
1130	return next.HandleInitialize(ctx, in)
1131}
1132
1133type validateOpListQuickConnects struct {
1134}
1135
1136func (*validateOpListQuickConnects) ID() string {
1137	return "OperationInputValidation"
1138}
1139
1140func (m *validateOpListQuickConnects) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1141	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1142) {
1143	input, ok := in.Parameters.(*ListQuickConnectsInput)
1144	if !ok {
1145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1146	}
1147	if err := validateOpListQuickConnectsInput(input); err != nil {
1148		return out, metadata, err
1149	}
1150	return next.HandleInitialize(ctx, in)
1151}
1152
1153type validateOpListRoutingProfileQueues struct {
1154}
1155
1156func (*validateOpListRoutingProfileQueues) ID() string {
1157	return "OperationInputValidation"
1158}
1159
1160func (m *validateOpListRoutingProfileQueues) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1161	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1162) {
1163	input, ok := in.Parameters.(*ListRoutingProfileQueuesInput)
1164	if !ok {
1165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1166	}
1167	if err := validateOpListRoutingProfileQueuesInput(input); err != nil {
1168		return out, metadata, err
1169	}
1170	return next.HandleInitialize(ctx, in)
1171}
1172
1173type validateOpListRoutingProfiles struct {
1174}
1175
1176func (*validateOpListRoutingProfiles) ID() string {
1177	return "OperationInputValidation"
1178}
1179
1180func (m *validateOpListRoutingProfiles) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1181	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1182) {
1183	input, ok := in.Parameters.(*ListRoutingProfilesInput)
1184	if !ok {
1185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1186	}
1187	if err := validateOpListRoutingProfilesInput(input); err != nil {
1188		return out, metadata, err
1189	}
1190	return next.HandleInitialize(ctx, in)
1191}
1192
1193type validateOpListSecurityKeys struct {
1194}
1195
1196func (*validateOpListSecurityKeys) ID() string {
1197	return "OperationInputValidation"
1198}
1199
1200func (m *validateOpListSecurityKeys) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1201	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1202) {
1203	input, ok := in.Parameters.(*ListSecurityKeysInput)
1204	if !ok {
1205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1206	}
1207	if err := validateOpListSecurityKeysInput(input); err != nil {
1208		return out, metadata, err
1209	}
1210	return next.HandleInitialize(ctx, in)
1211}
1212
1213type validateOpListSecurityProfiles struct {
1214}
1215
1216func (*validateOpListSecurityProfiles) ID() string {
1217	return "OperationInputValidation"
1218}
1219
1220func (m *validateOpListSecurityProfiles) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1221	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1222) {
1223	input, ok := in.Parameters.(*ListSecurityProfilesInput)
1224	if !ok {
1225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1226	}
1227	if err := validateOpListSecurityProfilesInput(input); err != nil {
1228		return out, metadata, err
1229	}
1230	return next.HandleInitialize(ctx, in)
1231}
1232
1233type validateOpListTagsForResource struct {
1234}
1235
1236func (*validateOpListTagsForResource) ID() string {
1237	return "OperationInputValidation"
1238}
1239
1240func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1241	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1242) {
1243	input, ok := in.Parameters.(*ListTagsForResourceInput)
1244	if !ok {
1245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1246	}
1247	if err := validateOpListTagsForResourceInput(input); err != nil {
1248		return out, metadata, err
1249	}
1250	return next.HandleInitialize(ctx, in)
1251}
1252
1253type validateOpListUseCases struct {
1254}
1255
1256func (*validateOpListUseCases) ID() string {
1257	return "OperationInputValidation"
1258}
1259
1260func (m *validateOpListUseCases) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1261	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1262) {
1263	input, ok := in.Parameters.(*ListUseCasesInput)
1264	if !ok {
1265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1266	}
1267	if err := validateOpListUseCasesInput(input); err != nil {
1268		return out, metadata, err
1269	}
1270	return next.HandleInitialize(ctx, in)
1271}
1272
1273type validateOpListUserHierarchyGroups struct {
1274}
1275
1276func (*validateOpListUserHierarchyGroups) ID() string {
1277	return "OperationInputValidation"
1278}
1279
1280func (m *validateOpListUserHierarchyGroups) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1281	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1282) {
1283	input, ok := in.Parameters.(*ListUserHierarchyGroupsInput)
1284	if !ok {
1285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1286	}
1287	if err := validateOpListUserHierarchyGroupsInput(input); err != nil {
1288		return out, metadata, err
1289	}
1290	return next.HandleInitialize(ctx, in)
1291}
1292
1293type validateOpListUsers struct {
1294}
1295
1296func (*validateOpListUsers) ID() string {
1297	return "OperationInputValidation"
1298}
1299
1300func (m *validateOpListUsers) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1301	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1302) {
1303	input, ok := in.Parameters.(*ListUsersInput)
1304	if !ok {
1305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1306	}
1307	if err := validateOpListUsersInput(input); err != nil {
1308		return out, metadata, err
1309	}
1310	return next.HandleInitialize(ctx, in)
1311}
1312
1313type validateOpResumeContactRecording struct {
1314}
1315
1316func (*validateOpResumeContactRecording) ID() string {
1317	return "OperationInputValidation"
1318}
1319
1320func (m *validateOpResumeContactRecording) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1321	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1322) {
1323	input, ok := in.Parameters.(*ResumeContactRecordingInput)
1324	if !ok {
1325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1326	}
1327	if err := validateOpResumeContactRecordingInput(input); err != nil {
1328		return out, metadata, err
1329	}
1330	return next.HandleInitialize(ctx, in)
1331}
1332
1333type validateOpStartChatContact struct {
1334}
1335
1336func (*validateOpStartChatContact) ID() string {
1337	return "OperationInputValidation"
1338}
1339
1340func (m *validateOpStartChatContact) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1341	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1342) {
1343	input, ok := in.Parameters.(*StartChatContactInput)
1344	if !ok {
1345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1346	}
1347	if err := validateOpStartChatContactInput(input); err != nil {
1348		return out, metadata, err
1349	}
1350	return next.HandleInitialize(ctx, in)
1351}
1352
1353type validateOpStartContactRecording struct {
1354}
1355
1356func (*validateOpStartContactRecording) ID() string {
1357	return "OperationInputValidation"
1358}
1359
1360func (m *validateOpStartContactRecording) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1361	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1362) {
1363	input, ok := in.Parameters.(*StartContactRecordingInput)
1364	if !ok {
1365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1366	}
1367	if err := validateOpStartContactRecordingInput(input); err != nil {
1368		return out, metadata, err
1369	}
1370	return next.HandleInitialize(ctx, in)
1371}
1372
1373type validateOpStartOutboundVoiceContact struct {
1374}
1375
1376func (*validateOpStartOutboundVoiceContact) ID() string {
1377	return "OperationInputValidation"
1378}
1379
1380func (m *validateOpStartOutboundVoiceContact) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1381	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1382) {
1383	input, ok := in.Parameters.(*StartOutboundVoiceContactInput)
1384	if !ok {
1385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1386	}
1387	if err := validateOpStartOutboundVoiceContactInput(input); err != nil {
1388		return out, metadata, err
1389	}
1390	return next.HandleInitialize(ctx, in)
1391}
1392
1393type validateOpStartTaskContact struct {
1394}
1395
1396func (*validateOpStartTaskContact) ID() string {
1397	return "OperationInputValidation"
1398}
1399
1400func (m *validateOpStartTaskContact) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1401	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1402) {
1403	input, ok := in.Parameters.(*StartTaskContactInput)
1404	if !ok {
1405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1406	}
1407	if err := validateOpStartTaskContactInput(input); err != nil {
1408		return out, metadata, err
1409	}
1410	return next.HandleInitialize(ctx, in)
1411}
1412
1413type validateOpStopContact struct {
1414}
1415
1416func (*validateOpStopContact) ID() string {
1417	return "OperationInputValidation"
1418}
1419
1420func (m *validateOpStopContact) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1421	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1422) {
1423	input, ok := in.Parameters.(*StopContactInput)
1424	if !ok {
1425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1426	}
1427	if err := validateOpStopContactInput(input); err != nil {
1428		return out, metadata, err
1429	}
1430	return next.HandleInitialize(ctx, in)
1431}
1432
1433type validateOpStopContactRecording struct {
1434}
1435
1436func (*validateOpStopContactRecording) ID() string {
1437	return "OperationInputValidation"
1438}
1439
1440func (m *validateOpStopContactRecording) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1441	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1442) {
1443	input, ok := in.Parameters.(*StopContactRecordingInput)
1444	if !ok {
1445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1446	}
1447	if err := validateOpStopContactRecordingInput(input); err != nil {
1448		return out, metadata, err
1449	}
1450	return next.HandleInitialize(ctx, in)
1451}
1452
1453type validateOpSuspendContactRecording struct {
1454}
1455
1456func (*validateOpSuspendContactRecording) ID() string {
1457	return "OperationInputValidation"
1458}
1459
1460func (m *validateOpSuspendContactRecording) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1461	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1462) {
1463	input, ok := in.Parameters.(*SuspendContactRecordingInput)
1464	if !ok {
1465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1466	}
1467	if err := validateOpSuspendContactRecordingInput(input); err != nil {
1468		return out, metadata, err
1469	}
1470	return next.HandleInitialize(ctx, in)
1471}
1472
1473type validateOpTagResource struct {
1474}
1475
1476func (*validateOpTagResource) ID() string {
1477	return "OperationInputValidation"
1478}
1479
1480func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1481	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1482) {
1483	input, ok := in.Parameters.(*TagResourceInput)
1484	if !ok {
1485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1486	}
1487	if err := validateOpTagResourceInput(input); err != nil {
1488		return out, metadata, err
1489	}
1490	return next.HandleInitialize(ctx, in)
1491}
1492
1493type validateOpUntagResource struct {
1494}
1495
1496func (*validateOpUntagResource) ID() string {
1497	return "OperationInputValidation"
1498}
1499
1500func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1501	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1502) {
1503	input, ok := in.Parameters.(*UntagResourceInput)
1504	if !ok {
1505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1506	}
1507	if err := validateOpUntagResourceInput(input); err != nil {
1508		return out, metadata, err
1509	}
1510	return next.HandleInitialize(ctx, in)
1511}
1512
1513type validateOpUpdateContactAttributes struct {
1514}
1515
1516func (*validateOpUpdateContactAttributes) ID() string {
1517	return "OperationInputValidation"
1518}
1519
1520func (m *validateOpUpdateContactAttributes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1521	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1522) {
1523	input, ok := in.Parameters.(*UpdateContactAttributesInput)
1524	if !ok {
1525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1526	}
1527	if err := validateOpUpdateContactAttributesInput(input); err != nil {
1528		return out, metadata, err
1529	}
1530	return next.HandleInitialize(ctx, in)
1531}
1532
1533type validateOpUpdateContactFlowContent struct {
1534}
1535
1536func (*validateOpUpdateContactFlowContent) ID() string {
1537	return "OperationInputValidation"
1538}
1539
1540func (m *validateOpUpdateContactFlowContent) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1541	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1542) {
1543	input, ok := in.Parameters.(*UpdateContactFlowContentInput)
1544	if !ok {
1545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1546	}
1547	if err := validateOpUpdateContactFlowContentInput(input); err != nil {
1548		return out, metadata, err
1549	}
1550	return next.HandleInitialize(ctx, in)
1551}
1552
1553type validateOpUpdateContactFlowName struct {
1554}
1555
1556func (*validateOpUpdateContactFlowName) ID() string {
1557	return "OperationInputValidation"
1558}
1559
1560func (m *validateOpUpdateContactFlowName) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1561	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1562) {
1563	input, ok := in.Parameters.(*UpdateContactFlowNameInput)
1564	if !ok {
1565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1566	}
1567	if err := validateOpUpdateContactFlowNameInput(input); err != nil {
1568		return out, metadata, err
1569	}
1570	return next.HandleInitialize(ctx, in)
1571}
1572
1573type validateOpUpdateInstanceAttribute struct {
1574}
1575
1576func (*validateOpUpdateInstanceAttribute) ID() string {
1577	return "OperationInputValidation"
1578}
1579
1580func (m *validateOpUpdateInstanceAttribute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1581	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1582) {
1583	input, ok := in.Parameters.(*UpdateInstanceAttributeInput)
1584	if !ok {
1585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1586	}
1587	if err := validateOpUpdateInstanceAttributeInput(input); err != nil {
1588		return out, metadata, err
1589	}
1590	return next.HandleInitialize(ctx, in)
1591}
1592
1593type validateOpUpdateInstanceStorageConfig struct {
1594}
1595
1596func (*validateOpUpdateInstanceStorageConfig) ID() string {
1597	return "OperationInputValidation"
1598}
1599
1600func (m *validateOpUpdateInstanceStorageConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1601	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1602) {
1603	input, ok := in.Parameters.(*UpdateInstanceStorageConfigInput)
1604	if !ok {
1605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1606	}
1607	if err := validateOpUpdateInstanceStorageConfigInput(input); err != nil {
1608		return out, metadata, err
1609	}
1610	return next.HandleInitialize(ctx, in)
1611}
1612
1613type validateOpUpdateQueueHoursOfOperation struct {
1614}
1615
1616func (*validateOpUpdateQueueHoursOfOperation) ID() string {
1617	return "OperationInputValidation"
1618}
1619
1620func (m *validateOpUpdateQueueHoursOfOperation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1621	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1622) {
1623	input, ok := in.Parameters.(*UpdateQueueHoursOfOperationInput)
1624	if !ok {
1625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1626	}
1627	if err := validateOpUpdateQueueHoursOfOperationInput(input); err != nil {
1628		return out, metadata, err
1629	}
1630	return next.HandleInitialize(ctx, in)
1631}
1632
1633type validateOpUpdateQueueMaxContacts struct {
1634}
1635
1636func (*validateOpUpdateQueueMaxContacts) ID() string {
1637	return "OperationInputValidation"
1638}
1639
1640func (m *validateOpUpdateQueueMaxContacts) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1641	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1642) {
1643	input, ok := in.Parameters.(*UpdateQueueMaxContactsInput)
1644	if !ok {
1645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1646	}
1647	if err := validateOpUpdateQueueMaxContactsInput(input); err != nil {
1648		return out, metadata, err
1649	}
1650	return next.HandleInitialize(ctx, in)
1651}
1652
1653type validateOpUpdateQueueName struct {
1654}
1655
1656func (*validateOpUpdateQueueName) ID() string {
1657	return "OperationInputValidation"
1658}
1659
1660func (m *validateOpUpdateQueueName) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1661	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1662) {
1663	input, ok := in.Parameters.(*UpdateQueueNameInput)
1664	if !ok {
1665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1666	}
1667	if err := validateOpUpdateQueueNameInput(input); err != nil {
1668		return out, metadata, err
1669	}
1670	return next.HandleInitialize(ctx, in)
1671}
1672
1673type validateOpUpdateQueueOutboundCallerConfig struct {
1674}
1675
1676func (*validateOpUpdateQueueOutboundCallerConfig) ID() string {
1677	return "OperationInputValidation"
1678}
1679
1680func (m *validateOpUpdateQueueOutboundCallerConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1681	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1682) {
1683	input, ok := in.Parameters.(*UpdateQueueOutboundCallerConfigInput)
1684	if !ok {
1685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1686	}
1687	if err := validateOpUpdateQueueOutboundCallerConfigInput(input); err != nil {
1688		return out, metadata, err
1689	}
1690	return next.HandleInitialize(ctx, in)
1691}
1692
1693type validateOpUpdateQueueStatus struct {
1694}
1695
1696func (*validateOpUpdateQueueStatus) ID() string {
1697	return "OperationInputValidation"
1698}
1699
1700func (m *validateOpUpdateQueueStatus) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1701	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1702) {
1703	input, ok := in.Parameters.(*UpdateQueueStatusInput)
1704	if !ok {
1705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1706	}
1707	if err := validateOpUpdateQueueStatusInput(input); err != nil {
1708		return out, metadata, err
1709	}
1710	return next.HandleInitialize(ctx, in)
1711}
1712
1713type validateOpUpdateQuickConnectConfig struct {
1714}
1715
1716func (*validateOpUpdateQuickConnectConfig) ID() string {
1717	return "OperationInputValidation"
1718}
1719
1720func (m *validateOpUpdateQuickConnectConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1721	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1722) {
1723	input, ok := in.Parameters.(*UpdateQuickConnectConfigInput)
1724	if !ok {
1725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1726	}
1727	if err := validateOpUpdateQuickConnectConfigInput(input); err != nil {
1728		return out, metadata, err
1729	}
1730	return next.HandleInitialize(ctx, in)
1731}
1732
1733type validateOpUpdateQuickConnectName struct {
1734}
1735
1736func (*validateOpUpdateQuickConnectName) ID() string {
1737	return "OperationInputValidation"
1738}
1739
1740func (m *validateOpUpdateQuickConnectName) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1741	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1742) {
1743	input, ok := in.Parameters.(*UpdateQuickConnectNameInput)
1744	if !ok {
1745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1746	}
1747	if err := validateOpUpdateQuickConnectNameInput(input); err != nil {
1748		return out, metadata, err
1749	}
1750	return next.HandleInitialize(ctx, in)
1751}
1752
1753type validateOpUpdateRoutingProfileConcurrency struct {
1754}
1755
1756func (*validateOpUpdateRoutingProfileConcurrency) ID() string {
1757	return "OperationInputValidation"
1758}
1759
1760func (m *validateOpUpdateRoutingProfileConcurrency) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1761	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1762) {
1763	input, ok := in.Parameters.(*UpdateRoutingProfileConcurrencyInput)
1764	if !ok {
1765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1766	}
1767	if err := validateOpUpdateRoutingProfileConcurrencyInput(input); err != nil {
1768		return out, metadata, err
1769	}
1770	return next.HandleInitialize(ctx, in)
1771}
1772
1773type validateOpUpdateRoutingProfileDefaultOutboundQueue struct {
1774}
1775
1776func (*validateOpUpdateRoutingProfileDefaultOutboundQueue) ID() string {
1777	return "OperationInputValidation"
1778}
1779
1780func (m *validateOpUpdateRoutingProfileDefaultOutboundQueue) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1781	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1782) {
1783	input, ok := in.Parameters.(*UpdateRoutingProfileDefaultOutboundQueueInput)
1784	if !ok {
1785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1786	}
1787	if err := validateOpUpdateRoutingProfileDefaultOutboundQueueInput(input); err != nil {
1788		return out, metadata, err
1789	}
1790	return next.HandleInitialize(ctx, in)
1791}
1792
1793type validateOpUpdateRoutingProfileName struct {
1794}
1795
1796func (*validateOpUpdateRoutingProfileName) ID() string {
1797	return "OperationInputValidation"
1798}
1799
1800func (m *validateOpUpdateRoutingProfileName) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1801	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1802) {
1803	input, ok := in.Parameters.(*UpdateRoutingProfileNameInput)
1804	if !ok {
1805		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1806	}
1807	if err := validateOpUpdateRoutingProfileNameInput(input); err != nil {
1808		return out, metadata, err
1809	}
1810	return next.HandleInitialize(ctx, in)
1811}
1812
1813type validateOpUpdateRoutingProfileQueues struct {
1814}
1815
1816func (*validateOpUpdateRoutingProfileQueues) ID() string {
1817	return "OperationInputValidation"
1818}
1819
1820func (m *validateOpUpdateRoutingProfileQueues) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1821	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1822) {
1823	input, ok := in.Parameters.(*UpdateRoutingProfileQueuesInput)
1824	if !ok {
1825		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1826	}
1827	if err := validateOpUpdateRoutingProfileQueuesInput(input); err != nil {
1828		return out, metadata, err
1829	}
1830	return next.HandleInitialize(ctx, in)
1831}
1832
1833type validateOpUpdateUserHierarchyGroupName struct {
1834}
1835
1836func (*validateOpUpdateUserHierarchyGroupName) ID() string {
1837	return "OperationInputValidation"
1838}
1839
1840func (m *validateOpUpdateUserHierarchyGroupName) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1841	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1842) {
1843	input, ok := in.Parameters.(*UpdateUserHierarchyGroupNameInput)
1844	if !ok {
1845		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1846	}
1847	if err := validateOpUpdateUserHierarchyGroupNameInput(input); err != nil {
1848		return out, metadata, err
1849	}
1850	return next.HandleInitialize(ctx, in)
1851}
1852
1853type validateOpUpdateUserHierarchy struct {
1854}
1855
1856func (*validateOpUpdateUserHierarchy) ID() string {
1857	return "OperationInputValidation"
1858}
1859
1860func (m *validateOpUpdateUserHierarchy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1861	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1862) {
1863	input, ok := in.Parameters.(*UpdateUserHierarchyInput)
1864	if !ok {
1865		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1866	}
1867	if err := validateOpUpdateUserHierarchyInput(input); err != nil {
1868		return out, metadata, err
1869	}
1870	return next.HandleInitialize(ctx, in)
1871}
1872
1873type validateOpUpdateUserHierarchyStructure struct {
1874}
1875
1876func (*validateOpUpdateUserHierarchyStructure) ID() string {
1877	return "OperationInputValidation"
1878}
1879
1880func (m *validateOpUpdateUserHierarchyStructure) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1881	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1882) {
1883	input, ok := in.Parameters.(*UpdateUserHierarchyStructureInput)
1884	if !ok {
1885		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1886	}
1887	if err := validateOpUpdateUserHierarchyStructureInput(input); err != nil {
1888		return out, metadata, err
1889	}
1890	return next.HandleInitialize(ctx, in)
1891}
1892
1893type validateOpUpdateUserIdentityInfo struct {
1894}
1895
1896func (*validateOpUpdateUserIdentityInfo) ID() string {
1897	return "OperationInputValidation"
1898}
1899
1900func (m *validateOpUpdateUserIdentityInfo) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1901	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1902) {
1903	input, ok := in.Parameters.(*UpdateUserIdentityInfoInput)
1904	if !ok {
1905		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1906	}
1907	if err := validateOpUpdateUserIdentityInfoInput(input); err != nil {
1908		return out, metadata, err
1909	}
1910	return next.HandleInitialize(ctx, in)
1911}
1912
1913type validateOpUpdateUserPhoneConfig struct {
1914}
1915
1916func (*validateOpUpdateUserPhoneConfig) ID() string {
1917	return "OperationInputValidation"
1918}
1919
1920func (m *validateOpUpdateUserPhoneConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1921	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1922) {
1923	input, ok := in.Parameters.(*UpdateUserPhoneConfigInput)
1924	if !ok {
1925		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1926	}
1927	if err := validateOpUpdateUserPhoneConfigInput(input); err != nil {
1928		return out, metadata, err
1929	}
1930	return next.HandleInitialize(ctx, in)
1931}
1932
1933type validateOpUpdateUserRoutingProfile struct {
1934}
1935
1936func (*validateOpUpdateUserRoutingProfile) ID() string {
1937	return "OperationInputValidation"
1938}
1939
1940func (m *validateOpUpdateUserRoutingProfile) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1941	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1942) {
1943	input, ok := in.Parameters.(*UpdateUserRoutingProfileInput)
1944	if !ok {
1945		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1946	}
1947	if err := validateOpUpdateUserRoutingProfileInput(input); err != nil {
1948		return out, metadata, err
1949	}
1950	return next.HandleInitialize(ctx, in)
1951}
1952
1953type validateOpUpdateUserSecurityProfiles struct {
1954}
1955
1956func (*validateOpUpdateUserSecurityProfiles) ID() string {
1957	return "OperationInputValidation"
1958}
1959
1960func (m *validateOpUpdateUserSecurityProfiles) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1961	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1962) {
1963	input, ok := in.Parameters.(*UpdateUserSecurityProfilesInput)
1964	if !ok {
1965		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1966	}
1967	if err := validateOpUpdateUserSecurityProfilesInput(input); err != nil {
1968		return out, metadata, err
1969	}
1970	return next.HandleInitialize(ctx, in)
1971}
1972
1973func addOpAssociateApprovedOriginValidationMiddleware(stack *middleware.Stack) error {
1974	return stack.Initialize.Add(&validateOpAssociateApprovedOrigin{}, middleware.After)
1975}
1976
1977func addOpAssociateInstanceStorageConfigValidationMiddleware(stack *middleware.Stack) error {
1978	return stack.Initialize.Add(&validateOpAssociateInstanceStorageConfig{}, middleware.After)
1979}
1980
1981func addOpAssociateLambdaFunctionValidationMiddleware(stack *middleware.Stack) error {
1982	return stack.Initialize.Add(&validateOpAssociateLambdaFunction{}, middleware.After)
1983}
1984
1985func addOpAssociateLexBotValidationMiddleware(stack *middleware.Stack) error {
1986	return stack.Initialize.Add(&validateOpAssociateLexBot{}, middleware.After)
1987}
1988
1989func addOpAssociateQueueQuickConnectsValidationMiddleware(stack *middleware.Stack) error {
1990	return stack.Initialize.Add(&validateOpAssociateQueueQuickConnects{}, middleware.After)
1991}
1992
1993func addOpAssociateRoutingProfileQueuesValidationMiddleware(stack *middleware.Stack) error {
1994	return stack.Initialize.Add(&validateOpAssociateRoutingProfileQueues{}, middleware.After)
1995}
1996
1997func addOpAssociateSecurityKeyValidationMiddleware(stack *middleware.Stack) error {
1998	return stack.Initialize.Add(&validateOpAssociateSecurityKey{}, middleware.After)
1999}
2000
2001func addOpCreateContactFlowValidationMiddleware(stack *middleware.Stack) error {
2002	return stack.Initialize.Add(&validateOpCreateContactFlow{}, middleware.After)
2003}
2004
2005func addOpCreateInstanceValidationMiddleware(stack *middleware.Stack) error {
2006	return stack.Initialize.Add(&validateOpCreateInstance{}, middleware.After)
2007}
2008
2009func addOpCreateIntegrationAssociationValidationMiddleware(stack *middleware.Stack) error {
2010	return stack.Initialize.Add(&validateOpCreateIntegrationAssociation{}, middleware.After)
2011}
2012
2013func addOpCreateQueueValidationMiddleware(stack *middleware.Stack) error {
2014	return stack.Initialize.Add(&validateOpCreateQueue{}, middleware.After)
2015}
2016
2017func addOpCreateQuickConnectValidationMiddleware(stack *middleware.Stack) error {
2018	return stack.Initialize.Add(&validateOpCreateQuickConnect{}, middleware.After)
2019}
2020
2021func addOpCreateRoutingProfileValidationMiddleware(stack *middleware.Stack) error {
2022	return stack.Initialize.Add(&validateOpCreateRoutingProfile{}, middleware.After)
2023}
2024
2025func addOpCreateUseCaseValidationMiddleware(stack *middleware.Stack) error {
2026	return stack.Initialize.Add(&validateOpCreateUseCase{}, middleware.After)
2027}
2028
2029func addOpCreateUserHierarchyGroupValidationMiddleware(stack *middleware.Stack) error {
2030	return stack.Initialize.Add(&validateOpCreateUserHierarchyGroup{}, middleware.After)
2031}
2032
2033func addOpCreateUserValidationMiddleware(stack *middleware.Stack) error {
2034	return stack.Initialize.Add(&validateOpCreateUser{}, middleware.After)
2035}
2036
2037func addOpDeleteInstanceValidationMiddleware(stack *middleware.Stack) error {
2038	return stack.Initialize.Add(&validateOpDeleteInstance{}, middleware.After)
2039}
2040
2041func addOpDeleteIntegrationAssociationValidationMiddleware(stack *middleware.Stack) error {
2042	return stack.Initialize.Add(&validateOpDeleteIntegrationAssociation{}, middleware.After)
2043}
2044
2045func addOpDeleteQuickConnectValidationMiddleware(stack *middleware.Stack) error {
2046	return stack.Initialize.Add(&validateOpDeleteQuickConnect{}, middleware.After)
2047}
2048
2049func addOpDeleteUseCaseValidationMiddleware(stack *middleware.Stack) error {
2050	return stack.Initialize.Add(&validateOpDeleteUseCase{}, middleware.After)
2051}
2052
2053func addOpDeleteUserHierarchyGroupValidationMiddleware(stack *middleware.Stack) error {
2054	return stack.Initialize.Add(&validateOpDeleteUserHierarchyGroup{}, middleware.After)
2055}
2056
2057func addOpDeleteUserValidationMiddleware(stack *middleware.Stack) error {
2058	return stack.Initialize.Add(&validateOpDeleteUser{}, middleware.After)
2059}
2060
2061func addOpDescribeContactFlowValidationMiddleware(stack *middleware.Stack) error {
2062	return stack.Initialize.Add(&validateOpDescribeContactFlow{}, middleware.After)
2063}
2064
2065func addOpDescribeHoursOfOperationValidationMiddleware(stack *middleware.Stack) error {
2066	return stack.Initialize.Add(&validateOpDescribeHoursOfOperation{}, middleware.After)
2067}
2068
2069func addOpDescribeInstanceAttributeValidationMiddleware(stack *middleware.Stack) error {
2070	return stack.Initialize.Add(&validateOpDescribeInstanceAttribute{}, middleware.After)
2071}
2072
2073func addOpDescribeInstanceValidationMiddleware(stack *middleware.Stack) error {
2074	return stack.Initialize.Add(&validateOpDescribeInstance{}, middleware.After)
2075}
2076
2077func addOpDescribeInstanceStorageConfigValidationMiddleware(stack *middleware.Stack) error {
2078	return stack.Initialize.Add(&validateOpDescribeInstanceStorageConfig{}, middleware.After)
2079}
2080
2081func addOpDescribeQueueValidationMiddleware(stack *middleware.Stack) error {
2082	return stack.Initialize.Add(&validateOpDescribeQueue{}, middleware.After)
2083}
2084
2085func addOpDescribeQuickConnectValidationMiddleware(stack *middleware.Stack) error {
2086	return stack.Initialize.Add(&validateOpDescribeQuickConnect{}, middleware.After)
2087}
2088
2089func addOpDescribeRoutingProfileValidationMiddleware(stack *middleware.Stack) error {
2090	return stack.Initialize.Add(&validateOpDescribeRoutingProfile{}, middleware.After)
2091}
2092
2093func addOpDescribeUserHierarchyGroupValidationMiddleware(stack *middleware.Stack) error {
2094	return stack.Initialize.Add(&validateOpDescribeUserHierarchyGroup{}, middleware.After)
2095}
2096
2097func addOpDescribeUserHierarchyStructureValidationMiddleware(stack *middleware.Stack) error {
2098	return stack.Initialize.Add(&validateOpDescribeUserHierarchyStructure{}, middleware.After)
2099}
2100
2101func addOpDescribeUserValidationMiddleware(stack *middleware.Stack) error {
2102	return stack.Initialize.Add(&validateOpDescribeUser{}, middleware.After)
2103}
2104
2105func addOpDisassociateApprovedOriginValidationMiddleware(stack *middleware.Stack) error {
2106	return stack.Initialize.Add(&validateOpDisassociateApprovedOrigin{}, middleware.After)
2107}
2108
2109func addOpDisassociateInstanceStorageConfigValidationMiddleware(stack *middleware.Stack) error {
2110	return stack.Initialize.Add(&validateOpDisassociateInstanceStorageConfig{}, middleware.After)
2111}
2112
2113func addOpDisassociateLambdaFunctionValidationMiddleware(stack *middleware.Stack) error {
2114	return stack.Initialize.Add(&validateOpDisassociateLambdaFunction{}, middleware.After)
2115}
2116
2117func addOpDisassociateLexBotValidationMiddleware(stack *middleware.Stack) error {
2118	return stack.Initialize.Add(&validateOpDisassociateLexBot{}, middleware.After)
2119}
2120
2121func addOpDisassociateQueueQuickConnectsValidationMiddleware(stack *middleware.Stack) error {
2122	return stack.Initialize.Add(&validateOpDisassociateQueueQuickConnects{}, middleware.After)
2123}
2124
2125func addOpDisassociateRoutingProfileQueuesValidationMiddleware(stack *middleware.Stack) error {
2126	return stack.Initialize.Add(&validateOpDisassociateRoutingProfileQueues{}, middleware.After)
2127}
2128
2129func addOpDisassociateSecurityKeyValidationMiddleware(stack *middleware.Stack) error {
2130	return stack.Initialize.Add(&validateOpDisassociateSecurityKey{}, middleware.After)
2131}
2132
2133func addOpGetContactAttributesValidationMiddleware(stack *middleware.Stack) error {
2134	return stack.Initialize.Add(&validateOpGetContactAttributes{}, middleware.After)
2135}
2136
2137func addOpGetCurrentMetricDataValidationMiddleware(stack *middleware.Stack) error {
2138	return stack.Initialize.Add(&validateOpGetCurrentMetricData{}, middleware.After)
2139}
2140
2141func addOpGetFederationTokenValidationMiddleware(stack *middleware.Stack) error {
2142	return stack.Initialize.Add(&validateOpGetFederationToken{}, middleware.After)
2143}
2144
2145func addOpGetMetricDataValidationMiddleware(stack *middleware.Stack) error {
2146	return stack.Initialize.Add(&validateOpGetMetricData{}, middleware.After)
2147}
2148
2149func addOpListApprovedOriginsValidationMiddleware(stack *middleware.Stack) error {
2150	return stack.Initialize.Add(&validateOpListApprovedOrigins{}, middleware.After)
2151}
2152
2153func addOpListContactFlowsValidationMiddleware(stack *middleware.Stack) error {
2154	return stack.Initialize.Add(&validateOpListContactFlows{}, middleware.After)
2155}
2156
2157func addOpListHoursOfOperationsValidationMiddleware(stack *middleware.Stack) error {
2158	return stack.Initialize.Add(&validateOpListHoursOfOperations{}, middleware.After)
2159}
2160
2161func addOpListInstanceAttributesValidationMiddleware(stack *middleware.Stack) error {
2162	return stack.Initialize.Add(&validateOpListInstanceAttributes{}, middleware.After)
2163}
2164
2165func addOpListInstanceStorageConfigsValidationMiddleware(stack *middleware.Stack) error {
2166	return stack.Initialize.Add(&validateOpListInstanceStorageConfigs{}, middleware.After)
2167}
2168
2169func addOpListIntegrationAssociationsValidationMiddleware(stack *middleware.Stack) error {
2170	return stack.Initialize.Add(&validateOpListIntegrationAssociations{}, middleware.After)
2171}
2172
2173func addOpListLambdaFunctionsValidationMiddleware(stack *middleware.Stack) error {
2174	return stack.Initialize.Add(&validateOpListLambdaFunctions{}, middleware.After)
2175}
2176
2177func addOpListLexBotsValidationMiddleware(stack *middleware.Stack) error {
2178	return stack.Initialize.Add(&validateOpListLexBots{}, middleware.After)
2179}
2180
2181func addOpListPhoneNumbersValidationMiddleware(stack *middleware.Stack) error {
2182	return stack.Initialize.Add(&validateOpListPhoneNumbers{}, middleware.After)
2183}
2184
2185func addOpListPromptsValidationMiddleware(stack *middleware.Stack) error {
2186	return stack.Initialize.Add(&validateOpListPrompts{}, middleware.After)
2187}
2188
2189func addOpListQueueQuickConnectsValidationMiddleware(stack *middleware.Stack) error {
2190	return stack.Initialize.Add(&validateOpListQueueQuickConnects{}, middleware.After)
2191}
2192
2193func addOpListQueuesValidationMiddleware(stack *middleware.Stack) error {
2194	return stack.Initialize.Add(&validateOpListQueues{}, middleware.After)
2195}
2196
2197func addOpListQuickConnectsValidationMiddleware(stack *middleware.Stack) error {
2198	return stack.Initialize.Add(&validateOpListQuickConnects{}, middleware.After)
2199}
2200
2201func addOpListRoutingProfileQueuesValidationMiddleware(stack *middleware.Stack) error {
2202	return stack.Initialize.Add(&validateOpListRoutingProfileQueues{}, middleware.After)
2203}
2204
2205func addOpListRoutingProfilesValidationMiddleware(stack *middleware.Stack) error {
2206	return stack.Initialize.Add(&validateOpListRoutingProfiles{}, middleware.After)
2207}
2208
2209func addOpListSecurityKeysValidationMiddleware(stack *middleware.Stack) error {
2210	return stack.Initialize.Add(&validateOpListSecurityKeys{}, middleware.After)
2211}
2212
2213func addOpListSecurityProfilesValidationMiddleware(stack *middleware.Stack) error {
2214	return stack.Initialize.Add(&validateOpListSecurityProfiles{}, middleware.After)
2215}
2216
2217func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
2218	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
2219}
2220
2221func addOpListUseCasesValidationMiddleware(stack *middleware.Stack) error {
2222	return stack.Initialize.Add(&validateOpListUseCases{}, middleware.After)
2223}
2224
2225func addOpListUserHierarchyGroupsValidationMiddleware(stack *middleware.Stack) error {
2226	return stack.Initialize.Add(&validateOpListUserHierarchyGroups{}, middleware.After)
2227}
2228
2229func addOpListUsersValidationMiddleware(stack *middleware.Stack) error {
2230	return stack.Initialize.Add(&validateOpListUsers{}, middleware.After)
2231}
2232
2233func addOpResumeContactRecordingValidationMiddleware(stack *middleware.Stack) error {
2234	return stack.Initialize.Add(&validateOpResumeContactRecording{}, middleware.After)
2235}
2236
2237func addOpStartChatContactValidationMiddleware(stack *middleware.Stack) error {
2238	return stack.Initialize.Add(&validateOpStartChatContact{}, middleware.After)
2239}
2240
2241func addOpStartContactRecordingValidationMiddleware(stack *middleware.Stack) error {
2242	return stack.Initialize.Add(&validateOpStartContactRecording{}, middleware.After)
2243}
2244
2245func addOpStartOutboundVoiceContactValidationMiddleware(stack *middleware.Stack) error {
2246	return stack.Initialize.Add(&validateOpStartOutboundVoiceContact{}, middleware.After)
2247}
2248
2249func addOpStartTaskContactValidationMiddleware(stack *middleware.Stack) error {
2250	return stack.Initialize.Add(&validateOpStartTaskContact{}, middleware.After)
2251}
2252
2253func addOpStopContactValidationMiddleware(stack *middleware.Stack) error {
2254	return stack.Initialize.Add(&validateOpStopContact{}, middleware.After)
2255}
2256
2257func addOpStopContactRecordingValidationMiddleware(stack *middleware.Stack) error {
2258	return stack.Initialize.Add(&validateOpStopContactRecording{}, middleware.After)
2259}
2260
2261func addOpSuspendContactRecordingValidationMiddleware(stack *middleware.Stack) error {
2262	return stack.Initialize.Add(&validateOpSuspendContactRecording{}, middleware.After)
2263}
2264
2265func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
2266	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
2267}
2268
2269func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
2270	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
2271}
2272
2273func addOpUpdateContactAttributesValidationMiddleware(stack *middleware.Stack) error {
2274	return stack.Initialize.Add(&validateOpUpdateContactAttributes{}, middleware.After)
2275}
2276
2277func addOpUpdateContactFlowContentValidationMiddleware(stack *middleware.Stack) error {
2278	return stack.Initialize.Add(&validateOpUpdateContactFlowContent{}, middleware.After)
2279}
2280
2281func addOpUpdateContactFlowNameValidationMiddleware(stack *middleware.Stack) error {
2282	return stack.Initialize.Add(&validateOpUpdateContactFlowName{}, middleware.After)
2283}
2284
2285func addOpUpdateInstanceAttributeValidationMiddleware(stack *middleware.Stack) error {
2286	return stack.Initialize.Add(&validateOpUpdateInstanceAttribute{}, middleware.After)
2287}
2288
2289func addOpUpdateInstanceStorageConfigValidationMiddleware(stack *middleware.Stack) error {
2290	return stack.Initialize.Add(&validateOpUpdateInstanceStorageConfig{}, middleware.After)
2291}
2292
2293func addOpUpdateQueueHoursOfOperationValidationMiddleware(stack *middleware.Stack) error {
2294	return stack.Initialize.Add(&validateOpUpdateQueueHoursOfOperation{}, middleware.After)
2295}
2296
2297func addOpUpdateQueueMaxContactsValidationMiddleware(stack *middleware.Stack) error {
2298	return stack.Initialize.Add(&validateOpUpdateQueueMaxContacts{}, middleware.After)
2299}
2300
2301func addOpUpdateQueueNameValidationMiddleware(stack *middleware.Stack) error {
2302	return stack.Initialize.Add(&validateOpUpdateQueueName{}, middleware.After)
2303}
2304
2305func addOpUpdateQueueOutboundCallerConfigValidationMiddleware(stack *middleware.Stack) error {
2306	return stack.Initialize.Add(&validateOpUpdateQueueOutboundCallerConfig{}, middleware.After)
2307}
2308
2309func addOpUpdateQueueStatusValidationMiddleware(stack *middleware.Stack) error {
2310	return stack.Initialize.Add(&validateOpUpdateQueueStatus{}, middleware.After)
2311}
2312
2313func addOpUpdateQuickConnectConfigValidationMiddleware(stack *middleware.Stack) error {
2314	return stack.Initialize.Add(&validateOpUpdateQuickConnectConfig{}, middleware.After)
2315}
2316
2317func addOpUpdateQuickConnectNameValidationMiddleware(stack *middleware.Stack) error {
2318	return stack.Initialize.Add(&validateOpUpdateQuickConnectName{}, middleware.After)
2319}
2320
2321func addOpUpdateRoutingProfileConcurrencyValidationMiddleware(stack *middleware.Stack) error {
2322	return stack.Initialize.Add(&validateOpUpdateRoutingProfileConcurrency{}, middleware.After)
2323}
2324
2325func addOpUpdateRoutingProfileDefaultOutboundQueueValidationMiddleware(stack *middleware.Stack) error {
2326	return stack.Initialize.Add(&validateOpUpdateRoutingProfileDefaultOutboundQueue{}, middleware.After)
2327}
2328
2329func addOpUpdateRoutingProfileNameValidationMiddleware(stack *middleware.Stack) error {
2330	return stack.Initialize.Add(&validateOpUpdateRoutingProfileName{}, middleware.After)
2331}
2332
2333func addOpUpdateRoutingProfileQueuesValidationMiddleware(stack *middleware.Stack) error {
2334	return stack.Initialize.Add(&validateOpUpdateRoutingProfileQueues{}, middleware.After)
2335}
2336
2337func addOpUpdateUserHierarchyGroupNameValidationMiddleware(stack *middleware.Stack) error {
2338	return stack.Initialize.Add(&validateOpUpdateUserHierarchyGroupName{}, middleware.After)
2339}
2340
2341func addOpUpdateUserHierarchyValidationMiddleware(stack *middleware.Stack) error {
2342	return stack.Initialize.Add(&validateOpUpdateUserHierarchy{}, middleware.After)
2343}
2344
2345func addOpUpdateUserHierarchyStructureValidationMiddleware(stack *middleware.Stack) error {
2346	return stack.Initialize.Add(&validateOpUpdateUserHierarchyStructure{}, middleware.After)
2347}
2348
2349func addOpUpdateUserIdentityInfoValidationMiddleware(stack *middleware.Stack) error {
2350	return stack.Initialize.Add(&validateOpUpdateUserIdentityInfo{}, middleware.After)
2351}
2352
2353func addOpUpdateUserPhoneConfigValidationMiddleware(stack *middleware.Stack) error {
2354	return stack.Initialize.Add(&validateOpUpdateUserPhoneConfig{}, middleware.After)
2355}
2356
2357func addOpUpdateUserRoutingProfileValidationMiddleware(stack *middleware.Stack) error {
2358	return stack.Initialize.Add(&validateOpUpdateUserRoutingProfile{}, middleware.After)
2359}
2360
2361func addOpUpdateUserSecurityProfilesValidationMiddleware(stack *middleware.Stack) error {
2362	return stack.Initialize.Add(&validateOpUpdateUserSecurityProfiles{}, middleware.After)
2363}
2364
2365func validateChatMessage(v *types.ChatMessage) error {
2366	if v == nil {
2367		return nil
2368	}
2369	invalidParams := smithy.InvalidParamsError{Context: "ChatMessage"}
2370	if v.ContentType == nil {
2371		invalidParams.Add(smithy.NewErrParamRequired("ContentType"))
2372	}
2373	if v.Content == nil {
2374		invalidParams.Add(smithy.NewErrParamRequired("Content"))
2375	}
2376	if invalidParams.Len() > 0 {
2377		return invalidParams
2378	} else {
2379		return nil
2380	}
2381}
2382
2383func validateContactReferences(v map[string]types.Reference) error {
2384	if v == nil {
2385		return nil
2386	}
2387	invalidParams := smithy.InvalidParamsError{Context: "ContactReferences"}
2388	for key := range v {
2389		value := v[key]
2390		if err := validateReference(&value); err != nil {
2391			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
2392		}
2393	}
2394	if invalidParams.Len() > 0 {
2395		return invalidParams
2396	} else {
2397		return nil
2398	}
2399}
2400
2401func validateEncryptionConfig(v *types.EncryptionConfig) error {
2402	if v == nil {
2403		return nil
2404	}
2405	invalidParams := smithy.InvalidParamsError{Context: "EncryptionConfig"}
2406	if len(v.EncryptionType) == 0 {
2407		invalidParams.Add(smithy.NewErrParamRequired("EncryptionType"))
2408	}
2409	if v.KeyId == nil {
2410		invalidParams.Add(smithy.NewErrParamRequired("KeyId"))
2411	}
2412	if invalidParams.Len() > 0 {
2413		return invalidParams
2414	} else {
2415		return nil
2416	}
2417}
2418
2419func validateHierarchyLevelUpdate(v *types.HierarchyLevelUpdate) error {
2420	if v == nil {
2421		return nil
2422	}
2423	invalidParams := smithy.InvalidParamsError{Context: "HierarchyLevelUpdate"}
2424	if v.Name == nil {
2425		invalidParams.Add(smithy.NewErrParamRequired("Name"))
2426	}
2427	if invalidParams.Len() > 0 {
2428		return invalidParams
2429	} else {
2430		return nil
2431	}
2432}
2433
2434func validateHierarchyStructureUpdate(v *types.HierarchyStructureUpdate) error {
2435	if v == nil {
2436		return nil
2437	}
2438	invalidParams := smithy.InvalidParamsError{Context: "HierarchyStructureUpdate"}
2439	if v.LevelOne != nil {
2440		if err := validateHierarchyLevelUpdate(v.LevelOne); err != nil {
2441			invalidParams.AddNested("LevelOne", err.(smithy.InvalidParamsError))
2442		}
2443	}
2444	if v.LevelTwo != nil {
2445		if err := validateHierarchyLevelUpdate(v.LevelTwo); err != nil {
2446			invalidParams.AddNested("LevelTwo", err.(smithy.InvalidParamsError))
2447		}
2448	}
2449	if v.LevelThree != nil {
2450		if err := validateHierarchyLevelUpdate(v.LevelThree); err != nil {
2451			invalidParams.AddNested("LevelThree", err.(smithy.InvalidParamsError))
2452		}
2453	}
2454	if v.LevelFour != nil {
2455		if err := validateHierarchyLevelUpdate(v.LevelFour); err != nil {
2456			invalidParams.AddNested("LevelFour", err.(smithy.InvalidParamsError))
2457		}
2458	}
2459	if v.LevelFive != nil {
2460		if err := validateHierarchyLevelUpdate(v.LevelFive); err != nil {
2461			invalidParams.AddNested("LevelFive", err.(smithy.InvalidParamsError))
2462		}
2463	}
2464	if invalidParams.Len() > 0 {
2465		return invalidParams
2466	} else {
2467		return nil
2468	}
2469}
2470
2471func validateInstanceStorageConfig(v *types.InstanceStorageConfig) error {
2472	if v == nil {
2473		return nil
2474	}
2475	invalidParams := smithy.InvalidParamsError{Context: "InstanceStorageConfig"}
2476	if len(v.StorageType) == 0 {
2477		invalidParams.Add(smithy.NewErrParamRequired("StorageType"))
2478	}
2479	if v.S3Config != nil {
2480		if err := validateS3Config(v.S3Config); err != nil {
2481			invalidParams.AddNested("S3Config", err.(smithy.InvalidParamsError))
2482		}
2483	}
2484	if v.KinesisVideoStreamConfig != nil {
2485		if err := validateKinesisVideoStreamConfig(v.KinesisVideoStreamConfig); err != nil {
2486			invalidParams.AddNested("KinesisVideoStreamConfig", err.(smithy.InvalidParamsError))
2487		}
2488	}
2489	if v.KinesisStreamConfig != nil {
2490		if err := validateKinesisStreamConfig(v.KinesisStreamConfig); err != nil {
2491			invalidParams.AddNested("KinesisStreamConfig", err.(smithy.InvalidParamsError))
2492		}
2493	}
2494	if v.KinesisFirehoseConfig != nil {
2495		if err := validateKinesisFirehoseConfig(v.KinesisFirehoseConfig); err != nil {
2496			invalidParams.AddNested("KinesisFirehoseConfig", err.(smithy.InvalidParamsError))
2497		}
2498	}
2499	if invalidParams.Len() > 0 {
2500		return invalidParams
2501	} else {
2502		return nil
2503	}
2504}
2505
2506func validateKinesisFirehoseConfig(v *types.KinesisFirehoseConfig) error {
2507	if v == nil {
2508		return nil
2509	}
2510	invalidParams := smithy.InvalidParamsError{Context: "KinesisFirehoseConfig"}
2511	if v.FirehoseArn == nil {
2512		invalidParams.Add(smithy.NewErrParamRequired("FirehoseArn"))
2513	}
2514	if invalidParams.Len() > 0 {
2515		return invalidParams
2516	} else {
2517		return nil
2518	}
2519}
2520
2521func validateKinesisStreamConfig(v *types.KinesisStreamConfig) error {
2522	if v == nil {
2523		return nil
2524	}
2525	invalidParams := smithy.InvalidParamsError{Context: "KinesisStreamConfig"}
2526	if v.StreamArn == nil {
2527		invalidParams.Add(smithy.NewErrParamRequired("StreamArn"))
2528	}
2529	if invalidParams.Len() > 0 {
2530		return invalidParams
2531	} else {
2532		return nil
2533	}
2534}
2535
2536func validateKinesisVideoStreamConfig(v *types.KinesisVideoStreamConfig) error {
2537	if v == nil {
2538		return nil
2539	}
2540	invalidParams := smithy.InvalidParamsError{Context: "KinesisVideoStreamConfig"}
2541	if v.Prefix == nil {
2542		invalidParams.Add(smithy.NewErrParamRequired("Prefix"))
2543	}
2544	if v.EncryptionConfig == nil {
2545		invalidParams.Add(smithy.NewErrParamRequired("EncryptionConfig"))
2546	} else if v.EncryptionConfig != nil {
2547		if err := validateEncryptionConfig(v.EncryptionConfig); err != nil {
2548			invalidParams.AddNested("EncryptionConfig", err.(smithy.InvalidParamsError))
2549		}
2550	}
2551	if invalidParams.Len() > 0 {
2552		return invalidParams
2553	} else {
2554		return nil
2555	}
2556}
2557
2558func validateMediaConcurrencies(v []types.MediaConcurrency) error {
2559	if v == nil {
2560		return nil
2561	}
2562	invalidParams := smithy.InvalidParamsError{Context: "MediaConcurrencies"}
2563	for i := range v {
2564		if err := validateMediaConcurrency(&v[i]); err != nil {
2565			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2566		}
2567	}
2568	if invalidParams.Len() > 0 {
2569		return invalidParams
2570	} else {
2571		return nil
2572	}
2573}
2574
2575func validateMediaConcurrency(v *types.MediaConcurrency) error {
2576	if v == nil {
2577		return nil
2578	}
2579	invalidParams := smithy.InvalidParamsError{Context: "MediaConcurrency"}
2580	if len(v.Channel) == 0 {
2581		invalidParams.Add(smithy.NewErrParamRequired("Channel"))
2582	}
2583	if invalidParams.Len() > 0 {
2584		return invalidParams
2585	} else {
2586		return nil
2587	}
2588}
2589
2590func validateParticipantDetails(v *types.ParticipantDetails) error {
2591	if v == nil {
2592		return nil
2593	}
2594	invalidParams := smithy.InvalidParamsError{Context: "ParticipantDetails"}
2595	if v.DisplayName == nil {
2596		invalidParams.Add(smithy.NewErrParamRequired("DisplayName"))
2597	}
2598	if invalidParams.Len() > 0 {
2599		return invalidParams
2600	} else {
2601		return nil
2602	}
2603}
2604
2605func validatePhoneNumberQuickConnectConfig(v *types.PhoneNumberQuickConnectConfig) error {
2606	if v == nil {
2607		return nil
2608	}
2609	invalidParams := smithy.InvalidParamsError{Context: "PhoneNumberQuickConnectConfig"}
2610	if v.PhoneNumber == nil {
2611		invalidParams.Add(smithy.NewErrParamRequired("PhoneNumber"))
2612	}
2613	if invalidParams.Len() > 0 {
2614		return invalidParams
2615	} else {
2616		return nil
2617	}
2618}
2619
2620func validateQueueQuickConnectConfig(v *types.QueueQuickConnectConfig) error {
2621	if v == nil {
2622		return nil
2623	}
2624	invalidParams := smithy.InvalidParamsError{Context: "QueueQuickConnectConfig"}
2625	if v.QueueId == nil {
2626		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
2627	}
2628	if v.ContactFlowId == nil {
2629		invalidParams.Add(smithy.NewErrParamRequired("ContactFlowId"))
2630	}
2631	if invalidParams.Len() > 0 {
2632		return invalidParams
2633	} else {
2634		return nil
2635	}
2636}
2637
2638func validateQuickConnectConfig(v *types.QuickConnectConfig) error {
2639	if v == nil {
2640		return nil
2641	}
2642	invalidParams := smithy.InvalidParamsError{Context: "QuickConnectConfig"}
2643	if len(v.QuickConnectType) == 0 {
2644		invalidParams.Add(smithy.NewErrParamRequired("QuickConnectType"))
2645	}
2646	if v.UserConfig != nil {
2647		if err := validateUserQuickConnectConfig(v.UserConfig); err != nil {
2648			invalidParams.AddNested("UserConfig", err.(smithy.InvalidParamsError))
2649		}
2650	}
2651	if v.QueueConfig != nil {
2652		if err := validateQueueQuickConnectConfig(v.QueueConfig); err != nil {
2653			invalidParams.AddNested("QueueConfig", err.(smithy.InvalidParamsError))
2654		}
2655	}
2656	if v.PhoneConfig != nil {
2657		if err := validatePhoneNumberQuickConnectConfig(v.PhoneConfig); err != nil {
2658			invalidParams.AddNested("PhoneConfig", err.(smithy.InvalidParamsError))
2659		}
2660	}
2661	if invalidParams.Len() > 0 {
2662		return invalidParams
2663	} else {
2664		return nil
2665	}
2666}
2667
2668func validateReference(v *types.Reference) error {
2669	if v == nil {
2670		return nil
2671	}
2672	invalidParams := smithy.InvalidParamsError{Context: "Reference"}
2673	if v.Value == nil {
2674		invalidParams.Add(smithy.NewErrParamRequired("Value"))
2675	}
2676	if len(v.Type) == 0 {
2677		invalidParams.Add(smithy.NewErrParamRequired("Type"))
2678	}
2679	if invalidParams.Len() > 0 {
2680		return invalidParams
2681	} else {
2682		return nil
2683	}
2684}
2685
2686func validateRoutingProfileQueueConfig(v *types.RoutingProfileQueueConfig) error {
2687	if v == nil {
2688		return nil
2689	}
2690	invalidParams := smithy.InvalidParamsError{Context: "RoutingProfileQueueConfig"}
2691	if v.QueueReference == nil {
2692		invalidParams.Add(smithy.NewErrParamRequired("QueueReference"))
2693	} else if v.QueueReference != nil {
2694		if err := validateRoutingProfileQueueReference(v.QueueReference); err != nil {
2695			invalidParams.AddNested("QueueReference", err.(smithy.InvalidParamsError))
2696		}
2697	}
2698	if invalidParams.Len() > 0 {
2699		return invalidParams
2700	} else {
2701		return nil
2702	}
2703}
2704
2705func validateRoutingProfileQueueConfigList(v []types.RoutingProfileQueueConfig) error {
2706	if v == nil {
2707		return nil
2708	}
2709	invalidParams := smithy.InvalidParamsError{Context: "RoutingProfileQueueConfigList"}
2710	for i := range v {
2711		if err := validateRoutingProfileQueueConfig(&v[i]); err != nil {
2712			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2713		}
2714	}
2715	if invalidParams.Len() > 0 {
2716		return invalidParams
2717	} else {
2718		return nil
2719	}
2720}
2721
2722func validateRoutingProfileQueueReference(v *types.RoutingProfileQueueReference) error {
2723	if v == nil {
2724		return nil
2725	}
2726	invalidParams := smithy.InvalidParamsError{Context: "RoutingProfileQueueReference"}
2727	if v.QueueId == nil {
2728		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
2729	}
2730	if len(v.Channel) == 0 {
2731		invalidParams.Add(smithy.NewErrParamRequired("Channel"))
2732	}
2733	if invalidParams.Len() > 0 {
2734		return invalidParams
2735	} else {
2736		return nil
2737	}
2738}
2739
2740func validateRoutingProfileQueueReferenceList(v []types.RoutingProfileQueueReference) error {
2741	if v == nil {
2742		return nil
2743	}
2744	invalidParams := smithy.InvalidParamsError{Context: "RoutingProfileQueueReferenceList"}
2745	for i := range v {
2746		if err := validateRoutingProfileQueueReference(&v[i]); err != nil {
2747			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2748		}
2749	}
2750	if invalidParams.Len() > 0 {
2751		return invalidParams
2752	} else {
2753		return nil
2754	}
2755}
2756
2757func validateS3Config(v *types.S3Config) error {
2758	if v == nil {
2759		return nil
2760	}
2761	invalidParams := smithy.InvalidParamsError{Context: "S3Config"}
2762	if v.BucketName == nil {
2763		invalidParams.Add(smithy.NewErrParamRequired("BucketName"))
2764	}
2765	if v.BucketPrefix == nil {
2766		invalidParams.Add(smithy.NewErrParamRequired("BucketPrefix"))
2767	}
2768	if v.EncryptionConfig != nil {
2769		if err := validateEncryptionConfig(v.EncryptionConfig); err != nil {
2770			invalidParams.AddNested("EncryptionConfig", err.(smithy.InvalidParamsError))
2771		}
2772	}
2773	if invalidParams.Len() > 0 {
2774		return invalidParams
2775	} else {
2776		return nil
2777	}
2778}
2779
2780func validateUserPhoneConfig(v *types.UserPhoneConfig) error {
2781	if v == nil {
2782		return nil
2783	}
2784	invalidParams := smithy.InvalidParamsError{Context: "UserPhoneConfig"}
2785	if len(v.PhoneType) == 0 {
2786		invalidParams.Add(smithy.NewErrParamRequired("PhoneType"))
2787	}
2788	if invalidParams.Len() > 0 {
2789		return invalidParams
2790	} else {
2791		return nil
2792	}
2793}
2794
2795func validateUserQuickConnectConfig(v *types.UserQuickConnectConfig) error {
2796	if v == nil {
2797		return nil
2798	}
2799	invalidParams := smithy.InvalidParamsError{Context: "UserQuickConnectConfig"}
2800	if v.UserId == nil {
2801		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
2802	}
2803	if v.ContactFlowId == nil {
2804		invalidParams.Add(smithy.NewErrParamRequired("ContactFlowId"))
2805	}
2806	if invalidParams.Len() > 0 {
2807		return invalidParams
2808	} else {
2809		return nil
2810	}
2811}
2812
2813func validateOpAssociateApprovedOriginInput(v *AssociateApprovedOriginInput) error {
2814	if v == nil {
2815		return nil
2816	}
2817	invalidParams := smithy.InvalidParamsError{Context: "AssociateApprovedOriginInput"}
2818	if v.InstanceId == nil {
2819		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
2820	}
2821	if v.Origin == nil {
2822		invalidParams.Add(smithy.NewErrParamRequired("Origin"))
2823	}
2824	if invalidParams.Len() > 0 {
2825		return invalidParams
2826	} else {
2827		return nil
2828	}
2829}
2830
2831func validateOpAssociateInstanceStorageConfigInput(v *AssociateInstanceStorageConfigInput) error {
2832	if v == nil {
2833		return nil
2834	}
2835	invalidParams := smithy.InvalidParamsError{Context: "AssociateInstanceStorageConfigInput"}
2836	if v.InstanceId == nil {
2837		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
2838	}
2839	if len(v.ResourceType) == 0 {
2840		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
2841	}
2842	if v.StorageConfig == nil {
2843		invalidParams.Add(smithy.NewErrParamRequired("StorageConfig"))
2844	} else if v.StorageConfig != nil {
2845		if err := validateInstanceStorageConfig(v.StorageConfig); err != nil {
2846			invalidParams.AddNested("StorageConfig", err.(smithy.InvalidParamsError))
2847		}
2848	}
2849	if invalidParams.Len() > 0 {
2850		return invalidParams
2851	} else {
2852		return nil
2853	}
2854}
2855
2856func validateOpAssociateLambdaFunctionInput(v *AssociateLambdaFunctionInput) error {
2857	if v == nil {
2858		return nil
2859	}
2860	invalidParams := smithy.InvalidParamsError{Context: "AssociateLambdaFunctionInput"}
2861	if v.InstanceId == nil {
2862		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
2863	}
2864	if v.FunctionArn == nil {
2865		invalidParams.Add(smithy.NewErrParamRequired("FunctionArn"))
2866	}
2867	if invalidParams.Len() > 0 {
2868		return invalidParams
2869	} else {
2870		return nil
2871	}
2872}
2873
2874func validateOpAssociateLexBotInput(v *AssociateLexBotInput) error {
2875	if v == nil {
2876		return nil
2877	}
2878	invalidParams := smithy.InvalidParamsError{Context: "AssociateLexBotInput"}
2879	if v.InstanceId == nil {
2880		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
2881	}
2882	if v.LexBot == nil {
2883		invalidParams.Add(smithy.NewErrParamRequired("LexBot"))
2884	}
2885	if invalidParams.Len() > 0 {
2886		return invalidParams
2887	} else {
2888		return nil
2889	}
2890}
2891
2892func validateOpAssociateQueueQuickConnectsInput(v *AssociateQueueQuickConnectsInput) error {
2893	if v == nil {
2894		return nil
2895	}
2896	invalidParams := smithy.InvalidParamsError{Context: "AssociateQueueQuickConnectsInput"}
2897	if v.InstanceId == nil {
2898		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
2899	}
2900	if v.QueueId == nil {
2901		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
2902	}
2903	if v.QuickConnectIds == nil {
2904		invalidParams.Add(smithy.NewErrParamRequired("QuickConnectIds"))
2905	}
2906	if invalidParams.Len() > 0 {
2907		return invalidParams
2908	} else {
2909		return nil
2910	}
2911}
2912
2913func validateOpAssociateRoutingProfileQueuesInput(v *AssociateRoutingProfileQueuesInput) error {
2914	if v == nil {
2915		return nil
2916	}
2917	invalidParams := smithy.InvalidParamsError{Context: "AssociateRoutingProfileQueuesInput"}
2918	if v.InstanceId == nil {
2919		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
2920	}
2921	if v.RoutingProfileId == nil {
2922		invalidParams.Add(smithy.NewErrParamRequired("RoutingProfileId"))
2923	}
2924	if v.QueueConfigs == nil {
2925		invalidParams.Add(smithy.NewErrParamRequired("QueueConfigs"))
2926	} else if v.QueueConfigs != nil {
2927		if err := validateRoutingProfileQueueConfigList(v.QueueConfigs); err != nil {
2928			invalidParams.AddNested("QueueConfigs", err.(smithy.InvalidParamsError))
2929		}
2930	}
2931	if invalidParams.Len() > 0 {
2932		return invalidParams
2933	} else {
2934		return nil
2935	}
2936}
2937
2938func validateOpAssociateSecurityKeyInput(v *AssociateSecurityKeyInput) error {
2939	if v == nil {
2940		return nil
2941	}
2942	invalidParams := smithy.InvalidParamsError{Context: "AssociateSecurityKeyInput"}
2943	if v.InstanceId == nil {
2944		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
2945	}
2946	if v.Key == nil {
2947		invalidParams.Add(smithy.NewErrParamRequired("Key"))
2948	}
2949	if invalidParams.Len() > 0 {
2950		return invalidParams
2951	} else {
2952		return nil
2953	}
2954}
2955
2956func validateOpCreateContactFlowInput(v *CreateContactFlowInput) error {
2957	if v == nil {
2958		return nil
2959	}
2960	invalidParams := smithy.InvalidParamsError{Context: "CreateContactFlowInput"}
2961	if v.InstanceId == nil {
2962		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
2963	}
2964	if v.Name == nil {
2965		invalidParams.Add(smithy.NewErrParamRequired("Name"))
2966	}
2967	if len(v.Type) == 0 {
2968		invalidParams.Add(smithy.NewErrParamRequired("Type"))
2969	}
2970	if v.Content == nil {
2971		invalidParams.Add(smithy.NewErrParamRequired("Content"))
2972	}
2973	if invalidParams.Len() > 0 {
2974		return invalidParams
2975	} else {
2976		return nil
2977	}
2978}
2979
2980func validateOpCreateInstanceInput(v *CreateInstanceInput) error {
2981	if v == nil {
2982		return nil
2983	}
2984	invalidParams := smithy.InvalidParamsError{Context: "CreateInstanceInput"}
2985	if len(v.IdentityManagementType) == 0 {
2986		invalidParams.Add(smithy.NewErrParamRequired("IdentityManagementType"))
2987	}
2988	if v.InboundCallsEnabled == nil {
2989		invalidParams.Add(smithy.NewErrParamRequired("InboundCallsEnabled"))
2990	}
2991	if v.OutboundCallsEnabled == nil {
2992		invalidParams.Add(smithy.NewErrParamRequired("OutboundCallsEnabled"))
2993	}
2994	if invalidParams.Len() > 0 {
2995		return invalidParams
2996	} else {
2997		return nil
2998	}
2999}
3000
3001func validateOpCreateIntegrationAssociationInput(v *CreateIntegrationAssociationInput) error {
3002	if v == nil {
3003		return nil
3004	}
3005	invalidParams := smithy.InvalidParamsError{Context: "CreateIntegrationAssociationInput"}
3006	if v.InstanceId == nil {
3007		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3008	}
3009	if len(v.IntegrationType) == 0 {
3010		invalidParams.Add(smithy.NewErrParamRequired("IntegrationType"))
3011	}
3012	if v.IntegrationArn == nil {
3013		invalidParams.Add(smithy.NewErrParamRequired("IntegrationArn"))
3014	}
3015	if v.SourceApplicationUrl == nil {
3016		invalidParams.Add(smithy.NewErrParamRequired("SourceApplicationUrl"))
3017	}
3018	if v.SourceApplicationName == nil {
3019		invalidParams.Add(smithy.NewErrParamRequired("SourceApplicationName"))
3020	}
3021	if len(v.SourceType) == 0 {
3022		invalidParams.Add(smithy.NewErrParamRequired("SourceType"))
3023	}
3024	if invalidParams.Len() > 0 {
3025		return invalidParams
3026	} else {
3027		return nil
3028	}
3029}
3030
3031func validateOpCreateQueueInput(v *CreateQueueInput) error {
3032	if v == nil {
3033		return nil
3034	}
3035	invalidParams := smithy.InvalidParamsError{Context: "CreateQueueInput"}
3036	if v.InstanceId == nil {
3037		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3038	}
3039	if v.Name == nil {
3040		invalidParams.Add(smithy.NewErrParamRequired("Name"))
3041	}
3042	if v.HoursOfOperationId == nil {
3043		invalidParams.Add(smithy.NewErrParamRequired("HoursOfOperationId"))
3044	}
3045	if invalidParams.Len() > 0 {
3046		return invalidParams
3047	} else {
3048		return nil
3049	}
3050}
3051
3052func validateOpCreateQuickConnectInput(v *CreateQuickConnectInput) error {
3053	if v == nil {
3054		return nil
3055	}
3056	invalidParams := smithy.InvalidParamsError{Context: "CreateQuickConnectInput"}
3057	if v.InstanceId == nil {
3058		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3059	}
3060	if v.Name == nil {
3061		invalidParams.Add(smithy.NewErrParamRequired("Name"))
3062	}
3063	if v.QuickConnectConfig == nil {
3064		invalidParams.Add(smithy.NewErrParamRequired("QuickConnectConfig"))
3065	} else if v.QuickConnectConfig != nil {
3066		if err := validateQuickConnectConfig(v.QuickConnectConfig); err != nil {
3067			invalidParams.AddNested("QuickConnectConfig", err.(smithy.InvalidParamsError))
3068		}
3069	}
3070	if invalidParams.Len() > 0 {
3071		return invalidParams
3072	} else {
3073		return nil
3074	}
3075}
3076
3077func validateOpCreateRoutingProfileInput(v *CreateRoutingProfileInput) error {
3078	if v == nil {
3079		return nil
3080	}
3081	invalidParams := smithy.InvalidParamsError{Context: "CreateRoutingProfileInput"}
3082	if v.InstanceId == nil {
3083		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3084	}
3085	if v.Name == nil {
3086		invalidParams.Add(smithy.NewErrParamRequired("Name"))
3087	}
3088	if v.Description == nil {
3089		invalidParams.Add(smithy.NewErrParamRequired("Description"))
3090	}
3091	if v.DefaultOutboundQueueId == nil {
3092		invalidParams.Add(smithy.NewErrParamRequired("DefaultOutboundQueueId"))
3093	}
3094	if v.QueueConfigs != nil {
3095		if err := validateRoutingProfileQueueConfigList(v.QueueConfigs); err != nil {
3096			invalidParams.AddNested("QueueConfigs", err.(smithy.InvalidParamsError))
3097		}
3098	}
3099	if v.MediaConcurrencies == nil {
3100		invalidParams.Add(smithy.NewErrParamRequired("MediaConcurrencies"))
3101	} else if v.MediaConcurrencies != nil {
3102		if err := validateMediaConcurrencies(v.MediaConcurrencies); err != nil {
3103			invalidParams.AddNested("MediaConcurrencies", err.(smithy.InvalidParamsError))
3104		}
3105	}
3106	if invalidParams.Len() > 0 {
3107		return invalidParams
3108	} else {
3109		return nil
3110	}
3111}
3112
3113func validateOpCreateUseCaseInput(v *CreateUseCaseInput) error {
3114	if v == nil {
3115		return nil
3116	}
3117	invalidParams := smithy.InvalidParamsError{Context: "CreateUseCaseInput"}
3118	if v.InstanceId == nil {
3119		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3120	}
3121	if v.IntegrationAssociationId == nil {
3122		invalidParams.Add(smithy.NewErrParamRequired("IntegrationAssociationId"))
3123	}
3124	if len(v.UseCaseType) == 0 {
3125		invalidParams.Add(smithy.NewErrParamRequired("UseCaseType"))
3126	}
3127	if invalidParams.Len() > 0 {
3128		return invalidParams
3129	} else {
3130		return nil
3131	}
3132}
3133
3134func validateOpCreateUserHierarchyGroupInput(v *CreateUserHierarchyGroupInput) error {
3135	if v == nil {
3136		return nil
3137	}
3138	invalidParams := smithy.InvalidParamsError{Context: "CreateUserHierarchyGroupInput"}
3139	if v.Name == nil {
3140		invalidParams.Add(smithy.NewErrParamRequired("Name"))
3141	}
3142	if v.InstanceId == nil {
3143		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3144	}
3145	if invalidParams.Len() > 0 {
3146		return invalidParams
3147	} else {
3148		return nil
3149	}
3150}
3151
3152func validateOpCreateUserInput(v *CreateUserInput) error {
3153	if v == nil {
3154		return nil
3155	}
3156	invalidParams := smithy.InvalidParamsError{Context: "CreateUserInput"}
3157	if v.Username == nil {
3158		invalidParams.Add(smithy.NewErrParamRequired("Username"))
3159	}
3160	if v.PhoneConfig == nil {
3161		invalidParams.Add(smithy.NewErrParamRequired("PhoneConfig"))
3162	} else if v.PhoneConfig != nil {
3163		if err := validateUserPhoneConfig(v.PhoneConfig); err != nil {
3164			invalidParams.AddNested("PhoneConfig", err.(smithy.InvalidParamsError))
3165		}
3166	}
3167	if v.SecurityProfileIds == nil {
3168		invalidParams.Add(smithy.NewErrParamRequired("SecurityProfileIds"))
3169	}
3170	if v.RoutingProfileId == nil {
3171		invalidParams.Add(smithy.NewErrParamRequired("RoutingProfileId"))
3172	}
3173	if v.InstanceId == nil {
3174		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3175	}
3176	if invalidParams.Len() > 0 {
3177		return invalidParams
3178	} else {
3179		return nil
3180	}
3181}
3182
3183func validateOpDeleteInstanceInput(v *DeleteInstanceInput) error {
3184	if v == nil {
3185		return nil
3186	}
3187	invalidParams := smithy.InvalidParamsError{Context: "DeleteInstanceInput"}
3188	if v.InstanceId == nil {
3189		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3190	}
3191	if invalidParams.Len() > 0 {
3192		return invalidParams
3193	} else {
3194		return nil
3195	}
3196}
3197
3198func validateOpDeleteIntegrationAssociationInput(v *DeleteIntegrationAssociationInput) error {
3199	if v == nil {
3200		return nil
3201	}
3202	invalidParams := smithy.InvalidParamsError{Context: "DeleteIntegrationAssociationInput"}
3203	if v.InstanceId == nil {
3204		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3205	}
3206	if v.IntegrationAssociationId == nil {
3207		invalidParams.Add(smithy.NewErrParamRequired("IntegrationAssociationId"))
3208	}
3209	if invalidParams.Len() > 0 {
3210		return invalidParams
3211	} else {
3212		return nil
3213	}
3214}
3215
3216func validateOpDeleteQuickConnectInput(v *DeleteQuickConnectInput) error {
3217	if v == nil {
3218		return nil
3219	}
3220	invalidParams := smithy.InvalidParamsError{Context: "DeleteQuickConnectInput"}
3221	if v.InstanceId == nil {
3222		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3223	}
3224	if v.QuickConnectId == nil {
3225		invalidParams.Add(smithy.NewErrParamRequired("QuickConnectId"))
3226	}
3227	if invalidParams.Len() > 0 {
3228		return invalidParams
3229	} else {
3230		return nil
3231	}
3232}
3233
3234func validateOpDeleteUseCaseInput(v *DeleteUseCaseInput) error {
3235	if v == nil {
3236		return nil
3237	}
3238	invalidParams := smithy.InvalidParamsError{Context: "DeleteUseCaseInput"}
3239	if v.InstanceId == nil {
3240		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3241	}
3242	if v.IntegrationAssociationId == nil {
3243		invalidParams.Add(smithy.NewErrParamRequired("IntegrationAssociationId"))
3244	}
3245	if v.UseCaseId == nil {
3246		invalidParams.Add(smithy.NewErrParamRequired("UseCaseId"))
3247	}
3248	if invalidParams.Len() > 0 {
3249		return invalidParams
3250	} else {
3251		return nil
3252	}
3253}
3254
3255func validateOpDeleteUserHierarchyGroupInput(v *DeleteUserHierarchyGroupInput) error {
3256	if v == nil {
3257		return nil
3258	}
3259	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserHierarchyGroupInput"}
3260	if v.HierarchyGroupId == nil {
3261		invalidParams.Add(smithy.NewErrParamRequired("HierarchyGroupId"))
3262	}
3263	if v.InstanceId == nil {
3264		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3265	}
3266	if invalidParams.Len() > 0 {
3267		return invalidParams
3268	} else {
3269		return nil
3270	}
3271}
3272
3273func validateOpDeleteUserInput(v *DeleteUserInput) error {
3274	if v == nil {
3275		return nil
3276	}
3277	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserInput"}
3278	if v.InstanceId == nil {
3279		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3280	}
3281	if v.UserId == nil {
3282		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
3283	}
3284	if invalidParams.Len() > 0 {
3285		return invalidParams
3286	} else {
3287		return nil
3288	}
3289}
3290
3291func validateOpDescribeContactFlowInput(v *DescribeContactFlowInput) error {
3292	if v == nil {
3293		return nil
3294	}
3295	invalidParams := smithy.InvalidParamsError{Context: "DescribeContactFlowInput"}
3296	if v.InstanceId == nil {
3297		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3298	}
3299	if v.ContactFlowId == nil {
3300		invalidParams.Add(smithy.NewErrParamRequired("ContactFlowId"))
3301	}
3302	if invalidParams.Len() > 0 {
3303		return invalidParams
3304	} else {
3305		return nil
3306	}
3307}
3308
3309func validateOpDescribeHoursOfOperationInput(v *DescribeHoursOfOperationInput) error {
3310	if v == nil {
3311		return nil
3312	}
3313	invalidParams := smithy.InvalidParamsError{Context: "DescribeHoursOfOperationInput"}
3314	if v.InstanceId == nil {
3315		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3316	}
3317	if v.HoursOfOperationId == nil {
3318		invalidParams.Add(smithy.NewErrParamRequired("HoursOfOperationId"))
3319	}
3320	if invalidParams.Len() > 0 {
3321		return invalidParams
3322	} else {
3323		return nil
3324	}
3325}
3326
3327func validateOpDescribeInstanceAttributeInput(v *DescribeInstanceAttributeInput) error {
3328	if v == nil {
3329		return nil
3330	}
3331	invalidParams := smithy.InvalidParamsError{Context: "DescribeInstanceAttributeInput"}
3332	if v.InstanceId == nil {
3333		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3334	}
3335	if len(v.AttributeType) == 0 {
3336		invalidParams.Add(smithy.NewErrParamRequired("AttributeType"))
3337	}
3338	if invalidParams.Len() > 0 {
3339		return invalidParams
3340	} else {
3341		return nil
3342	}
3343}
3344
3345func validateOpDescribeInstanceInput(v *DescribeInstanceInput) error {
3346	if v == nil {
3347		return nil
3348	}
3349	invalidParams := smithy.InvalidParamsError{Context: "DescribeInstanceInput"}
3350	if v.InstanceId == nil {
3351		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3352	}
3353	if invalidParams.Len() > 0 {
3354		return invalidParams
3355	} else {
3356		return nil
3357	}
3358}
3359
3360func validateOpDescribeInstanceStorageConfigInput(v *DescribeInstanceStorageConfigInput) error {
3361	if v == nil {
3362		return nil
3363	}
3364	invalidParams := smithy.InvalidParamsError{Context: "DescribeInstanceStorageConfigInput"}
3365	if v.InstanceId == nil {
3366		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3367	}
3368	if v.AssociationId == nil {
3369		invalidParams.Add(smithy.NewErrParamRequired("AssociationId"))
3370	}
3371	if len(v.ResourceType) == 0 {
3372		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
3373	}
3374	if invalidParams.Len() > 0 {
3375		return invalidParams
3376	} else {
3377		return nil
3378	}
3379}
3380
3381func validateOpDescribeQueueInput(v *DescribeQueueInput) error {
3382	if v == nil {
3383		return nil
3384	}
3385	invalidParams := smithy.InvalidParamsError{Context: "DescribeQueueInput"}
3386	if v.InstanceId == nil {
3387		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3388	}
3389	if v.QueueId == nil {
3390		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
3391	}
3392	if invalidParams.Len() > 0 {
3393		return invalidParams
3394	} else {
3395		return nil
3396	}
3397}
3398
3399func validateOpDescribeQuickConnectInput(v *DescribeQuickConnectInput) error {
3400	if v == nil {
3401		return nil
3402	}
3403	invalidParams := smithy.InvalidParamsError{Context: "DescribeQuickConnectInput"}
3404	if v.InstanceId == nil {
3405		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3406	}
3407	if v.QuickConnectId == nil {
3408		invalidParams.Add(smithy.NewErrParamRequired("QuickConnectId"))
3409	}
3410	if invalidParams.Len() > 0 {
3411		return invalidParams
3412	} else {
3413		return nil
3414	}
3415}
3416
3417func validateOpDescribeRoutingProfileInput(v *DescribeRoutingProfileInput) error {
3418	if v == nil {
3419		return nil
3420	}
3421	invalidParams := smithy.InvalidParamsError{Context: "DescribeRoutingProfileInput"}
3422	if v.InstanceId == nil {
3423		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3424	}
3425	if v.RoutingProfileId == nil {
3426		invalidParams.Add(smithy.NewErrParamRequired("RoutingProfileId"))
3427	}
3428	if invalidParams.Len() > 0 {
3429		return invalidParams
3430	} else {
3431		return nil
3432	}
3433}
3434
3435func validateOpDescribeUserHierarchyGroupInput(v *DescribeUserHierarchyGroupInput) error {
3436	if v == nil {
3437		return nil
3438	}
3439	invalidParams := smithy.InvalidParamsError{Context: "DescribeUserHierarchyGroupInput"}
3440	if v.HierarchyGroupId == nil {
3441		invalidParams.Add(smithy.NewErrParamRequired("HierarchyGroupId"))
3442	}
3443	if v.InstanceId == nil {
3444		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3445	}
3446	if invalidParams.Len() > 0 {
3447		return invalidParams
3448	} else {
3449		return nil
3450	}
3451}
3452
3453func validateOpDescribeUserHierarchyStructureInput(v *DescribeUserHierarchyStructureInput) error {
3454	if v == nil {
3455		return nil
3456	}
3457	invalidParams := smithy.InvalidParamsError{Context: "DescribeUserHierarchyStructureInput"}
3458	if v.InstanceId == nil {
3459		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3460	}
3461	if invalidParams.Len() > 0 {
3462		return invalidParams
3463	} else {
3464		return nil
3465	}
3466}
3467
3468func validateOpDescribeUserInput(v *DescribeUserInput) error {
3469	if v == nil {
3470		return nil
3471	}
3472	invalidParams := smithy.InvalidParamsError{Context: "DescribeUserInput"}
3473	if v.UserId == nil {
3474		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
3475	}
3476	if v.InstanceId == nil {
3477		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3478	}
3479	if invalidParams.Len() > 0 {
3480		return invalidParams
3481	} else {
3482		return nil
3483	}
3484}
3485
3486func validateOpDisassociateApprovedOriginInput(v *DisassociateApprovedOriginInput) error {
3487	if v == nil {
3488		return nil
3489	}
3490	invalidParams := smithy.InvalidParamsError{Context: "DisassociateApprovedOriginInput"}
3491	if v.InstanceId == nil {
3492		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3493	}
3494	if v.Origin == nil {
3495		invalidParams.Add(smithy.NewErrParamRequired("Origin"))
3496	}
3497	if invalidParams.Len() > 0 {
3498		return invalidParams
3499	} else {
3500		return nil
3501	}
3502}
3503
3504func validateOpDisassociateInstanceStorageConfigInput(v *DisassociateInstanceStorageConfigInput) error {
3505	if v == nil {
3506		return nil
3507	}
3508	invalidParams := smithy.InvalidParamsError{Context: "DisassociateInstanceStorageConfigInput"}
3509	if v.InstanceId == nil {
3510		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3511	}
3512	if v.AssociationId == nil {
3513		invalidParams.Add(smithy.NewErrParamRequired("AssociationId"))
3514	}
3515	if len(v.ResourceType) == 0 {
3516		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
3517	}
3518	if invalidParams.Len() > 0 {
3519		return invalidParams
3520	} else {
3521		return nil
3522	}
3523}
3524
3525func validateOpDisassociateLambdaFunctionInput(v *DisassociateLambdaFunctionInput) error {
3526	if v == nil {
3527		return nil
3528	}
3529	invalidParams := smithy.InvalidParamsError{Context: "DisassociateLambdaFunctionInput"}
3530	if v.InstanceId == nil {
3531		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3532	}
3533	if v.FunctionArn == nil {
3534		invalidParams.Add(smithy.NewErrParamRequired("FunctionArn"))
3535	}
3536	if invalidParams.Len() > 0 {
3537		return invalidParams
3538	} else {
3539		return nil
3540	}
3541}
3542
3543func validateOpDisassociateLexBotInput(v *DisassociateLexBotInput) error {
3544	if v == nil {
3545		return nil
3546	}
3547	invalidParams := smithy.InvalidParamsError{Context: "DisassociateLexBotInput"}
3548	if v.InstanceId == nil {
3549		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3550	}
3551	if v.BotName == nil {
3552		invalidParams.Add(smithy.NewErrParamRequired("BotName"))
3553	}
3554	if v.LexRegion == nil {
3555		invalidParams.Add(smithy.NewErrParamRequired("LexRegion"))
3556	}
3557	if invalidParams.Len() > 0 {
3558		return invalidParams
3559	} else {
3560		return nil
3561	}
3562}
3563
3564func validateOpDisassociateQueueQuickConnectsInput(v *DisassociateQueueQuickConnectsInput) error {
3565	if v == nil {
3566		return nil
3567	}
3568	invalidParams := smithy.InvalidParamsError{Context: "DisassociateQueueQuickConnectsInput"}
3569	if v.InstanceId == nil {
3570		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3571	}
3572	if v.QueueId == nil {
3573		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
3574	}
3575	if v.QuickConnectIds == nil {
3576		invalidParams.Add(smithy.NewErrParamRequired("QuickConnectIds"))
3577	}
3578	if invalidParams.Len() > 0 {
3579		return invalidParams
3580	} else {
3581		return nil
3582	}
3583}
3584
3585func validateOpDisassociateRoutingProfileQueuesInput(v *DisassociateRoutingProfileQueuesInput) error {
3586	if v == nil {
3587		return nil
3588	}
3589	invalidParams := smithy.InvalidParamsError{Context: "DisassociateRoutingProfileQueuesInput"}
3590	if v.InstanceId == nil {
3591		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3592	}
3593	if v.RoutingProfileId == nil {
3594		invalidParams.Add(smithy.NewErrParamRequired("RoutingProfileId"))
3595	}
3596	if v.QueueReferences == nil {
3597		invalidParams.Add(smithy.NewErrParamRequired("QueueReferences"))
3598	} else if v.QueueReferences != nil {
3599		if err := validateRoutingProfileQueueReferenceList(v.QueueReferences); err != nil {
3600			invalidParams.AddNested("QueueReferences", err.(smithy.InvalidParamsError))
3601		}
3602	}
3603	if invalidParams.Len() > 0 {
3604		return invalidParams
3605	} else {
3606		return nil
3607	}
3608}
3609
3610func validateOpDisassociateSecurityKeyInput(v *DisassociateSecurityKeyInput) error {
3611	if v == nil {
3612		return nil
3613	}
3614	invalidParams := smithy.InvalidParamsError{Context: "DisassociateSecurityKeyInput"}
3615	if v.InstanceId == nil {
3616		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3617	}
3618	if v.AssociationId == nil {
3619		invalidParams.Add(smithy.NewErrParamRequired("AssociationId"))
3620	}
3621	if invalidParams.Len() > 0 {
3622		return invalidParams
3623	} else {
3624		return nil
3625	}
3626}
3627
3628func validateOpGetContactAttributesInput(v *GetContactAttributesInput) error {
3629	if v == nil {
3630		return nil
3631	}
3632	invalidParams := smithy.InvalidParamsError{Context: "GetContactAttributesInput"}
3633	if v.InstanceId == nil {
3634		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3635	}
3636	if v.InitialContactId == nil {
3637		invalidParams.Add(smithy.NewErrParamRequired("InitialContactId"))
3638	}
3639	if invalidParams.Len() > 0 {
3640		return invalidParams
3641	} else {
3642		return nil
3643	}
3644}
3645
3646func validateOpGetCurrentMetricDataInput(v *GetCurrentMetricDataInput) error {
3647	if v == nil {
3648		return nil
3649	}
3650	invalidParams := smithy.InvalidParamsError{Context: "GetCurrentMetricDataInput"}
3651	if v.InstanceId == nil {
3652		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3653	}
3654	if v.Filters == nil {
3655		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
3656	}
3657	if v.CurrentMetrics == nil {
3658		invalidParams.Add(smithy.NewErrParamRequired("CurrentMetrics"))
3659	}
3660	if invalidParams.Len() > 0 {
3661		return invalidParams
3662	} else {
3663		return nil
3664	}
3665}
3666
3667func validateOpGetFederationTokenInput(v *GetFederationTokenInput) error {
3668	if v == nil {
3669		return nil
3670	}
3671	invalidParams := smithy.InvalidParamsError{Context: "GetFederationTokenInput"}
3672	if v.InstanceId == nil {
3673		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3674	}
3675	if invalidParams.Len() > 0 {
3676		return invalidParams
3677	} else {
3678		return nil
3679	}
3680}
3681
3682func validateOpGetMetricDataInput(v *GetMetricDataInput) error {
3683	if v == nil {
3684		return nil
3685	}
3686	invalidParams := smithy.InvalidParamsError{Context: "GetMetricDataInput"}
3687	if v.InstanceId == nil {
3688		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3689	}
3690	if v.StartTime == nil {
3691		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
3692	}
3693	if v.EndTime == nil {
3694		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
3695	}
3696	if v.Filters == nil {
3697		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
3698	}
3699	if v.HistoricalMetrics == nil {
3700		invalidParams.Add(smithy.NewErrParamRequired("HistoricalMetrics"))
3701	}
3702	if invalidParams.Len() > 0 {
3703		return invalidParams
3704	} else {
3705		return nil
3706	}
3707}
3708
3709func validateOpListApprovedOriginsInput(v *ListApprovedOriginsInput) error {
3710	if v == nil {
3711		return nil
3712	}
3713	invalidParams := smithy.InvalidParamsError{Context: "ListApprovedOriginsInput"}
3714	if v.InstanceId == nil {
3715		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3716	}
3717	if invalidParams.Len() > 0 {
3718		return invalidParams
3719	} else {
3720		return nil
3721	}
3722}
3723
3724func validateOpListContactFlowsInput(v *ListContactFlowsInput) error {
3725	if v == nil {
3726		return nil
3727	}
3728	invalidParams := smithy.InvalidParamsError{Context: "ListContactFlowsInput"}
3729	if v.InstanceId == nil {
3730		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3731	}
3732	if invalidParams.Len() > 0 {
3733		return invalidParams
3734	} else {
3735		return nil
3736	}
3737}
3738
3739func validateOpListHoursOfOperationsInput(v *ListHoursOfOperationsInput) error {
3740	if v == nil {
3741		return nil
3742	}
3743	invalidParams := smithy.InvalidParamsError{Context: "ListHoursOfOperationsInput"}
3744	if v.InstanceId == nil {
3745		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3746	}
3747	if invalidParams.Len() > 0 {
3748		return invalidParams
3749	} else {
3750		return nil
3751	}
3752}
3753
3754func validateOpListInstanceAttributesInput(v *ListInstanceAttributesInput) error {
3755	if v == nil {
3756		return nil
3757	}
3758	invalidParams := smithy.InvalidParamsError{Context: "ListInstanceAttributesInput"}
3759	if v.InstanceId == nil {
3760		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3761	}
3762	if invalidParams.Len() > 0 {
3763		return invalidParams
3764	} else {
3765		return nil
3766	}
3767}
3768
3769func validateOpListInstanceStorageConfigsInput(v *ListInstanceStorageConfigsInput) error {
3770	if v == nil {
3771		return nil
3772	}
3773	invalidParams := smithy.InvalidParamsError{Context: "ListInstanceStorageConfigsInput"}
3774	if v.InstanceId == nil {
3775		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3776	}
3777	if len(v.ResourceType) == 0 {
3778		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
3779	}
3780	if invalidParams.Len() > 0 {
3781		return invalidParams
3782	} else {
3783		return nil
3784	}
3785}
3786
3787func validateOpListIntegrationAssociationsInput(v *ListIntegrationAssociationsInput) error {
3788	if v == nil {
3789		return nil
3790	}
3791	invalidParams := smithy.InvalidParamsError{Context: "ListIntegrationAssociationsInput"}
3792	if v.InstanceId == nil {
3793		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3794	}
3795	if invalidParams.Len() > 0 {
3796		return invalidParams
3797	} else {
3798		return nil
3799	}
3800}
3801
3802func validateOpListLambdaFunctionsInput(v *ListLambdaFunctionsInput) error {
3803	if v == nil {
3804		return nil
3805	}
3806	invalidParams := smithy.InvalidParamsError{Context: "ListLambdaFunctionsInput"}
3807	if v.InstanceId == nil {
3808		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3809	}
3810	if invalidParams.Len() > 0 {
3811		return invalidParams
3812	} else {
3813		return nil
3814	}
3815}
3816
3817func validateOpListLexBotsInput(v *ListLexBotsInput) error {
3818	if v == nil {
3819		return nil
3820	}
3821	invalidParams := smithy.InvalidParamsError{Context: "ListLexBotsInput"}
3822	if v.InstanceId == nil {
3823		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3824	}
3825	if invalidParams.Len() > 0 {
3826		return invalidParams
3827	} else {
3828		return nil
3829	}
3830}
3831
3832func validateOpListPhoneNumbersInput(v *ListPhoneNumbersInput) error {
3833	if v == nil {
3834		return nil
3835	}
3836	invalidParams := smithy.InvalidParamsError{Context: "ListPhoneNumbersInput"}
3837	if v.InstanceId == nil {
3838		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3839	}
3840	if invalidParams.Len() > 0 {
3841		return invalidParams
3842	} else {
3843		return nil
3844	}
3845}
3846
3847func validateOpListPromptsInput(v *ListPromptsInput) error {
3848	if v == nil {
3849		return nil
3850	}
3851	invalidParams := smithy.InvalidParamsError{Context: "ListPromptsInput"}
3852	if v.InstanceId == nil {
3853		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3854	}
3855	if invalidParams.Len() > 0 {
3856		return invalidParams
3857	} else {
3858		return nil
3859	}
3860}
3861
3862func validateOpListQueueQuickConnectsInput(v *ListQueueQuickConnectsInput) error {
3863	if v == nil {
3864		return nil
3865	}
3866	invalidParams := smithy.InvalidParamsError{Context: "ListQueueQuickConnectsInput"}
3867	if v.InstanceId == nil {
3868		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3869	}
3870	if v.QueueId == nil {
3871		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
3872	}
3873	if invalidParams.Len() > 0 {
3874		return invalidParams
3875	} else {
3876		return nil
3877	}
3878}
3879
3880func validateOpListQueuesInput(v *ListQueuesInput) error {
3881	if v == nil {
3882		return nil
3883	}
3884	invalidParams := smithy.InvalidParamsError{Context: "ListQueuesInput"}
3885	if v.InstanceId == nil {
3886		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3887	}
3888	if invalidParams.Len() > 0 {
3889		return invalidParams
3890	} else {
3891		return nil
3892	}
3893}
3894
3895func validateOpListQuickConnectsInput(v *ListQuickConnectsInput) error {
3896	if v == nil {
3897		return nil
3898	}
3899	invalidParams := smithy.InvalidParamsError{Context: "ListQuickConnectsInput"}
3900	if v.InstanceId == nil {
3901		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3902	}
3903	if invalidParams.Len() > 0 {
3904		return invalidParams
3905	} else {
3906		return nil
3907	}
3908}
3909
3910func validateOpListRoutingProfileQueuesInput(v *ListRoutingProfileQueuesInput) error {
3911	if v == nil {
3912		return nil
3913	}
3914	invalidParams := smithy.InvalidParamsError{Context: "ListRoutingProfileQueuesInput"}
3915	if v.InstanceId == nil {
3916		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3917	}
3918	if v.RoutingProfileId == nil {
3919		invalidParams.Add(smithy.NewErrParamRequired("RoutingProfileId"))
3920	}
3921	if invalidParams.Len() > 0 {
3922		return invalidParams
3923	} else {
3924		return nil
3925	}
3926}
3927
3928func validateOpListRoutingProfilesInput(v *ListRoutingProfilesInput) error {
3929	if v == nil {
3930		return nil
3931	}
3932	invalidParams := smithy.InvalidParamsError{Context: "ListRoutingProfilesInput"}
3933	if v.InstanceId == nil {
3934		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3935	}
3936	if invalidParams.Len() > 0 {
3937		return invalidParams
3938	} else {
3939		return nil
3940	}
3941}
3942
3943func validateOpListSecurityKeysInput(v *ListSecurityKeysInput) error {
3944	if v == nil {
3945		return nil
3946	}
3947	invalidParams := smithy.InvalidParamsError{Context: "ListSecurityKeysInput"}
3948	if v.InstanceId == nil {
3949		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3950	}
3951	if invalidParams.Len() > 0 {
3952		return invalidParams
3953	} else {
3954		return nil
3955	}
3956}
3957
3958func validateOpListSecurityProfilesInput(v *ListSecurityProfilesInput) error {
3959	if v == nil {
3960		return nil
3961	}
3962	invalidParams := smithy.InvalidParamsError{Context: "ListSecurityProfilesInput"}
3963	if v.InstanceId == nil {
3964		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3965	}
3966	if invalidParams.Len() > 0 {
3967		return invalidParams
3968	} else {
3969		return nil
3970	}
3971}
3972
3973func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
3974	if v == nil {
3975		return nil
3976	}
3977	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
3978	if v.ResourceArn == nil {
3979		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
3980	}
3981	if invalidParams.Len() > 0 {
3982		return invalidParams
3983	} else {
3984		return nil
3985	}
3986}
3987
3988func validateOpListUseCasesInput(v *ListUseCasesInput) error {
3989	if v == nil {
3990		return nil
3991	}
3992	invalidParams := smithy.InvalidParamsError{Context: "ListUseCasesInput"}
3993	if v.InstanceId == nil {
3994		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
3995	}
3996	if v.IntegrationAssociationId == nil {
3997		invalidParams.Add(smithy.NewErrParamRequired("IntegrationAssociationId"))
3998	}
3999	if invalidParams.Len() > 0 {
4000		return invalidParams
4001	} else {
4002		return nil
4003	}
4004}
4005
4006func validateOpListUserHierarchyGroupsInput(v *ListUserHierarchyGroupsInput) error {
4007	if v == nil {
4008		return nil
4009	}
4010	invalidParams := smithy.InvalidParamsError{Context: "ListUserHierarchyGroupsInput"}
4011	if v.InstanceId == nil {
4012		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4013	}
4014	if invalidParams.Len() > 0 {
4015		return invalidParams
4016	} else {
4017		return nil
4018	}
4019}
4020
4021func validateOpListUsersInput(v *ListUsersInput) error {
4022	if v == nil {
4023		return nil
4024	}
4025	invalidParams := smithy.InvalidParamsError{Context: "ListUsersInput"}
4026	if v.InstanceId == nil {
4027		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4028	}
4029	if invalidParams.Len() > 0 {
4030		return invalidParams
4031	} else {
4032		return nil
4033	}
4034}
4035
4036func validateOpResumeContactRecordingInput(v *ResumeContactRecordingInput) error {
4037	if v == nil {
4038		return nil
4039	}
4040	invalidParams := smithy.InvalidParamsError{Context: "ResumeContactRecordingInput"}
4041	if v.InstanceId == nil {
4042		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4043	}
4044	if v.ContactId == nil {
4045		invalidParams.Add(smithy.NewErrParamRequired("ContactId"))
4046	}
4047	if v.InitialContactId == nil {
4048		invalidParams.Add(smithy.NewErrParamRequired("InitialContactId"))
4049	}
4050	if invalidParams.Len() > 0 {
4051		return invalidParams
4052	} else {
4053		return nil
4054	}
4055}
4056
4057func validateOpStartChatContactInput(v *StartChatContactInput) error {
4058	if v == nil {
4059		return nil
4060	}
4061	invalidParams := smithy.InvalidParamsError{Context: "StartChatContactInput"}
4062	if v.InstanceId == nil {
4063		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4064	}
4065	if v.ContactFlowId == nil {
4066		invalidParams.Add(smithy.NewErrParamRequired("ContactFlowId"))
4067	}
4068	if v.ParticipantDetails == nil {
4069		invalidParams.Add(smithy.NewErrParamRequired("ParticipantDetails"))
4070	} else if v.ParticipantDetails != nil {
4071		if err := validateParticipantDetails(v.ParticipantDetails); err != nil {
4072			invalidParams.AddNested("ParticipantDetails", err.(smithy.InvalidParamsError))
4073		}
4074	}
4075	if v.InitialMessage != nil {
4076		if err := validateChatMessage(v.InitialMessage); err != nil {
4077			invalidParams.AddNested("InitialMessage", err.(smithy.InvalidParamsError))
4078		}
4079	}
4080	if invalidParams.Len() > 0 {
4081		return invalidParams
4082	} else {
4083		return nil
4084	}
4085}
4086
4087func validateOpStartContactRecordingInput(v *StartContactRecordingInput) error {
4088	if v == nil {
4089		return nil
4090	}
4091	invalidParams := smithy.InvalidParamsError{Context: "StartContactRecordingInput"}
4092	if v.InstanceId == nil {
4093		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4094	}
4095	if v.ContactId == nil {
4096		invalidParams.Add(smithy.NewErrParamRequired("ContactId"))
4097	}
4098	if v.InitialContactId == nil {
4099		invalidParams.Add(smithy.NewErrParamRequired("InitialContactId"))
4100	}
4101	if v.VoiceRecordingConfiguration == nil {
4102		invalidParams.Add(smithy.NewErrParamRequired("VoiceRecordingConfiguration"))
4103	}
4104	if invalidParams.Len() > 0 {
4105		return invalidParams
4106	} else {
4107		return nil
4108	}
4109}
4110
4111func validateOpStartOutboundVoiceContactInput(v *StartOutboundVoiceContactInput) error {
4112	if v == nil {
4113		return nil
4114	}
4115	invalidParams := smithy.InvalidParamsError{Context: "StartOutboundVoiceContactInput"}
4116	if v.DestinationPhoneNumber == nil {
4117		invalidParams.Add(smithy.NewErrParamRequired("DestinationPhoneNumber"))
4118	}
4119	if v.ContactFlowId == nil {
4120		invalidParams.Add(smithy.NewErrParamRequired("ContactFlowId"))
4121	}
4122	if v.InstanceId == nil {
4123		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4124	}
4125	if invalidParams.Len() > 0 {
4126		return invalidParams
4127	} else {
4128		return nil
4129	}
4130}
4131
4132func validateOpStartTaskContactInput(v *StartTaskContactInput) error {
4133	if v == nil {
4134		return nil
4135	}
4136	invalidParams := smithy.InvalidParamsError{Context: "StartTaskContactInput"}
4137	if v.InstanceId == nil {
4138		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4139	}
4140	if v.ContactFlowId == nil {
4141		invalidParams.Add(smithy.NewErrParamRequired("ContactFlowId"))
4142	}
4143	if v.Name == nil {
4144		invalidParams.Add(smithy.NewErrParamRequired("Name"))
4145	}
4146	if v.References != nil {
4147		if err := validateContactReferences(v.References); err != nil {
4148			invalidParams.AddNested("References", err.(smithy.InvalidParamsError))
4149		}
4150	}
4151	if invalidParams.Len() > 0 {
4152		return invalidParams
4153	} else {
4154		return nil
4155	}
4156}
4157
4158func validateOpStopContactInput(v *StopContactInput) error {
4159	if v == nil {
4160		return nil
4161	}
4162	invalidParams := smithy.InvalidParamsError{Context: "StopContactInput"}
4163	if v.ContactId == nil {
4164		invalidParams.Add(smithy.NewErrParamRequired("ContactId"))
4165	}
4166	if v.InstanceId == nil {
4167		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4168	}
4169	if invalidParams.Len() > 0 {
4170		return invalidParams
4171	} else {
4172		return nil
4173	}
4174}
4175
4176func validateOpStopContactRecordingInput(v *StopContactRecordingInput) error {
4177	if v == nil {
4178		return nil
4179	}
4180	invalidParams := smithy.InvalidParamsError{Context: "StopContactRecordingInput"}
4181	if v.InstanceId == nil {
4182		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4183	}
4184	if v.ContactId == nil {
4185		invalidParams.Add(smithy.NewErrParamRequired("ContactId"))
4186	}
4187	if v.InitialContactId == nil {
4188		invalidParams.Add(smithy.NewErrParamRequired("InitialContactId"))
4189	}
4190	if invalidParams.Len() > 0 {
4191		return invalidParams
4192	} else {
4193		return nil
4194	}
4195}
4196
4197func validateOpSuspendContactRecordingInput(v *SuspendContactRecordingInput) error {
4198	if v == nil {
4199		return nil
4200	}
4201	invalidParams := smithy.InvalidParamsError{Context: "SuspendContactRecordingInput"}
4202	if v.InstanceId == nil {
4203		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4204	}
4205	if v.ContactId == nil {
4206		invalidParams.Add(smithy.NewErrParamRequired("ContactId"))
4207	}
4208	if v.InitialContactId == nil {
4209		invalidParams.Add(smithy.NewErrParamRequired("InitialContactId"))
4210	}
4211	if invalidParams.Len() > 0 {
4212		return invalidParams
4213	} else {
4214		return nil
4215	}
4216}
4217
4218func validateOpTagResourceInput(v *TagResourceInput) error {
4219	if v == nil {
4220		return nil
4221	}
4222	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
4223	if v.ResourceArn == nil {
4224		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
4225	}
4226	if v.Tags == nil {
4227		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
4228	}
4229	if invalidParams.Len() > 0 {
4230		return invalidParams
4231	} else {
4232		return nil
4233	}
4234}
4235
4236func validateOpUntagResourceInput(v *UntagResourceInput) error {
4237	if v == nil {
4238		return nil
4239	}
4240	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
4241	if v.ResourceArn == nil {
4242		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
4243	}
4244	if v.TagKeys == nil {
4245		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
4246	}
4247	if invalidParams.Len() > 0 {
4248		return invalidParams
4249	} else {
4250		return nil
4251	}
4252}
4253
4254func validateOpUpdateContactAttributesInput(v *UpdateContactAttributesInput) error {
4255	if v == nil {
4256		return nil
4257	}
4258	invalidParams := smithy.InvalidParamsError{Context: "UpdateContactAttributesInput"}
4259	if v.InitialContactId == nil {
4260		invalidParams.Add(smithy.NewErrParamRequired("InitialContactId"))
4261	}
4262	if v.InstanceId == nil {
4263		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4264	}
4265	if v.Attributes == nil {
4266		invalidParams.Add(smithy.NewErrParamRequired("Attributes"))
4267	}
4268	if invalidParams.Len() > 0 {
4269		return invalidParams
4270	} else {
4271		return nil
4272	}
4273}
4274
4275func validateOpUpdateContactFlowContentInput(v *UpdateContactFlowContentInput) error {
4276	if v == nil {
4277		return nil
4278	}
4279	invalidParams := smithy.InvalidParamsError{Context: "UpdateContactFlowContentInput"}
4280	if v.InstanceId == nil {
4281		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4282	}
4283	if v.ContactFlowId == nil {
4284		invalidParams.Add(smithy.NewErrParamRequired("ContactFlowId"))
4285	}
4286	if v.Content == nil {
4287		invalidParams.Add(smithy.NewErrParamRequired("Content"))
4288	}
4289	if invalidParams.Len() > 0 {
4290		return invalidParams
4291	} else {
4292		return nil
4293	}
4294}
4295
4296func validateOpUpdateContactFlowNameInput(v *UpdateContactFlowNameInput) error {
4297	if v == nil {
4298		return nil
4299	}
4300	invalidParams := smithy.InvalidParamsError{Context: "UpdateContactFlowNameInput"}
4301	if v.InstanceId == nil {
4302		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4303	}
4304	if v.ContactFlowId == nil {
4305		invalidParams.Add(smithy.NewErrParamRequired("ContactFlowId"))
4306	}
4307	if invalidParams.Len() > 0 {
4308		return invalidParams
4309	} else {
4310		return nil
4311	}
4312}
4313
4314func validateOpUpdateInstanceAttributeInput(v *UpdateInstanceAttributeInput) error {
4315	if v == nil {
4316		return nil
4317	}
4318	invalidParams := smithy.InvalidParamsError{Context: "UpdateInstanceAttributeInput"}
4319	if v.InstanceId == nil {
4320		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4321	}
4322	if len(v.AttributeType) == 0 {
4323		invalidParams.Add(smithy.NewErrParamRequired("AttributeType"))
4324	}
4325	if v.Value == nil {
4326		invalidParams.Add(smithy.NewErrParamRequired("Value"))
4327	}
4328	if invalidParams.Len() > 0 {
4329		return invalidParams
4330	} else {
4331		return nil
4332	}
4333}
4334
4335func validateOpUpdateInstanceStorageConfigInput(v *UpdateInstanceStorageConfigInput) error {
4336	if v == nil {
4337		return nil
4338	}
4339	invalidParams := smithy.InvalidParamsError{Context: "UpdateInstanceStorageConfigInput"}
4340	if v.InstanceId == nil {
4341		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4342	}
4343	if v.AssociationId == nil {
4344		invalidParams.Add(smithy.NewErrParamRequired("AssociationId"))
4345	}
4346	if len(v.ResourceType) == 0 {
4347		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
4348	}
4349	if v.StorageConfig == nil {
4350		invalidParams.Add(smithy.NewErrParamRequired("StorageConfig"))
4351	} else if v.StorageConfig != nil {
4352		if err := validateInstanceStorageConfig(v.StorageConfig); err != nil {
4353			invalidParams.AddNested("StorageConfig", err.(smithy.InvalidParamsError))
4354		}
4355	}
4356	if invalidParams.Len() > 0 {
4357		return invalidParams
4358	} else {
4359		return nil
4360	}
4361}
4362
4363func validateOpUpdateQueueHoursOfOperationInput(v *UpdateQueueHoursOfOperationInput) error {
4364	if v == nil {
4365		return nil
4366	}
4367	invalidParams := smithy.InvalidParamsError{Context: "UpdateQueueHoursOfOperationInput"}
4368	if v.InstanceId == nil {
4369		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4370	}
4371	if v.QueueId == nil {
4372		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
4373	}
4374	if v.HoursOfOperationId == nil {
4375		invalidParams.Add(smithy.NewErrParamRequired("HoursOfOperationId"))
4376	}
4377	if invalidParams.Len() > 0 {
4378		return invalidParams
4379	} else {
4380		return nil
4381	}
4382}
4383
4384func validateOpUpdateQueueMaxContactsInput(v *UpdateQueueMaxContactsInput) error {
4385	if v == nil {
4386		return nil
4387	}
4388	invalidParams := smithy.InvalidParamsError{Context: "UpdateQueueMaxContactsInput"}
4389	if v.InstanceId == nil {
4390		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4391	}
4392	if v.QueueId == nil {
4393		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
4394	}
4395	if invalidParams.Len() > 0 {
4396		return invalidParams
4397	} else {
4398		return nil
4399	}
4400}
4401
4402func validateOpUpdateQueueNameInput(v *UpdateQueueNameInput) error {
4403	if v == nil {
4404		return nil
4405	}
4406	invalidParams := smithy.InvalidParamsError{Context: "UpdateQueueNameInput"}
4407	if v.InstanceId == nil {
4408		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4409	}
4410	if v.QueueId == nil {
4411		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
4412	}
4413	if invalidParams.Len() > 0 {
4414		return invalidParams
4415	} else {
4416		return nil
4417	}
4418}
4419
4420func validateOpUpdateQueueOutboundCallerConfigInput(v *UpdateQueueOutboundCallerConfigInput) error {
4421	if v == nil {
4422		return nil
4423	}
4424	invalidParams := smithy.InvalidParamsError{Context: "UpdateQueueOutboundCallerConfigInput"}
4425	if v.InstanceId == nil {
4426		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4427	}
4428	if v.QueueId == nil {
4429		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
4430	}
4431	if v.OutboundCallerConfig == nil {
4432		invalidParams.Add(smithy.NewErrParamRequired("OutboundCallerConfig"))
4433	}
4434	if invalidParams.Len() > 0 {
4435		return invalidParams
4436	} else {
4437		return nil
4438	}
4439}
4440
4441func validateOpUpdateQueueStatusInput(v *UpdateQueueStatusInput) error {
4442	if v == nil {
4443		return nil
4444	}
4445	invalidParams := smithy.InvalidParamsError{Context: "UpdateQueueStatusInput"}
4446	if v.InstanceId == nil {
4447		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4448	}
4449	if v.QueueId == nil {
4450		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
4451	}
4452	if len(v.Status) == 0 {
4453		invalidParams.Add(smithy.NewErrParamRequired("Status"))
4454	}
4455	if invalidParams.Len() > 0 {
4456		return invalidParams
4457	} else {
4458		return nil
4459	}
4460}
4461
4462func validateOpUpdateQuickConnectConfigInput(v *UpdateQuickConnectConfigInput) error {
4463	if v == nil {
4464		return nil
4465	}
4466	invalidParams := smithy.InvalidParamsError{Context: "UpdateQuickConnectConfigInput"}
4467	if v.InstanceId == nil {
4468		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4469	}
4470	if v.QuickConnectId == nil {
4471		invalidParams.Add(smithy.NewErrParamRequired("QuickConnectId"))
4472	}
4473	if v.QuickConnectConfig == nil {
4474		invalidParams.Add(smithy.NewErrParamRequired("QuickConnectConfig"))
4475	} else if v.QuickConnectConfig != nil {
4476		if err := validateQuickConnectConfig(v.QuickConnectConfig); err != nil {
4477			invalidParams.AddNested("QuickConnectConfig", err.(smithy.InvalidParamsError))
4478		}
4479	}
4480	if invalidParams.Len() > 0 {
4481		return invalidParams
4482	} else {
4483		return nil
4484	}
4485}
4486
4487func validateOpUpdateQuickConnectNameInput(v *UpdateQuickConnectNameInput) error {
4488	if v == nil {
4489		return nil
4490	}
4491	invalidParams := smithy.InvalidParamsError{Context: "UpdateQuickConnectNameInput"}
4492	if v.InstanceId == nil {
4493		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4494	}
4495	if v.QuickConnectId == nil {
4496		invalidParams.Add(smithy.NewErrParamRequired("QuickConnectId"))
4497	}
4498	if invalidParams.Len() > 0 {
4499		return invalidParams
4500	} else {
4501		return nil
4502	}
4503}
4504
4505func validateOpUpdateRoutingProfileConcurrencyInput(v *UpdateRoutingProfileConcurrencyInput) error {
4506	if v == nil {
4507		return nil
4508	}
4509	invalidParams := smithy.InvalidParamsError{Context: "UpdateRoutingProfileConcurrencyInput"}
4510	if v.InstanceId == nil {
4511		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4512	}
4513	if v.RoutingProfileId == nil {
4514		invalidParams.Add(smithy.NewErrParamRequired("RoutingProfileId"))
4515	}
4516	if v.MediaConcurrencies == nil {
4517		invalidParams.Add(smithy.NewErrParamRequired("MediaConcurrencies"))
4518	} else if v.MediaConcurrencies != nil {
4519		if err := validateMediaConcurrencies(v.MediaConcurrencies); err != nil {
4520			invalidParams.AddNested("MediaConcurrencies", err.(smithy.InvalidParamsError))
4521		}
4522	}
4523	if invalidParams.Len() > 0 {
4524		return invalidParams
4525	} else {
4526		return nil
4527	}
4528}
4529
4530func validateOpUpdateRoutingProfileDefaultOutboundQueueInput(v *UpdateRoutingProfileDefaultOutboundQueueInput) error {
4531	if v == nil {
4532		return nil
4533	}
4534	invalidParams := smithy.InvalidParamsError{Context: "UpdateRoutingProfileDefaultOutboundQueueInput"}
4535	if v.InstanceId == nil {
4536		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4537	}
4538	if v.RoutingProfileId == nil {
4539		invalidParams.Add(smithy.NewErrParamRequired("RoutingProfileId"))
4540	}
4541	if v.DefaultOutboundQueueId == nil {
4542		invalidParams.Add(smithy.NewErrParamRequired("DefaultOutboundQueueId"))
4543	}
4544	if invalidParams.Len() > 0 {
4545		return invalidParams
4546	} else {
4547		return nil
4548	}
4549}
4550
4551func validateOpUpdateRoutingProfileNameInput(v *UpdateRoutingProfileNameInput) error {
4552	if v == nil {
4553		return nil
4554	}
4555	invalidParams := smithy.InvalidParamsError{Context: "UpdateRoutingProfileNameInput"}
4556	if v.InstanceId == nil {
4557		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4558	}
4559	if v.RoutingProfileId == nil {
4560		invalidParams.Add(smithy.NewErrParamRequired("RoutingProfileId"))
4561	}
4562	if invalidParams.Len() > 0 {
4563		return invalidParams
4564	} else {
4565		return nil
4566	}
4567}
4568
4569func validateOpUpdateRoutingProfileQueuesInput(v *UpdateRoutingProfileQueuesInput) error {
4570	if v == nil {
4571		return nil
4572	}
4573	invalidParams := smithy.InvalidParamsError{Context: "UpdateRoutingProfileQueuesInput"}
4574	if v.InstanceId == nil {
4575		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4576	}
4577	if v.RoutingProfileId == nil {
4578		invalidParams.Add(smithy.NewErrParamRequired("RoutingProfileId"))
4579	}
4580	if v.QueueConfigs == nil {
4581		invalidParams.Add(smithy.NewErrParamRequired("QueueConfigs"))
4582	} else if v.QueueConfigs != nil {
4583		if err := validateRoutingProfileQueueConfigList(v.QueueConfigs); err != nil {
4584			invalidParams.AddNested("QueueConfigs", err.(smithy.InvalidParamsError))
4585		}
4586	}
4587	if invalidParams.Len() > 0 {
4588		return invalidParams
4589	} else {
4590		return nil
4591	}
4592}
4593
4594func validateOpUpdateUserHierarchyGroupNameInput(v *UpdateUserHierarchyGroupNameInput) error {
4595	if v == nil {
4596		return nil
4597	}
4598	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserHierarchyGroupNameInput"}
4599	if v.Name == nil {
4600		invalidParams.Add(smithy.NewErrParamRequired("Name"))
4601	}
4602	if v.HierarchyGroupId == nil {
4603		invalidParams.Add(smithy.NewErrParamRequired("HierarchyGroupId"))
4604	}
4605	if v.InstanceId == nil {
4606		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4607	}
4608	if invalidParams.Len() > 0 {
4609		return invalidParams
4610	} else {
4611		return nil
4612	}
4613}
4614
4615func validateOpUpdateUserHierarchyInput(v *UpdateUserHierarchyInput) error {
4616	if v == nil {
4617		return nil
4618	}
4619	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserHierarchyInput"}
4620	if v.UserId == nil {
4621		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
4622	}
4623	if v.InstanceId == nil {
4624		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4625	}
4626	if invalidParams.Len() > 0 {
4627		return invalidParams
4628	} else {
4629		return nil
4630	}
4631}
4632
4633func validateOpUpdateUserHierarchyStructureInput(v *UpdateUserHierarchyStructureInput) error {
4634	if v == nil {
4635		return nil
4636	}
4637	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserHierarchyStructureInput"}
4638	if v.HierarchyStructure == nil {
4639		invalidParams.Add(smithy.NewErrParamRequired("HierarchyStructure"))
4640	} else if v.HierarchyStructure != nil {
4641		if err := validateHierarchyStructureUpdate(v.HierarchyStructure); err != nil {
4642			invalidParams.AddNested("HierarchyStructure", err.(smithy.InvalidParamsError))
4643		}
4644	}
4645	if v.InstanceId == nil {
4646		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4647	}
4648	if invalidParams.Len() > 0 {
4649		return invalidParams
4650	} else {
4651		return nil
4652	}
4653}
4654
4655func validateOpUpdateUserIdentityInfoInput(v *UpdateUserIdentityInfoInput) error {
4656	if v == nil {
4657		return nil
4658	}
4659	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserIdentityInfoInput"}
4660	if v.IdentityInfo == nil {
4661		invalidParams.Add(smithy.NewErrParamRequired("IdentityInfo"))
4662	}
4663	if v.UserId == nil {
4664		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
4665	}
4666	if v.InstanceId == nil {
4667		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4668	}
4669	if invalidParams.Len() > 0 {
4670		return invalidParams
4671	} else {
4672		return nil
4673	}
4674}
4675
4676func validateOpUpdateUserPhoneConfigInput(v *UpdateUserPhoneConfigInput) error {
4677	if v == nil {
4678		return nil
4679	}
4680	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserPhoneConfigInput"}
4681	if v.PhoneConfig == nil {
4682		invalidParams.Add(smithy.NewErrParamRequired("PhoneConfig"))
4683	} else if v.PhoneConfig != nil {
4684		if err := validateUserPhoneConfig(v.PhoneConfig); err != nil {
4685			invalidParams.AddNested("PhoneConfig", err.(smithy.InvalidParamsError))
4686		}
4687	}
4688	if v.UserId == nil {
4689		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
4690	}
4691	if v.InstanceId == nil {
4692		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4693	}
4694	if invalidParams.Len() > 0 {
4695		return invalidParams
4696	} else {
4697		return nil
4698	}
4699}
4700
4701func validateOpUpdateUserRoutingProfileInput(v *UpdateUserRoutingProfileInput) error {
4702	if v == nil {
4703		return nil
4704	}
4705	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserRoutingProfileInput"}
4706	if v.RoutingProfileId == nil {
4707		invalidParams.Add(smithy.NewErrParamRequired("RoutingProfileId"))
4708	}
4709	if v.UserId == nil {
4710		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
4711	}
4712	if v.InstanceId == nil {
4713		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4714	}
4715	if invalidParams.Len() > 0 {
4716		return invalidParams
4717	} else {
4718		return nil
4719	}
4720}
4721
4722func validateOpUpdateUserSecurityProfilesInput(v *UpdateUserSecurityProfilesInput) error {
4723	if v == nil {
4724		return nil
4725	}
4726	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserSecurityProfilesInput"}
4727	if v.SecurityProfileIds == nil {
4728		invalidParams.Add(smithy.NewErrParamRequired("SecurityProfileIds"))
4729	}
4730	if v.UserId == nil {
4731		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
4732	}
4733	if v.InstanceId == nil {
4734		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
4735	}
4736	if invalidParams.Len() > 0 {
4737		return invalidParams
4738	} else {
4739		return nil
4740	}
4741}
4742