1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package elasticache
4
5import (
6	"bytes"
7	"context"
8	"encoding/xml"
9	"fmt"
10	awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
11	awsxml "github.com/aws/aws-sdk-go-v2/aws/protocol/xml"
12	"github.com/aws/aws-sdk-go-v2/service/elasticache/types"
13	smithy "github.com/aws/smithy-go"
14	smithyxml "github.com/aws/smithy-go/encoding/xml"
15	smithyio "github.com/aws/smithy-go/io"
16	"github.com/aws/smithy-go/middleware"
17	"github.com/aws/smithy-go/ptr"
18	smithytime "github.com/aws/smithy-go/time"
19	smithyhttp "github.com/aws/smithy-go/transport/http"
20	"io"
21	"io/ioutil"
22	"strconv"
23	"strings"
24)
25
26type awsAwsquery_deserializeOpAddTagsToResource struct {
27}
28
29func (*awsAwsquery_deserializeOpAddTagsToResource) ID() string {
30	return "OperationDeserializer"
31}
32
33func (m *awsAwsquery_deserializeOpAddTagsToResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
34	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
35) {
36	out, metadata, err = next.HandleDeserialize(ctx, in)
37	if err != nil {
38		return out, metadata, err
39	}
40
41	response, ok := out.RawResponse.(*smithyhttp.Response)
42	if !ok {
43		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
44	}
45
46	if response.StatusCode < 200 || response.StatusCode >= 300 {
47		return out, metadata, awsAwsquery_deserializeOpErrorAddTagsToResource(response, &metadata)
48	}
49	output := &AddTagsToResourceOutput{}
50	out.Result = output
51
52	var buff [1024]byte
53	ringBuffer := smithyio.NewRingBuffer(buff[:])
54	body := io.TeeReader(response.Body, ringBuffer)
55	rootDecoder := xml.NewDecoder(body)
56	t, err := smithyxml.FetchRootElement(rootDecoder)
57	if err == io.EOF {
58		return out, metadata, nil
59	}
60	if err != nil {
61		var snapshot bytes.Buffer
62		io.Copy(&snapshot, ringBuffer)
63		return out, metadata, &smithy.DeserializationError{
64			Err:      fmt.Errorf("failed to decode response body, %w", err),
65			Snapshot: snapshot.Bytes(),
66		}
67	}
68
69	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
70	t, err = decoder.GetElement("AddTagsToResourceResult")
71	if err != nil {
72		var snapshot bytes.Buffer
73		io.Copy(&snapshot, ringBuffer)
74		err = &smithy.DeserializationError{
75			Err:      fmt.Errorf("failed to decode response body, %w", err),
76			Snapshot: snapshot.Bytes(),
77		}
78		return out, metadata, err
79	}
80
81	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
82	err = awsAwsquery_deserializeOpDocumentAddTagsToResourceOutput(&output, decoder)
83	if err != nil {
84		var snapshot bytes.Buffer
85		io.Copy(&snapshot, ringBuffer)
86		err = &smithy.DeserializationError{
87			Err:      fmt.Errorf("failed to decode response body, %w", err),
88			Snapshot: snapshot.Bytes(),
89		}
90		return out, metadata, err
91	}
92
93	return out, metadata, err
94}
95
96func awsAwsquery_deserializeOpErrorAddTagsToResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
97	var errorBuffer bytes.Buffer
98	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
99		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
100	}
101	errorBody := bytes.NewReader(errorBuffer.Bytes())
102
103	errorCode := "UnknownError"
104	errorMessage := errorCode
105
106	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
107	if err != nil {
108		return err
109	}
110	if reqID := errorComponents.RequestID; len(reqID) != 0 {
111		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
112	}
113	if len(errorComponents.Code) != 0 {
114		errorCode = errorComponents.Code
115	}
116	if len(errorComponents.Message) != 0 {
117		errorMessage = errorComponents.Message
118	}
119	errorBody.Seek(0, io.SeekStart)
120	switch {
121	case strings.EqualFold("CacheClusterNotFoundFault", errorCode):
122		return awsAwsquery_deserializeErrorCacheClusterNotFoundFault(response, errorBody)
123
124	case strings.EqualFold("InvalidARNFault", errorCode):
125		return awsAwsquery_deserializeErrorInvalidARNFault(response, errorBody)
126
127	case strings.EqualFold("SnapshotNotFoundFault", errorCode):
128		return awsAwsquery_deserializeErrorSnapshotNotFoundFault(response, errorBody)
129
130	case strings.EqualFold("TagQuotaPerResourceExceeded", errorCode):
131		return awsAwsquery_deserializeErrorTagQuotaPerResourceExceeded(response, errorBody)
132
133	default:
134		genericError := &smithy.GenericAPIError{
135			Code:    errorCode,
136			Message: errorMessage,
137		}
138		return genericError
139
140	}
141}
142
143type awsAwsquery_deserializeOpAuthorizeCacheSecurityGroupIngress struct {
144}
145
146func (*awsAwsquery_deserializeOpAuthorizeCacheSecurityGroupIngress) ID() string {
147	return "OperationDeserializer"
148}
149
150func (m *awsAwsquery_deserializeOpAuthorizeCacheSecurityGroupIngress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
151	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
152) {
153	out, metadata, err = next.HandleDeserialize(ctx, in)
154	if err != nil {
155		return out, metadata, err
156	}
157
158	response, ok := out.RawResponse.(*smithyhttp.Response)
159	if !ok {
160		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
161	}
162
163	if response.StatusCode < 200 || response.StatusCode >= 300 {
164		return out, metadata, awsAwsquery_deserializeOpErrorAuthorizeCacheSecurityGroupIngress(response, &metadata)
165	}
166	output := &AuthorizeCacheSecurityGroupIngressOutput{}
167	out.Result = output
168
169	var buff [1024]byte
170	ringBuffer := smithyio.NewRingBuffer(buff[:])
171	body := io.TeeReader(response.Body, ringBuffer)
172	rootDecoder := xml.NewDecoder(body)
173	t, err := smithyxml.FetchRootElement(rootDecoder)
174	if err == io.EOF {
175		return out, metadata, nil
176	}
177	if err != nil {
178		var snapshot bytes.Buffer
179		io.Copy(&snapshot, ringBuffer)
180		return out, metadata, &smithy.DeserializationError{
181			Err:      fmt.Errorf("failed to decode response body, %w", err),
182			Snapshot: snapshot.Bytes(),
183		}
184	}
185
186	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
187	t, err = decoder.GetElement("AuthorizeCacheSecurityGroupIngressResult")
188	if err != nil {
189		var snapshot bytes.Buffer
190		io.Copy(&snapshot, ringBuffer)
191		err = &smithy.DeserializationError{
192			Err:      fmt.Errorf("failed to decode response body, %w", err),
193			Snapshot: snapshot.Bytes(),
194		}
195		return out, metadata, err
196	}
197
198	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
199	err = awsAwsquery_deserializeOpDocumentAuthorizeCacheSecurityGroupIngressOutput(&output, decoder)
200	if err != nil {
201		var snapshot bytes.Buffer
202		io.Copy(&snapshot, ringBuffer)
203		err = &smithy.DeserializationError{
204			Err:      fmt.Errorf("failed to decode response body, %w", err),
205			Snapshot: snapshot.Bytes(),
206		}
207		return out, metadata, err
208	}
209
210	return out, metadata, err
211}
212
213func awsAwsquery_deserializeOpErrorAuthorizeCacheSecurityGroupIngress(response *smithyhttp.Response, metadata *middleware.Metadata) error {
214	var errorBuffer bytes.Buffer
215	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
216		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
217	}
218	errorBody := bytes.NewReader(errorBuffer.Bytes())
219
220	errorCode := "UnknownError"
221	errorMessage := errorCode
222
223	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
224	if err != nil {
225		return err
226	}
227	if reqID := errorComponents.RequestID; len(reqID) != 0 {
228		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
229	}
230	if len(errorComponents.Code) != 0 {
231		errorCode = errorComponents.Code
232	}
233	if len(errorComponents.Message) != 0 {
234		errorMessage = errorComponents.Message
235	}
236	errorBody.Seek(0, io.SeekStart)
237	switch {
238	case strings.EqualFold("AuthorizationAlreadyExistsFault", errorCode):
239		return awsAwsquery_deserializeErrorAuthorizationAlreadyExistsFault(response, errorBody)
240
241	case strings.EqualFold("CacheSecurityGroupNotFoundFault", errorCode):
242		return awsAwsquery_deserializeErrorCacheSecurityGroupNotFoundFault(response, errorBody)
243
244	case strings.EqualFold("InvalidCacheSecurityGroupStateFault", errorCode):
245		return awsAwsquery_deserializeErrorInvalidCacheSecurityGroupStateFault(response, errorBody)
246
247	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
248		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
249
250	case strings.EqualFold("InvalidParameterValueException", errorCode):
251		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
252
253	default:
254		genericError := &smithy.GenericAPIError{
255			Code:    errorCode,
256			Message: errorMessage,
257		}
258		return genericError
259
260	}
261}
262
263type awsAwsquery_deserializeOpBatchApplyUpdateAction struct {
264}
265
266func (*awsAwsquery_deserializeOpBatchApplyUpdateAction) ID() string {
267	return "OperationDeserializer"
268}
269
270func (m *awsAwsquery_deserializeOpBatchApplyUpdateAction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
271	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
272) {
273	out, metadata, err = next.HandleDeserialize(ctx, in)
274	if err != nil {
275		return out, metadata, err
276	}
277
278	response, ok := out.RawResponse.(*smithyhttp.Response)
279	if !ok {
280		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
281	}
282
283	if response.StatusCode < 200 || response.StatusCode >= 300 {
284		return out, metadata, awsAwsquery_deserializeOpErrorBatchApplyUpdateAction(response, &metadata)
285	}
286	output := &BatchApplyUpdateActionOutput{}
287	out.Result = output
288
289	var buff [1024]byte
290	ringBuffer := smithyio.NewRingBuffer(buff[:])
291	body := io.TeeReader(response.Body, ringBuffer)
292	rootDecoder := xml.NewDecoder(body)
293	t, err := smithyxml.FetchRootElement(rootDecoder)
294	if err == io.EOF {
295		return out, metadata, nil
296	}
297	if err != nil {
298		var snapshot bytes.Buffer
299		io.Copy(&snapshot, ringBuffer)
300		return out, metadata, &smithy.DeserializationError{
301			Err:      fmt.Errorf("failed to decode response body, %w", err),
302			Snapshot: snapshot.Bytes(),
303		}
304	}
305
306	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
307	t, err = decoder.GetElement("BatchApplyUpdateActionResult")
308	if err != nil {
309		var snapshot bytes.Buffer
310		io.Copy(&snapshot, ringBuffer)
311		err = &smithy.DeserializationError{
312			Err:      fmt.Errorf("failed to decode response body, %w", err),
313			Snapshot: snapshot.Bytes(),
314		}
315		return out, metadata, err
316	}
317
318	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
319	err = awsAwsquery_deserializeOpDocumentBatchApplyUpdateActionOutput(&output, decoder)
320	if err != nil {
321		var snapshot bytes.Buffer
322		io.Copy(&snapshot, ringBuffer)
323		err = &smithy.DeserializationError{
324			Err:      fmt.Errorf("failed to decode response body, %w", err),
325			Snapshot: snapshot.Bytes(),
326		}
327		return out, metadata, err
328	}
329
330	return out, metadata, err
331}
332
333func awsAwsquery_deserializeOpErrorBatchApplyUpdateAction(response *smithyhttp.Response, metadata *middleware.Metadata) error {
334	var errorBuffer bytes.Buffer
335	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
336		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
337	}
338	errorBody := bytes.NewReader(errorBuffer.Bytes())
339
340	errorCode := "UnknownError"
341	errorMessage := errorCode
342
343	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
344	if err != nil {
345		return err
346	}
347	if reqID := errorComponents.RequestID; len(reqID) != 0 {
348		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
349	}
350	if len(errorComponents.Code) != 0 {
351		errorCode = errorComponents.Code
352	}
353	if len(errorComponents.Message) != 0 {
354		errorMessage = errorComponents.Message
355	}
356	errorBody.Seek(0, io.SeekStart)
357	switch {
358	case strings.EqualFold("InvalidParameterValueException", errorCode):
359		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
360
361	case strings.EqualFold("ServiceUpdateNotFoundFault", errorCode):
362		return awsAwsquery_deserializeErrorServiceUpdateNotFoundFault(response, errorBody)
363
364	default:
365		genericError := &smithy.GenericAPIError{
366			Code:    errorCode,
367			Message: errorMessage,
368		}
369		return genericError
370
371	}
372}
373
374type awsAwsquery_deserializeOpBatchStopUpdateAction struct {
375}
376
377func (*awsAwsquery_deserializeOpBatchStopUpdateAction) ID() string {
378	return "OperationDeserializer"
379}
380
381func (m *awsAwsquery_deserializeOpBatchStopUpdateAction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
382	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
383) {
384	out, metadata, err = next.HandleDeserialize(ctx, in)
385	if err != nil {
386		return out, metadata, err
387	}
388
389	response, ok := out.RawResponse.(*smithyhttp.Response)
390	if !ok {
391		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
392	}
393
394	if response.StatusCode < 200 || response.StatusCode >= 300 {
395		return out, metadata, awsAwsquery_deserializeOpErrorBatchStopUpdateAction(response, &metadata)
396	}
397	output := &BatchStopUpdateActionOutput{}
398	out.Result = output
399
400	var buff [1024]byte
401	ringBuffer := smithyio.NewRingBuffer(buff[:])
402	body := io.TeeReader(response.Body, ringBuffer)
403	rootDecoder := xml.NewDecoder(body)
404	t, err := smithyxml.FetchRootElement(rootDecoder)
405	if err == io.EOF {
406		return out, metadata, nil
407	}
408	if err != nil {
409		var snapshot bytes.Buffer
410		io.Copy(&snapshot, ringBuffer)
411		return out, metadata, &smithy.DeserializationError{
412			Err:      fmt.Errorf("failed to decode response body, %w", err),
413			Snapshot: snapshot.Bytes(),
414		}
415	}
416
417	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
418	t, err = decoder.GetElement("BatchStopUpdateActionResult")
419	if err != nil {
420		var snapshot bytes.Buffer
421		io.Copy(&snapshot, ringBuffer)
422		err = &smithy.DeserializationError{
423			Err:      fmt.Errorf("failed to decode response body, %w", err),
424			Snapshot: snapshot.Bytes(),
425		}
426		return out, metadata, err
427	}
428
429	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
430	err = awsAwsquery_deserializeOpDocumentBatchStopUpdateActionOutput(&output, decoder)
431	if err != nil {
432		var snapshot bytes.Buffer
433		io.Copy(&snapshot, ringBuffer)
434		err = &smithy.DeserializationError{
435			Err:      fmt.Errorf("failed to decode response body, %w", err),
436			Snapshot: snapshot.Bytes(),
437		}
438		return out, metadata, err
439	}
440
441	return out, metadata, err
442}
443
444func awsAwsquery_deserializeOpErrorBatchStopUpdateAction(response *smithyhttp.Response, metadata *middleware.Metadata) error {
445	var errorBuffer bytes.Buffer
446	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
447		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
448	}
449	errorBody := bytes.NewReader(errorBuffer.Bytes())
450
451	errorCode := "UnknownError"
452	errorMessage := errorCode
453
454	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
455	if err != nil {
456		return err
457	}
458	if reqID := errorComponents.RequestID; len(reqID) != 0 {
459		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
460	}
461	if len(errorComponents.Code) != 0 {
462		errorCode = errorComponents.Code
463	}
464	if len(errorComponents.Message) != 0 {
465		errorMessage = errorComponents.Message
466	}
467	errorBody.Seek(0, io.SeekStart)
468	switch {
469	case strings.EqualFold("InvalidParameterValueException", errorCode):
470		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
471
472	case strings.EqualFold("ServiceUpdateNotFoundFault", errorCode):
473		return awsAwsquery_deserializeErrorServiceUpdateNotFoundFault(response, errorBody)
474
475	default:
476		genericError := &smithy.GenericAPIError{
477			Code:    errorCode,
478			Message: errorMessage,
479		}
480		return genericError
481
482	}
483}
484
485type awsAwsquery_deserializeOpCompleteMigration struct {
486}
487
488func (*awsAwsquery_deserializeOpCompleteMigration) ID() string {
489	return "OperationDeserializer"
490}
491
492func (m *awsAwsquery_deserializeOpCompleteMigration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
493	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
494) {
495	out, metadata, err = next.HandleDeserialize(ctx, in)
496	if err != nil {
497		return out, metadata, err
498	}
499
500	response, ok := out.RawResponse.(*smithyhttp.Response)
501	if !ok {
502		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
503	}
504
505	if response.StatusCode < 200 || response.StatusCode >= 300 {
506		return out, metadata, awsAwsquery_deserializeOpErrorCompleteMigration(response, &metadata)
507	}
508	output := &CompleteMigrationOutput{}
509	out.Result = output
510
511	var buff [1024]byte
512	ringBuffer := smithyio.NewRingBuffer(buff[:])
513	body := io.TeeReader(response.Body, ringBuffer)
514	rootDecoder := xml.NewDecoder(body)
515	t, err := smithyxml.FetchRootElement(rootDecoder)
516	if err == io.EOF {
517		return out, metadata, nil
518	}
519	if err != nil {
520		var snapshot bytes.Buffer
521		io.Copy(&snapshot, ringBuffer)
522		return out, metadata, &smithy.DeserializationError{
523			Err:      fmt.Errorf("failed to decode response body, %w", err),
524			Snapshot: snapshot.Bytes(),
525		}
526	}
527
528	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
529	t, err = decoder.GetElement("CompleteMigrationResult")
530	if err != nil {
531		var snapshot bytes.Buffer
532		io.Copy(&snapshot, ringBuffer)
533		err = &smithy.DeserializationError{
534			Err:      fmt.Errorf("failed to decode response body, %w", err),
535			Snapshot: snapshot.Bytes(),
536		}
537		return out, metadata, err
538	}
539
540	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
541	err = awsAwsquery_deserializeOpDocumentCompleteMigrationOutput(&output, decoder)
542	if err != nil {
543		var snapshot bytes.Buffer
544		io.Copy(&snapshot, ringBuffer)
545		err = &smithy.DeserializationError{
546			Err:      fmt.Errorf("failed to decode response body, %w", err),
547			Snapshot: snapshot.Bytes(),
548		}
549		return out, metadata, err
550	}
551
552	return out, metadata, err
553}
554
555func awsAwsquery_deserializeOpErrorCompleteMigration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
556	var errorBuffer bytes.Buffer
557	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
558		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
559	}
560	errorBody := bytes.NewReader(errorBuffer.Bytes())
561
562	errorCode := "UnknownError"
563	errorMessage := errorCode
564
565	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
566	if err != nil {
567		return err
568	}
569	if reqID := errorComponents.RequestID; len(reqID) != 0 {
570		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
571	}
572	if len(errorComponents.Code) != 0 {
573		errorCode = errorComponents.Code
574	}
575	if len(errorComponents.Message) != 0 {
576		errorMessage = errorComponents.Message
577	}
578	errorBody.Seek(0, io.SeekStart)
579	switch {
580	case strings.EqualFold("InvalidReplicationGroupStateFault", errorCode):
581		return awsAwsquery_deserializeErrorInvalidReplicationGroupStateFault(response, errorBody)
582
583	case strings.EqualFold("ReplicationGroupNotFoundFault", errorCode):
584		return awsAwsquery_deserializeErrorReplicationGroupNotFoundFault(response, errorBody)
585
586	case strings.EqualFold("ReplicationGroupNotUnderMigrationFault", errorCode):
587		return awsAwsquery_deserializeErrorReplicationGroupNotUnderMigrationFault(response, errorBody)
588
589	default:
590		genericError := &smithy.GenericAPIError{
591			Code:    errorCode,
592			Message: errorMessage,
593		}
594		return genericError
595
596	}
597}
598
599type awsAwsquery_deserializeOpCopySnapshot struct {
600}
601
602func (*awsAwsquery_deserializeOpCopySnapshot) ID() string {
603	return "OperationDeserializer"
604}
605
606func (m *awsAwsquery_deserializeOpCopySnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
607	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
608) {
609	out, metadata, err = next.HandleDeserialize(ctx, in)
610	if err != nil {
611		return out, metadata, err
612	}
613
614	response, ok := out.RawResponse.(*smithyhttp.Response)
615	if !ok {
616		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
617	}
618
619	if response.StatusCode < 200 || response.StatusCode >= 300 {
620		return out, metadata, awsAwsquery_deserializeOpErrorCopySnapshot(response, &metadata)
621	}
622	output := &CopySnapshotOutput{}
623	out.Result = output
624
625	var buff [1024]byte
626	ringBuffer := smithyio.NewRingBuffer(buff[:])
627	body := io.TeeReader(response.Body, ringBuffer)
628	rootDecoder := xml.NewDecoder(body)
629	t, err := smithyxml.FetchRootElement(rootDecoder)
630	if err == io.EOF {
631		return out, metadata, nil
632	}
633	if err != nil {
634		var snapshot bytes.Buffer
635		io.Copy(&snapshot, ringBuffer)
636		return out, metadata, &smithy.DeserializationError{
637			Err:      fmt.Errorf("failed to decode response body, %w", err),
638			Snapshot: snapshot.Bytes(),
639		}
640	}
641
642	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
643	t, err = decoder.GetElement("CopySnapshotResult")
644	if err != nil {
645		var snapshot bytes.Buffer
646		io.Copy(&snapshot, ringBuffer)
647		err = &smithy.DeserializationError{
648			Err:      fmt.Errorf("failed to decode response body, %w", err),
649			Snapshot: snapshot.Bytes(),
650		}
651		return out, metadata, err
652	}
653
654	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
655	err = awsAwsquery_deserializeOpDocumentCopySnapshotOutput(&output, decoder)
656	if err != nil {
657		var snapshot bytes.Buffer
658		io.Copy(&snapshot, ringBuffer)
659		err = &smithy.DeserializationError{
660			Err:      fmt.Errorf("failed to decode response body, %w", err),
661			Snapshot: snapshot.Bytes(),
662		}
663		return out, metadata, err
664	}
665
666	return out, metadata, err
667}
668
669func awsAwsquery_deserializeOpErrorCopySnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
670	var errorBuffer bytes.Buffer
671	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
672		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
673	}
674	errorBody := bytes.NewReader(errorBuffer.Bytes())
675
676	errorCode := "UnknownError"
677	errorMessage := errorCode
678
679	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
680	if err != nil {
681		return err
682	}
683	if reqID := errorComponents.RequestID; len(reqID) != 0 {
684		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
685	}
686	if len(errorComponents.Code) != 0 {
687		errorCode = errorComponents.Code
688	}
689	if len(errorComponents.Message) != 0 {
690		errorMessage = errorComponents.Message
691	}
692	errorBody.Seek(0, io.SeekStart)
693	switch {
694	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
695		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
696
697	case strings.EqualFold("InvalidParameterValueException", errorCode):
698		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
699
700	case strings.EqualFold("InvalidSnapshotStateFault", errorCode):
701		return awsAwsquery_deserializeErrorInvalidSnapshotStateFault(response, errorBody)
702
703	case strings.EqualFold("SnapshotAlreadyExistsFault", errorCode):
704		return awsAwsquery_deserializeErrorSnapshotAlreadyExistsFault(response, errorBody)
705
706	case strings.EqualFold("SnapshotNotFoundFault", errorCode):
707		return awsAwsquery_deserializeErrorSnapshotNotFoundFault(response, errorBody)
708
709	case strings.EqualFold("SnapshotQuotaExceededFault", errorCode):
710		return awsAwsquery_deserializeErrorSnapshotQuotaExceededFault(response, errorBody)
711
712	default:
713		genericError := &smithy.GenericAPIError{
714			Code:    errorCode,
715			Message: errorMessage,
716		}
717		return genericError
718
719	}
720}
721
722type awsAwsquery_deserializeOpCreateCacheCluster struct {
723}
724
725func (*awsAwsquery_deserializeOpCreateCacheCluster) ID() string {
726	return "OperationDeserializer"
727}
728
729func (m *awsAwsquery_deserializeOpCreateCacheCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
730	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
731) {
732	out, metadata, err = next.HandleDeserialize(ctx, in)
733	if err != nil {
734		return out, metadata, err
735	}
736
737	response, ok := out.RawResponse.(*smithyhttp.Response)
738	if !ok {
739		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
740	}
741
742	if response.StatusCode < 200 || response.StatusCode >= 300 {
743		return out, metadata, awsAwsquery_deserializeOpErrorCreateCacheCluster(response, &metadata)
744	}
745	output := &CreateCacheClusterOutput{}
746	out.Result = output
747
748	var buff [1024]byte
749	ringBuffer := smithyio.NewRingBuffer(buff[:])
750	body := io.TeeReader(response.Body, ringBuffer)
751	rootDecoder := xml.NewDecoder(body)
752	t, err := smithyxml.FetchRootElement(rootDecoder)
753	if err == io.EOF {
754		return out, metadata, nil
755	}
756	if err != nil {
757		var snapshot bytes.Buffer
758		io.Copy(&snapshot, ringBuffer)
759		return out, metadata, &smithy.DeserializationError{
760			Err:      fmt.Errorf("failed to decode response body, %w", err),
761			Snapshot: snapshot.Bytes(),
762		}
763	}
764
765	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
766	t, err = decoder.GetElement("CreateCacheClusterResult")
767	if err != nil {
768		var snapshot bytes.Buffer
769		io.Copy(&snapshot, ringBuffer)
770		err = &smithy.DeserializationError{
771			Err:      fmt.Errorf("failed to decode response body, %w", err),
772			Snapshot: snapshot.Bytes(),
773		}
774		return out, metadata, err
775	}
776
777	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
778	err = awsAwsquery_deserializeOpDocumentCreateCacheClusterOutput(&output, decoder)
779	if err != nil {
780		var snapshot bytes.Buffer
781		io.Copy(&snapshot, ringBuffer)
782		err = &smithy.DeserializationError{
783			Err:      fmt.Errorf("failed to decode response body, %w", err),
784			Snapshot: snapshot.Bytes(),
785		}
786		return out, metadata, err
787	}
788
789	return out, metadata, err
790}
791
792func awsAwsquery_deserializeOpErrorCreateCacheCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error {
793	var errorBuffer bytes.Buffer
794	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
795		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
796	}
797	errorBody := bytes.NewReader(errorBuffer.Bytes())
798
799	errorCode := "UnknownError"
800	errorMessage := errorCode
801
802	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
803	if err != nil {
804		return err
805	}
806	if reqID := errorComponents.RequestID; len(reqID) != 0 {
807		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
808	}
809	if len(errorComponents.Code) != 0 {
810		errorCode = errorComponents.Code
811	}
812	if len(errorComponents.Message) != 0 {
813		errorMessage = errorComponents.Message
814	}
815	errorBody.Seek(0, io.SeekStart)
816	switch {
817	case strings.EqualFold("CacheClusterAlreadyExistsFault", errorCode):
818		return awsAwsquery_deserializeErrorCacheClusterAlreadyExistsFault(response, errorBody)
819
820	case strings.EqualFold("CacheParameterGroupNotFoundFault", errorCode):
821		return awsAwsquery_deserializeErrorCacheParameterGroupNotFoundFault(response, errorBody)
822
823	case strings.EqualFold("CacheSecurityGroupNotFoundFault", errorCode):
824		return awsAwsquery_deserializeErrorCacheSecurityGroupNotFoundFault(response, errorBody)
825
826	case strings.EqualFold("CacheSubnetGroupNotFoundFault", errorCode):
827		return awsAwsquery_deserializeErrorCacheSubnetGroupNotFoundFault(response, errorBody)
828
829	case strings.EqualFold("ClusterQuotaForCustomerExceededFault", errorCode):
830		return awsAwsquery_deserializeErrorClusterQuotaForCustomerExceededFault(response, errorBody)
831
832	case strings.EqualFold("InsufficientCacheClusterCapacityFault", errorCode):
833		return awsAwsquery_deserializeErrorInsufficientCacheClusterCapacityFault(response, errorBody)
834
835	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
836		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
837
838	case strings.EqualFold("InvalidParameterValueException", errorCode):
839		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
840
841	case strings.EqualFold("InvalidReplicationGroupStateFault", errorCode):
842		return awsAwsquery_deserializeErrorInvalidReplicationGroupStateFault(response, errorBody)
843
844	case strings.EqualFold("InvalidVPCNetworkStateFault", errorCode):
845		return awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response, errorBody)
846
847	case strings.EqualFold("NodeQuotaForClusterExceededFault", errorCode):
848		return awsAwsquery_deserializeErrorNodeQuotaForClusterExceededFault(response, errorBody)
849
850	case strings.EqualFold("NodeQuotaForCustomerExceededFault", errorCode):
851		return awsAwsquery_deserializeErrorNodeQuotaForCustomerExceededFault(response, errorBody)
852
853	case strings.EqualFold("ReplicationGroupNotFoundFault", errorCode):
854		return awsAwsquery_deserializeErrorReplicationGroupNotFoundFault(response, errorBody)
855
856	case strings.EqualFold("TagQuotaPerResourceExceeded", errorCode):
857		return awsAwsquery_deserializeErrorTagQuotaPerResourceExceeded(response, errorBody)
858
859	default:
860		genericError := &smithy.GenericAPIError{
861			Code:    errorCode,
862			Message: errorMessage,
863		}
864		return genericError
865
866	}
867}
868
869type awsAwsquery_deserializeOpCreateCacheParameterGroup struct {
870}
871
872func (*awsAwsquery_deserializeOpCreateCacheParameterGroup) ID() string {
873	return "OperationDeserializer"
874}
875
876func (m *awsAwsquery_deserializeOpCreateCacheParameterGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
877	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
878) {
879	out, metadata, err = next.HandleDeserialize(ctx, in)
880	if err != nil {
881		return out, metadata, err
882	}
883
884	response, ok := out.RawResponse.(*smithyhttp.Response)
885	if !ok {
886		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
887	}
888
889	if response.StatusCode < 200 || response.StatusCode >= 300 {
890		return out, metadata, awsAwsquery_deserializeOpErrorCreateCacheParameterGroup(response, &metadata)
891	}
892	output := &CreateCacheParameterGroupOutput{}
893	out.Result = output
894
895	var buff [1024]byte
896	ringBuffer := smithyio.NewRingBuffer(buff[:])
897	body := io.TeeReader(response.Body, ringBuffer)
898	rootDecoder := xml.NewDecoder(body)
899	t, err := smithyxml.FetchRootElement(rootDecoder)
900	if err == io.EOF {
901		return out, metadata, nil
902	}
903	if err != nil {
904		var snapshot bytes.Buffer
905		io.Copy(&snapshot, ringBuffer)
906		return out, metadata, &smithy.DeserializationError{
907			Err:      fmt.Errorf("failed to decode response body, %w", err),
908			Snapshot: snapshot.Bytes(),
909		}
910	}
911
912	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
913	t, err = decoder.GetElement("CreateCacheParameterGroupResult")
914	if err != nil {
915		var snapshot bytes.Buffer
916		io.Copy(&snapshot, ringBuffer)
917		err = &smithy.DeserializationError{
918			Err:      fmt.Errorf("failed to decode response body, %w", err),
919			Snapshot: snapshot.Bytes(),
920		}
921		return out, metadata, err
922	}
923
924	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
925	err = awsAwsquery_deserializeOpDocumentCreateCacheParameterGroupOutput(&output, decoder)
926	if err != nil {
927		var snapshot bytes.Buffer
928		io.Copy(&snapshot, ringBuffer)
929		err = &smithy.DeserializationError{
930			Err:      fmt.Errorf("failed to decode response body, %w", err),
931			Snapshot: snapshot.Bytes(),
932		}
933		return out, metadata, err
934	}
935
936	return out, metadata, err
937}
938
939func awsAwsquery_deserializeOpErrorCreateCacheParameterGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
940	var errorBuffer bytes.Buffer
941	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
942		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
943	}
944	errorBody := bytes.NewReader(errorBuffer.Bytes())
945
946	errorCode := "UnknownError"
947	errorMessage := errorCode
948
949	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
950	if err != nil {
951		return err
952	}
953	if reqID := errorComponents.RequestID; len(reqID) != 0 {
954		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
955	}
956	if len(errorComponents.Code) != 0 {
957		errorCode = errorComponents.Code
958	}
959	if len(errorComponents.Message) != 0 {
960		errorMessage = errorComponents.Message
961	}
962	errorBody.Seek(0, io.SeekStart)
963	switch {
964	case strings.EqualFold("CacheParameterGroupAlreadyExistsFault", errorCode):
965		return awsAwsquery_deserializeErrorCacheParameterGroupAlreadyExistsFault(response, errorBody)
966
967	case strings.EqualFold("CacheParameterGroupQuotaExceededFault", errorCode):
968		return awsAwsquery_deserializeErrorCacheParameterGroupQuotaExceededFault(response, errorBody)
969
970	case strings.EqualFold("InvalidCacheParameterGroupStateFault", errorCode):
971		return awsAwsquery_deserializeErrorInvalidCacheParameterGroupStateFault(response, errorBody)
972
973	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
974		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
975
976	case strings.EqualFold("InvalidParameterValueException", errorCode):
977		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
978
979	default:
980		genericError := &smithy.GenericAPIError{
981			Code:    errorCode,
982			Message: errorMessage,
983		}
984		return genericError
985
986	}
987}
988
989type awsAwsquery_deserializeOpCreateCacheSecurityGroup struct {
990}
991
992func (*awsAwsquery_deserializeOpCreateCacheSecurityGroup) ID() string {
993	return "OperationDeserializer"
994}
995
996func (m *awsAwsquery_deserializeOpCreateCacheSecurityGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
997	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
998) {
999	out, metadata, err = next.HandleDeserialize(ctx, in)
1000	if err != nil {
1001		return out, metadata, err
1002	}
1003
1004	response, ok := out.RawResponse.(*smithyhttp.Response)
1005	if !ok {
1006		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1007	}
1008
1009	if response.StatusCode < 200 || response.StatusCode >= 300 {
1010		return out, metadata, awsAwsquery_deserializeOpErrorCreateCacheSecurityGroup(response, &metadata)
1011	}
1012	output := &CreateCacheSecurityGroupOutput{}
1013	out.Result = output
1014
1015	var buff [1024]byte
1016	ringBuffer := smithyio.NewRingBuffer(buff[:])
1017	body := io.TeeReader(response.Body, ringBuffer)
1018	rootDecoder := xml.NewDecoder(body)
1019	t, err := smithyxml.FetchRootElement(rootDecoder)
1020	if err == io.EOF {
1021		return out, metadata, nil
1022	}
1023	if err != nil {
1024		var snapshot bytes.Buffer
1025		io.Copy(&snapshot, ringBuffer)
1026		return out, metadata, &smithy.DeserializationError{
1027			Err:      fmt.Errorf("failed to decode response body, %w", err),
1028			Snapshot: snapshot.Bytes(),
1029		}
1030	}
1031
1032	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1033	t, err = decoder.GetElement("CreateCacheSecurityGroupResult")
1034	if err != nil {
1035		var snapshot bytes.Buffer
1036		io.Copy(&snapshot, ringBuffer)
1037		err = &smithy.DeserializationError{
1038			Err:      fmt.Errorf("failed to decode response body, %w", err),
1039			Snapshot: snapshot.Bytes(),
1040		}
1041		return out, metadata, err
1042	}
1043
1044	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1045	err = awsAwsquery_deserializeOpDocumentCreateCacheSecurityGroupOutput(&output, decoder)
1046	if err != nil {
1047		var snapshot bytes.Buffer
1048		io.Copy(&snapshot, ringBuffer)
1049		err = &smithy.DeserializationError{
1050			Err:      fmt.Errorf("failed to decode response body, %w", err),
1051			Snapshot: snapshot.Bytes(),
1052		}
1053		return out, metadata, err
1054	}
1055
1056	return out, metadata, err
1057}
1058
1059func awsAwsquery_deserializeOpErrorCreateCacheSecurityGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1060	var errorBuffer bytes.Buffer
1061	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1062		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1063	}
1064	errorBody := bytes.NewReader(errorBuffer.Bytes())
1065
1066	errorCode := "UnknownError"
1067	errorMessage := errorCode
1068
1069	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
1070	if err != nil {
1071		return err
1072	}
1073	if reqID := errorComponents.RequestID; len(reqID) != 0 {
1074		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
1075	}
1076	if len(errorComponents.Code) != 0 {
1077		errorCode = errorComponents.Code
1078	}
1079	if len(errorComponents.Message) != 0 {
1080		errorMessage = errorComponents.Message
1081	}
1082	errorBody.Seek(0, io.SeekStart)
1083	switch {
1084	case strings.EqualFold("CacheSecurityGroupAlreadyExistsFault", errorCode):
1085		return awsAwsquery_deserializeErrorCacheSecurityGroupAlreadyExistsFault(response, errorBody)
1086
1087	case strings.EqualFold("CacheSecurityGroupQuotaExceededFault", errorCode):
1088		return awsAwsquery_deserializeErrorCacheSecurityGroupQuotaExceededFault(response, errorBody)
1089
1090	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
1091		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
1092
1093	case strings.EqualFold("InvalidParameterValueException", errorCode):
1094		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
1095
1096	default:
1097		genericError := &smithy.GenericAPIError{
1098			Code:    errorCode,
1099			Message: errorMessage,
1100		}
1101		return genericError
1102
1103	}
1104}
1105
1106type awsAwsquery_deserializeOpCreateCacheSubnetGroup struct {
1107}
1108
1109func (*awsAwsquery_deserializeOpCreateCacheSubnetGroup) ID() string {
1110	return "OperationDeserializer"
1111}
1112
1113func (m *awsAwsquery_deserializeOpCreateCacheSubnetGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1114	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1115) {
1116	out, metadata, err = next.HandleDeserialize(ctx, in)
1117	if err != nil {
1118		return out, metadata, err
1119	}
1120
1121	response, ok := out.RawResponse.(*smithyhttp.Response)
1122	if !ok {
1123		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1124	}
1125
1126	if response.StatusCode < 200 || response.StatusCode >= 300 {
1127		return out, metadata, awsAwsquery_deserializeOpErrorCreateCacheSubnetGroup(response, &metadata)
1128	}
1129	output := &CreateCacheSubnetGroupOutput{}
1130	out.Result = output
1131
1132	var buff [1024]byte
1133	ringBuffer := smithyio.NewRingBuffer(buff[:])
1134	body := io.TeeReader(response.Body, ringBuffer)
1135	rootDecoder := xml.NewDecoder(body)
1136	t, err := smithyxml.FetchRootElement(rootDecoder)
1137	if err == io.EOF {
1138		return out, metadata, nil
1139	}
1140	if err != nil {
1141		var snapshot bytes.Buffer
1142		io.Copy(&snapshot, ringBuffer)
1143		return out, metadata, &smithy.DeserializationError{
1144			Err:      fmt.Errorf("failed to decode response body, %w", err),
1145			Snapshot: snapshot.Bytes(),
1146		}
1147	}
1148
1149	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1150	t, err = decoder.GetElement("CreateCacheSubnetGroupResult")
1151	if err != nil {
1152		var snapshot bytes.Buffer
1153		io.Copy(&snapshot, ringBuffer)
1154		err = &smithy.DeserializationError{
1155			Err:      fmt.Errorf("failed to decode response body, %w", err),
1156			Snapshot: snapshot.Bytes(),
1157		}
1158		return out, metadata, err
1159	}
1160
1161	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1162	err = awsAwsquery_deserializeOpDocumentCreateCacheSubnetGroupOutput(&output, decoder)
1163	if err != nil {
1164		var snapshot bytes.Buffer
1165		io.Copy(&snapshot, ringBuffer)
1166		err = &smithy.DeserializationError{
1167			Err:      fmt.Errorf("failed to decode response body, %w", err),
1168			Snapshot: snapshot.Bytes(),
1169		}
1170		return out, metadata, err
1171	}
1172
1173	return out, metadata, err
1174}
1175
1176func awsAwsquery_deserializeOpErrorCreateCacheSubnetGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1177	var errorBuffer bytes.Buffer
1178	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1179		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1180	}
1181	errorBody := bytes.NewReader(errorBuffer.Bytes())
1182
1183	errorCode := "UnknownError"
1184	errorMessage := errorCode
1185
1186	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
1187	if err != nil {
1188		return err
1189	}
1190	if reqID := errorComponents.RequestID; len(reqID) != 0 {
1191		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
1192	}
1193	if len(errorComponents.Code) != 0 {
1194		errorCode = errorComponents.Code
1195	}
1196	if len(errorComponents.Message) != 0 {
1197		errorMessage = errorComponents.Message
1198	}
1199	errorBody.Seek(0, io.SeekStart)
1200	switch {
1201	case strings.EqualFold("CacheSubnetGroupAlreadyExistsFault", errorCode):
1202		return awsAwsquery_deserializeErrorCacheSubnetGroupAlreadyExistsFault(response, errorBody)
1203
1204	case strings.EqualFold("CacheSubnetGroupQuotaExceededFault", errorCode):
1205		return awsAwsquery_deserializeErrorCacheSubnetGroupQuotaExceededFault(response, errorBody)
1206
1207	case strings.EqualFold("CacheSubnetQuotaExceededFault", errorCode):
1208		return awsAwsquery_deserializeErrorCacheSubnetQuotaExceededFault(response, errorBody)
1209
1210	case strings.EqualFold("InvalidSubnet", errorCode):
1211		return awsAwsquery_deserializeErrorInvalidSubnet(response, errorBody)
1212
1213	case strings.EqualFold("SubnetNotAllowedFault", errorCode):
1214		return awsAwsquery_deserializeErrorSubnetNotAllowedFault(response, errorBody)
1215
1216	default:
1217		genericError := &smithy.GenericAPIError{
1218			Code:    errorCode,
1219			Message: errorMessage,
1220		}
1221		return genericError
1222
1223	}
1224}
1225
1226type awsAwsquery_deserializeOpCreateGlobalReplicationGroup struct {
1227}
1228
1229func (*awsAwsquery_deserializeOpCreateGlobalReplicationGroup) ID() string {
1230	return "OperationDeserializer"
1231}
1232
1233func (m *awsAwsquery_deserializeOpCreateGlobalReplicationGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1234	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1235) {
1236	out, metadata, err = next.HandleDeserialize(ctx, in)
1237	if err != nil {
1238		return out, metadata, err
1239	}
1240
1241	response, ok := out.RawResponse.(*smithyhttp.Response)
1242	if !ok {
1243		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1244	}
1245
1246	if response.StatusCode < 200 || response.StatusCode >= 300 {
1247		return out, metadata, awsAwsquery_deserializeOpErrorCreateGlobalReplicationGroup(response, &metadata)
1248	}
1249	output := &CreateGlobalReplicationGroupOutput{}
1250	out.Result = output
1251
1252	var buff [1024]byte
1253	ringBuffer := smithyio.NewRingBuffer(buff[:])
1254	body := io.TeeReader(response.Body, ringBuffer)
1255	rootDecoder := xml.NewDecoder(body)
1256	t, err := smithyxml.FetchRootElement(rootDecoder)
1257	if err == io.EOF {
1258		return out, metadata, nil
1259	}
1260	if err != nil {
1261		var snapshot bytes.Buffer
1262		io.Copy(&snapshot, ringBuffer)
1263		return out, metadata, &smithy.DeserializationError{
1264			Err:      fmt.Errorf("failed to decode response body, %w", err),
1265			Snapshot: snapshot.Bytes(),
1266		}
1267	}
1268
1269	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1270	t, err = decoder.GetElement("CreateGlobalReplicationGroupResult")
1271	if err != nil {
1272		var snapshot bytes.Buffer
1273		io.Copy(&snapshot, ringBuffer)
1274		err = &smithy.DeserializationError{
1275			Err:      fmt.Errorf("failed to decode response body, %w", err),
1276			Snapshot: snapshot.Bytes(),
1277		}
1278		return out, metadata, err
1279	}
1280
1281	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1282	err = awsAwsquery_deserializeOpDocumentCreateGlobalReplicationGroupOutput(&output, decoder)
1283	if err != nil {
1284		var snapshot bytes.Buffer
1285		io.Copy(&snapshot, ringBuffer)
1286		err = &smithy.DeserializationError{
1287			Err:      fmt.Errorf("failed to decode response body, %w", err),
1288			Snapshot: snapshot.Bytes(),
1289		}
1290		return out, metadata, err
1291	}
1292
1293	return out, metadata, err
1294}
1295
1296func awsAwsquery_deserializeOpErrorCreateGlobalReplicationGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1297	var errorBuffer bytes.Buffer
1298	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1299		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1300	}
1301	errorBody := bytes.NewReader(errorBuffer.Bytes())
1302
1303	errorCode := "UnknownError"
1304	errorMessage := errorCode
1305
1306	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
1307	if err != nil {
1308		return err
1309	}
1310	if reqID := errorComponents.RequestID; len(reqID) != 0 {
1311		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
1312	}
1313	if len(errorComponents.Code) != 0 {
1314		errorCode = errorComponents.Code
1315	}
1316	if len(errorComponents.Message) != 0 {
1317		errorMessage = errorComponents.Message
1318	}
1319	errorBody.Seek(0, io.SeekStart)
1320	switch {
1321	case strings.EqualFold("GlobalReplicationGroupAlreadyExistsFault", errorCode):
1322		return awsAwsquery_deserializeErrorGlobalReplicationGroupAlreadyExistsFault(response, errorBody)
1323
1324	case strings.EqualFold("InvalidParameterValueException", errorCode):
1325		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
1326
1327	case strings.EqualFold("InvalidReplicationGroupStateFault", errorCode):
1328		return awsAwsquery_deserializeErrorInvalidReplicationGroupStateFault(response, errorBody)
1329
1330	case strings.EqualFold("ReplicationGroupNotFoundFault", errorCode):
1331		return awsAwsquery_deserializeErrorReplicationGroupNotFoundFault(response, errorBody)
1332
1333	case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
1334		return awsAwsquery_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
1335
1336	default:
1337		genericError := &smithy.GenericAPIError{
1338			Code:    errorCode,
1339			Message: errorMessage,
1340		}
1341		return genericError
1342
1343	}
1344}
1345
1346type awsAwsquery_deserializeOpCreateReplicationGroup struct {
1347}
1348
1349func (*awsAwsquery_deserializeOpCreateReplicationGroup) ID() string {
1350	return "OperationDeserializer"
1351}
1352
1353func (m *awsAwsquery_deserializeOpCreateReplicationGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1354	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1355) {
1356	out, metadata, err = next.HandleDeserialize(ctx, in)
1357	if err != nil {
1358		return out, metadata, err
1359	}
1360
1361	response, ok := out.RawResponse.(*smithyhttp.Response)
1362	if !ok {
1363		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1364	}
1365
1366	if response.StatusCode < 200 || response.StatusCode >= 300 {
1367		return out, metadata, awsAwsquery_deserializeOpErrorCreateReplicationGroup(response, &metadata)
1368	}
1369	output := &CreateReplicationGroupOutput{}
1370	out.Result = output
1371
1372	var buff [1024]byte
1373	ringBuffer := smithyio.NewRingBuffer(buff[:])
1374	body := io.TeeReader(response.Body, ringBuffer)
1375	rootDecoder := xml.NewDecoder(body)
1376	t, err := smithyxml.FetchRootElement(rootDecoder)
1377	if err == io.EOF {
1378		return out, metadata, nil
1379	}
1380	if err != nil {
1381		var snapshot bytes.Buffer
1382		io.Copy(&snapshot, ringBuffer)
1383		return out, metadata, &smithy.DeserializationError{
1384			Err:      fmt.Errorf("failed to decode response body, %w", err),
1385			Snapshot: snapshot.Bytes(),
1386		}
1387	}
1388
1389	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1390	t, err = decoder.GetElement("CreateReplicationGroupResult")
1391	if err != nil {
1392		var snapshot bytes.Buffer
1393		io.Copy(&snapshot, ringBuffer)
1394		err = &smithy.DeserializationError{
1395			Err:      fmt.Errorf("failed to decode response body, %w", err),
1396			Snapshot: snapshot.Bytes(),
1397		}
1398		return out, metadata, err
1399	}
1400
1401	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1402	err = awsAwsquery_deserializeOpDocumentCreateReplicationGroupOutput(&output, decoder)
1403	if err != nil {
1404		var snapshot bytes.Buffer
1405		io.Copy(&snapshot, ringBuffer)
1406		err = &smithy.DeserializationError{
1407			Err:      fmt.Errorf("failed to decode response body, %w", err),
1408			Snapshot: snapshot.Bytes(),
1409		}
1410		return out, metadata, err
1411	}
1412
1413	return out, metadata, err
1414}
1415
1416func awsAwsquery_deserializeOpErrorCreateReplicationGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1417	var errorBuffer bytes.Buffer
1418	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1419		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1420	}
1421	errorBody := bytes.NewReader(errorBuffer.Bytes())
1422
1423	errorCode := "UnknownError"
1424	errorMessage := errorCode
1425
1426	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
1427	if err != nil {
1428		return err
1429	}
1430	if reqID := errorComponents.RequestID; len(reqID) != 0 {
1431		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
1432	}
1433	if len(errorComponents.Code) != 0 {
1434		errorCode = errorComponents.Code
1435	}
1436	if len(errorComponents.Message) != 0 {
1437		errorMessage = errorComponents.Message
1438	}
1439	errorBody.Seek(0, io.SeekStart)
1440	switch {
1441	case strings.EqualFold("CacheClusterNotFoundFault", errorCode):
1442		return awsAwsquery_deserializeErrorCacheClusterNotFoundFault(response, errorBody)
1443
1444	case strings.EqualFold("CacheParameterGroupNotFoundFault", errorCode):
1445		return awsAwsquery_deserializeErrorCacheParameterGroupNotFoundFault(response, errorBody)
1446
1447	case strings.EqualFold("CacheSecurityGroupNotFoundFault", errorCode):
1448		return awsAwsquery_deserializeErrorCacheSecurityGroupNotFoundFault(response, errorBody)
1449
1450	case strings.EqualFold("CacheSubnetGroupNotFoundFault", errorCode):
1451		return awsAwsquery_deserializeErrorCacheSubnetGroupNotFoundFault(response, errorBody)
1452
1453	case strings.EqualFold("ClusterQuotaForCustomerExceededFault", errorCode):
1454		return awsAwsquery_deserializeErrorClusterQuotaForCustomerExceededFault(response, errorBody)
1455
1456	case strings.EqualFold("GlobalReplicationGroupNotFoundFault", errorCode):
1457		return awsAwsquery_deserializeErrorGlobalReplicationGroupNotFoundFault(response, errorBody)
1458
1459	case strings.EqualFold("InsufficientCacheClusterCapacityFault", errorCode):
1460		return awsAwsquery_deserializeErrorInsufficientCacheClusterCapacityFault(response, errorBody)
1461
1462	case strings.EqualFold("InvalidCacheClusterStateFault", errorCode):
1463		return awsAwsquery_deserializeErrorInvalidCacheClusterStateFault(response, errorBody)
1464
1465	case strings.EqualFold("InvalidGlobalReplicationGroupStateFault", errorCode):
1466		return awsAwsquery_deserializeErrorInvalidGlobalReplicationGroupStateFault(response, errorBody)
1467
1468	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
1469		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
1470
1471	case strings.EqualFold("InvalidParameterValueException", errorCode):
1472		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
1473
1474	case strings.EqualFold("InvalidUserGroupStateFault", errorCode):
1475		return awsAwsquery_deserializeErrorInvalidUserGroupStateFault(response, errorBody)
1476
1477	case strings.EqualFold("InvalidVPCNetworkStateFault", errorCode):
1478		return awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response, errorBody)
1479
1480	case strings.EqualFold("NodeGroupsPerReplicationGroupQuotaExceededFault", errorCode):
1481		return awsAwsquery_deserializeErrorNodeGroupsPerReplicationGroupQuotaExceededFault(response, errorBody)
1482
1483	case strings.EqualFold("NodeQuotaForClusterExceededFault", errorCode):
1484		return awsAwsquery_deserializeErrorNodeQuotaForClusterExceededFault(response, errorBody)
1485
1486	case strings.EqualFold("NodeQuotaForCustomerExceededFault", errorCode):
1487		return awsAwsquery_deserializeErrorNodeQuotaForCustomerExceededFault(response, errorBody)
1488
1489	case strings.EqualFold("ReplicationGroupAlreadyExistsFault", errorCode):
1490		return awsAwsquery_deserializeErrorReplicationGroupAlreadyExistsFault(response, errorBody)
1491
1492	case strings.EqualFold("TagQuotaPerResourceExceeded", errorCode):
1493		return awsAwsquery_deserializeErrorTagQuotaPerResourceExceeded(response, errorBody)
1494
1495	case strings.EqualFold("UserGroupNotFoundFault", errorCode):
1496		return awsAwsquery_deserializeErrorUserGroupNotFoundFault(response, errorBody)
1497
1498	default:
1499		genericError := &smithy.GenericAPIError{
1500			Code:    errorCode,
1501			Message: errorMessage,
1502		}
1503		return genericError
1504
1505	}
1506}
1507
1508type awsAwsquery_deserializeOpCreateSnapshot struct {
1509}
1510
1511func (*awsAwsquery_deserializeOpCreateSnapshot) ID() string {
1512	return "OperationDeserializer"
1513}
1514
1515func (m *awsAwsquery_deserializeOpCreateSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1516	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1517) {
1518	out, metadata, err = next.HandleDeserialize(ctx, in)
1519	if err != nil {
1520		return out, metadata, err
1521	}
1522
1523	response, ok := out.RawResponse.(*smithyhttp.Response)
1524	if !ok {
1525		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1526	}
1527
1528	if response.StatusCode < 200 || response.StatusCode >= 300 {
1529		return out, metadata, awsAwsquery_deserializeOpErrorCreateSnapshot(response, &metadata)
1530	}
1531	output := &CreateSnapshotOutput{}
1532	out.Result = output
1533
1534	var buff [1024]byte
1535	ringBuffer := smithyio.NewRingBuffer(buff[:])
1536	body := io.TeeReader(response.Body, ringBuffer)
1537	rootDecoder := xml.NewDecoder(body)
1538	t, err := smithyxml.FetchRootElement(rootDecoder)
1539	if err == io.EOF {
1540		return out, metadata, nil
1541	}
1542	if err != nil {
1543		var snapshot bytes.Buffer
1544		io.Copy(&snapshot, ringBuffer)
1545		return out, metadata, &smithy.DeserializationError{
1546			Err:      fmt.Errorf("failed to decode response body, %w", err),
1547			Snapshot: snapshot.Bytes(),
1548		}
1549	}
1550
1551	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1552	t, err = decoder.GetElement("CreateSnapshotResult")
1553	if err != nil {
1554		var snapshot bytes.Buffer
1555		io.Copy(&snapshot, ringBuffer)
1556		err = &smithy.DeserializationError{
1557			Err:      fmt.Errorf("failed to decode response body, %w", err),
1558			Snapshot: snapshot.Bytes(),
1559		}
1560		return out, metadata, err
1561	}
1562
1563	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1564	err = awsAwsquery_deserializeOpDocumentCreateSnapshotOutput(&output, decoder)
1565	if err != nil {
1566		var snapshot bytes.Buffer
1567		io.Copy(&snapshot, ringBuffer)
1568		err = &smithy.DeserializationError{
1569			Err:      fmt.Errorf("failed to decode response body, %w", err),
1570			Snapshot: snapshot.Bytes(),
1571		}
1572		return out, metadata, err
1573	}
1574
1575	return out, metadata, err
1576}
1577
1578func awsAwsquery_deserializeOpErrorCreateSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1579	var errorBuffer bytes.Buffer
1580	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1581		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1582	}
1583	errorBody := bytes.NewReader(errorBuffer.Bytes())
1584
1585	errorCode := "UnknownError"
1586	errorMessage := errorCode
1587
1588	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
1589	if err != nil {
1590		return err
1591	}
1592	if reqID := errorComponents.RequestID; len(reqID) != 0 {
1593		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
1594	}
1595	if len(errorComponents.Code) != 0 {
1596		errorCode = errorComponents.Code
1597	}
1598	if len(errorComponents.Message) != 0 {
1599		errorMessage = errorComponents.Message
1600	}
1601	errorBody.Seek(0, io.SeekStart)
1602	switch {
1603	case strings.EqualFold("CacheClusterNotFoundFault", errorCode):
1604		return awsAwsquery_deserializeErrorCacheClusterNotFoundFault(response, errorBody)
1605
1606	case strings.EqualFold("InvalidCacheClusterStateFault", errorCode):
1607		return awsAwsquery_deserializeErrorInvalidCacheClusterStateFault(response, errorBody)
1608
1609	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
1610		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
1611
1612	case strings.EqualFold("InvalidParameterValueException", errorCode):
1613		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
1614
1615	case strings.EqualFold("InvalidReplicationGroupStateFault", errorCode):
1616		return awsAwsquery_deserializeErrorInvalidReplicationGroupStateFault(response, errorBody)
1617
1618	case strings.EqualFold("ReplicationGroupNotFoundFault", errorCode):
1619		return awsAwsquery_deserializeErrorReplicationGroupNotFoundFault(response, errorBody)
1620
1621	case strings.EqualFold("SnapshotAlreadyExistsFault", errorCode):
1622		return awsAwsquery_deserializeErrorSnapshotAlreadyExistsFault(response, errorBody)
1623
1624	case strings.EqualFold("SnapshotFeatureNotSupportedFault", errorCode):
1625		return awsAwsquery_deserializeErrorSnapshotFeatureNotSupportedFault(response, errorBody)
1626
1627	case strings.EqualFold("SnapshotQuotaExceededFault", errorCode):
1628		return awsAwsquery_deserializeErrorSnapshotQuotaExceededFault(response, errorBody)
1629
1630	default:
1631		genericError := &smithy.GenericAPIError{
1632			Code:    errorCode,
1633			Message: errorMessage,
1634		}
1635		return genericError
1636
1637	}
1638}
1639
1640type awsAwsquery_deserializeOpCreateUser struct {
1641}
1642
1643func (*awsAwsquery_deserializeOpCreateUser) ID() string {
1644	return "OperationDeserializer"
1645}
1646
1647func (m *awsAwsquery_deserializeOpCreateUser) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1648	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1649) {
1650	out, metadata, err = next.HandleDeserialize(ctx, in)
1651	if err != nil {
1652		return out, metadata, err
1653	}
1654
1655	response, ok := out.RawResponse.(*smithyhttp.Response)
1656	if !ok {
1657		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1658	}
1659
1660	if response.StatusCode < 200 || response.StatusCode >= 300 {
1661		return out, metadata, awsAwsquery_deserializeOpErrorCreateUser(response, &metadata)
1662	}
1663	output := &CreateUserOutput{}
1664	out.Result = output
1665
1666	var buff [1024]byte
1667	ringBuffer := smithyio.NewRingBuffer(buff[:])
1668	body := io.TeeReader(response.Body, ringBuffer)
1669	rootDecoder := xml.NewDecoder(body)
1670	t, err := smithyxml.FetchRootElement(rootDecoder)
1671	if err == io.EOF {
1672		return out, metadata, nil
1673	}
1674	if err != nil {
1675		var snapshot bytes.Buffer
1676		io.Copy(&snapshot, ringBuffer)
1677		return out, metadata, &smithy.DeserializationError{
1678			Err:      fmt.Errorf("failed to decode response body, %w", err),
1679			Snapshot: snapshot.Bytes(),
1680		}
1681	}
1682
1683	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1684	t, err = decoder.GetElement("CreateUserResult")
1685	if err != nil {
1686		var snapshot bytes.Buffer
1687		io.Copy(&snapshot, ringBuffer)
1688		err = &smithy.DeserializationError{
1689			Err:      fmt.Errorf("failed to decode response body, %w", err),
1690			Snapshot: snapshot.Bytes(),
1691		}
1692		return out, metadata, err
1693	}
1694
1695	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1696	err = awsAwsquery_deserializeOpDocumentCreateUserOutput(&output, decoder)
1697	if err != nil {
1698		var snapshot bytes.Buffer
1699		io.Copy(&snapshot, ringBuffer)
1700		err = &smithy.DeserializationError{
1701			Err:      fmt.Errorf("failed to decode response body, %w", err),
1702			Snapshot: snapshot.Bytes(),
1703		}
1704		return out, metadata, err
1705	}
1706
1707	return out, metadata, err
1708}
1709
1710func awsAwsquery_deserializeOpErrorCreateUser(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1711	var errorBuffer bytes.Buffer
1712	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1713		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1714	}
1715	errorBody := bytes.NewReader(errorBuffer.Bytes())
1716
1717	errorCode := "UnknownError"
1718	errorMessage := errorCode
1719
1720	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
1721	if err != nil {
1722		return err
1723	}
1724	if reqID := errorComponents.RequestID; len(reqID) != 0 {
1725		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
1726	}
1727	if len(errorComponents.Code) != 0 {
1728		errorCode = errorComponents.Code
1729	}
1730	if len(errorComponents.Message) != 0 {
1731		errorMessage = errorComponents.Message
1732	}
1733	errorBody.Seek(0, io.SeekStart)
1734	switch {
1735	case strings.EqualFold("DuplicateUserNameFault", errorCode):
1736		return awsAwsquery_deserializeErrorDuplicateUserNameFault(response, errorBody)
1737
1738	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
1739		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
1740
1741	case strings.EqualFold("InvalidParameterValueException", errorCode):
1742		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
1743
1744	case strings.EqualFold("UserAlreadyExistsFault", errorCode):
1745		return awsAwsquery_deserializeErrorUserAlreadyExistsFault(response, errorBody)
1746
1747	case strings.EqualFold("UserQuotaExceededFault", errorCode):
1748		return awsAwsquery_deserializeErrorUserQuotaExceededFault(response, errorBody)
1749
1750	default:
1751		genericError := &smithy.GenericAPIError{
1752			Code:    errorCode,
1753			Message: errorMessage,
1754		}
1755		return genericError
1756
1757	}
1758}
1759
1760type awsAwsquery_deserializeOpCreateUserGroup struct {
1761}
1762
1763func (*awsAwsquery_deserializeOpCreateUserGroup) ID() string {
1764	return "OperationDeserializer"
1765}
1766
1767func (m *awsAwsquery_deserializeOpCreateUserGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1768	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1769) {
1770	out, metadata, err = next.HandleDeserialize(ctx, in)
1771	if err != nil {
1772		return out, metadata, err
1773	}
1774
1775	response, ok := out.RawResponse.(*smithyhttp.Response)
1776	if !ok {
1777		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1778	}
1779
1780	if response.StatusCode < 200 || response.StatusCode >= 300 {
1781		return out, metadata, awsAwsquery_deserializeOpErrorCreateUserGroup(response, &metadata)
1782	}
1783	output := &CreateUserGroupOutput{}
1784	out.Result = output
1785
1786	var buff [1024]byte
1787	ringBuffer := smithyio.NewRingBuffer(buff[:])
1788	body := io.TeeReader(response.Body, ringBuffer)
1789	rootDecoder := xml.NewDecoder(body)
1790	t, err := smithyxml.FetchRootElement(rootDecoder)
1791	if err == io.EOF {
1792		return out, metadata, nil
1793	}
1794	if err != nil {
1795		var snapshot bytes.Buffer
1796		io.Copy(&snapshot, ringBuffer)
1797		return out, metadata, &smithy.DeserializationError{
1798			Err:      fmt.Errorf("failed to decode response body, %w", err),
1799			Snapshot: snapshot.Bytes(),
1800		}
1801	}
1802
1803	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1804	t, err = decoder.GetElement("CreateUserGroupResult")
1805	if err != nil {
1806		var snapshot bytes.Buffer
1807		io.Copy(&snapshot, ringBuffer)
1808		err = &smithy.DeserializationError{
1809			Err:      fmt.Errorf("failed to decode response body, %w", err),
1810			Snapshot: snapshot.Bytes(),
1811		}
1812		return out, metadata, err
1813	}
1814
1815	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1816	err = awsAwsquery_deserializeOpDocumentCreateUserGroupOutput(&output, decoder)
1817	if err != nil {
1818		var snapshot bytes.Buffer
1819		io.Copy(&snapshot, ringBuffer)
1820		err = &smithy.DeserializationError{
1821			Err:      fmt.Errorf("failed to decode response body, %w", err),
1822			Snapshot: snapshot.Bytes(),
1823		}
1824		return out, metadata, err
1825	}
1826
1827	return out, metadata, err
1828}
1829
1830func awsAwsquery_deserializeOpErrorCreateUserGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1831	var errorBuffer bytes.Buffer
1832	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1833		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1834	}
1835	errorBody := bytes.NewReader(errorBuffer.Bytes())
1836
1837	errorCode := "UnknownError"
1838	errorMessage := errorCode
1839
1840	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
1841	if err != nil {
1842		return err
1843	}
1844	if reqID := errorComponents.RequestID; len(reqID) != 0 {
1845		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
1846	}
1847	if len(errorComponents.Code) != 0 {
1848		errorCode = errorComponents.Code
1849	}
1850	if len(errorComponents.Message) != 0 {
1851		errorMessage = errorComponents.Message
1852	}
1853	errorBody.Seek(0, io.SeekStart)
1854	switch {
1855	case strings.EqualFold("DefaultUserRequired", errorCode):
1856		return awsAwsquery_deserializeErrorDefaultUserRequired(response, errorBody)
1857
1858	case strings.EqualFold("DuplicateUserNameFault", errorCode):
1859		return awsAwsquery_deserializeErrorDuplicateUserNameFault(response, errorBody)
1860
1861	case strings.EqualFold("InvalidParameterValueException", errorCode):
1862		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
1863
1864	case strings.EqualFold("UserGroupAlreadyExistsFault", errorCode):
1865		return awsAwsquery_deserializeErrorUserGroupAlreadyExistsFault(response, errorBody)
1866
1867	case strings.EqualFold("UserGroupQuotaExceededFault", errorCode):
1868		return awsAwsquery_deserializeErrorUserGroupQuotaExceededFault(response, errorBody)
1869
1870	case strings.EqualFold("UserNotFoundFault", errorCode):
1871		return awsAwsquery_deserializeErrorUserNotFoundFault(response, errorBody)
1872
1873	default:
1874		genericError := &smithy.GenericAPIError{
1875			Code:    errorCode,
1876			Message: errorMessage,
1877		}
1878		return genericError
1879
1880	}
1881}
1882
1883type awsAwsquery_deserializeOpDecreaseNodeGroupsInGlobalReplicationGroup struct {
1884}
1885
1886func (*awsAwsquery_deserializeOpDecreaseNodeGroupsInGlobalReplicationGroup) ID() string {
1887	return "OperationDeserializer"
1888}
1889
1890func (m *awsAwsquery_deserializeOpDecreaseNodeGroupsInGlobalReplicationGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1891	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1892) {
1893	out, metadata, err = next.HandleDeserialize(ctx, in)
1894	if err != nil {
1895		return out, metadata, err
1896	}
1897
1898	response, ok := out.RawResponse.(*smithyhttp.Response)
1899	if !ok {
1900		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1901	}
1902
1903	if response.StatusCode < 200 || response.StatusCode >= 300 {
1904		return out, metadata, awsAwsquery_deserializeOpErrorDecreaseNodeGroupsInGlobalReplicationGroup(response, &metadata)
1905	}
1906	output := &DecreaseNodeGroupsInGlobalReplicationGroupOutput{}
1907	out.Result = output
1908
1909	var buff [1024]byte
1910	ringBuffer := smithyio.NewRingBuffer(buff[:])
1911	body := io.TeeReader(response.Body, ringBuffer)
1912	rootDecoder := xml.NewDecoder(body)
1913	t, err := smithyxml.FetchRootElement(rootDecoder)
1914	if err == io.EOF {
1915		return out, metadata, nil
1916	}
1917	if err != nil {
1918		var snapshot bytes.Buffer
1919		io.Copy(&snapshot, ringBuffer)
1920		return out, metadata, &smithy.DeserializationError{
1921			Err:      fmt.Errorf("failed to decode response body, %w", err),
1922			Snapshot: snapshot.Bytes(),
1923		}
1924	}
1925
1926	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1927	t, err = decoder.GetElement("DecreaseNodeGroupsInGlobalReplicationGroupResult")
1928	if err != nil {
1929		var snapshot bytes.Buffer
1930		io.Copy(&snapshot, ringBuffer)
1931		err = &smithy.DeserializationError{
1932			Err:      fmt.Errorf("failed to decode response body, %w", err),
1933			Snapshot: snapshot.Bytes(),
1934		}
1935		return out, metadata, err
1936	}
1937
1938	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1939	err = awsAwsquery_deserializeOpDocumentDecreaseNodeGroupsInGlobalReplicationGroupOutput(&output, decoder)
1940	if err != nil {
1941		var snapshot bytes.Buffer
1942		io.Copy(&snapshot, ringBuffer)
1943		err = &smithy.DeserializationError{
1944			Err:      fmt.Errorf("failed to decode response body, %w", err),
1945			Snapshot: snapshot.Bytes(),
1946		}
1947		return out, metadata, err
1948	}
1949
1950	return out, metadata, err
1951}
1952
1953func awsAwsquery_deserializeOpErrorDecreaseNodeGroupsInGlobalReplicationGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1954	var errorBuffer bytes.Buffer
1955	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1956		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1957	}
1958	errorBody := bytes.NewReader(errorBuffer.Bytes())
1959
1960	errorCode := "UnknownError"
1961	errorMessage := errorCode
1962
1963	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
1964	if err != nil {
1965		return err
1966	}
1967	if reqID := errorComponents.RequestID; len(reqID) != 0 {
1968		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
1969	}
1970	if len(errorComponents.Code) != 0 {
1971		errorCode = errorComponents.Code
1972	}
1973	if len(errorComponents.Message) != 0 {
1974		errorMessage = errorComponents.Message
1975	}
1976	errorBody.Seek(0, io.SeekStart)
1977	switch {
1978	case strings.EqualFold("GlobalReplicationGroupNotFoundFault", errorCode):
1979		return awsAwsquery_deserializeErrorGlobalReplicationGroupNotFoundFault(response, errorBody)
1980
1981	case strings.EqualFold("InvalidGlobalReplicationGroupStateFault", errorCode):
1982		return awsAwsquery_deserializeErrorInvalidGlobalReplicationGroupStateFault(response, errorBody)
1983
1984	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
1985		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
1986
1987	case strings.EqualFold("InvalidParameterValueException", errorCode):
1988		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
1989
1990	default:
1991		genericError := &smithy.GenericAPIError{
1992			Code:    errorCode,
1993			Message: errorMessage,
1994		}
1995		return genericError
1996
1997	}
1998}
1999
2000type awsAwsquery_deserializeOpDecreaseReplicaCount struct {
2001}
2002
2003func (*awsAwsquery_deserializeOpDecreaseReplicaCount) ID() string {
2004	return "OperationDeserializer"
2005}
2006
2007func (m *awsAwsquery_deserializeOpDecreaseReplicaCount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2008	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2009) {
2010	out, metadata, err = next.HandleDeserialize(ctx, in)
2011	if err != nil {
2012		return out, metadata, err
2013	}
2014
2015	response, ok := out.RawResponse.(*smithyhttp.Response)
2016	if !ok {
2017		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2018	}
2019
2020	if response.StatusCode < 200 || response.StatusCode >= 300 {
2021		return out, metadata, awsAwsquery_deserializeOpErrorDecreaseReplicaCount(response, &metadata)
2022	}
2023	output := &DecreaseReplicaCountOutput{}
2024	out.Result = output
2025
2026	var buff [1024]byte
2027	ringBuffer := smithyio.NewRingBuffer(buff[:])
2028	body := io.TeeReader(response.Body, ringBuffer)
2029	rootDecoder := xml.NewDecoder(body)
2030	t, err := smithyxml.FetchRootElement(rootDecoder)
2031	if err == io.EOF {
2032		return out, metadata, nil
2033	}
2034	if err != nil {
2035		var snapshot bytes.Buffer
2036		io.Copy(&snapshot, ringBuffer)
2037		return out, metadata, &smithy.DeserializationError{
2038			Err:      fmt.Errorf("failed to decode response body, %w", err),
2039			Snapshot: snapshot.Bytes(),
2040		}
2041	}
2042
2043	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
2044	t, err = decoder.GetElement("DecreaseReplicaCountResult")
2045	if err != nil {
2046		var snapshot bytes.Buffer
2047		io.Copy(&snapshot, ringBuffer)
2048		err = &smithy.DeserializationError{
2049			Err:      fmt.Errorf("failed to decode response body, %w", err),
2050			Snapshot: snapshot.Bytes(),
2051		}
2052		return out, metadata, err
2053	}
2054
2055	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
2056	err = awsAwsquery_deserializeOpDocumentDecreaseReplicaCountOutput(&output, decoder)
2057	if err != nil {
2058		var snapshot bytes.Buffer
2059		io.Copy(&snapshot, ringBuffer)
2060		err = &smithy.DeserializationError{
2061			Err:      fmt.Errorf("failed to decode response body, %w", err),
2062			Snapshot: snapshot.Bytes(),
2063		}
2064		return out, metadata, err
2065	}
2066
2067	return out, metadata, err
2068}
2069
2070func awsAwsquery_deserializeOpErrorDecreaseReplicaCount(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2071	var errorBuffer bytes.Buffer
2072	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2073		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2074	}
2075	errorBody := bytes.NewReader(errorBuffer.Bytes())
2076
2077	errorCode := "UnknownError"
2078	errorMessage := errorCode
2079
2080	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
2081	if err != nil {
2082		return err
2083	}
2084	if reqID := errorComponents.RequestID; len(reqID) != 0 {
2085		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
2086	}
2087	if len(errorComponents.Code) != 0 {
2088		errorCode = errorComponents.Code
2089	}
2090	if len(errorComponents.Message) != 0 {
2091		errorMessage = errorComponents.Message
2092	}
2093	errorBody.Seek(0, io.SeekStart)
2094	switch {
2095	case strings.EqualFold("ClusterQuotaForCustomerExceededFault", errorCode):
2096		return awsAwsquery_deserializeErrorClusterQuotaForCustomerExceededFault(response, errorBody)
2097
2098	case strings.EqualFold("InsufficientCacheClusterCapacityFault", errorCode):
2099		return awsAwsquery_deserializeErrorInsufficientCacheClusterCapacityFault(response, errorBody)
2100
2101	case strings.EqualFold("InvalidCacheClusterStateFault", errorCode):
2102		return awsAwsquery_deserializeErrorInvalidCacheClusterStateFault(response, errorBody)
2103
2104	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
2105		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
2106
2107	case strings.EqualFold("InvalidParameterValueException", errorCode):
2108		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
2109
2110	case strings.EqualFold("InvalidReplicationGroupStateFault", errorCode):
2111		return awsAwsquery_deserializeErrorInvalidReplicationGroupStateFault(response, errorBody)
2112
2113	case strings.EqualFold("InvalidVPCNetworkStateFault", errorCode):
2114		return awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response, errorBody)
2115
2116	case strings.EqualFold("NodeGroupsPerReplicationGroupQuotaExceededFault", errorCode):
2117		return awsAwsquery_deserializeErrorNodeGroupsPerReplicationGroupQuotaExceededFault(response, errorBody)
2118
2119	case strings.EqualFold("NodeQuotaForCustomerExceededFault", errorCode):
2120		return awsAwsquery_deserializeErrorNodeQuotaForCustomerExceededFault(response, errorBody)
2121
2122	case strings.EqualFold("NoOperationFault", errorCode):
2123		return awsAwsquery_deserializeErrorNoOperationFault(response, errorBody)
2124
2125	case strings.EqualFold("ReplicationGroupNotFoundFault", errorCode):
2126		return awsAwsquery_deserializeErrorReplicationGroupNotFoundFault(response, errorBody)
2127
2128	case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
2129		return awsAwsquery_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
2130
2131	default:
2132		genericError := &smithy.GenericAPIError{
2133			Code:    errorCode,
2134			Message: errorMessage,
2135		}
2136		return genericError
2137
2138	}
2139}
2140
2141type awsAwsquery_deserializeOpDeleteCacheCluster struct {
2142}
2143
2144func (*awsAwsquery_deserializeOpDeleteCacheCluster) ID() string {
2145	return "OperationDeserializer"
2146}
2147
2148func (m *awsAwsquery_deserializeOpDeleteCacheCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2149	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2150) {
2151	out, metadata, err = next.HandleDeserialize(ctx, in)
2152	if err != nil {
2153		return out, metadata, err
2154	}
2155
2156	response, ok := out.RawResponse.(*smithyhttp.Response)
2157	if !ok {
2158		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2159	}
2160
2161	if response.StatusCode < 200 || response.StatusCode >= 300 {
2162		return out, metadata, awsAwsquery_deserializeOpErrorDeleteCacheCluster(response, &metadata)
2163	}
2164	output := &DeleteCacheClusterOutput{}
2165	out.Result = output
2166
2167	var buff [1024]byte
2168	ringBuffer := smithyio.NewRingBuffer(buff[:])
2169	body := io.TeeReader(response.Body, ringBuffer)
2170	rootDecoder := xml.NewDecoder(body)
2171	t, err := smithyxml.FetchRootElement(rootDecoder)
2172	if err == io.EOF {
2173		return out, metadata, nil
2174	}
2175	if err != nil {
2176		var snapshot bytes.Buffer
2177		io.Copy(&snapshot, ringBuffer)
2178		return out, metadata, &smithy.DeserializationError{
2179			Err:      fmt.Errorf("failed to decode response body, %w", err),
2180			Snapshot: snapshot.Bytes(),
2181		}
2182	}
2183
2184	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
2185	t, err = decoder.GetElement("DeleteCacheClusterResult")
2186	if err != nil {
2187		var snapshot bytes.Buffer
2188		io.Copy(&snapshot, ringBuffer)
2189		err = &smithy.DeserializationError{
2190			Err:      fmt.Errorf("failed to decode response body, %w", err),
2191			Snapshot: snapshot.Bytes(),
2192		}
2193		return out, metadata, err
2194	}
2195
2196	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
2197	err = awsAwsquery_deserializeOpDocumentDeleteCacheClusterOutput(&output, decoder)
2198	if err != nil {
2199		var snapshot bytes.Buffer
2200		io.Copy(&snapshot, ringBuffer)
2201		err = &smithy.DeserializationError{
2202			Err:      fmt.Errorf("failed to decode response body, %w", err),
2203			Snapshot: snapshot.Bytes(),
2204		}
2205		return out, metadata, err
2206	}
2207
2208	return out, metadata, err
2209}
2210
2211func awsAwsquery_deserializeOpErrorDeleteCacheCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2212	var errorBuffer bytes.Buffer
2213	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2214		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2215	}
2216	errorBody := bytes.NewReader(errorBuffer.Bytes())
2217
2218	errorCode := "UnknownError"
2219	errorMessage := errorCode
2220
2221	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
2222	if err != nil {
2223		return err
2224	}
2225	if reqID := errorComponents.RequestID; len(reqID) != 0 {
2226		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
2227	}
2228	if len(errorComponents.Code) != 0 {
2229		errorCode = errorComponents.Code
2230	}
2231	if len(errorComponents.Message) != 0 {
2232		errorMessage = errorComponents.Message
2233	}
2234	errorBody.Seek(0, io.SeekStart)
2235	switch {
2236	case strings.EqualFold("CacheClusterNotFoundFault", errorCode):
2237		return awsAwsquery_deserializeErrorCacheClusterNotFoundFault(response, errorBody)
2238
2239	case strings.EqualFold("InvalidCacheClusterStateFault", errorCode):
2240		return awsAwsquery_deserializeErrorInvalidCacheClusterStateFault(response, errorBody)
2241
2242	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
2243		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
2244
2245	case strings.EqualFold("InvalidParameterValueException", errorCode):
2246		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
2247
2248	case strings.EqualFold("SnapshotAlreadyExistsFault", errorCode):
2249		return awsAwsquery_deserializeErrorSnapshotAlreadyExistsFault(response, errorBody)
2250
2251	case strings.EqualFold("SnapshotFeatureNotSupportedFault", errorCode):
2252		return awsAwsquery_deserializeErrorSnapshotFeatureNotSupportedFault(response, errorBody)
2253
2254	case strings.EqualFold("SnapshotQuotaExceededFault", errorCode):
2255		return awsAwsquery_deserializeErrorSnapshotQuotaExceededFault(response, errorBody)
2256
2257	default:
2258		genericError := &smithy.GenericAPIError{
2259			Code:    errorCode,
2260			Message: errorMessage,
2261		}
2262		return genericError
2263
2264	}
2265}
2266
2267type awsAwsquery_deserializeOpDeleteCacheParameterGroup struct {
2268}
2269
2270func (*awsAwsquery_deserializeOpDeleteCacheParameterGroup) ID() string {
2271	return "OperationDeserializer"
2272}
2273
2274func (m *awsAwsquery_deserializeOpDeleteCacheParameterGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2275	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2276) {
2277	out, metadata, err = next.HandleDeserialize(ctx, in)
2278	if err != nil {
2279		return out, metadata, err
2280	}
2281
2282	response, ok := out.RawResponse.(*smithyhttp.Response)
2283	if !ok {
2284		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2285	}
2286
2287	if response.StatusCode < 200 || response.StatusCode >= 300 {
2288		return out, metadata, awsAwsquery_deserializeOpErrorDeleteCacheParameterGroup(response, &metadata)
2289	}
2290	output := &DeleteCacheParameterGroupOutput{}
2291	out.Result = output
2292
2293	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
2294		return out, metadata, &smithy.DeserializationError{
2295			Err: fmt.Errorf("failed to discard response body, %w", err),
2296		}
2297	}
2298
2299	return out, metadata, err
2300}
2301
2302func awsAwsquery_deserializeOpErrorDeleteCacheParameterGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2303	var errorBuffer bytes.Buffer
2304	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2305		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2306	}
2307	errorBody := bytes.NewReader(errorBuffer.Bytes())
2308
2309	errorCode := "UnknownError"
2310	errorMessage := errorCode
2311
2312	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
2313	if err != nil {
2314		return err
2315	}
2316	if reqID := errorComponents.RequestID; len(reqID) != 0 {
2317		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
2318	}
2319	if len(errorComponents.Code) != 0 {
2320		errorCode = errorComponents.Code
2321	}
2322	if len(errorComponents.Message) != 0 {
2323		errorMessage = errorComponents.Message
2324	}
2325	errorBody.Seek(0, io.SeekStart)
2326	switch {
2327	case strings.EqualFold("CacheParameterGroupNotFoundFault", errorCode):
2328		return awsAwsquery_deserializeErrorCacheParameterGroupNotFoundFault(response, errorBody)
2329
2330	case strings.EqualFold("InvalidCacheParameterGroupStateFault", errorCode):
2331		return awsAwsquery_deserializeErrorInvalidCacheParameterGroupStateFault(response, errorBody)
2332
2333	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
2334		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
2335
2336	case strings.EqualFold("InvalidParameterValueException", errorCode):
2337		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
2338
2339	default:
2340		genericError := &smithy.GenericAPIError{
2341			Code:    errorCode,
2342			Message: errorMessage,
2343		}
2344		return genericError
2345
2346	}
2347}
2348
2349type awsAwsquery_deserializeOpDeleteCacheSecurityGroup struct {
2350}
2351
2352func (*awsAwsquery_deserializeOpDeleteCacheSecurityGroup) ID() string {
2353	return "OperationDeserializer"
2354}
2355
2356func (m *awsAwsquery_deserializeOpDeleteCacheSecurityGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2357	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2358) {
2359	out, metadata, err = next.HandleDeserialize(ctx, in)
2360	if err != nil {
2361		return out, metadata, err
2362	}
2363
2364	response, ok := out.RawResponse.(*smithyhttp.Response)
2365	if !ok {
2366		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2367	}
2368
2369	if response.StatusCode < 200 || response.StatusCode >= 300 {
2370		return out, metadata, awsAwsquery_deserializeOpErrorDeleteCacheSecurityGroup(response, &metadata)
2371	}
2372	output := &DeleteCacheSecurityGroupOutput{}
2373	out.Result = output
2374
2375	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
2376		return out, metadata, &smithy.DeserializationError{
2377			Err: fmt.Errorf("failed to discard response body, %w", err),
2378		}
2379	}
2380
2381	return out, metadata, err
2382}
2383
2384func awsAwsquery_deserializeOpErrorDeleteCacheSecurityGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2385	var errorBuffer bytes.Buffer
2386	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2387		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2388	}
2389	errorBody := bytes.NewReader(errorBuffer.Bytes())
2390
2391	errorCode := "UnknownError"
2392	errorMessage := errorCode
2393
2394	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
2395	if err != nil {
2396		return err
2397	}
2398	if reqID := errorComponents.RequestID; len(reqID) != 0 {
2399		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
2400	}
2401	if len(errorComponents.Code) != 0 {
2402		errorCode = errorComponents.Code
2403	}
2404	if len(errorComponents.Message) != 0 {
2405		errorMessage = errorComponents.Message
2406	}
2407	errorBody.Seek(0, io.SeekStart)
2408	switch {
2409	case strings.EqualFold("CacheSecurityGroupNotFoundFault", errorCode):
2410		return awsAwsquery_deserializeErrorCacheSecurityGroupNotFoundFault(response, errorBody)
2411
2412	case strings.EqualFold("InvalidCacheSecurityGroupStateFault", errorCode):
2413		return awsAwsquery_deserializeErrorInvalidCacheSecurityGroupStateFault(response, errorBody)
2414
2415	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
2416		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
2417
2418	case strings.EqualFold("InvalidParameterValueException", errorCode):
2419		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
2420
2421	default:
2422		genericError := &smithy.GenericAPIError{
2423			Code:    errorCode,
2424			Message: errorMessage,
2425		}
2426		return genericError
2427
2428	}
2429}
2430
2431type awsAwsquery_deserializeOpDeleteCacheSubnetGroup struct {
2432}
2433
2434func (*awsAwsquery_deserializeOpDeleteCacheSubnetGroup) ID() string {
2435	return "OperationDeserializer"
2436}
2437
2438func (m *awsAwsquery_deserializeOpDeleteCacheSubnetGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2439	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2440) {
2441	out, metadata, err = next.HandleDeserialize(ctx, in)
2442	if err != nil {
2443		return out, metadata, err
2444	}
2445
2446	response, ok := out.RawResponse.(*smithyhttp.Response)
2447	if !ok {
2448		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2449	}
2450
2451	if response.StatusCode < 200 || response.StatusCode >= 300 {
2452		return out, metadata, awsAwsquery_deserializeOpErrorDeleteCacheSubnetGroup(response, &metadata)
2453	}
2454	output := &DeleteCacheSubnetGroupOutput{}
2455	out.Result = output
2456
2457	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
2458		return out, metadata, &smithy.DeserializationError{
2459			Err: fmt.Errorf("failed to discard response body, %w", err),
2460		}
2461	}
2462
2463	return out, metadata, err
2464}
2465
2466func awsAwsquery_deserializeOpErrorDeleteCacheSubnetGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2467	var errorBuffer bytes.Buffer
2468	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2469		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2470	}
2471	errorBody := bytes.NewReader(errorBuffer.Bytes())
2472
2473	errorCode := "UnknownError"
2474	errorMessage := errorCode
2475
2476	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
2477	if err != nil {
2478		return err
2479	}
2480	if reqID := errorComponents.RequestID; len(reqID) != 0 {
2481		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
2482	}
2483	if len(errorComponents.Code) != 0 {
2484		errorCode = errorComponents.Code
2485	}
2486	if len(errorComponents.Message) != 0 {
2487		errorMessage = errorComponents.Message
2488	}
2489	errorBody.Seek(0, io.SeekStart)
2490	switch {
2491	case strings.EqualFold("CacheSubnetGroupInUse", errorCode):
2492		return awsAwsquery_deserializeErrorCacheSubnetGroupInUse(response, errorBody)
2493
2494	case strings.EqualFold("CacheSubnetGroupNotFoundFault", errorCode):
2495		return awsAwsquery_deserializeErrorCacheSubnetGroupNotFoundFault(response, errorBody)
2496
2497	default:
2498		genericError := &smithy.GenericAPIError{
2499			Code:    errorCode,
2500			Message: errorMessage,
2501		}
2502		return genericError
2503
2504	}
2505}
2506
2507type awsAwsquery_deserializeOpDeleteGlobalReplicationGroup struct {
2508}
2509
2510func (*awsAwsquery_deserializeOpDeleteGlobalReplicationGroup) ID() string {
2511	return "OperationDeserializer"
2512}
2513
2514func (m *awsAwsquery_deserializeOpDeleteGlobalReplicationGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2515	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2516) {
2517	out, metadata, err = next.HandleDeserialize(ctx, in)
2518	if err != nil {
2519		return out, metadata, err
2520	}
2521
2522	response, ok := out.RawResponse.(*smithyhttp.Response)
2523	if !ok {
2524		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2525	}
2526
2527	if response.StatusCode < 200 || response.StatusCode >= 300 {
2528		return out, metadata, awsAwsquery_deserializeOpErrorDeleteGlobalReplicationGroup(response, &metadata)
2529	}
2530	output := &DeleteGlobalReplicationGroupOutput{}
2531	out.Result = output
2532
2533	var buff [1024]byte
2534	ringBuffer := smithyio.NewRingBuffer(buff[:])
2535	body := io.TeeReader(response.Body, ringBuffer)
2536	rootDecoder := xml.NewDecoder(body)
2537	t, err := smithyxml.FetchRootElement(rootDecoder)
2538	if err == io.EOF {
2539		return out, metadata, nil
2540	}
2541	if err != nil {
2542		var snapshot bytes.Buffer
2543		io.Copy(&snapshot, ringBuffer)
2544		return out, metadata, &smithy.DeserializationError{
2545			Err:      fmt.Errorf("failed to decode response body, %w", err),
2546			Snapshot: snapshot.Bytes(),
2547		}
2548	}
2549
2550	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
2551	t, err = decoder.GetElement("DeleteGlobalReplicationGroupResult")
2552	if err != nil {
2553		var snapshot bytes.Buffer
2554		io.Copy(&snapshot, ringBuffer)
2555		err = &smithy.DeserializationError{
2556			Err:      fmt.Errorf("failed to decode response body, %w", err),
2557			Snapshot: snapshot.Bytes(),
2558		}
2559		return out, metadata, err
2560	}
2561
2562	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
2563	err = awsAwsquery_deserializeOpDocumentDeleteGlobalReplicationGroupOutput(&output, decoder)
2564	if err != nil {
2565		var snapshot bytes.Buffer
2566		io.Copy(&snapshot, ringBuffer)
2567		err = &smithy.DeserializationError{
2568			Err:      fmt.Errorf("failed to decode response body, %w", err),
2569			Snapshot: snapshot.Bytes(),
2570		}
2571		return out, metadata, err
2572	}
2573
2574	return out, metadata, err
2575}
2576
2577func awsAwsquery_deserializeOpErrorDeleteGlobalReplicationGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2578	var errorBuffer bytes.Buffer
2579	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2580		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2581	}
2582	errorBody := bytes.NewReader(errorBuffer.Bytes())
2583
2584	errorCode := "UnknownError"
2585	errorMessage := errorCode
2586
2587	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
2588	if err != nil {
2589		return err
2590	}
2591	if reqID := errorComponents.RequestID; len(reqID) != 0 {
2592		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
2593	}
2594	if len(errorComponents.Code) != 0 {
2595		errorCode = errorComponents.Code
2596	}
2597	if len(errorComponents.Message) != 0 {
2598		errorMessage = errorComponents.Message
2599	}
2600	errorBody.Seek(0, io.SeekStart)
2601	switch {
2602	case strings.EqualFold("GlobalReplicationGroupNotFoundFault", errorCode):
2603		return awsAwsquery_deserializeErrorGlobalReplicationGroupNotFoundFault(response, errorBody)
2604
2605	case strings.EqualFold("InvalidGlobalReplicationGroupStateFault", errorCode):
2606		return awsAwsquery_deserializeErrorInvalidGlobalReplicationGroupStateFault(response, errorBody)
2607
2608	case strings.EqualFold("InvalidParameterValueException", errorCode):
2609		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
2610
2611	default:
2612		genericError := &smithy.GenericAPIError{
2613			Code:    errorCode,
2614			Message: errorMessage,
2615		}
2616		return genericError
2617
2618	}
2619}
2620
2621type awsAwsquery_deserializeOpDeleteReplicationGroup struct {
2622}
2623
2624func (*awsAwsquery_deserializeOpDeleteReplicationGroup) ID() string {
2625	return "OperationDeserializer"
2626}
2627
2628func (m *awsAwsquery_deserializeOpDeleteReplicationGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2629	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2630) {
2631	out, metadata, err = next.HandleDeserialize(ctx, in)
2632	if err != nil {
2633		return out, metadata, err
2634	}
2635
2636	response, ok := out.RawResponse.(*smithyhttp.Response)
2637	if !ok {
2638		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2639	}
2640
2641	if response.StatusCode < 200 || response.StatusCode >= 300 {
2642		return out, metadata, awsAwsquery_deserializeOpErrorDeleteReplicationGroup(response, &metadata)
2643	}
2644	output := &DeleteReplicationGroupOutput{}
2645	out.Result = output
2646
2647	var buff [1024]byte
2648	ringBuffer := smithyio.NewRingBuffer(buff[:])
2649	body := io.TeeReader(response.Body, ringBuffer)
2650	rootDecoder := xml.NewDecoder(body)
2651	t, err := smithyxml.FetchRootElement(rootDecoder)
2652	if err == io.EOF {
2653		return out, metadata, nil
2654	}
2655	if err != nil {
2656		var snapshot bytes.Buffer
2657		io.Copy(&snapshot, ringBuffer)
2658		return out, metadata, &smithy.DeserializationError{
2659			Err:      fmt.Errorf("failed to decode response body, %w", err),
2660			Snapshot: snapshot.Bytes(),
2661		}
2662	}
2663
2664	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
2665	t, err = decoder.GetElement("DeleteReplicationGroupResult")
2666	if err != nil {
2667		var snapshot bytes.Buffer
2668		io.Copy(&snapshot, ringBuffer)
2669		err = &smithy.DeserializationError{
2670			Err:      fmt.Errorf("failed to decode response body, %w", err),
2671			Snapshot: snapshot.Bytes(),
2672		}
2673		return out, metadata, err
2674	}
2675
2676	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
2677	err = awsAwsquery_deserializeOpDocumentDeleteReplicationGroupOutput(&output, decoder)
2678	if err != nil {
2679		var snapshot bytes.Buffer
2680		io.Copy(&snapshot, ringBuffer)
2681		err = &smithy.DeserializationError{
2682			Err:      fmt.Errorf("failed to decode response body, %w", err),
2683			Snapshot: snapshot.Bytes(),
2684		}
2685		return out, metadata, err
2686	}
2687
2688	return out, metadata, err
2689}
2690
2691func awsAwsquery_deserializeOpErrorDeleteReplicationGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2692	var errorBuffer bytes.Buffer
2693	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2694		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2695	}
2696	errorBody := bytes.NewReader(errorBuffer.Bytes())
2697
2698	errorCode := "UnknownError"
2699	errorMessage := errorCode
2700
2701	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
2702	if err != nil {
2703		return err
2704	}
2705	if reqID := errorComponents.RequestID; len(reqID) != 0 {
2706		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
2707	}
2708	if len(errorComponents.Code) != 0 {
2709		errorCode = errorComponents.Code
2710	}
2711	if len(errorComponents.Message) != 0 {
2712		errorMessage = errorComponents.Message
2713	}
2714	errorBody.Seek(0, io.SeekStart)
2715	switch {
2716	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
2717		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
2718
2719	case strings.EqualFold("InvalidParameterValueException", errorCode):
2720		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
2721
2722	case strings.EqualFold("InvalidReplicationGroupStateFault", errorCode):
2723		return awsAwsquery_deserializeErrorInvalidReplicationGroupStateFault(response, errorBody)
2724
2725	case strings.EqualFold("ReplicationGroupNotFoundFault", errorCode):
2726		return awsAwsquery_deserializeErrorReplicationGroupNotFoundFault(response, errorBody)
2727
2728	case strings.EqualFold("SnapshotAlreadyExistsFault", errorCode):
2729		return awsAwsquery_deserializeErrorSnapshotAlreadyExistsFault(response, errorBody)
2730
2731	case strings.EqualFold("SnapshotFeatureNotSupportedFault", errorCode):
2732		return awsAwsquery_deserializeErrorSnapshotFeatureNotSupportedFault(response, errorBody)
2733
2734	case strings.EqualFold("SnapshotQuotaExceededFault", errorCode):
2735		return awsAwsquery_deserializeErrorSnapshotQuotaExceededFault(response, errorBody)
2736
2737	default:
2738		genericError := &smithy.GenericAPIError{
2739			Code:    errorCode,
2740			Message: errorMessage,
2741		}
2742		return genericError
2743
2744	}
2745}
2746
2747type awsAwsquery_deserializeOpDeleteSnapshot struct {
2748}
2749
2750func (*awsAwsquery_deserializeOpDeleteSnapshot) ID() string {
2751	return "OperationDeserializer"
2752}
2753
2754func (m *awsAwsquery_deserializeOpDeleteSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2755	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2756) {
2757	out, metadata, err = next.HandleDeserialize(ctx, in)
2758	if err != nil {
2759		return out, metadata, err
2760	}
2761
2762	response, ok := out.RawResponse.(*smithyhttp.Response)
2763	if !ok {
2764		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2765	}
2766
2767	if response.StatusCode < 200 || response.StatusCode >= 300 {
2768		return out, metadata, awsAwsquery_deserializeOpErrorDeleteSnapshot(response, &metadata)
2769	}
2770	output := &DeleteSnapshotOutput{}
2771	out.Result = output
2772
2773	var buff [1024]byte
2774	ringBuffer := smithyio.NewRingBuffer(buff[:])
2775	body := io.TeeReader(response.Body, ringBuffer)
2776	rootDecoder := xml.NewDecoder(body)
2777	t, err := smithyxml.FetchRootElement(rootDecoder)
2778	if err == io.EOF {
2779		return out, metadata, nil
2780	}
2781	if err != nil {
2782		var snapshot bytes.Buffer
2783		io.Copy(&snapshot, ringBuffer)
2784		return out, metadata, &smithy.DeserializationError{
2785			Err:      fmt.Errorf("failed to decode response body, %w", err),
2786			Snapshot: snapshot.Bytes(),
2787		}
2788	}
2789
2790	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
2791	t, err = decoder.GetElement("DeleteSnapshotResult")
2792	if err != nil {
2793		var snapshot bytes.Buffer
2794		io.Copy(&snapshot, ringBuffer)
2795		err = &smithy.DeserializationError{
2796			Err:      fmt.Errorf("failed to decode response body, %w", err),
2797			Snapshot: snapshot.Bytes(),
2798		}
2799		return out, metadata, err
2800	}
2801
2802	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
2803	err = awsAwsquery_deserializeOpDocumentDeleteSnapshotOutput(&output, decoder)
2804	if err != nil {
2805		var snapshot bytes.Buffer
2806		io.Copy(&snapshot, ringBuffer)
2807		err = &smithy.DeserializationError{
2808			Err:      fmt.Errorf("failed to decode response body, %w", err),
2809			Snapshot: snapshot.Bytes(),
2810		}
2811		return out, metadata, err
2812	}
2813
2814	return out, metadata, err
2815}
2816
2817func awsAwsquery_deserializeOpErrorDeleteSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2818	var errorBuffer bytes.Buffer
2819	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2820		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2821	}
2822	errorBody := bytes.NewReader(errorBuffer.Bytes())
2823
2824	errorCode := "UnknownError"
2825	errorMessage := errorCode
2826
2827	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
2828	if err != nil {
2829		return err
2830	}
2831	if reqID := errorComponents.RequestID; len(reqID) != 0 {
2832		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
2833	}
2834	if len(errorComponents.Code) != 0 {
2835		errorCode = errorComponents.Code
2836	}
2837	if len(errorComponents.Message) != 0 {
2838		errorMessage = errorComponents.Message
2839	}
2840	errorBody.Seek(0, io.SeekStart)
2841	switch {
2842	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
2843		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
2844
2845	case strings.EqualFold("InvalidParameterValueException", errorCode):
2846		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
2847
2848	case strings.EqualFold("InvalidSnapshotStateFault", errorCode):
2849		return awsAwsquery_deserializeErrorInvalidSnapshotStateFault(response, errorBody)
2850
2851	case strings.EqualFold("SnapshotNotFoundFault", errorCode):
2852		return awsAwsquery_deserializeErrorSnapshotNotFoundFault(response, errorBody)
2853
2854	default:
2855		genericError := &smithy.GenericAPIError{
2856			Code:    errorCode,
2857			Message: errorMessage,
2858		}
2859		return genericError
2860
2861	}
2862}
2863
2864type awsAwsquery_deserializeOpDeleteUser struct {
2865}
2866
2867func (*awsAwsquery_deserializeOpDeleteUser) ID() string {
2868	return "OperationDeserializer"
2869}
2870
2871func (m *awsAwsquery_deserializeOpDeleteUser) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2872	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2873) {
2874	out, metadata, err = next.HandleDeserialize(ctx, in)
2875	if err != nil {
2876		return out, metadata, err
2877	}
2878
2879	response, ok := out.RawResponse.(*smithyhttp.Response)
2880	if !ok {
2881		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2882	}
2883
2884	if response.StatusCode < 200 || response.StatusCode >= 300 {
2885		return out, metadata, awsAwsquery_deserializeOpErrorDeleteUser(response, &metadata)
2886	}
2887	output := &DeleteUserOutput{}
2888	out.Result = output
2889
2890	var buff [1024]byte
2891	ringBuffer := smithyio.NewRingBuffer(buff[:])
2892	body := io.TeeReader(response.Body, ringBuffer)
2893	rootDecoder := xml.NewDecoder(body)
2894	t, err := smithyxml.FetchRootElement(rootDecoder)
2895	if err == io.EOF {
2896		return out, metadata, nil
2897	}
2898	if err != nil {
2899		var snapshot bytes.Buffer
2900		io.Copy(&snapshot, ringBuffer)
2901		return out, metadata, &smithy.DeserializationError{
2902			Err:      fmt.Errorf("failed to decode response body, %w", err),
2903			Snapshot: snapshot.Bytes(),
2904		}
2905	}
2906
2907	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
2908	t, err = decoder.GetElement("DeleteUserResult")
2909	if err != nil {
2910		var snapshot bytes.Buffer
2911		io.Copy(&snapshot, ringBuffer)
2912		err = &smithy.DeserializationError{
2913			Err:      fmt.Errorf("failed to decode response body, %w", err),
2914			Snapshot: snapshot.Bytes(),
2915		}
2916		return out, metadata, err
2917	}
2918
2919	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
2920	err = awsAwsquery_deserializeOpDocumentDeleteUserOutput(&output, decoder)
2921	if err != nil {
2922		var snapshot bytes.Buffer
2923		io.Copy(&snapshot, ringBuffer)
2924		err = &smithy.DeserializationError{
2925			Err:      fmt.Errorf("failed to decode response body, %w", err),
2926			Snapshot: snapshot.Bytes(),
2927		}
2928		return out, metadata, err
2929	}
2930
2931	return out, metadata, err
2932}
2933
2934func awsAwsquery_deserializeOpErrorDeleteUser(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2935	var errorBuffer bytes.Buffer
2936	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2937		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2938	}
2939	errorBody := bytes.NewReader(errorBuffer.Bytes())
2940
2941	errorCode := "UnknownError"
2942	errorMessage := errorCode
2943
2944	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
2945	if err != nil {
2946		return err
2947	}
2948	if reqID := errorComponents.RequestID; len(reqID) != 0 {
2949		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
2950	}
2951	if len(errorComponents.Code) != 0 {
2952		errorCode = errorComponents.Code
2953	}
2954	if len(errorComponents.Message) != 0 {
2955		errorMessage = errorComponents.Message
2956	}
2957	errorBody.Seek(0, io.SeekStart)
2958	switch {
2959	case strings.EqualFold("DefaultUserAssociatedToUserGroupFault", errorCode):
2960		return awsAwsquery_deserializeErrorDefaultUserAssociatedToUserGroupFault(response, errorBody)
2961
2962	case strings.EqualFold("InvalidParameterValueException", errorCode):
2963		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
2964
2965	case strings.EqualFold("InvalidUserStateFault", errorCode):
2966		return awsAwsquery_deserializeErrorInvalidUserStateFault(response, errorBody)
2967
2968	case strings.EqualFold("UserNotFoundFault", errorCode):
2969		return awsAwsquery_deserializeErrorUserNotFoundFault(response, errorBody)
2970
2971	default:
2972		genericError := &smithy.GenericAPIError{
2973			Code:    errorCode,
2974			Message: errorMessage,
2975		}
2976		return genericError
2977
2978	}
2979}
2980
2981type awsAwsquery_deserializeOpDeleteUserGroup struct {
2982}
2983
2984func (*awsAwsquery_deserializeOpDeleteUserGroup) ID() string {
2985	return "OperationDeserializer"
2986}
2987
2988func (m *awsAwsquery_deserializeOpDeleteUserGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2989	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2990) {
2991	out, metadata, err = next.HandleDeserialize(ctx, in)
2992	if err != nil {
2993		return out, metadata, err
2994	}
2995
2996	response, ok := out.RawResponse.(*smithyhttp.Response)
2997	if !ok {
2998		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2999	}
3000
3001	if response.StatusCode < 200 || response.StatusCode >= 300 {
3002		return out, metadata, awsAwsquery_deserializeOpErrorDeleteUserGroup(response, &metadata)
3003	}
3004	output := &DeleteUserGroupOutput{}
3005	out.Result = output
3006
3007	var buff [1024]byte
3008	ringBuffer := smithyio.NewRingBuffer(buff[:])
3009	body := io.TeeReader(response.Body, ringBuffer)
3010	rootDecoder := xml.NewDecoder(body)
3011	t, err := smithyxml.FetchRootElement(rootDecoder)
3012	if err == io.EOF {
3013		return out, metadata, nil
3014	}
3015	if err != nil {
3016		var snapshot bytes.Buffer
3017		io.Copy(&snapshot, ringBuffer)
3018		return out, metadata, &smithy.DeserializationError{
3019			Err:      fmt.Errorf("failed to decode response body, %w", err),
3020			Snapshot: snapshot.Bytes(),
3021		}
3022	}
3023
3024	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
3025	t, err = decoder.GetElement("DeleteUserGroupResult")
3026	if err != nil {
3027		var snapshot bytes.Buffer
3028		io.Copy(&snapshot, ringBuffer)
3029		err = &smithy.DeserializationError{
3030			Err:      fmt.Errorf("failed to decode response body, %w", err),
3031			Snapshot: snapshot.Bytes(),
3032		}
3033		return out, metadata, err
3034	}
3035
3036	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
3037	err = awsAwsquery_deserializeOpDocumentDeleteUserGroupOutput(&output, decoder)
3038	if err != nil {
3039		var snapshot bytes.Buffer
3040		io.Copy(&snapshot, ringBuffer)
3041		err = &smithy.DeserializationError{
3042			Err:      fmt.Errorf("failed to decode response body, %w", err),
3043			Snapshot: snapshot.Bytes(),
3044		}
3045		return out, metadata, err
3046	}
3047
3048	return out, metadata, err
3049}
3050
3051func awsAwsquery_deserializeOpErrorDeleteUserGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3052	var errorBuffer bytes.Buffer
3053	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3054		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3055	}
3056	errorBody := bytes.NewReader(errorBuffer.Bytes())
3057
3058	errorCode := "UnknownError"
3059	errorMessage := errorCode
3060
3061	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
3062	if err != nil {
3063		return err
3064	}
3065	if reqID := errorComponents.RequestID; len(reqID) != 0 {
3066		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
3067	}
3068	if len(errorComponents.Code) != 0 {
3069		errorCode = errorComponents.Code
3070	}
3071	if len(errorComponents.Message) != 0 {
3072		errorMessage = errorComponents.Message
3073	}
3074	errorBody.Seek(0, io.SeekStart)
3075	switch {
3076	case strings.EqualFold("InvalidParameterValueException", errorCode):
3077		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
3078
3079	case strings.EqualFold("InvalidUserGroupStateFault", errorCode):
3080		return awsAwsquery_deserializeErrorInvalidUserGroupStateFault(response, errorBody)
3081
3082	case strings.EqualFold("UserGroupNotFoundFault", errorCode):
3083		return awsAwsquery_deserializeErrorUserGroupNotFoundFault(response, errorBody)
3084
3085	default:
3086		genericError := &smithy.GenericAPIError{
3087			Code:    errorCode,
3088			Message: errorMessage,
3089		}
3090		return genericError
3091
3092	}
3093}
3094
3095type awsAwsquery_deserializeOpDescribeCacheClusters struct {
3096}
3097
3098func (*awsAwsquery_deserializeOpDescribeCacheClusters) ID() string {
3099	return "OperationDeserializer"
3100}
3101
3102func (m *awsAwsquery_deserializeOpDescribeCacheClusters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3103	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3104) {
3105	out, metadata, err = next.HandleDeserialize(ctx, in)
3106	if err != nil {
3107		return out, metadata, err
3108	}
3109
3110	response, ok := out.RawResponse.(*smithyhttp.Response)
3111	if !ok {
3112		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3113	}
3114
3115	if response.StatusCode < 200 || response.StatusCode >= 300 {
3116		return out, metadata, awsAwsquery_deserializeOpErrorDescribeCacheClusters(response, &metadata)
3117	}
3118	output := &DescribeCacheClustersOutput{}
3119	out.Result = output
3120
3121	var buff [1024]byte
3122	ringBuffer := smithyio.NewRingBuffer(buff[:])
3123	body := io.TeeReader(response.Body, ringBuffer)
3124	rootDecoder := xml.NewDecoder(body)
3125	t, err := smithyxml.FetchRootElement(rootDecoder)
3126	if err == io.EOF {
3127		return out, metadata, nil
3128	}
3129	if err != nil {
3130		var snapshot bytes.Buffer
3131		io.Copy(&snapshot, ringBuffer)
3132		return out, metadata, &smithy.DeserializationError{
3133			Err:      fmt.Errorf("failed to decode response body, %w", err),
3134			Snapshot: snapshot.Bytes(),
3135		}
3136	}
3137
3138	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
3139	t, err = decoder.GetElement("DescribeCacheClustersResult")
3140	if err != nil {
3141		var snapshot bytes.Buffer
3142		io.Copy(&snapshot, ringBuffer)
3143		err = &smithy.DeserializationError{
3144			Err:      fmt.Errorf("failed to decode response body, %w", err),
3145			Snapshot: snapshot.Bytes(),
3146		}
3147		return out, metadata, err
3148	}
3149
3150	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
3151	err = awsAwsquery_deserializeOpDocumentDescribeCacheClustersOutput(&output, decoder)
3152	if err != nil {
3153		var snapshot bytes.Buffer
3154		io.Copy(&snapshot, ringBuffer)
3155		err = &smithy.DeserializationError{
3156			Err:      fmt.Errorf("failed to decode response body, %w", err),
3157			Snapshot: snapshot.Bytes(),
3158		}
3159		return out, metadata, err
3160	}
3161
3162	return out, metadata, err
3163}
3164
3165func awsAwsquery_deserializeOpErrorDescribeCacheClusters(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3166	var errorBuffer bytes.Buffer
3167	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3168		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3169	}
3170	errorBody := bytes.NewReader(errorBuffer.Bytes())
3171
3172	errorCode := "UnknownError"
3173	errorMessage := errorCode
3174
3175	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
3176	if err != nil {
3177		return err
3178	}
3179	if reqID := errorComponents.RequestID; len(reqID) != 0 {
3180		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
3181	}
3182	if len(errorComponents.Code) != 0 {
3183		errorCode = errorComponents.Code
3184	}
3185	if len(errorComponents.Message) != 0 {
3186		errorMessage = errorComponents.Message
3187	}
3188	errorBody.Seek(0, io.SeekStart)
3189	switch {
3190	case strings.EqualFold("CacheClusterNotFoundFault", errorCode):
3191		return awsAwsquery_deserializeErrorCacheClusterNotFoundFault(response, errorBody)
3192
3193	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
3194		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
3195
3196	case strings.EqualFold("InvalidParameterValueException", errorCode):
3197		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
3198
3199	default:
3200		genericError := &smithy.GenericAPIError{
3201			Code:    errorCode,
3202			Message: errorMessage,
3203		}
3204		return genericError
3205
3206	}
3207}
3208
3209type awsAwsquery_deserializeOpDescribeCacheEngineVersions struct {
3210}
3211
3212func (*awsAwsquery_deserializeOpDescribeCacheEngineVersions) ID() string {
3213	return "OperationDeserializer"
3214}
3215
3216func (m *awsAwsquery_deserializeOpDescribeCacheEngineVersions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3217	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3218) {
3219	out, metadata, err = next.HandleDeserialize(ctx, in)
3220	if err != nil {
3221		return out, metadata, err
3222	}
3223
3224	response, ok := out.RawResponse.(*smithyhttp.Response)
3225	if !ok {
3226		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3227	}
3228
3229	if response.StatusCode < 200 || response.StatusCode >= 300 {
3230		return out, metadata, awsAwsquery_deserializeOpErrorDescribeCacheEngineVersions(response, &metadata)
3231	}
3232	output := &DescribeCacheEngineVersionsOutput{}
3233	out.Result = output
3234
3235	var buff [1024]byte
3236	ringBuffer := smithyio.NewRingBuffer(buff[:])
3237	body := io.TeeReader(response.Body, ringBuffer)
3238	rootDecoder := xml.NewDecoder(body)
3239	t, err := smithyxml.FetchRootElement(rootDecoder)
3240	if err == io.EOF {
3241		return out, metadata, nil
3242	}
3243	if err != nil {
3244		var snapshot bytes.Buffer
3245		io.Copy(&snapshot, ringBuffer)
3246		return out, metadata, &smithy.DeserializationError{
3247			Err:      fmt.Errorf("failed to decode response body, %w", err),
3248			Snapshot: snapshot.Bytes(),
3249		}
3250	}
3251
3252	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
3253	t, err = decoder.GetElement("DescribeCacheEngineVersionsResult")
3254	if err != nil {
3255		var snapshot bytes.Buffer
3256		io.Copy(&snapshot, ringBuffer)
3257		err = &smithy.DeserializationError{
3258			Err:      fmt.Errorf("failed to decode response body, %w", err),
3259			Snapshot: snapshot.Bytes(),
3260		}
3261		return out, metadata, err
3262	}
3263
3264	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
3265	err = awsAwsquery_deserializeOpDocumentDescribeCacheEngineVersionsOutput(&output, decoder)
3266	if err != nil {
3267		var snapshot bytes.Buffer
3268		io.Copy(&snapshot, ringBuffer)
3269		err = &smithy.DeserializationError{
3270			Err:      fmt.Errorf("failed to decode response body, %w", err),
3271			Snapshot: snapshot.Bytes(),
3272		}
3273		return out, metadata, err
3274	}
3275
3276	return out, metadata, err
3277}
3278
3279func awsAwsquery_deserializeOpErrorDescribeCacheEngineVersions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3280	var errorBuffer bytes.Buffer
3281	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3282		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3283	}
3284	errorBody := bytes.NewReader(errorBuffer.Bytes())
3285
3286	errorCode := "UnknownError"
3287	errorMessage := errorCode
3288
3289	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
3290	if err != nil {
3291		return err
3292	}
3293	if reqID := errorComponents.RequestID; len(reqID) != 0 {
3294		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
3295	}
3296	if len(errorComponents.Code) != 0 {
3297		errorCode = errorComponents.Code
3298	}
3299	if len(errorComponents.Message) != 0 {
3300		errorMessage = errorComponents.Message
3301	}
3302	errorBody.Seek(0, io.SeekStart)
3303	switch {
3304	default:
3305		genericError := &smithy.GenericAPIError{
3306			Code:    errorCode,
3307			Message: errorMessage,
3308		}
3309		return genericError
3310
3311	}
3312}
3313
3314type awsAwsquery_deserializeOpDescribeCacheParameterGroups struct {
3315}
3316
3317func (*awsAwsquery_deserializeOpDescribeCacheParameterGroups) ID() string {
3318	return "OperationDeserializer"
3319}
3320
3321func (m *awsAwsquery_deserializeOpDescribeCacheParameterGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3322	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3323) {
3324	out, metadata, err = next.HandleDeserialize(ctx, in)
3325	if err != nil {
3326		return out, metadata, err
3327	}
3328
3329	response, ok := out.RawResponse.(*smithyhttp.Response)
3330	if !ok {
3331		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3332	}
3333
3334	if response.StatusCode < 200 || response.StatusCode >= 300 {
3335		return out, metadata, awsAwsquery_deserializeOpErrorDescribeCacheParameterGroups(response, &metadata)
3336	}
3337	output := &DescribeCacheParameterGroupsOutput{}
3338	out.Result = output
3339
3340	var buff [1024]byte
3341	ringBuffer := smithyio.NewRingBuffer(buff[:])
3342	body := io.TeeReader(response.Body, ringBuffer)
3343	rootDecoder := xml.NewDecoder(body)
3344	t, err := smithyxml.FetchRootElement(rootDecoder)
3345	if err == io.EOF {
3346		return out, metadata, nil
3347	}
3348	if err != nil {
3349		var snapshot bytes.Buffer
3350		io.Copy(&snapshot, ringBuffer)
3351		return out, metadata, &smithy.DeserializationError{
3352			Err:      fmt.Errorf("failed to decode response body, %w", err),
3353			Snapshot: snapshot.Bytes(),
3354		}
3355	}
3356
3357	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
3358	t, err = decoder.GetElement("DescribeCacheParameterGroupsResult")
3359	if err != nil {
3360		var snapshot bytes.Buffer
3361		io.Copy(&snapshot, ringBuffer)
3362		err = &smithy.DeserializationError{
3363			Err:      fmt.Errorf("failed to decode response body, %w", err),
3364			Snapshot: snapshot.Bytes(),
3365		}
3366		return out, metadata, err
3367	}
3368
3369	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
3370	err = awsAwsquery_deserializeOpDocumentDescribeCacheParameterGroupsOutput(&output, decoder)
3371	if err != nil {
3372		var snapshot bytes.Buffer
3373		io.Copy(&snapshot, ringBuffer)
3374		err = &smithy.DeserializationError{
3375			Err:      fmt.Errorf("failed to decode response body, %w", err),
3376			Snapshot: snapshot.Bytes(),
3377		}
3378		return out, metadata, err
3379	}
3380
3381	return out, metadata, err
3382}
3383
3384func awsAwsquery_deserializeOpErrorDescribeCacheParameterGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3385	var errorBuffer bytes.Buffer
3386	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3387		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3388	}
3389	errorBody := bytes.NewReader(errorBuffer.Bytes())
3390
3391	errorCode := "UnknownError"
3392	errorMessage := errorCode
3393
3394	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
3395	if err != nil {
3396		return err
3397	}
3398	if reqID := errorComponents.RequestID; len(reqID) != 0 {
3399		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
3400	}
3401	if len(errorComponents.Code) != 0 {
3402		errorCode = errorComponents.Code
3403	}
3404	if len(errorComponents.Message) != 0 {
3405		errorMessage = errorComponents.Message
3406	}
3407	errorBody.Seek(0, io.SeekStart)
3408	switch {
3409	case strings.EqualFold("CacheParameterGroupNotFoundFault", errorCode):
3410		return awsAwsquery_deserializeErrorCacheParameterGroupNotFoundFault(response, errorBody)
3411
3412	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
3413		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
3414
3415	case strings.EqualFold("InvalidParameterValueException", errorCode):
3416		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
3417
3418	default:
3419		genericError := &smithy.GenericAPIError{
3420			Code:    errorCode,
3421			Message: errorMessage,
3422		}
3423		return genericError
3424
3425	}
3426}
3427
3428type awsAwsquery_deserializeOpDescribeCacheParameters struct {
3429}
3430
3431func (*awsAwsquery_deserializeOpDescribeCacheParameters) ID() string {
3432	return "OperationDeserializer"
3433}
3434
3435func (m *awsAwsquery_deserializeOpDescribeCacheParameters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3436	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3437) {
3438	out, metadata, err = next.HandleDeserialize(ctx, in)
3439	if err != nil {
3440		return out, metadata, err
3441	}
3442
3443	response, ok := out.RawResponse.(*smithyhttp.Response)
3444	if !ok {
3445		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3446	}
3447
3448	if response.StatusCode < 200 || response.StatusCode >= 300 {
3449		return out, metadata, awsAwsquery_deserializeOpErrorDescribeCacheParameters(response, &metadata)
3450	}
3451	output := &DescribeCacheParametersOutput{}
3452	out.Result = output
3453
3454	var buff [1024]byte
3455	ringBuffer := smithyio.NewRingBuffer(buff[:])
3456	body := io.TeeReader(response.Body, ringBuffer)
3457	rootDecoder := xml.NewDecoder(body)
3458	t, err := smithyxml.FetchRootElement(rootDecoder)
3459	if err == io.EOF {
3460		return out, metadata, nil
3461	}
3462	if err != nil {
3463		var snapshot bytes.Buffer
3464		io.Copy(&snapshot, ringBuffer)
3465		return out, metadata, &smithy.DeserializationError{
3466			Err:      fmt.Errorf("failed to decode response body, %w", err),
3467			Snapshot: snapshot.Bytes(),
3468		}
3469	}
3470
3471	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
3472	t, err = decoder.GetElement("DescribeCacheParametersResult")
3473	if err != nil {
3474		var snapshot bytes.Buffer
3475		io.Copy(&snapshot, ringBuffer)
3476		err = &smithy.DeserializationError{
3477			Err:      fmt.Errorf("failed to decode response body, %w", err),
3478			Snapshot: snapshot.Bytes(),
3479		}
3480		return out, metadata, err
3481	}
3482
3483	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
3484	err = awsAwsquery_deserializeOpDocumentDescribeCacheParametersOutput(&output, decoder)
3485	if err != nil {
3486		var snapshot bytes.Buffer
3487		io.Copy(&snapshot, ringBuffer)
3488		err = &smithy.DeserializationError{
3489			Err:      fmt.Errorf("failed to decode response body, %w", err),
3490			Snapshot: snapshot.Bytes(),
3491		}
3492		return out, metadata, err
3493	}
3494
3495	return out, metadata, err
3496}
3497
3498func awsAwsquery_deserializeOpErrorDescribeCacheParameters(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3499	var errorBuffer bytes.Buffer
3500	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3501		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3502	}
3503	errorBody := bytes.NewReader(errorBuffer.Bytes())
3504
3505	errorCode := "UnknownError"
3506	errorMessage := errorCode
3507
3508	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
3509	if err != nil {
3510		return err
3511	}
3512	if reqID := errorComponents.RequestID; len(reqID) != 0 {
3513		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
3514	}
3515	if len(errorComponents.Code) != 0 {
3516		errorCode = errorComponents.Code
3517	}
3518	if len(errorComponents.Message) != 0 {
3519		errorMessage = errorComponents.Message
3520	}
3521	errorBody.Seek(0, io.SeekStart)
3522	switch {
3523	case strings.EqualFold("CacheParameterGroupNotFoundFault", errorCode):
3524		return awsAwsquery_deserializeErrorCacheParameterGroupNotFoundFault(response, errorBody)
3525
3526	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
3527		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
3528
3529	case strings.EqualFold("InvalidParameterValueException", errorCode):
3530		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
3531
3532	default:
3533		genericError := &smithy.GenericAPIError{
3534			Code:    errorCode,
3535			Message: errorMessage,
3536		}
3537		return genericError
3538
3539	}
3540}
3541
3542type awsAwsquery_deserializeOpDescribeCacheSecurityGroups struct {
3543}
3544
3545func (*awsAwsquery_deserializeOpDescribeCacheSecurityGroups) ID() string {
3546	return "OperationDeserializer"
3547}
3548
3549func (m *awsAwsquery_deserializeOpDescribeCacheSecurityGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3550	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3551) {
3552	out, metadata, err = next.HandleDeserialize(ctx, in)
3553	if err != nil {
3554		return out, metadata, err
3555	}
3556
3557	response, ok := out.RawResponse.(*smithyhttp.Response)
3558	if !ok {
3559		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3560	}
3561
3562	if response.StatusCode < 200 || response.StatusCode >= 300 {
3563		return out, metadata, awsAwsquery_deserializeOpErrorDescribeCacheSecurityGroups(response, &metadata)
3564	}
3565	output := &DescribeCacheSecurityGroupsOutput{}
3566	out.Result = output
3567
3568	var buff [1024]byte
3569	ringBuffer := smithyio.NewRingBuffer(buff[:])
3570	body := io.TeeReader(response.Body, ringBuffer)
3571	rootDecoder := xml.NewDecoder(body)
3572	t, err := smithyxml.FetchRootElement(rootDecoder)
3573	if err == io.EOF {
3574		return out, metadata, nil
3575	}
3576	if err != nil {
3577		var snapshot bytes.Buffer
3578		io.Copy(&snapshot, ringBuffer)
3579		return out, metadata, &smithy.DeserializationError{
3580			Err:      fmt.Errorf("failed to decode response body, %w", err),
3581			Snapshot: snapshot.Bytes(),
3582		}
3583	}
3584
3585	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
3586	t, err = decoder.GetElement("DescribeCacheSecurityGroupsResult")
3587	if err != nil {
3588		var snapshot bytes.Buffer
3589		io.Copy(&snapshot, ringBuffer)
3590		err = &smithy.DeserializationError{
3591			Err:      fmt.Errorf("failed to decode response body, %w", err),
3592			Snapshot: snapshot.Bytes(),
3593		}
3594		return out, metadata, err
3595	}
3596
3597	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
3598	err = awsAwsquery_deserializeOpDocumentDescribeCacheSecurityGroupsOutput(&output, decoder)
3599	if err != nil {
3600		var snapshot bytes.Buffer
3601		io.Copy(&snapshot, ringBuffer)
3602		err = &smithy.DeserializationError{
3603			Err:      fmt.Errorf("failed to decode response body, %w", err),
3604			Snapshot: snapshot.Bytes(),
3605		}
3606		return out, metadata, err
3607	}
3608
3609	return out, metadata, err
3610}
3611
3612func awsAwsquery_deserializeOpErrorDescribeCacheSecurityGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3613	var errorBuffer bytes.Buffer
3614	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3615		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3616	}
3617	errorBody := bytes.NewReader(errorBuffer.Bytes())
3618
3619	errorCode := "UnknownError"
3620	errorMessage := errorCode
3621
3622	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
3623	if err != nil {
3624		return err
3625	}
3626	if reqID := errorComponents.RequestID; len(reqID) != 0 {
3627		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
3628	}
3629	if len(errorComponents.Code) != 0 {
3630		errorCode = errorComponents.Code
3631	}
3632	if len(errorComponents.Message) != 0 {
3633		errorMessage = errorComponents.Message
3634	}
3635	errorBody.Seek(0, io.SeekStart)
3636	switch {
3637	case strings.EqualFold("CacheSecurityGroupNotFoundFault", errorCode):
3638		return awsAwsquery_deserializeErrorCacheSecurityGroupNotFoundFault(response, errorBody)
3639
3640	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
3641		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
3642
3643	case strings.EqualFold("InvalidParameterValueException", errorCode):
3644		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
3645
3646	default:
3647		genericError := &smithy.GenericAPIError{
3648			Code:    errorCode,
3649			Message: errorMessage,
3650		}
3651		return genericError
3652
3653	}
3654}
3655
3656type awsAwsquery_deserializeOpDescribeCacheSubnetGroups struct {
3657}
3658
3659func (*awsAwsquery_deserializeOpDescribeCacheSubnetGroups) ID() string {
3660	return "OperationDeserializer"
3661}
3662
3663func (m *awsAwsquery_deserializeOpDescribeCacheSubnetGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3664	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3665) {
3666	out, metadata, err = next.HandleDeserialize(ctx, in)
3667	if err != nil {
3668		return out, metadata, err
3669	}
3670
3671	response, ok := out.RawResponse.(*smithyhttp.Response)
3672	if !ok {
3673		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3674	}
3675
3676	if response.StatusCode < 200 || response.StatusCode >= 300 {
3677		return out, metadata, awsAwsquery_deserializeOpErrorDescribeCacheSubnetGroups(response, &metadata)
3678	}
3679	output := &DescribeCacheSubnetGroupsOutput{}
3680	out.Result = output
3681
3682	var buff [1024]byte
3683	ringBuffer := smithyio.NewRingBuffer(buff[:])
3684	body := io.TeeReader(response.Body, ringBuffer)
3685	rootDecoder := xml.NewDecoder(body)
3686	t, err := smithyxml.FetchRootElement(rootDecoder)
3687	if err == io.EOF {
3688		return out, metadata, nil
3689	}
3690	if err != nil {
3691		var snapshot bytes.Buffer
3692		io.Copy(&snapshot, ringBuffer)
3693		return out, metadata, &smithy.DeserializationError{
3694			Err:      fmt.Errorf("failed to decode response body, %w", err),
3695			Snapshot: snapshot.Bytes(),
3696		}
3697	}
3698
3699	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
3700	t, err = decoder.GetElement("DescribeCacheSubnetGroupsResult")
3701	if err != nil {
3702		var snapshot bytes.Buffer
3703		io.Copy(&snapshot, ringBuffer)
3704		err = &smithy.DeserializationError{
3705			Err:      fmt.Errorf("failed to decode response body, %w", err),
3706			Snapshot: snapshot.Bytes(),
3707		}
3708		return out, metadata, err
3709	}
3710
3711	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
3712	err = awsAwsquery_deserializeOpDocumentDescribeCacheSubnetGroupsOutput(&output, decoder)
3713	if err != nil {
3714		var snapshot bytes.Buffer
3715		io.Copy(&snapshot, ringBuffer)
3716		err = &smithy.DeserializationError{
3717			Err:      fmt.Errorf("failed to decode response body, %w", err),
3718			Snapshot: snapshot.Bytes(),
3719		}
3720		return out, metadata, err
3721	}
3722
3723	return out, metadata, err
3724}
3725
3726func awsAwsquery_deserializeOpErrorDescribeCacheSubnetGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3727	var errorBuffer bytes.Buffer
3728	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3729		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3730	}
3731	errorBody := bytes.NewReader(errorBuffer.Bytes())
3732
3733	errorCode := "UnknownError"
3734	errorMessage := errorCode
3735
3736	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
3737	if err != nil {
3738		return err
3739	}
3740	if reqID := errorComponents.RequestID; len(reqID) != 0 {
3741		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
3742	}
3743	if len(errorComponents.Code) != 0 {
3744		errorCode = errorComponents.Code
3745	}
3746	if len(errorComponents.Message) != 0 {
3747		errorMessage = errorComponents.Message
3748	}
3749	errorBody.Seek(0, io.SeekStart)
3750	switch {
3751	case strings.EqualFold("CacheSubnetGroupNotFoundFault", errorCode):
3752		return awsAwsquery_deserializeErrorCacheSubnetGroupNotFoundFault(response, errorBody)
3753
3754	default:
3755		genericError := &smithy.GenericAPIError{
3756			Code:    errorCode,
3757			Message: errorMessage,
3758		}
3759		return genericError
3760
3761	}
3762}
3763
3764type awsAwsquery_deserializeOpDescribeEngineDefaultParameters struct {
3765}
3766
3767func (*awsAwsquery_deserializeOpDescribeEngineDefaultParameters) ID() string {
3768	return "OperationDeserializer"
3769}
3770
3771func (m *awsAwsquery_deserializeOpDescribeEngineDefaultParameters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3772	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3773) {
3774	out, metadata, err = next.HandleDeserialize(ctx, in)
3775	if err != nil {
3776		return out, metadata, err
3777	}
3778
3779	response, ok := out.RawResponse.(*smithyhttp.Response)
3780	if !ok {
3781		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3782	}
3783
3784	if response.StatusCode < 200 || response.StatusCode >= 300 {
3785		return out, metadata, awsAwsquery_deserializeOpErrorDescribeEngineDefaultParameters(response, &metadata)
3786	}
3787	output := &DescribeEngineDefaultParametersOutput{}
3788	out.Result = output
3789
3790	var buff [1024]byte
3791	ringBuffer := smithyio.NewRingBuffer(buff[:])
3792	body := io.TeeReader(response.Body, ringBuffer)
3793	rootDecoder := xml.NewDecoder(body)
3794	t, err := smithyxml.FetchRootElement(rootDecoder)
3795	if err == io.EOF {
3796		return out, metadata, nil
3797	}
3798	if err != nil {
3799		var snapshot bytes.Buffer
3800		io.Copy(&snapshot, ringBuffer)
3801		return out, metadata, &smithy.DeserializationError{
3802			Err:      fmt.Errorf("failed to decode response body, %w", err),
3803			Snapshot: snapshot.Bytes(),
3804		}
3805	}
3806
3807	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
3808	t, err = decoder.GetElement("DescribeEngineDefaultParametersResult")
3809	if err != nil {
3810		var snapshot bytes.Buffer
3811		io.Copy(&snapshot, ringBuffer)
3812		err = &smithy.DeserializationError{
3813			Err:      fmt.Errorf("failed to decode response body, %w", err),
3814			Snapshot: snapshot.Bytes(),
3815		}
3816		return out, metadata, err
3817	}
3818
3819	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
3820	err = awsAwsquery_deserializeOpDocumentDescribeEngineDefaultParametersOutput(&output, decoder)
3821	if err != nil {
3822		var snapshot bytes.Buffer
3823		io.Copy(&snapshot, ringBuffer)
3824		err = &smithy.DeserializationError{
3825			Err:      fmt.Errorf("failed to decode response body, %w", err),
3826			Snapshot: snapshot.Bytes(),
3827		}
3828		return out, metadata, err
3829	}
3830
3831	return out, metadata, err
3832}
3833
3834func awsAwsquery_deserializeOpErrorDescribeEngineDefaultParameters(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3835	var errorBuffer bytes.Buffer
3836	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3837		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3838	}
3839	errorBody := bytes.NewReader(errorBuffer.Bytes())
3840
3841	errorCode := "UnknownError"
3842	errorMessage := errorCode
3843
3844	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
3845	if err != nil {
3846		return err
3847	}
3848	if reqID := errorComponents.RequestID; len(reqID) != 0 {
3849		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
3850	}
3851	if len(errorComponents.Code) != 0 {
3852		errorCode = errorComponents.Code
3853	}
3854	if len(errorComponents.Message) != 0 {
3855		errorMessage = errorComponents.Message
3856	}
3857	errorBody.Seek(0, io.SeekStart)
3858	switch {
3859	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
3860		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
3861
3862	case strings.EqualFold("InvalidParameterValueException", errorCode):
3863		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
3864
3865	default:
3866		genericError := &smithy.GenericAPIError{
3867			Code:    errorCode,
3868			Message: errorMessage,
3869		}
3870		return genericError
3871
3872	}
3873}
3874
3875type awsAwsquery_deserializeOpDescribeEvents struct {
3876}
3877
3878func (*awsAwsquery_deserializeOpDescribeEvents) ID() string {
3879	return "OperationDeserializer"
3880}
3881
3882func (m *awsAwsquery_deserializeOpDescribeEvents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3883	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3884) {
3885	out, metadata, err = next.HandleDeserialize(ctx, in)
3886	if err != nil {
3887		return out, metadata, err
3888	}
3889
3890	response, ok := out.RawResponse.(*smithyhttp.Response)
3891	if !ok {
3892		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3893	}
3894
3895	if response.StatusCode < 200 || response.StatusCode >= 300 {
3896		return out, metadata, awsAwsquery_deserializeOpErrorDescribeEvents(response, &metadata)
3897	}
3898	output := &DescribeEventsOutput{}
3899	out.Result = output
3900
3901	var buff [1024]byte
3902	ringBuffer := smithyio.NewRingBuffer(buff[:])
3903	body := io.TeeReader(response.Body, ringBuffer)
3904	rootDecoder := xml.NewDecoder(body)
3905	t, err := smithyxml.FetchRootElement(rootDecoder)
3906	if err == io.EOF {
3907		return out, metadata, nil
3908	}
3909	if err != nil {
3910		var snapshot bytes.Buffer
3911		io.Copy(&snapshot, ringBuffer)
3912		return out, metadata, &smithy.DeserializationError{
3913			Err:      fmt.Errorf("failed to decode response body, %w", err),
3914			Snapshot: snapshot.Bytes(),
3915		}
3916	}
3917
3918	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
3919	t, err = decoder.GetElement("DescribeEventsResult")
3920	if err != nil {
3921		var snapshot bytes.Buffer
3922		io.Copy(&snapshot, ringBuffer)
3923		err = &smithy.DeserializationError{
3924			Err:      fmt.Errorf("failed to decode response body, %w", err),
3925			Snapshot: snapshot.Bytes(),
3926		}
3927		return out, metadata, err
3928	}
3929
3930	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
3931	err = awsAwsquery_deserializeOpDocumentDescribeEventsOutput(&output, decoder)
3932	if err != nil {
3933		var snapshot bytes.Buffer
3934		io.Copy(&snapshot, ringBuffer)
3935		err = &smithy.DeserializationError{
3936			Err:      fmt.Errorf("failed to decode response body, %w", err),
3937			Snapshot: snapshot.Bytes(),
3938		}
3939		return out, metadata, err
3940	}
3941
3942	return out, metadata, err
3943}
3944
3945func awsAwsquery_deserializeOpErrorDescribeEvents(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3946	var errorBuffer bytes.Buffer
3947	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3948		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3949	}
3950	errorBody := bytes.NewReader(errorBuffer.Bytes())
3951
3952	errorCode := "UnknownError"
3953	errorMessage := errorCode
3954
3955	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
3956	if err != nil {
3957		return err
3958	}
3959	if reqID := errorComponents.RequestID; len(reqID) != 0 {
3960		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
3961	}
3962	if len(errorComponents.Code) != 0 {
3963		errorCode = errorComponents.Code
3964	}
3965	if len(errorComponents.Message) != 0 {
3966		errorMessage = errorComponents.Message
3967	}
3968	errorBody.Seek(0, io.SeekStart)
3969	switch {
3970	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
3971		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
3972
3973	case strings.EqualFold("InvalidParameterValueException", errorCode):
3974		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
3975
3976	default:
3977		genericError := &smithy.GenericAPIError{
3978			Code:    errorCode,
3979			Message: errorMessage,
3980		}
3981		return genericError
3982
3983	}
3984}
3985
3986type awsAwsquery_deserializeOpDescribeGlobalReplicationGroups struct {
3987}
3988
3989func (*awsAwsquery_deserializeOpDescribeGlobalReplicationGroups) ID() string {
3990	return "OperationDeserializer"
3991}
3992
3993func (m *awsAwsquery_deserializeOpDescribeGlobalReplicationGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3994	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3995) {
3996	out, metadata, err = next.HandleDeserialize(ctx, in)
3997	if err != nil {
3998		return out, metadata, err
3999	}
4000
4001	response, ok := out.RawResponse.(*smithyhttp.Response)
4002	if !ok {
4003		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4004	}
4005
4006	if response.StatusCode < 200 || response.StatusCode >= 300 {
4007		return out, metadata, awsAwsquery_deserializeOpErrorDescribeGlobalReplicationGroups(response, &metadata)
4008	}
4009	output := &DescribeGlobalReplicationGroupsOutput{}
4010	out.Result = output
4011
4012	var buff [1024]byte
4013	ringBuffer := smithyio.NewRingBuffer(buff[:])
4014	body := io.TeeReader(response.Body, ringBuffer)
4015	rootDecoder := xml.NewDecoder(body)
4016	t, err := smithyxml.FetchRootElement(rootDecoder)
4017	if err == io.EOF {
4018		return out, metadata, nil
4019	}
4020	if err != nil {
4021		var snapshot bytes.Buffer
4022		io.Copy(&snapshot, ringBuffer)
4023		return out, metadata, &smithy.DeserializationError{
4024			Err:      fmt.Errorf("failed to decode response body, %w", err),
4025			Snapshot: snapshot.Bytes(),
4026		}
4027	}
4028
4029	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
4030	t, err = decoder.GetElement("DescribeGlobalReplicationGroupsResult")
4031	if err != nil {
4032		var snapshot bytes.Buffer
4033		io.Copy(&snapshot, ringBuffer)
4034		err = &smithy.DeserializationError{
4035			Err:      fmt.Errorf("failed to decode response body, %w", err),
4036			Snapshot: snapshot.Bytes(),
4037		}
4038		return out, metadata, err
4039	}
4040
4041	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
4042	err = awsAwsquery_deserializeOpDocumentDescribeGlobalReplicationGroupsOutput(&output, decoder)
4043	if err != nil {
4044		var snapshot bytes.Buffer
4045		io.Copy(&snapshot, ringBuffer)
4046		err = &smithy.DeserializationError{
4047			Err:      fmt.Errorf("failed to decode response body, %w", err),
4048			Snapshot: snapshot.Bytes(),
4049		}
4050		return out, metadata, err
4051	}
4052
4053	return out, metadata, err
4054}
4055
4056func awsAwsquery_deserializeOpErrorDescribeGlobalReplicationGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4057	var errorBuffer bytes.Buffer
4058	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4059		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4060	}
4061	errorBody := bytes.NewReader(errorBuffer.Bytes())
4062
4063	errorCode := "UnknownError"
4064	errorMessage := errorCode
4065
4066	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
4067	if err != nil {
4068		return err
4069	}
4070	if reqID := errorComponents.RequestID; len(reqID) != 0 {
4071		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
4072	}
4073	if len(errorComponents.Code) != 0 {
4074		errorCode = errorComponents.Code
4075	}
4076	if len(errorComponents.Message) != 0 {
4077		errorMessage = errorComponents.Message
4078	}
4079	errorBody.Seek(0, io.SeekStart)
4080	switch {
4081	case strings.EqualFold("GlobalReplicationGroupNotFoundFault", errorCode):
4082		return awsAwsquery_deserializeErrorGlobalReplicationGroupNotFoundFault(response, errorBody)
4083
4084	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
4085		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
4086
4087	case strings.EqualFold("InvalidParameterValueException", errorCode):
4088		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
4089
4090	default:
4091		genericError := &smithy.GenericAPIError{
4092			Code:    errorCode,
4093			Message: errorMessage,
4094		}
4095		return genericError
4096
4097	}
4098}
4099
4100type awsAwsquery_deserializeOpDescribeReplicationGroups struct {
4101}
4102
4103func (*awsAwsquery_deserializeOpDescribeReplicationGroups) ID() string {
4104	return "OperationDeserializer"
4105}
4106
4107func (m *awsAwsquery_deserializeOpDescribeReplicationGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4108	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4109) {
4110	out, metadata, err = next.HandleDeserialize(ctx, in)
4111	if err != nil {
4112		return out, metadata, err
4113	}
4114
4115	response, ok := out.RawResponse.(*smithyhttp.Response)
4116	if !ok {
4117		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4118	}
4119
4120	if response.StatusCode < 200 || response.StatusCode >= 300 {
4121		return out, metadata, awsAwsquery_deserializeOpErrorDescribeReplicationGroups(response, &metadata)
4122	}
4123	output := &DescribeReplicationGroupsOutput{}
4124	out.Result = output
4125
4126	var buff [1024]byte
4127	ringBuffer := smithyio.NewRingBuffer(buff[:])
4128	body := io.TeeReader(response.Body, ringBuffer)
4129	rootDecoder := xml.NewDecoder(body)
4130	t, err := smithyxml.FetchRootElement(rootDecoder)
4131	if err == io.EOF {
4132		return out, metadata, nil
4133	}
4134	if err != nil {
4135		var snapshot bytes.Buffer
4136		io.Copy(&snapshot, ringBuffer)
4137		return out, metadata, &smithy.DeserializationError{
4138			Err:      fmt.Errorf("failed to decode response body, %w", err),
4139			Snapshot: snapshot.Bytes(),
4140		}
4141	}
4142
4143	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
4144	t, err = decoder.GetElement("DescribeReplicationGroupsResult")
4145	if err != nil {
4146		var snapshot bytes.Buffer
4147		io.Copy(&snapshot, ringBuffer)
4148		err = &smithy.DeserializationError{
4149			Err:      fmt.Errorf("failed to decode response body, %w", err),
4150			Snapshot: snapshot.Bytes(),
4151		}
4152		return out, metadata, err
4153	}
4154
4155	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
4156	err = awsAwsquery_deserializeOpDocumentDescribeReplicationGroupsOutput(&output, decoder)
4157	if err != nil {
4158		var snapshot bytes.Buffer
4159		io.Copy(&snapshot, ringBuffer)
4160		err = &smithy.DeserializationError{
4161			Err:      fmt.Errorf("failed to decode response body, %w", err),
4162			Snapshot: snapshot.Bytes(),
4163		}
4164		return out, metadata, err
4165	}
4166
4167	return out, metadata, err
4168}
4169
4170func awsAwsquery_deserializeOpErrorDescribeReplicationGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4171	var errorBuffer bytes.Buffer
4172	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4173		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4174	}
4175	errorBody := bytes.NewReader(errorBuffer.Bytes())
4176
4177	errorCode := "UnknownError"
4178	errorMessage := errorCode
4179
4180	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
4181	if err != nil {
4182		return err
4183	}
4184	if reqID := errorComponents.RequestID; len(reqID) != 0 {
4185		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
4186	}
4187	if len(errorComponents.Code) != 0 {
4188		errorCode = errorComponents.Code
4189	}
4190	if len(errorComponents.Message) != 0 {
4191		errorMessage = errorComponents.Message
4192	}
4193	errorBody.Seek(0, io.SeekStart)
4194	switch {
4195	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
4196		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
4197
4198	case strings.EqualFold("InvalidParameterValueException", errorCode):
4199		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
4200
4201	case strings.EqualFold("ReplicationGroupNotFoundFault", errorCode):
4202		return awsAwsquery_deserializeErrorReplicationGroupNotFoundFault(response, errorBody)
4203
4204	default:
4205		genericError := &smithy.GenericAPIError{
4206			Code:    errorCode,
4207			Message: errorMessage,
4208		}
4209		return genericError
4210
4211	}
4212}
4213
4214type awsAwsquery_deserializeOpDescribeReservedCacheNodes struct {
4215}
4216
4217func (*awsAwsquery_deserializeOpDescribeReservedCacheNodes) ID() string {
4218	return "OperationDeserializer"
4219}
4220
4221func (m *awsAwsquery_deserializeOpDescribeReservedCacheNodes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4222	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4223) {
4224	out, metadata, err = next.HandleDeserialize(ctx, in)
4225	if err != nil {
4226		return out, metadata, err
4227	}
4228
4229	response, ok := out.RawResponse.(*smithyhttp.Response)
4230	if !ok {
4231		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4232	}
4233
4234	if response.StatusCode < 200 || response.StatusCode >= 300 {
4235		return out, metadata, awsAwsquery_deserializeOpErrorDescribeReservedCacheNodes(response, &metadata)
4236	}
4237	output := &DescribeReservedCacheNodesOutput{}
4238	out.Result = output
4239
4240	var buff [1024]byte
4241	ringBuffer := smithyio.NewRingBuffer(buff[:])
4242	body := io.TeeReader(response.Body, ringBuffer)
4243	rootDecoder := xml.NewDecoder(body)
4244	t, err := smithyxml.FetchRootElement(rootDecoder)
4245	if err == io.EOF {
4246		return out, metadata, nil
4247	}
4248	if err != nil {
4249		var snapshot bytes.Buffer
4250		io.Copy(&snapshot, ringBuffer)
4251		return out, metadata, &smithy.DeserializationError{
4252			Err:      fmt.Errorf("failed to decode response body, %w", err),
4253			Snapshot: snapshot.Bytes(),
4254		}
4255	}
4256
4257	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
4258	t, err = decoder.GetElement("DescribeReservedCacheNodesResult")
4259	if err != nil {
4260		var snapshot bytes.Buffer
4261		io.Copy(&snapshot, ringBuffer)
4262		err = &smithy.DeserializationError{
4263			Err:      fmt.Errorf("failed to decode response body, %w", err),
4264			Snapshot: snapshot.Bytes(),
4265		}
4266		return out, metadata, err
4267	}
4268
4269	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
4270	err = awsAwsquery_deserializeOpDocumentDescribeReservedCacheNodesOutput(&output, decoder)
4271	if err != nil {
4272		var snapshot bytes.Buffer
4273		io.Copy(&snapshot, ringBuffer)
4274		err = &smithy.DeserializationError{
4275			Err:      fmt.Errorf("failed to decode response body, %w", err),
4276			Snapshot: snapshot.Bytes(),
4277		}
4278		return out, metadata, err
4279	}
4280
4281	return out, metadata, err
4282}
4283
4284func awsAwsquery_deserializeOpErrorDescribeReservedCacheNodes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4285	var errorBuffer bytes.Buffer
4286	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4287		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4288	}
4289	errorBody := bytes.NewReader(errorBuffer.Bytes())
4290
4291	errorCode := "UnknownError"
4292	errorMessage := errorCode
4293
4294	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
4295	if err != nil {
4296		return err
4297	}
4298	if reqID := errorComponents.RequestID; len(reqID) != 0 {
4299		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
4300	}
4301	if len(errorComponents.Code) != 0 {
4302		errorCode = errorComponents.Code
4303	}
4304	if len(errorComponents.Message) != 0 {
4305		errorMessage = errorComponents.Message
4306	}
4307	errorBody.Seek(0, io.SeekStart)
4308	switch {
4309	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
4310		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
4311
4312	case strings.EqualFold("InvalidParameterValueException", errorCode):
4313		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
4314
4315	case strings.EqualFold("ReservedCacheNodeNotFoundFault", errorCode):
4316		return awsAwsquery_deserializeErrorReservedCacheNodeNotFoundFault(response, errorBody)
4317
4318	default:
4319		genericError := &smithy.GenericAPIError{
4320			Code:    errorCode,
4321			Message: errorMessage,
4322		}
4323		return genericError
4324
4325	}
4326}
4327
4328type awsAwsquery_deserializeOpDescribeReservedCacheNodesOfferings struct {
4329}
4330
4331func (*awsAwsquery_deserializeOpDescribeReservedCacheNodesOfferings) ID() string {
4332	return "OperationDeserializer"
4333}
4334
4335func (m *awsAwsquery_deserializeOpDescribeReservedCacheNodesOfferings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4336	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4337) {
4338	out, metadata, err = next.HandleDeserialize(ctx, in)
4339	if err != nil {
4340		return out, metadata, err
4341	}
4342
4343	response, ok := out.RawResponse.(*smithyhttp.Response)
4344	if !ok {
4345		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4346	}
4347
4348	if response.StatusCode < 200 || response.StatusCode >= 300 {
4349		return out, metadata, awsAwsquery_deserializeOpErrorDescribeReservedCacheNodesOfferings(response, &metadata)
4350	}
4351	output := &DescribeReservedCacheNodesOfferingsOutput{}
4352	out.Result = output
4353
4354	var buff [1024]byte
4355	ringBuffer := smithyio.NewRingBuffer(buff[:])
4356	body := io.TeeReader(response.Body, ringBuffer)
4357	rootDecoder := xml.NewDecoder(body)
4358	t, err := smithyxml.FetchRootElement(rootDecoder)
4359	if err == io.EOF {
4360		return out, metadata, nil
4361	}
4362	if err != nil {
4363		var snapshot bytes.Buffer
4364		io.Copy(&snapshot, ringBuffer)
4365		return out, metadata, &smithy.DeserializationError{
4366			Err:      fmt.Errorf("failed to decode response body, %w", err),
4367			Snapshot: snapshot.Bytes(),
4368		}
4369	}
4370
4371	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
4372	t, err = decoder.GetElement("DescribeReservedCacheNodesOfferingsResult")
4373	if err != nil {
4374		var snapshot bytes.Buffer
4375		io.Copy(&snapshot, ringBuffer)
4376		err = &smithy.DeserializationError{
4377			Err:      fmt.Errorf("failed to decode response body, %w", err),
4378			Snapshot: snapshot.Bytes(),
4379		}
4380		return out, metadata, err
4381	}
4382
4383	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
4384	err = awsAwsquery_deserializeOpDocumentDescribeReservedCacheNodesOfferingsOutput(&output, decoder)
4385	if err != nil {
4386		var snapshot bytes.Buffer
4387		io.Copy(&snapshot, ringBuffer)
4388		err = &smithy.DeserializationError{
4389			Err:      fmt.Errorf("failed to decode response body, %w", err),
4390			Snapshot: snapshot.Bytes(),
4391		}
4392		return out, metadata, err
4393	}
4394
4395	return out, metadata, err
4396}
4397
4398func awsAwsquery_deserializeOpErrorDescribeReservedCacheNodesOfferings(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4399	var errorBuffer bytes.Buffer
4400	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4401		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4402	}
4403	errorBody := bytes.NewReader(errorBuffer.Bytes())
4404
4405	errorCode := "UnknownError"
4406	errorMessage := errorCode
4407
4408	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
4409	if err != nil {
4410		return err
4411	}
4412	if reqID := errorComponents.RequestID; len(reqID) != 0 {
4413		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
4414	}
4415	if len(errorComponents.Code) != 0 {
4416		errorCode = errorComponents.Code
4417	}
4418	if len(errorComponents.Message) != 0 {
4419		errorMessage = errorComponents.Message
4420	}
4421	errorBody.Seek(0, io.SeekStart)
4422	switch {
4423	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
4424		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
4425
4426	case strings.EqualFold("InvalidParameterValueException", errorCode):
4427		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
4428
4429	case strings.EqualFold("ReservedCacheNodesOfferingNotFoundFault", errorCode):
4430		return awsAwsquery_deserializeErrorReservedCacheNodesOfferingNotFoundFault(response, errorBody)
4431
4432	default:
4433		genericError := &smithy.GenericAPIError{
4434			Code:    errorCode,
4435			Message: errorMessage,
4436		}
4437		return genericError
4438
4439	}
4440}
4441
4442type awsAwsquery_deserializeOpDescribeServiceUpdates struct {
4443}
4444
4445func (*awsAwsquery_deserializeOpDescribeServiceUpdates) ID() string {
4446	return "OperationDeserializer"
4447}
4448
4449func (m *awsAwsquery_deserializeOpDescribeServiceUpdates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4450	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4451) {
4452	out, metadata, err = next.HandleDeserialize(ctx, in)
4453	if err != nil {
4454		return out, metadata, err
4455	}
4456
4457	response, ok := out.RawResponse.(*smithyhttp.Response)
4458	if !ok {
4459		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4460	}
4461
4462	if response.StatusCode < 200 || response.StatusCode >= 300 {
4463		return out, metadata, awsAwsquery_deserializeOpErrorDescribeServiceUpdates(response, &metadata)
4464	}
4465	output := &DescribeServiceUpdatesOutput{}
4466	out.Result = output
4467
4468	var buff [1024]byte
4469	ringBuffer := smithyio.NewRingBuffer(buff[:])
4470	body := io.TeeReader(response.Body, ringBuffer)
4471	rootDecoder := xml.NewDecoder(body)
4472	t, err := smithyxml.FetchRootElement(rootDecoder)
4473	if err == io.EOF {
4474		return out, metadata, nil
4475	}
4476	if err != nil {
4477		var snapshot bytes.Buffer
4478		io.Copy(&snapshot, ringBuffer)
4479		return out, metadata, &smithy.DeserializationError{
4480			Err:      fmt.Errorf("failed to decode response body, %w", err),
4481			Snapshot: snapshot.Bytes(),
4482		}
4483	}
4484
4485	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
4486	t, err = decoder.GetElement("DescribeServiceUpdatesResult")
4487	if err != nil {
4488		var snapshot bytes.Buffer
4489		io.Copy(&snapshot, ringBuffer)
4490		err = &smithy.DeserializationError{
4491			Err:      fmt.Errorf("failed to decode response body, %w", err),
4492			Snapshot: snapshot.Bytes(),
4493		}
4494		return out, metadata, err
4495	}
4496
4497	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
4498	err = awsAwsquery_deserializeOpDocumentDescribeServiceUpdatesOutput(&output, decoder)
4499	if err != nil {
4500		var snapshot bytes.Buffer
4501		io.Copy(&snapshot, ringBuffer)
4502		err = &smithy.DeserializationError{
4503			Err:      fmt.Errorf("failed to decode response body, %w", err),
4504			Snapshot: snapshot.Bytes(),
4505		}
4506		return out, metadata, err
4507	}
4508
4509	return out, metadata, err
4510}
4511
4512func awsAwsquery_deserializeOpErrorDescribeServiceUpdates(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4513	var errorBuffer bytes.Buffer
4514	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4515		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4516	}
4517	errorBody := bytes.NewReader(errorBuffer.Bytes())
4518
4519	errorCode := "UnknownError"
4520	errorMessage := errorCode
4521
4522	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
4523	if err != nil {
4524		return err
4525	}
4526	if reqID := errorComponents.RequestID; len(reqID) != 0 {
4527		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
4528	}
4529	if len(errorComponents.Code) != 0 {
4530		errorCode = errorComponents.Code
4531	}
4532	if len(errorComponents.Message) != 0 {
4533		errorMessage = errorComponents.Message
4534	}
4535	errorBody.Seek(0, io.SeekStart)
4536	switch {
4537	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
4538		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
4539
4540	case strings.EqualFold("InvalidParameterValueException", errorCode):
4541		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
4542
4543	case strings.EqualFold("ServiceUpdateNotFoundFault", errorCode):
4544		return awsAwsquery_deserializeErrorServiceUpdateNotFoundFault(response, errorBody)
4545
4546	default:
4547		genericError := &smithy.GenericAPIError{
4548			Code:    errorCode,
4549			Message: errorMessage,
4550		}
4551		return genericError
4552
4553	}
4554}
4555
4556type awsAwsquery_deserializeOpDescribeSnapshots struct {
4557}
4558
4559func (*awsAwsquery_deserializeOpDescribeSnapshots) ID() string {
4560	return "OperationDeserializer"
4561}
4562
4563func (m *awsAwsquery_deserializeOpDescribeSnapshots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4564	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4565) {
4566	out, metadata, err = next.HandleDeserialize(ctx, in)
4567	if err != nil {
4568		return out, metadata, err
4569	}
4570
4571	response, ok := out.RawResponse.(*smithyhttp.Response)
4572	if !ok {
4573		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4574	}
4575
4576	if response.StatusCode < 200 || response.StatusCode >= 300 {
4577		return out, metadata, awsAwsquery_deserializeOpErrorDescribeSnapshots(response, &metadata)
4578	}
4579	output := &DescribeSnapshotsOutput{}
4580	out.Result = output
4581
4582	var buff [1024]byte
4583	ringBuffer := smithyio.NewRingBuffer(buff[:])
4584	body := io.TeeReader(response.Body, ringBuffer)
4585	rootDecoder := xml.NewDecoder(body)
4586	t, err := smithyxml.FetchRootElement(rootDecoder)
4587	if err == io.EOF {
4588		return out, metadata, nil
4589	}
4590	if err != nil {
4591		var snapshot bytes.Buffer
4592		io.Copy(&snapshot, ringBuffer)
4593		return out, metadata, &smithy.DeserializationError{
4594			Err:      fmt.Errorf("failed to decode response body, %w", err),
4595			Snapshot: snapshot.Bytes(),
4596		}
4597	}
4598
4599	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
4600	t, err = decoder.GetElement("DescribeSnapshotsResult")
4601	if err != nil {
4602		var snapshot bytes.Buffer
4603		io.Copy(&snapshot, ringBuffer)
4604		err = &smithy.DeserializationError{
4605			Err:      fmt.Errorf("failed to decode response body, %w", err),
4606			Snapshot: snapshot.Bytes(),
4607		}
4608		return out, metadata, err
4609	}
4610
4611	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
4612	err = awsAwsquery_deserializeOpDocumentDescribeSnapshotsOutput(&output, decoder)
4613	if err != nil {
4614		var snapshot bytes.Buffer
4615		io.Copy(&snapshot, ringBuffer)
4616		err = &smithy.DeserializationError{
4617			Err:      fmt.Errorf("failed to decode response body, %w", err),
4618			Snapshot: snapshot.Bytes(),
4619		}
4620		return out, metadata, err
4621	}
4622
4623	return out, metadata, err
4624}
4625
4626func awsAwsquery_deserializeOpErrorDescribeSnapshots(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4627	var errorBuffer bytes.Buffer
4628	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4629		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4630	}
4631	errorBody := bytes.NewReader(errorBuffer.Bytes())
4632
4633	errorCode := "UnknownError"
4634	errorMessage := errorCode
4635
4636	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
4637	if err != nil {
4638		return err
4639	}
4640	if reqID := errorComponents.RequestID; len(reqID) != 0 {
4641		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
4642	}
4643	if len(errorComponents.Code) != 0 {
4644		errorCode = errorComponents.Code
4645	}
4646	if len(errorComponents.Message) != 0 {
4647		errorMessage = errorComponents.Message
4648	}
4649	errorBody.Seek(0, io.SeekStart)
4650	switch {
4651	case strings.EqualFold("CacheClusterNotFoundFault", errorCode):
4652		return awsAwsquery_deserializeErrorCacheClusterNotFoundFault(response, errorBody)
4653
4654	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
4655		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
4656
4657	case strings.EqualFold("InvalidParameterValueException", errorCode):
4658		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
4659
4660	case strings.EqualFold("SnapshotNotFoundFault", errorCode):
4661		return awsAwsquery_deserializeErrorSnapshotNotFoundFault(response, errorBody)
4662
4663	default:
4664		genericError := &smithy.GenericAPIError{
4665			Code:    errorCode,
4666			Message: errorMessage,
4667		}
4668		return genericError
4669
4670	}
4671}
4672
4673type awsAwsquery_deserializeOpDescribeUpdateActions struct {
4674}
4675
4676func (*awsAwsquery_deserializeOpDescribeUpdateActions) ID() string {
4677	return "OperationDeserializer"
4678}
4679
4680func (m *awsAwsquery_deserializeOpDescribeUpdateActions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4681	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4682) {
4683	out, metadata, err = next.HandleDeserialize(ctx, in)
4684	if err != nil {
4685		return out, metadata, err
4686	}
4687
4688	response, ok := out.RawResponse.(*smithyhttp.Response)
4689	if !ok {
4690		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4691	}
4692
4693	if response.StatusCode < 200 || response.StatusCode >= 300 {
4694		return out, metadata, awsAwsquery_deserializeOpErrorDescribeUpdateActions(response, &metadata)
4695	}
4696	output := &DescribeUpdateActionsOutput{}
4697	out.Result = output
4698
4699	var buff [1024]byte
4700	ringBuffer := smithyio.NewRingBuffer(buff[:])
4701	body := io.TeeReader(response.Body, ringBuffer)
4702	rootDecoder := xml.NewDecoder(body)
4703	t, err := smithyxml.FetchRootElement(rootDecoder)
4704	if err == io.EOF {
4705		return out, metadata, nil
4706	}
4707	if err != nil {
4708		var snapshot bytes.Buffer
4709		io.Copy(&snapshot, ringBuffer)
4710		return out, metadata, &smithy.DeserializationError{
4711			Err:      fmt.Errorf("failed to decode response body, %w", err),
4712			Snapshot: snapshot.Bytes(),
4713		}
4714	}
4715
4716	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
4717	t, err = decoder.GetElement("DescribeUpdateActionsResult")
4718	if err != nil {
4719		var snapshot bytes.Buffer
4720		io.Copy(&snapshot, ringBuffer)
4721		err = &smithy.DeserializationError{
4722			Err:      fmt.Errorf("failed to decode response body, %w", err),
4723			Snapshot: snapshot.Bytes(),
4724		}
4725		return out, metadata, err
4726	}
4727
4728	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
4729	err = awsAwsquery_deserializeOpDocumentDescribeUpdateActionsOutput(&output, decoder)
4730	if err != nil {
4731		var snapshot bytes.Buffer
4732		io.Copy(&snapshot, ringBuffer)
4733		err = &smithy.DeserializationError{
4734			Err:      fmt.Errorf("failed to decode response body, %w", err),
4735			Snapshot: snapshot.Bytes(),
4736		}
4737		return out, metadata, err
4738	}
4739
4740	return out, metadata, err
4741}
4742
4743func awsAwsquery_deserializeOpErrorDescribeUpdateActions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4744	var errorBuffer bytes.Buffer
4745	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4746		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4747	}
4748	errorBody := bytes.NewReader(errorBuffer.Bytes())
4749
4750	errorCode := "UnknownError"
4751	errorMessage := errorCode
4752
4753	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
4754	if err != nil {
4755		return err
4756	}
4757	if reqID := errorComponents.RequestID; len(reqID) != 0 {
4758		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
4759	}
4760	if len(errorComponents.Code) != 0 {
4761		errorCode = errorComponents.Code
4762	}
4763	if len(errorComponents.Message) != 0 {
4764		errorMessage = errorComponents.Message
4765	}
4766	errorBody.Seek(0, io.SeekStart)
4767	switch {
4768	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
4769		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
4770
4771	case strings.EqualFold("InvalidParameterValueException", errorCode):
4772		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
4773
4774	default:
4775		genericError := &smithy.GenericAPIError{
4776			Code:    errorCode,
4777			Message: errorMessage,
4778		}
4779		return genericError
4780
4781	}
4782}
4783
4784type awsAwsquery_deserializeOpDescribeUserGroups struct {
4785}
4786
4787func (*awsAwsquery_deserializeOpDescribeUserGroups) ID() string {
4788	return "OperationDeserializer"
4789}
4790
4791func (m *awsAwsquery_deserializeOpDescribeUserGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4792	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4793) {
4794	out, metadata, err = next.HandleDeserialize(ctx, in)
4795	if err != nil {
4796		return out, metadata, err
4797	}
4798
4799	response, ok := out.RawResponse.(*smithyhttp.Response)
4800	if !ok {
4801		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4802	}
4803
4804	if response.StatusCode < 200 || response.StatusCode >= 300 {
4805		return out, metadata, awsAwsquery_deserializeOpErrorDescribeUserGroups(response, &metadata)
4806	}
4807	output := &DescribeUserGroupsOutput{}
4808	out.Result = output
4809
4810	var buff [1024]byte
4811	ringBuffer := smithyio.NewRingBuffer(buff[:])
4812	body := io.TeeReader(response.Body, ringBuffer)
4813	rootDecoder := xml.NewDecoder(body)
4814	t, err := smithyxml.FetchRootElement(rootDecoder)
4815	if err == io.EOF {
4816		return out, metadata, nil
4817	}
4818	if err != nil {
4819		var snapshot bytes.Buffer
4820		io.Copy(&snapshot, ringBuffer)
4821		return out, metadata, &smithy.DeserializationError{
4822			Err:      fmt.Errorf("failed to decode response body, %w", err),
4823			Snapshot: snapshot.Bytes(),
4824		}
4825	}
4826
4827	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
4828	t, err = decoder.GetElement("DescribeUserGroupsResult")
4829	if err != nil {
4830		var snapshot bytes.Buffer
4831		io.Copy(&snapshot, ringBuffer)
4832		err = &smithy.DeserializationError{
4833			Err:      fmt.Errorf("failed to decode response body, %w", err),
4834			Snapshot: snapshot.Bytes(),
4835		}
4836		return out, metadata, err
4837	}
4838
4839	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
4840	err = awsAwsquery_deserializeOpDocumentDescribeUserGroupsOutput(&output, decoder)
4841	if err != nil {
4842		var snapshot bytes.Buffer
4843		io.Copy(&snapshot, ringBuffer)
4844		err = &smithy.DeserializationError{
4845			Err:      fmt.Errorf("failed to decode response body, %w", err),
4846			Snapshot: snapshot.Bytes(),
4847		}
4848		return out, metadata, err
4849	}
4850
4851	return out, metadata, err
4852}
4853
4854func awsAwsquery_deserializeOpErrorDescribeUserGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4855	var errorBuffer bytes.Buffer
4856	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4857		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4858	}
4859	errorBody := bytes.NewReader(errorBuffer.Bytes())
4860
4861	errorCode := "UnknownError"
4862	errorMessage := errorCode
4863
4864	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
4865	if err != nil {
4866		return err
4867	}
4868	if reqID := errorComponents.RequestID; len(reqID) != 0 {
4869		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
4870	}
4871	if len(errorComponents.Code) != 0 {
4872		errorCode = errorComponents.Code
4873	}
4874	if len(errorComponents.Message) != 0 {
4875		errorMessage = errorComponents.Message
4876	}
4877	errorBody.Seek(0, io.SeekStart)
4878	switch {
4879	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
4880		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
4881
4882	case strings.EqualFold("UserGroupNotFoundFault", errorCode):
4883		return awsAwsquery_deserializeErrorUserGroupNotFoundFault(response, errorBody)
4884
4885	default:
4886		genericError := &smithy.GenericAPIError{
4887			Code:    errorCode,
4888			Message: errorMessage,
4889		}
4890		return genericError
4891
4892	}
4893}
4894
4895type awsAwsquery_deserializeOpDescribeUsers struct {
4896}
4897
4898func (*awsAwsquery_deserializeOpDescribeUsers) ID() string {
4899	return "OperationDeserializer"
4900}
4901
4902func (m *awsAwsquery_deserializeOpDescribeUsers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4903	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4904) {
4905	out, metadata, err = next.HandleDeserialize(ctx, in)
4906	if err != nil {
4907		return out, metadata, err
4908	}
4909
4910	response, ok := out.RawResponse.(*smithyhttp.Response)
4911	if !ok {
4912		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4913	}
4914
4915	if response.StatusCode < 200 || response.StatusCode >= 300 {
4916		return out, metadata, awsAwsquery_deserializeOpErrorDescribeUsers(response, &metadata)
4917	}
4918	output := &DescribeUsersOutput{}
4919	out.Result = output
4920
4921	var buff [1024]byte
4922	ringBuffer := smithyio.NewRingBuffer(buff[:])
4923	body := io.TeeReader(response.Body, ringBuffer)
4924	rootDecoder := xml.NewDecoder(body)
4925	t, err := smithyxml.FetchRootElement(rootDecoder)
4926	if err == io.EOF {
4927		return out, metadata, nil
4928	}
4929	if err != nil {
4930		var snapshot bytes.Buffer
4931		io.Copy(&snapshot, ringBuffer)
4932		return out, metadata, &smithy.DeserializationError{
4933			Err:      fmt.Errorf("failed to decode response body, %w", err),
4934			Snapshot: snapshot.Bytes(),
4935		}
4936	}
4937
4938	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
4939	t, err = decoder.GetElement("DescribeUsersResult")
4940	if err != nil {
4941		var snapshot bytes.Buffer
4942		io.Copy(&snapshot, ringBuffer)
4943		err = &smithy.DeserializationError{
4944			Err:      fmt.Errorf("failed to decode response body, %w", err),
4945			Snapshot: snapshot.Bytes(),
4946		}
4947		return out, metadata, err
4948	}
4949
4950	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
4951	err = awsAwsquery_deserializeOpDocumentDescribeUsersOutput(&output, decoder)
4952	if err != nil {
4953		var snapshot bytes.Buffer
4954		io.Copy(&snapshot, ringBuffer)
4955		err = &smithy.DeserializationError{
4956			Err:      fmt.Errorf("failed to decode response body, %w", err),
4957			Snapshot: snapshot.Bytes(),
4958		}
4959		return out, metadata, err
4960	}
4961
4962	return out, metadata, err
4963}
4964
4965func awsAwsquery_deserializeOpErrorDescribeUsers(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4966	var errorBuffer bytes.Buffer
4967	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4968		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4969	}
4970	errorBody := bytes.NewReader(errorBuffer.Bytes())
4971
4972	errorCode := "UnknownError"
4973	errorMessage := errorCode
4974
4975	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
4976	if err != nil {
4977		return err
4978	}
4979	if reqID := errorComponents.RequestID; len(reqID) != 0 {
4980		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
4981	}
4982	if len(errorComponents.Code) != 0 {
4983		errorCode = errorComponents.Code
4984	}
4985	if len(errorComponents.Message) != 0 {
4986		errorMessage = errorComponents.Message
4987	}
4988	errorBody.Seek(0, io.SeekStart)
4989	switch {
4990	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
4991		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
4992
4993	case strings.EqualFold("UserNotFoundFault", errorCode):
4994		return awsAwsquery_deserializeErrorUserNotFoundFault(response, errorBody)
4995
4996	default:
4997		genericError := &smithy.GenericAPIError{
4998			Code:    errorCode,
4999			Message: errorMessage,
5000		}
5001		return genericError
5002
5003	}
5004}
5005
5006type awsAwsquery_deserializeOpDisassociateGlobalReplicationGroup struct {
5007}
5008
5009func (*awsAwsquery_deserializeOpDisassociateGlobalReplicationGroup) ID() string {
5010	return "OperationDeserializer"
5011}
5012
5013func (m *awsAwsquery_deserializeOpDisassociateGlobalReplicationGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5014	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5015) {
5016	out, metadata, err = next.HandleDeserialize(ctx, in)
5017	if err != nil {
5018		return out, metadata, err
5019	}
5020
5021	response, ok := out.RawResponse.(*smithyhttp.Response)
5022	if !ok {
5023		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5024	}
5025
5026	if response.StatusCode < 200 || response.StatusCode >= 300 {
5027		return out, metadata, awsAwsquery_deserializeOpErrorDisassociateGlobalReplicationGroup(response, &metadata)
5028	}
5029	output := &DisassociateGlobalReplicationGroupOutput{}
5030	out.Result = output
5031
5032	var buff [1024]byte
5033	ringBuffer := smithyio.NewRingBuffer(buff[:])
5034	body := io.TeeReader(response.Body, ringBuffer)
5035	rootDecoder := xml.NewDecoder(body)
5036	t, err := smithyxml.FetchRootElement(rootDecoder)
5037	if err == io.EOF {
5038		return out, metadata, nil
5039	}
5040	if err != nil {
5041		var snapshot bytes.Buffer
5042		io.Copy(&snapshot, ringBuffer)
5043		return out, metadata, &smithy.DeserializationError{
5044			Err:      fmt.Errorf("failed to decode response body, %w", err),
5045			Snapshot: snapshot.Bytes(),
5046		}
5047	}
5048
5049	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
5050	t, err = decoder.GetElement("DisassociateGlobalReplicationGroupResult")
5051	if err != nil {
5052		var snapshot bytes.Buffer
5053		io.Copy(&snapshot, ringBuffer)
5054		err = &smithy.DeserializationError{
5055			Err:      fmt.Errorf("failed to decode response body, %w", err),
5056			Snapshot: snapshot.Bytes(),
5057		}
5058		return out, metadata, err
5059	}
5060
5061	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
5062	err = awsAwsquery_deserializeOpDocumentDisassociateGlobalReplicationGroupOutput(&output, decoder)
5063	if err != nil {
5064		var snapshot bytes.Buffer
5065		io.Copy(&snapshot, ringBuffer)
5066		err = &smithy.DeserializationError{
5067			Err:      fmt.Errorf("failed to decode response body, %w", err),
5068			Snapshot: snapshot.Bytes(),
5069		}
5070		return out, metadata, err
5071	}
5072
5073	return out, metadata, err
5074}
5075
5076func awsAwsquery_deserializeOpErrorDisassociateGlobalReplicationGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5077	var errorBuffer bytes.Buffer
5078	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5079		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5080	}
5081	errorBody := bytes.NewReader(errorBuffer.Bytes())
5082
5083	errorCode := "UnknownError"
5084	errorMessage := errorCode
5085
5086	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
5087	if err != nil {
5088		return err
5089	}
5090	if reqID := errorComponents.RequestID; len(reqID) != 0 {
5091		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
5092	}
5093	if len(errorComponents.Code) != 0 {
5094		errorCode = errorComponents.Code
5095	}
5096	if len(errorComponents.Message) != 0 {
5097		errorMessage = errorComponents.Message
5098	}
5099	errorBody.Seek(0, io.SeekStart)
5100	switch {
5101	case strings.EqualFold("GlobalReplicationGroupNotFoundFault", errorCode):
5102		return awsAwsquery_deserializeErrorGlobalReplicationGroupNotFoundFault(response, errorBody)
5103
5104	case strings.EqualFold("InvalidGlobalReplicationGroupStateFault", errorCode):
5105		return awsAwsquery_deserializeErrorInvalidGlobalReplicationGroupStateFault(response, errorBody)
5106
5107	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
5108		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
5109
5110	case strings.EqualFold("InvalidParameterValueException", errorCode):
5111		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
5112
5113	default:
5114		genericError := &smithy.GenericAPIError{
5115			Code:    errorCode,
5116			Message: errorMessage,
5117		}
5118		return genericError
5119
5120	}
5121}
5122
5123type awsAwsquery_deserializeOpFailoverGlobalReplicationGroup struct {
5124}
5125
5126func (*awsAwsquery_deserializeOpFailoverGlobalReplicationGroup) ID() string {
5127	return "OperationDeserializer"
5128}
5129
5130func (m *awsAwsquery_deserializeOpFailoverGlobalReplicationGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5131	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5132) {
5133	out, metadata, err = next.HandleDeserialize(ctx, in)
5134	if err != nil {
5135		return out, metadata, err
5136	}
5137
5138	response, ok := out.RawResponse.(*smithyhttp.Response)
5139	if !ok {
5140		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5141	}
5142
5143	if response.StatusCode < 200 || response.StatusCode >= 300 {
5144		return out, metadata, awsAwsquery_deserializeOpErrorFailoverGlobalReplicationGroup(response, &metadata)
5145	}
5146	output := &FailoverGlobalReplicationGroupOutput{}
5147	out.Result = output
5148
5149	var buff [1024]byte
5150	ringBuffer := smithyio.NewRingBuffer(buff[:])
5151	body := io.TeeReader(response.Body, ringBuffer)
5152	rootDecoder := xml.NewDecoder(body)
5153	t, err := smithyxml.FetchRootElement(rootDecoder)
5154	if err == io.EOF {
5155		return out, metadata, nil
5156	}
5157	if err != nil {
5158		var snapshot bytes.Buffer
5159		io.Copy(&snapshot, ringBuffer)
5160		return out, metadata, &smithy.DeserializationError{
5161			Err:      fmt.Errorf("failed to decode response body, %w", err),
5162			Snapshot: snapshot.Bytes(),
5163		}
5164	}
5165
5166	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
5167	t, err = decoder.GetElement("FailoverGlobalReplicationGroupResult")
5168	if err != nil {
5169		var snapshot bytes.Buffer
5170		io.Copy(&snapshot, ringBuffer)
5171		err = &smithy.DeserializationError{
5172			Err:      fmt.Errorf("failed to decode response body, %w", err),
5173			Snapshot: snapshot.Bytes(),
5174		}
5175		return out, metadata, err
5176	}
5177
5178	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
5179	err = awsAwsquery_deserializeOpDocumentFailoverGlobalReplicationGroupOutput(&output, decoder)
5180	if err != nil {
5181		var snapshot bytes.Buffer
5182		io.Copy(&snapshot, ringBuffer)
5183		err = &smithy.DeserializationError{
5184			Err:      fmt.Errorf("failed to decode response body, %w", err),
5185			Snapshot: snapshot.Bytes(),
5186		}
5187		return out, metadata, err
5188	}
5189
5190	return out, metadata, err
5191}
5192
5193func awsAwsquery_deserializeOpErrorFailoverGlobalReplicationGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5194	var errorBuffer bytes.Buffer
5195	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5196		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5197	}
5198	errorBody := bytes.NewReader(errorBuffer.Bytes())
5199
5200	errorCode := "UnknownError"
5201	errorMessage := errorCode
5202
5203	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
5204	if err != nil {
5205		return err
5206	}
5207	if reqID := errorComponents.RequestID; len(reqID) != 0 {
5208		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
5209	}
5210	if len(errorComponents.Code) != 0 {
5211		errorCode = errorComponents.Code
5212	}
5213	if len(errorComponents.Message) != 0 {
5214		errorMessage = errorComponents.Message
5215	}
5216	errorBody.Seek(0, io.SeekStart)
5217	switch {
5218	case strings.EqualFold("GlobalReplicationGroupNotFoundFault", errorCode):
5219		return awsAwsquery_deserializeErrorGlobalReplicationGroupNotFoundFault(response, errorBody)
5220
5221	case strings.EqualFold("InvalidGlobalReplicationGroupStateFault", errorCode):
5222		return awsAwsquery_deserializeErrorInvalidGlobalReplicationGroupStateFault(response, errorBody)
5223
5224	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
5225		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
5226
5227	case strings.EqualFold("InvalidParameterValueException", errorCode):
5228		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
5229
5230	default:
5231		genericError := &smithy.GenericAPIError{
5232			Code:    errorCode,
5233			Message: errorMessage,
5234		}
5235		return genericError
5236
5237	}
5238}
5239
5240type awsAwsquery_deserializeOpIncreaseNodeGroupsInGlobalReplicationGroup struct {
5241}
5242
5243func (*awsAwsquery_deserializeOpIncreaseNodeGroupsInGlobalReplicationGroup) ID() string {
5244	return "OperationDeserializer"
5245}
5246
5247func (m *awsAwsquery_deserializeOpIncreaseNodeGroupsInGlobalReplicationGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5248	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5249) {
5250	out, metadata, err = next.HandleDeserialize(ctx, in)
5251	if err != nil {
5252		return out, metadata, err
5253	}
5254
5255	response, ok := out.RawResponse.(*smithyhttp.Response)
5256	if !ok {
5257		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5258	}
5259
5260	if response.StatusCode < 200 || response.StatusCode >= 300 {
5261		return out, metadata, awsAwsquery_deserializeOpErrorIncreaseNodeGroupsInGlobalReplicationGroup(response, &metadata)
5262	}
5263	output := &IncreaseNodeGroupsInGlobalReplicationGroupOutput{}
5264	out.Result = output
5265
5266	var buff [1024]byte
5267	ringBuffer := smithyio.NewRingBuffer(buff[:])
5268	body := io.TeeReader(response.Body, ringBuffer)
5269	rootDecoder := xml.NewDecoder(body)
5270	t, err := smithyxml.FetchRootElement(rootDecoder)
5271	if err == io.EOF {
5272		return out, metadata, nil
5273	}
5274	if err != nil {
5275		var snapshot bytes.Buffer
5276		io.Copy(&snapshot, ringBuffer)
5277		return out, metadata, &smithy.DeserializationError{
5278			Err:      fmt.Errorf("failed to decode response body, %w", err),
5279			Snapshot: snapshot.Bytes(),
5280		}
5281	}
5282
5283	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
5284	t, err = decoder.GetElement("IncreaseNodeGroupsInGlobalReplicationGroupResult")
5285	if err != nil {
5286		var snapshot bytes.Buffer
5287		io.Copy(&snapshot, ringBuffer)
5288		err = &smithy.DeserializationError{
5289			Err:      fmt.Errorf("failed to decode response body, %w", err),
5290			Snapshot: snapshot.Bytes(),
5291		}
5292		return out, metadata, err
5293	}
5294
5295	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
5296	err = awsAwsquery_deserializeOpDocumentIncreaseNodeGroupsInGlobalReplicationGroupOutput(&output, decoder)
5297	if err != nil {
5298		var snapshot bytes.Buffer
5299		io.Copy(&snapshot, ringBuffer)
5300		err = &smithy.DeserializationError{
5301			Err:      fmt.Errorf("failed to decode response body, %w", err),
5302			Snapshot: snapshot.Bytes(),
5303		}
5304		return out, metadata, err
5305	}
5306
5307	return out, metadata, err
5308}
5309
5310func awsAwsquery_deserializeOpErrorIncreaseNodeGroupsInGlobalReplicationGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5311	var errorBuffer bytes.Buffer
5312	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5313		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5314	}
5315	errorBody := bytes.NewReader(errorBuffer.Bytes())
5316
5317	errorCode := "UnknownError"
5318	errorMessage := errorCode
5319
5320	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
5321	if err != nil {
5322		return err
5323	}
5324	if reqID := errorComponents.RequestID; len(reqID) != 0 {
5325		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
5326	}
5327	if len(errorComponents.Code) != 0 {
5328		errorCode = errorComponents.Code
5329	}
5330	if len(errorComponents.Message) != 0 {
5331		errorMessage = errorComponents.Message
5332	}
5333	errorBody.Seek(0, io.SeekStart)
5334	switch {
5335	case strings.EqualFold("GlobalReplicationGroupNotFoundFault", errorCode):
5336		return awsAwsquery_deserializeErrorGlobalReplicationGroupNotFoundFault(response, errorBody)
5337
5338	case strings.EqualFold("InvalidGlobalReplicationGroupStateFault", errorCode):
5339		return awsAwsquery_deserializeErrorInvalidGlobalReplicationGroupStateFault(response, errorBody)
5340
5341	case strings.EqualFold("InvalidParameterValueException", errorCode):
5342		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
5343
5344	default:
5345		genericError := &smithy.GenericAPIError{
5346			Code:    errorCode,
5347			Message: errorMessage,
5348		}
5349		return genericError
5350
5351	}
5352}
5353
5354type awsAwsquery_deserializeOpIncreaseReplicaCount struct {
5355}
5356
5357func (*awsAwsquery_deserializeOpIncreaseReplicaCount) ID() string {
5358	return "OperationDeserializer"
5359}
5360
5361func (m *awsAwsquery_deserializeOpIncreaseReplicaCount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5362	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5363) {
5364	out, metadata, err = next.HandleDeserialize(ctx, in)
5365	if err != nil {
5366		return out, metadata, err
5367	}
5368
5369	response, ok := out.RawResponse.(*smithyhttp.Response)
5370	if !ok {
5371		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5372	}
5373
5374	if response.StatusCode < 200 || response.StatusCode >= 300 {
5375		return out, metadata, awsAwsquery_deserializeOpErrorIncreaseReplicaCount(response, &metadata)
5376	}
5377	output := &IncreaseReplicaCountOutput{}
5378	out.Result = output
5379
5380	var buff [1024]byte
5381	ringBuffer := smithyio.NewRingBuffer(buff[:])
5382	body := io.TeeReader(response.Body, ringBuffer)
5383	rootDecoder := xml.NewDecoder(body)
5384	t, err := smithyxml.FetchRootElement(rootDecoder)
5385	if err == io.EOF {
5386		return out, metadata, nil
5387	}
5388	if err != nil {
5389		var snapshot bytes.Buffer
5390		io.Copy(&snapshot, ringBuffer)
5391		return out, metadata, &smithy.DeserializationError{
5392			Err:      fmt.Errorf("failed to decode response body, %w", err),
5393			Snapshot: snapshot.Bytes(),
5394		}
5395	}
5396
5397	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
5398	t, err = decoder.GetElement("IncreaseReplicaCountResult")
5399	if err != nil {
5400		var snapshot bytes.Buffer
5401		io.Copy(&snapshot, ringBuffer)
5402		err = &smithy.DeserializationError{
5403			Err:      fmt.Errorf("failed to decode response body, %w", err),
5404			Snapshot: snapshot.Bytes(),
5405		}
5406		return out, metadata, err
5407	}
5408
5409	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
5410	err = awsAwsquery_deserializeOpDocumentIncreaseReplicaCountOutput(&output, decoder)
5411	if err != nil {
5412		var snapshot bytes.Buffer
5413		io.Copy(&snapshot, ringBuffer)
5414		err = &smithy.DeserializationError{
5415			Err:      fmt.Errorf("failed to decode response body, %w", err),
5416			Snapshot: snapshot.Bytes(),
5417		}
5418		return out, metadata, err
5419	}
5420
5421	return out, metadata, err
5422}
5423
5424func awsAwsquery_deserializeOpErrorIncreaseReplicaCount(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5425	var errorBuffer bytes.Buffer
5426	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5427		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5428	}
5429	errorBody := bytes.NewReader(errorBuffer.Bytes())
5430
5431	errorCode := "UnknownError"
5432	errorMessage := errorCode
5433
5434	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
5435	if err != nil {
5436		return err
5437	}
5438	if reqID := errorComponents.RequestID; len(reqID) != 0 {
5439		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
5440	}
5441	if len(errorComponents.Code) != 0 {
5442		errorCode = errorComponents.Code
5443	}
5444	if len(errorComponents.Message) != 0 {
5445		errorMessage = errorComponents.Message
5446	}
5447	errorBody.Seek(0, io.SeekStart)
5448	switch {
5449	case strings.EqualFold("ClusterQuotaForCustomerExceededFault", errorCode):
5450		return awsAwsquery_deserializeErrorClusterQuotaForCustomerExceededFault(response, errorBody)
5451
5452	case strings.EqualFold("InsufficientCacheClusterCapacityFault", errorCode):
5453		return awsAwsquery_deserializeErrorInsufficientCacheClusterCapacityFault(response, errorBody)
5454
5455	case strings.EqualFold("InvalidCacheClusterStateFault", errorCode):
5456		return awsAwsquery_deserializeErrorInvalidCacheClusterStateFault(response, errorBody)
5457
5458	case strings.EqualFold("InvalidKMSKeyFault", errorCode):
5459		return awsAwsquery_deserializeErrorInvalidKMSKeyFault(response, errorBody)
5460
5461	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
5462		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
5463
5464	case strings.EqualFold("InvalidParameterValueException", errorCode):
5465		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
5466
5467	case strings.EqualFold("InvalidReplicationGroupStateFault", errorCode):
5468		return awsAwsquery_deserializeErrorInvalidReplicationGroupStateFault(response, errorBody)
5469
5470	case strings.EqualFold("InvalidVPCNetworkStateFault", errorCode):
5471		return awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response, errorBody)
5472
5473	case strings.EqualFold("NodeGroupsPerReplicationGroupQuotaExceededFault", errorCode):
5474		return awsAwsquery_deserializeErrorNodeGroupsPerReplicationGroupQuotaExceededFault(response, errorBody)
5475
5476	case strings.EqualFold("NodeQuotaForCustomerExceededFault", errorCode):
5477		return awsAwsquery_deserializeErrorNodeQuotaForCustomerExceededFault(response, errorBody)
5478
5479	case strings.EqualFold("NoOperationFault", errorCode):
5480		return awsAwsquery_deserializeErrorNoOperationFault(response, errorBody)
5481
5482	case strings.EqualFold("ReplicationGroupNotFoundFault", errorCode):
5483		return awsAwsquery_deserializeErrorReplicationGroupNotFoundFault(response, errorBody)
5484
5485	default:
5486		genericError := &smithy.GenericAPIError{
5487			Code:    errorCode,
5488			Message: errorMessage,
5489		}
5490		return genericError
5491
5492	}
5493}
5494
5495type awsAwsquery_deserializeOpListAllowedNodeTypeModifications struct {
5496}
5497
5498func (*awsAwsquery_deserializeOpListAllowedNodeTypeModifications) ID() string {
5499	return "OperationDeserializer"
5500}
5501
5502func (m *awsAwsquery_deserializeOpListAllowedNodeTypeModifications) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5503	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5504) {
5505	out, metadata, err = next.HandleDeserialize(ctx, in)
5506	if err != nil {
5507		return out, metadata, err
5508	}
5509
5510	response, ok := out.RawResponse.(*smithyhttp.Response)
5511	if !ok {
5512		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5513	}
5514
5515	if response.StatusCode < 200 || response.StatusCode >= 300 {
5516		return out, metadata, awsAwsquery_deserializeOpErrorListAllowedNodeTypeModifications(response, &metadata)
5517	}
5518	output := &ListAllowedNodeTypeModificationsOutput{}
5519	out.Result = output
5520
5521	var buff [1024]byte
5522	ringBuffer := smithyio.NewRingBuffer(buff[:])
5523	body := io.TeeReader(response.Body, ringBuffer)
5524	rootDecoder := xml.NewDecoder(body)
5525	t, err := smithyxml.FetchRootElement(rootDecoder)
5526	if err == io.EOF {
5527		return out, metadata, nil
5528	}
5529	if err != nil {
5530		var snapshot bytes.Buffer
5531		io.Copy(&snapshot, ringBuffer)
5532		return out, metadata, &smithy.DeserializationError{
5533			Err:      fmt.Errorf("failed to decode response body, %w", err),
5534			Snapshot: snapshot.Bytes(),
5535		}
5536	}
5537
5538	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
5539	t, err = decoder.GetElement("ListAllowedNodeTypeModificationsResult")
5540	if err != nil {
5541		var snapshot bytes.Buffer
5542		io.Copy(&snapshot, ringBuffer)
5543		err = &smithy.DeserializationError{
5544			Err:      fmt.Errorf("failed to decode response body, %w", err),
5545			Snapshot: snapshot.Bytes(),
5546		}
5547		return out, metadata, err
5548	}
5549
5550	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
5551	err = awsAwsquery_deserializeOpDocumentListAllowedNodeTypeModificationsOutput(&output, decoder)
5552	if err != nil {
5553		var snapshot bytes.Buffer
5554		io.Copy(&snapshot, ringBuffer)
5555		err = &smithy.DeserializationError{
5556			Err:      fmt.Errorf("failed to decode response body, %w", err),
5557			Snapshot: snapshot.Bytes(),
5558		}
5559		return out, metadata, err
5560	}
5561
5562	return out, metadata, err
5563}
5564
5565func awsAwsquery_deserializeOpErrorListAllowedNodeTypeModifications(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5566	var errorBuffer bytes.Buffer
5567	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5568		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5569	}
5570	errorBody := bytes.NewReader(errorBuffer.Bytes())
5571
5572	errorCode := "UnknownError"
5573	errorMessage := errorCode
5574
5575	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
5576	if err != nil {
5577		return err
5578	}
5579	if reqID := errorComponents.RequestID; len(reqID) != 0 {
5580		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
5581	}
5582	if len(errorComponents.Code) != 0 {
5583		errorCode = errorComponents.Code
5584	}
5585	if len(errorComponents.Message) != 0 {
5586		errorMessage = errorComponents.Message
5587	}
5588	errorBody.Seek(0, io.SeekStart)
5589	switch {
5590	case strings.EqualFold("CacheClusterNotFoundFault", errorCode):
5591		return awsAwsquery_deserializeErrorCacheClusterNotFoundFault(response, errorBody)
5592
5593	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
5594		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
5595
5596	case strings.EqualFold("InvalidParameterValueException", errorCode):
5597		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
5598
5599	case strings.EqualFold("ReplicationGroupNotFoundFault", errorCode):
5600		return awsAwsquery_deserializeErrorReplicationGroupNotFoundFault(response, errorBody)
5601
5602	default:
5603		genericError := &smithy.GenericAPIError{
5604			Code:    errorCode,
5605			Message: errorMessage,
5606		}
5607		return genericError
5608
5609	}
5610}
5611
5612type awsAwsquery_deserializeOpListTagsForResource struct {
5613}
5614
5615func (*awsAwsquery_deserializeOpListTagsForResource) ID() string {
5616	return "OperationDeserializer"
5617}
5618
5619func (m *awsAwsquery_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5620	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5621) {
5622	out, metadata, err = next.HandleDeserialize(ctx, in)
5623	if err != nil {
5624		return out, metadata, err
5625	}
5626
5627	response, ok := out.RawResponse.(*smithyhttp.Response)
5628	if !ok {
5629		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5630	}
5631
5632	if response.StatusCode < 200 || response.StatusCode >= 300 {
5633		return out, metadata, awsAwsquery_deserializeOpErrorListTagsForResource(response, &metadata)
5634	}
5635	output := &ListTagsForResourceOutput{}
5636	out.Result = output
5637
5638	var buff [1024]byte
5639	ringBuffer := smithyio.NewRingBuffer(buff[:])
5640	body := io.TeeReader(response.Body, ringBuffer)
5641	rootDecoder := xml.NewDecoder(body)
5642	t, err := smithyxml.FetchRootElement(rootDecoder)
5643	if err == io.EOF {
5644		return out, metadata, nil
5645	}
5646	if err != nil {
5647		var snapshot bytes.Buffer
5648		io.Copy(&snapshot, ringBuffer)
5649		return out, metadata, &smithy.DeserializationError{
5650			Err:      fmt.Errorf("failed to decode response body, %w", err),
5651			Snapshot: snapshot.Bytes(),
5652		}
5653	}
5654
5655	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
5656	t, err = decoder.GetElement("ListTagsForResourceResult")
5657	if err != nil {
5658		var snapshot bytes.Buffer
5659		io.Copy(&snapshot, ringBuffer)
5660		err = &smithy.DeserializationError{
5661			Err:      fmt.Errorf("failed to decode response body, %w", err),
5662			Snapshot: snapshot.Bytes(),
5663		}
5664		return out, metadata, err
5665	}
5666
5667	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
5668	err = awsAwsquery_deserializeOpDocumentListTagsForResourceOutput(&output, decoder)
5669	if err != nil {
5670		var snapshot bytes.Buffer
5671		io.Copy(&snapshot, ringBuffer)
5672		err = &smithy.DeserializationError{
5673			Err:      fmt.Errorf("failed to decode response body, %w", err),
5674			Snapshot: snapshot.Bytes(),
5675		}
5676		return out, metadata, err
5677	}
5678
5679	return out, metadata, err
5680}
5681
5682func awsAwsquery_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5683	var errorBuffer bytes.Buffer
5684	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5685		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5686	}
5687	errorBody := bytes.NewReader(errorBuffer.Bytes())
5688
5689	errorCode := "UnknownError"
5690	errorMessage := errorCode
5691
5692	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
5693	if err != nil {
5694		return err
5695	}
5696	if reqID := errorComponents.RequestID; len(reqID) != 0 {
5697		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
5698	}
5699	if len(errorComponents.Code) != 0 {
5700		errorCode = errorComponents.Code
5701	}
5702	if len(errorComponents.Message) != 0 {
5703		errorMessage = errorComponents.Message
5704	}
5705	errorBody.Seek(0, io.SeekStart)
5706	switch {
5707	case strings.EqualFold("CacheClusterNotFoundFault", errorCode):
5708		return awsAwsquery_deserializeErrorCacheClusterNotFoundFault(response, errorBody)
5709
5710	case strings.EqualFold("InvalidARNFault", errorCode):
5711		return awsAwsquery_deserializeErrorInvalidARNFault(response, errorBody)
5712
5713	case strings.EqualFold("SnapshotNotFoundFault", errorCode):
5714		return awsAwsquery_deserializeErrorSnapshotNotFoundFault(response, errorBody)
5715
5716	default:
5717		genericError := &smithy.GenericAPIError{
5718			Code:    errorCode,
5719			Message: errorMessage,
5720		}
5721		return genericError
5722
5723	}
5724}
5725
5726type awsAwsquery_deserializeOpModifyCacheCluster struct {
5727}
5728
5729func (*awsAwsquery_deserializeOpModifyCacheCluster) ID() string {
5730	return "OperationDeserializer"
5731}
5732
5733func (m *awsAwsquery_deserializeOpModifyCacheCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5734	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5735) {
5736	out, metadata, err = next.HandleDeserialize(ctx, in)
5737	if err != nil {
5738		return out, metadata, err
5739	}
5740
5741	response, ok := out.RawResponse.(*smithyhttp.Response)
5742	if !ok {
5743		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5744	}
5745
5746	if response.StatusCode < 200 || response.StatusCode >= 300 {
5747		return out, metadata, awsAwsquery_deserializeOpErrorModifyCacheCluster(response, &metadata)
5748	}
5749	output := &ModifyCacheClusterOutput{}
5750	out.Result = output
5751
5752	var buff [1024]byte
5753	ringBuffer := smithyio.NewRingBuffer(buff[:])
5754	body := io.TeeReader(response.Body, ringBuffer)
5755	rootDecoder := xml.NewDecoder(body)
5756	t, err := smithyxml.FetchRootElement(rootDecoder)
5757	if err == io.EOF {
5758		return out, metadata, nil
5759	}
5760	if err != nil {
5761		var snapshot bytes.Buffer
5762		io.Copy(&snapshot, ringBuffer)
5763		return out, metadata, &smithy.DeserializationError{
5764			Err:      fmt.Errorf("failed to decode response body, %w", err),
5765			Snapshot: snapshot.Bytes(),
5766		}
5767	}
5768
5769	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
5770	t, err = decoder.GetElement("ModifyCacheClusterResult")
5771	if err != nil {
5772		var snapshot bytes.Buffer
5773		io.Copy(&snapshot, ringBuffer)
5774		err = &smithy.DeserializationError{
5775			Err:      fmt.Errorf("failed to decode response body, %w", err),
5776			Snapshot: snapshot.Bytes(),
5777		}
5778		return out, metadata, err
5779	}
5780
5781	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
5782	err = awsAwsquery_deserializeOpDocumentModifyCacheClusterOutput(&output, decoder)
5783	if err != nil {
5784		var snapshot bytes.Buffer
5785		io.Copy(&snapshot, ringBuffer)
5786		err = &smithy.DeserializationError{
5787			Err:      fmt.Errorf("failed to decode response body, %w", err),
5788			Snapshot: snapshot.Bytes(),
5789		}
5790		return out, metadata, err
5791	}
5792
5793	return out, metadata, err
5794}
5795
5796func awsAwsquery_deserializeOpErrorModifyCacheCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5797	var errorBuffer bytes.Buffer
5798	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5799		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5800	}
5801	errorBody := bytes.NewReader(errorBuffer.Bytes())
5802
5803	errorCode := "UnknownError"
5804	errorMessage := errorCode
5805
5806	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
5807	if err != nil {
5808		return err
5809	}
5810	if reqID := errorComponents.RequestID; len(reqID) != 0 {
5811		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
5812	}
5813	if len(errorComponents.Code) != 0 {
5814		errorCode = errorComponents.Code
5815	}
5816	if len(errorComponents.Message) != 0 {
5817		errorMessage = errorComponents.Message
5818	}
5819	errorBody.Seek(0, io.SeekStart)
5820	switch {
5821	case strings.EqualFold("CacheClusterNotFoundFault", errorCode):
5822		return awsAwsquery_deserializeErrorCacheClusterNotFoundFault(response, errorBody)
5823
5824	case strings.EqualFold("CacheParameterGroupNotFoundFault", errorCode):
5825		return awsAwsquery_deserializeErrorCacheParameterGroupNotFoundFault(response, errorBody)
5826
5827	case strings.EqualFold("CacheSecurityGroupNotFoundFault", errorCode):
5828		return awsAwsquery_deserializeErrorCacheSecurityGroupNotFoundFault(response, errorBody)
5829
5830	case strings.EqualFold("InsufficientCacheClusterCapacityFault", errorCode):
5831		return awsAwsquery_deserializeErrorInsufficientCacheClusterCapacityFault(response, errorBody)
5832
5833	case strings.EqualFold("InvalidCacheClusterStateFault", errorCode):
5834		return awsAwsquery_deserializeErrorInvalidCacheClusterStateFault(response, errorBody)
5835
5836	case strings.EqualFold("InvalidCacheSecurityGroupStateFault", errorCode):
5837		return awsAwsquery_deserializeErrorInvalidCacheSecurityGroupStateFault(response, errorBody)
5838
5839	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
5840		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
5841
5842	case strings.EqualFold("InvalidParameterValueException", errorCode):
5843		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
5844
5845	case strings.EqualFold("InvalidVPCNetworkStateFault", errorCode):
5846		return awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response, errorBody)
5847
5848	case strings.EqualFold("NodeQuotaForClusterExceededFault", errorCode):
5849		return awsAwsquery_deserializeErrorNodeQuotaForClusterExceededFault(response, errorBody)
5850
5851	case strings.EqualFold("NodeQuotaForCustomerExceededFault", errorCode):
5852		return awsAwsquery_deserializeErrorNodeQuotaForCustomerExceededFault(response, errorBody)
5853
5854	default:
5855		genericError := &smithy.GenericAPIError{
5856			Code:    errorCode,
5857			Message: errorMessage,
5858		}
5859		return genericError
5860
5861	}
5862}
5863
5864type awsAwsquery_deserializeOpModifyCacheParameterGroup struct {
5865}
5866
5867func (*awsAwsquery_deserializeOpModifyCacheParameterGroup) ID() string {
5868	return "OperationDeserializer"
5869}
5870
5871func (m *awsAwsquery_deserializeOpModifyCacheParameterGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5872	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5873) {
5874	out, metadata, err = next.HandleDeserialize(ctx, in)
5875	if err != nil {
5876		return out, metadata, err
5877	}
5878
5879	response, ok := out.RawResponse.(*smithyhttp.Response)
5880	if !ok {
5881		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5882	}
5883
5884	if response.StatusCode < 200 || response.StatusCode >= 300 {
5885		return out, metadata, awsAwsquery_deserializeOpErrorModifyCacheParameterGroup(response, &metadata)
5886	}
5887	output := &ModifyCacheParameterGroupOutput{}
5888	out.Result = output
5889
5890	var buff [1024]byte
5891	ringBuffer := smithyio.NewRingBuffer(buff[:])
5892	body := io.TeeReader(response.Body, ringBuffer)
5893	rootDecoder := xml.NewDecoder(body)
5894	t, err := smithyxml.FetchRootElement(rootDecoder)
5895	if err == io.EOF {
5896		return out, metadata, nil
5897	}
5898	if err != nil {
5899		var snapshot bytes.Buffer
5900		io.Copy(&snapshot, ringBuffer)
5901		return out, metadata, &smithy.DeserializationError{
5902			Err:      fmt.Errorf("failed to decode response body, %w", err),
5903			Snapshot: snapshot.Bytes(),
5904		}
5905	}
5906
5907	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
5908	t, err = decoder.GetElement("ModifyCacheParameterGroupResult")
5909	if err != nil {
5910		var snapshot bytes.Buffer
5911		io.Copy(&snapshot, ringBuffer)
5912		err = &smithy.DeserializationError{
5913			Err:      fmt.Errorf("failed to decode response body, %w", err),
5914			Snapshot: snapshot.Bytes(),
5915		}
5916		return out, metadata, err
5917	}
5918
5919	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
5920	err = awsAwsquery_deserializeOpDocumentModifyCacheParameterGroupOutput(&output, decoder)
5921	if err != nil {
5922		var snapshot bytes.Buffer
5923		io.Copy(&snapshot, ringBuffer)
5924		err = &smithy.DeserializationError{
5925			Err:      fmt.Errorf("failed to decode response body, %w", err),
5926			Snapshot: snapshot.Bytes(),
5927		}
5928		return out, metadata, err
5929	}
5930
5931	return out, metadata, err
5932}
5933
5934func awsAwsquery_deserializeOpErrorModifyCacheParameterGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5935	var errorBuffer bytes.Buffer
5936	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5937		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5938	}
5939	errorBody := bytes.NewReader(errorBuffer.Bytes())
5940
5941	errorCode := "UnknownError"
5942	errorMessage := errorCode
5943
5944	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
5945	if err != nil {
5946		return err
5947	}
5948	if reqID := errorComponents.RequestID; len(reqID) != 0 {
5949		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
5950	}
5951	if len(errorComponents.Code) != 0 {
5952		errorCode = errorComponents.Code
5953	}
5954	if len(errorComponents.Message) != 0 {
5955		errorMessage = errorComponents.Message
5956	}
5957	errorBody.Seek(0, io.SeekStart)
5958	switch {
5959	case strings.EqualFold("CacheParameterGroupNotFoundFault", errorCode):
5960		return awsAwsquery_deserializeErrorCacheParameterGroupNotFoundFault(response, errorBody)
5961
5962	case strings.EqualFold("InvalidCacheParameterGroupStateFault", errorCode):
5963		return awsAwsquery_deserializeErrorInvalidCacheParameterGroupStateFault(response, errorBody)
5964
5965	case strings.EqualFold("InvalidGlobalReplicationGroupStateFault", errorCode):
5966		return awsAwsquery_deserializeErrorInvalidGlobalReplicationGroupStateFault(response, errorBody)
5967
5968	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
5969		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
5970
5971	case strings.EqualFold("InvalidParameterValueException", errorCode):
5972		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
5973
5974	default:
5975		genericError := &smithy.GenericAPIError{
5976			Code:    errorCode,
5977			Message: errorMessage,
5978		}
5979		return genericError
5980
5981	}
5982}
5983
5984type awsAwsquery_deserializeOpModifyCacheSubnetGroup struct {
5985}
5986
5987func (*awsAwsquery_deserializeOpModifyCacheSubnetGroup) ID() string {
5988	return "OperationDeserializer"
5989}
5990
5991func (m *awsAwsquery_deserializeOpModifyCacheSubnetGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5992	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5993) {
5994	out, metadata, err = next.HandleDeserialize(ctx, in)
5995	if err != nil {
5996		return out, metadata, err
5997	}
5998
5999	response, ok := out.RawResponse.(*smithyhttp.Response)
6000	if !ok {
6001		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6002	}
6003
6004	if response.StatusCode < 200 || response.StatusCode >= 300 {
6005		return out, metadata, awsAwsquery_deserializeOpErrorModifyCacheSubnetGroup(response, &metadata)
6006	}
6007	output := &ModifyCacheSubnetGroupOutput{}
6008	out.Result = output
6009
6010	var buff [1024]byte
6011	ringBuffer := smithyio.NewRingBuffer(buff[:])
6012	body := io.TeeReader(response.Body, ringBuffer)
6013	rootDecoder := xml.NewDecoder(body)
6014	t, err := smithyxml.FetchRootElement(rootDecoder)
6015	if err == io.EOF {
6016		return out, metadata, nil
6017	}
6018	if err != nil {
6019		var snapshot bytes.Buffer
6020		io.Copy(&snapshot, ringBuffer)
6021		return out, metadata, &smithy.DeserializationError{
6022			Err:      fmt.Errorf("failed to decode response body, %w", err),
6023			Snapshot: snapshot.Bytes(),
6024		}
6025	}
6026
6027	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
6028	t, err = decoder.GetElement("ModifyCacheSubnetGroupResult")
6029	if err != nil {
6030		var snapshot bytes.Buffer
6031		io.Copy(&snapshot, ringBuffer)
6032		err = &smithy.DeserializationError{
6033			Err:      fmt.Errorf("failed to decode response body, %w", err),
6034			Snapshot: snapshot.Bytes(),
6035		}
6036		return out, metadata, err
6037	}
6038
6039	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
6040	err = awsAwsquery_deserializeOpDocumentModifyCacheSubnetGroupOutput(&output, decoder)
6041	if err != nil {
6042		var snapshot bytes.Buffer
6043		io.Copy(&snapshot, ringBuffer)
6044		err = &smithy.DeserializationError{
6045			Err:      fmt.Errorf("failed to decode response body, %w", err),
6046			Snapshot: snapshot.Bytes(),
6047		}
6048		return out, metadata, err
6049	}
6050
6051	return out, metadata, err
6052}
6053
6054func awsAwsquery_deserializeOpErrorModifyCacheSubnetGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6055	var errorBuffer bytes.Buffer
6056	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6057		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6058	}
6059	errorBody := bytes.NewReader(errorBuffer.Bytes())
6060
6061	errorCode := "UnknownError"
6062	errorMessage := errorCode
6063
6064	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
6065	if err != nil {
6066		return err
6067	}
6068	if reqID := errorComponents.RequestID; len(reqID) != 0 {
6069		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
6070	}
6071	if len(errorComponents.Code) != 0 {
6072		errorCode = errorComponents.Code
6073	}
6074	if len(errorComponents.Message) != 0 {
6075		errorMessage = errorComponents.Message
6076	}
6077	errorBody.Seek(0, io.SeekStart)
6078	switch {
6079	case strings.EqualFold("CacheSubnetGroupNotFoundFault", errorCode):
6080		return awsAwsquery_deserializeErrorCacheSubnetGroupNotFoundFault(response, errorBody)
6081
6082	case strings.EqualFold("CacheSubnetQuotaExceededFault", errorCode):
6083		return awsAwsquery_deserializeErrorCacheSubnetQuotaExceededFault(response, errorBody)
6084
6085	case strings.EqualFold("InvalidSubnet", errorCode):
6086		return awsAwsquery_deserializeErrorInvalidSubnet(response, errorBody)
6087
6088	case strings.EqualFold("SubnetInUse", errorCode):
6089		return awsAwsquery_deserializeErrorSubnetInUse(response, errorBody)
6090
6091	case strings.EqualFold("SubnetNotAllowedFault", errorCode):
6092		return awsAwsquery_deserializeErrorSubnetNotAllowedFault(response, errorBody)
6093
6094	default:
6095		genericError := &smithy.GenericAPIError{
6096			Code:    errorCode,
6097			Message: errorMessage,
6098		}
6099		return genericError
6100
6101	}
6102}
6103
6104type awsAwsquery_deserializeOpModifyGlobalReplicationGroup struct {
6105}
6106
6107func (*awsAwsquery_deserializeOpModifyGlobalReplicationGroup) ID() string {
6108	return "OperationDeserializer"
6109}
6110
6111func (m *awsAwsquery_deserializeOpModifyGlobalReplicationGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6112	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6113) {
6114	out, metadata, err = next.HandleDeserialize(ctx, in)
6115	if err != nil {
6116		return out, metadata, err
6117	}
6118
6119	response, ok := out.RawResponse.(*smithyhttp.Response)
6120	if !ok {
6121		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6122	}
6123
6124	if response.StatusCode < 200 || response.StatusCode >= 300 {
6125		return out, metadata, awsAwsquery_deserializeOpErrorModifyGlobalReplicationGroup(response, &metadata)
6126	}
6127	output := &ModifyGlobalReplicationGroupOutput{}
6128	out.Result = output
6129
6130	var buff [1024]byte
6131	ringBuffer := smithyio.NewRingBuffer(buff[:])
6132	body := io.TeeReader(response.Body, ringBuffer)
6133	rootDecoder := xml.NewDecoder(body)
6134	t, err := smithyxml.FetchRootElement(rootDecoder)
6135	if err == io.EOF {
6136		return out, metadata, nil
6137	}
6138	if err != nil {
6139		var snapshot bytes.Buffer
6140		io.Copy(&snapshot, ringBuffer)
6141		return out, metadata, &smithy.DeserializationError{
6142			Err:      fmt.Errorf("failed to decode response body, %w", err),
6143			Snapshot: snapshot.Bytes(),
6144		}
6145	}
6146
6147	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
6148	t, err = decoder.GetElement("ModifyGlobalReplicationGroupResult")
6149	if err != nil {
6150		var snapshot bytes.Buffer
6151		io.Copy(&snapshot, ringBuffer)
6152		err = &smithy.DeserializationError{
6153			Err:      fmt.Errorf("failed to decode response body, %w", err),
6154			Snapshot: snapshot.Bytes(),
6155		}
6156		return out, metadata, err
6157	}
6158
6159	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
6160	err = awsAwsquery_deserializeOpDocumentModifyGlobalReplicationGroupOutput(&output, decoder)
6161	if err != nil {
6162		var snapshot bytes.Buffer
6163		io.Copy(&snapshot, ringBuffer)
6164		err = &smithy.DeserializationError{
6165			Err:      fmt.Errorf("failed to decode response body, %w", err),
6166			Snapshot: snapshot.Bytes(),
6167		}
6168		return out, metadata, err
6169	}
6170
6171	return out, metadata, err
6172}
6173
6174func awsAwsquery_deserializeOpErrorModifyGlobalReplicationGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6175	var errorBuffer bytes.Buffer
6176	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6177		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6178	}
6179	errorBody := bytes.NewReader(errorBuffer.Bytes())
6180
6181	errorCode := "UnknownError"
6182	errorMessage := errorCode
6183
6184	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
6185	if err != nil {
6186		return err
6187	}
6188	if reqID := errorComponents.RequestID; len(reqID) != 0 {
6189		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
6190	}
6191	if len(errorComponents.Code) != 0 {
6192		errorCode = errorComponents.Code
6193	}
6194	if len(errorComponents.Message) != 0 {
6195		errorMessage = errorComponents.Message
6196	}
6197	errorBody.Seek(0, io.SeekStart)
6198	switch {
6199	case strings.EqualFold("GlobalReplicationGroupNotFoundFault", errorCode):
6200		return awsAwsquery_deserializeErrorGlobalReplicationGroupNotFoundFault(response, errorBody)
6201
6202	case strings.EqualFold("InvalidGlobalReplicationGroupStateFault", errorCode):
6203		return awsAwsquery_deserializeErrorInvalidGlobalReplicationGroupStateFault(response, errorBody)
6204
6205	case strings.EqualFold("InvalidParameterValueException", errorCode):
6206		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
6207
6208	default:
6209		genericError := &smithy.GenericAPIError{
6210			Code:    errorCode,
6211			Message: errorMessage,
6212		}
6213		return genericError
6214
6215	}
6216}
6217
6218type awsAwsquery_deserializeOpModifyReplicationGroup struct {
6219}
6220
6221func (*awsAwsquery_deserializeOpModifyReplicationGroup) ID() string {
6222	return "OperationDeserializer"
6223}
6224
6225func (m *awsAwsquery_deserializeOpModifyReplicationGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6226	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6227) {
6228	out, metadata, err = next.HandleDeserialize(ctx, in)
6229	if err != nil {
6230		return out, metadata, err
6231	}
6232
6233	response, ok := out.RawResponse.(*smithyhttp.Response)
6234	if !ok {
6235		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6236	}
6237
6238	if response.StatusCode < 200 || response.StatusCode >= 300 {
6239		return out, metadata, awsAwsquery_deserializeOpErrorModifyReplicationGroup(response, &metadata)
6240	}
6241	output := &ModifyReplicationGroupOutput{}
6242	out.Result = output
6243
6244	var buff [1024]byte
6245	ringBuffer := smithyio.NewRingBuffer(buff[:])
6246	body := io.TeeReader(response.Body, ringBuffer)
6247	rootDecoder := xml.NewDecoder(body)
6248	t, err := smithyxml.FetchRootElement(rootDecoder)
6249	if err == io.EOF {
6250		return out, metadata, nil
6251	}
6252	if err != nil {
6253		var snapshot bytes.Buffer
6254		io.Copy(&snapshot, ringBuffer)
6255		return out, metadata, &smithy.DeserializationError{
6256			Err:      fmt.Errorf("failed to decode response body, %w", err),
6257			Snapshot: snapshot.Bytes(),
6258		}
6259	}
6260
6261	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
6262	t, err = decoder.GetElement("ModifyReplicationGroupResult")
6263	if err != nil {
6264		var snapshot bytes.Buffer
6265		io.Copy(&snapshot, ringBuffer)
6266		err = &smithy.DeserializationError{
6267			Err:      fmt.Errorf("failed to decode response body, %w", err),
6268			Snapshot: snapshot.Bytes(),
6269		}
6270		return out, metadata, err
6271	}
6272
6273	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
6274	err = awsAwsquery_deserializeOpDocumentModifyReplicationGroupOutput(&output, decoder)
6275	if err != nil {
6276		var snapshot bytes.Buffer
6277		io.Copy(&snapshot, ringBuffer)
6278		err = &smithy.DeserializationError{
6279			Err:      fmt.Errorf("failed to decode response body, %w", err),
6280			Snapshot: snapshot.Bytes(),
6281		}
6282		return out, metadata, err
6283	}
6284
6285	return out, metadata, err
6286}
6287
6288func awsAwsquery_deserializeOpErrorModifyReplicationGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6289	var errorBuffer bytes.Buffer
6290	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6291		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6292	}
6293	errorBody := bytes.NewReader(errorBuffer.Bytes())
6294
6295	errorCode := "UnknownError"
6296	errorMessage := errorCode
6297
6298	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
6299	if err != nil {
6300		return err
6301	}
6302	if reqID := errorComponents.RequestID; len(reqID) != 0 {
6303		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
6304	}
6305	if len(errorComponents.Code) != 0 {
6306		errorCode = errorComponents.Code
6307	}
6308	if len(errorComponents.Message) != 0 {
6309		errorMessage = errorComponents.Message
6310	}
6311	errorBody.Seek(0, io.SeekStart)
6312	switch {
6313	case strings.EqualFold("CacheClusterNotFoundFault", errorCode):
6314		return awsAwsquery_deserializeErrorCacheClusterNotFoundFault(response, errorBody)
6315
6316	case strings.EqualFold("CacheParameterGroupNotFoundFault", errorCode):
6317		return awsAwsquery_deserializeErrorCacheParameterGroupNotFoundFault(response, errorBody)
6318
6319	case strings.EqualFold("CacheSecurityGroupNotFoundFault", errorCode):
6320		return awsAwsquery_deserializeErrorCacheSecurityGroupNotFoundFault(response, errorBody)
6321
6322	case strings.EqualFold("InsufficientCacheClusterCapacityFault", errorCode):
6323		return awsAwsquery_deserializeErrorInsufficientCacheClusterCapacityFault(response, errorBody)
6324
6325	case strings.EqualFold("InvalidCacheClusterStateFault", errorCode):
6326		return awsAwsquery_deserializeErrorInvalidCacheClusterStateFault(response, errorBody)
6327
6328	case strings.EqualFold("InvalidCacheSecurityGroupStateFault", errorCode):
6329		return awsAwsquery_deserializeErrorInvalidCacheSecurityGroupStateFault(response, errorBody)
6330
6331	case strings.EqualFold("InvalidKMSKeyFault", errorCode):
6332		return awsAwsquery_deserializeErrorInvalidKMSKeyFault(response, errorBody)
6333
6334	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
6335		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
6336
6337	case strings.EqualFold("InvalidParameterValueException", errorCode):
6338		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
6339
6340	case strings.EqualFold("InvalidReplicationGroupStateFault", errorCode):
6341		return awsAwsquery_deserializeErrorInvalidReplicationGroupStateFault(response, errorBody)
6342
6343	case strings.EqualFold("InvalidUserGroupStateFault", errorCode):
6344		return awsAwsquery_deserializeErrorInvalidUserGroupStateFault(response, errorBody)
6345
6346	case strings.EqualFold("InvalidVPCNetworkStateFault", errorCode):
6347		return awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response, errorBody)
6348
6349	case strings.EqualFold("NodeQuotaForClusterExceededFault", errorCode):
6350		return awsAwsquery_deserializeErrorNodeQuotaForClusterExceededFault(response, errorBody)
6351
6352	case strings.EqualFold("NodeQuotaForCustomerExceededFault", errorCode):
6353		return awsAwsquery_deserializeErrorNodeQuotaForCustomerExceededFault(response, errorBody)
6354
6355	case strings.EqualFold("ReplicationGroupNotFoundFault", errorCode):
6356		return awsAwsquery_deserializeErrorReplicationGroupNotFoundFault(response, errorBody)
6357
6358	case strings.EqualFold("UserGroupNotFoundFault", errorCode):
6359		return awsAwsquery_deserializeErrorUserGroupNotFoundFault(response, errorBody)
6360
6361	default:
6362		genericError := &smithy.GenericAPIError{
6363			Code:    errorCode,
6364			Message: errorMessage,
6365		}
6366		return genericError
6367
6368	}
6369}
6370
6371type awsAwsquery_deserializeOpModifyReplicationGroupShardConfiguration struct {
6372}
6373
6374func (*awsAwsquery_deserializeOpModifyReplicationGroupShardConfiguration) ID() string {
6375	return "OperationDeserializer"
6376}
6377
6378func (m *awsAwsquery_deserializeOpModifyReplicationGroupShardConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6379	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6380) {
6381	out, metadata, err = next.HandleDeserialize(ctx, in)
6382	if err != nil {
6383		return out, metadata, err
6384	}
6385
6386	response, ok := out.RawResponse.(*smithyhttp.Response)
6387	if !ok {
6388		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6389	}
6390
6391	if response.StatusCode < 200 || response.StatusCode >= 300 {
6392		return out, metadata, awsAwsquery_deserializeOpErrorModifyReplicationGroupShardConfiguration(response, &metadata)
6393	}
6394	output := &ModifyReplicationGroupShardConfigurationOutput{}
6395	out.Result = output
6396
6397	var buff [1024]byte
6398	ringBuffer := smithyio.NewRingBuffer(buff[:])
6399	body := io.TeeReader(response.Body, ringBuffer)
6400	rootDecoder := xml.NewDecoder(body)
6401	t, err := smithyxml.FetchRootElement(rootDecoder)
6402	if err == io.EOF {
6403		return out, metadata, nil
6404	}
6405	if err != nil {
6406		var snapshot bytes.Buffer
6407		io.Copy(&snapshot, ringBuffer)
6408		return out, metadata, &smithy.DeserializationError{
6409			Err:      fmt.Errorf("failed to decode response body, %w", err),
6410			Snapshot: snapshot.Bytes(),
6411		}
6412	}
6413
6414	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
6415	t, err = decoder.GetElement("ModifyReplicationGroupShardConfigurationResult")
6416	if err != nil {
6417		var snapshot bytes.Buffer
6418		io.Copy(&snapshot, ringBuffer)
6419		err = &smithy.DeserializationError{
6420			Err:      fmt.Errorf("failed to decode response body, %w", err),
6421			Snapshot: snapshot.Bytes(),
6422		}
6423		return out, metadata, err
6424	}
6425
6426	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
6427	err = awsAwsquery_deserializeOpDocumentModifyReplicationGroupShardConfigurationOutput(&output, decoder)
6428	if err != nil {
6429		var snapshot bytes.Buffer
6430		io.Copy(&snapshot, ringBuffer)
6431		err = &smithy.DeserializationError{
6432			Err:      fmt.Errorf("failed to decode response body, %w", err),
6433			Snapshot: snapshot.Bytes(),
6434		}
6435		return out, metadata, err
6436	}
6437
6438	return out, metadata, err
6439}
6440
6441func awsAwsquery_deserializeOpErrorModifyReplicationGroupShardConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6442	var errorBuffer bytes.Buffer
6443	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6444		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6445	}
6446	errorBody := bytes.NewReader(errorBuffer.Bytes())
6447
6448	errorCode := "UnknownError"
6449	errorMessage := errorCode
6450
6451	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
6452	if err != nil {
6453		return err
6454	}
6455	if reqID := errorComponents.RequestID; len(reqID) != 0 {
6456		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
6457	}
6458	if len(errorComponents.Code) != 0 {
6459		errorCode = errorComponents.Code
6460	}
6461	if len(errorComponents.Message) != 0 {
6462		errorMessage = errorComponents.Message
6463	}
6464	errorBody.Seek(0, io.SeekStart)
6465	switch {
6466	case strings.EqualFold("InsufficientCacheClusterCapacityFault", errorCode):
6467		return awsAwsquery_deserializeErrorInsufficientCacheClusterCapacityFault(response, errorBody)
6468
6469	case strings.EqualFold("InvalidCacheClusterStateFault", errorCode):
6470		return awsAwsquery_deserializeErrorInvalidCacheClusterStateFault(response, errorBody)
6471
6472	case strings.EqualFold("InvalidKMSKeyFault", errorCode):
6473		return awsAwsquery_deserializeErrorInvalidKMSKeyFault(response, errorBody)
6474
6475	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
6476		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
6477
6478	case strings.EqualFold("InvalidParameterValueException", errorCode):
6479		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
6480
6481	case strings.EqualFold("InvalidReplicationGroupStateFault", errorCode):
6482		return awsAwsquery_deserializeErrorInvalidReplicationGroupStateFault(response, errorBody)
6483
6484	case strings.EqualFold("InvalidVPCNetworkStateFault", errorCode):
6485		return awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response, errorBody)
6486
6487	case strings.EqualFold("NodeGroupsPerReplicationGroupQuotaExceededFault", errorCode):
6488		return awsAwsquery_deserializeErrorNodeGroupsPerReplicationGroupQuotaExceededFault(response, errorBody)
6489
6490	case strings.EqualFold("NodeQuotaForCustomerExceededFault", errorCode):
6491		return awsAwsquery_deserializeErrorNodeQuotaForCustomerExceededFault(response, errorBody)
6492
6493	case strings.EqualFold("ReplicationGroupNotFoundFault", errorCode):
6494		return awsAwsquery_deserializeErrorReplicationGroupNotFoundFault(response, errorBody)
6495
6496	default:
6497		genericError := &smithy.GenericAPIError{
6498			Code:    errorCode,
6499			Message: errorMessage,
6500		}
6501		return genericError
6502
6503	}
6504}
6505
6506type awsAwsquery_deserializeOpModifyUser struct {
6507}
6508
6509func (*awsAwsquery_deserializeOpModifyUser) ID() string {
6510	return "OperationDeserializer"
6511}
6512
6513func (m *awsAwsquery_deserializeOpModifyUser) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6514	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6515) {
6516	out, metadata, err = next.HandleDeserialize(ctx, in)
6517	if err != nil {
6518		return out, metadata, err
6519	}
6520
6521	response, ok := out.RawResponse.(*smithyhttp.Response)
6522	if !ok {
6523		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6524	}
6525
6526	if response.StatusCode < 200 || response.StatusCode >= 300 {
6527		return out, metadata, awsAwsquery_deserializeOpErrorModifyUser(response, &metadata)
6528	}
6529	output := &ModifyUserOutput{}
6530	out.Result = output
6531
6532	var buff [1024]byte
6533	ringBuffer := smithyio.NewRingBuffer(buff[:])
6534	body := io.TeeReader(response.Body, ringBuffer)
6535	rootDecoder := xml.NewDecoder(body)
6536	t, err := smithyxml.FetchRootElement(rootDecoder)
6537	if err == io.EOF {
6538		return out, metadata, nil
6539	}
6540	if err != nil {
6541		var snapshot bytes.Buffer
6542		io.Copy(&snapshot, ringBuffer)
6543		return out, metadata, &smithy.DeserializationError{
6544			Err:      fmt.Errorf("failed to decode response body, %w", err),
6545			Snapshot: snapshot.Bytes(),
6546		}
6547	}
6548
6549	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
6550	t, err = decoder.GetElement("ModifyUserResult")
6551	if err != nil {
6552		var snapshot bytes.Buffer
6553		io.Copy(&snapshot, ringBuffer)
6554		err = &smithy.DeserializationError{
6555			Err:      fmt.Errorf("failed to decode response body, %w", err),
6556			Snapshot: snapshot.Bytes(),
6557		}
6558		return out, metadata, err
6559	}
6560
6561	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
6562	err = awsAwsquery_deserializeOpDocumentModifyUserOutput(&output, decoder)
6563	if err != nil {
6564		var snapshot bytes.Buffer
6565		io.Copy(&snapshot, ringBuffer)
6566		err = &smithy.DeserializationError{
6567			Err:      fmt.Errorf("failed to decode response body, %w", err),
6568			Snapshot: snapshot.Bytes(),
6569		}
6570		return out, metadata, err
6571	}
6572
6573	return out, metadata, err
6574}
6575
6576func awsAwsquery_deserializeOpErrorModifyUser(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6577	var errorBuffer bytes.Buffer
6578	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6579		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6580	}
6581	errorBody := bytes.NewReader(errorBuffer.Bytes())
6582
6583	errorCode := "UnknownError"
6584	errorMessage := errorCode
6585
6586	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
6587	if err != nil {
6588		return err
6589	}
6590	if reqID := errorComponents.RequestID; len(reqID) != 0 {
6591		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
6592	}
6593	if len(errorComponents.Code) != 0 {
6594		errorCode = errorComponents.Code
6595	}
6596	if len(errorComponents.Message) != 0 {
6597		errorMessage = errorComponents.Message
6598	}
6599	errorBody.Seek(0, io.SeekStart)
6600	switch {
6601	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
6602		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
6603
6604	case strings.EqualFold("InvalidParameterValueException", errorCode):
6605		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
6606
6607	case strings.EqualFold("InvalidUserStateFault", errorCode):
6608		return awsAwsquery_deserializeErrorInvalidUserStateFault(response, errorBody)
6609
6610	case strings.EqualFold("UserNotFoundFault", errorCode):
6611		return awsAwsquery_deserializeErrorUserNotFoundFault(response, errorBody)
6612
6613	default:
6614		genericError := &smithy.GenericAPIError{
6615			Code:    errorCode,
6616			Message: errorMessage,
6617		}
6618		return genericError
6619
6620	}
6621}
6622
6623type awsAwsquery_deserializeOpModifyUserGroup struct {
6624}
6625
6626func (*awsAwsquery_deserializeOpModifyUserGroup) ID() string {
6627	return "OperationDeserializer"
6628}
6629
6630func (m *awsAwsquery_deserializeOpModifyUserGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6631	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6632) {
6633	out, metadata, err = next.HandleDeserialize(ctx, in)
6634	if err != nil {
6635		return out, metadata, err
6636	}
6637
6638	response, ok := out.RawResponse.(*smithyhttp.Response)
6639	if !ok {
6640		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6641	}
6642
6643	if response.StatusCode < 200 || response.StatusCode >= 300 {
6644		return out, metadata, awsAwsquery_deserializeOpErrorModifyUserGroup(response, &metadata)
6645	}
6646	output := &ModifyUserGroupOutput{}
6647	out.Result = output
6648
6649	var buff [1024]byte
6650	ringBuffer := smithyio.NewRingBuffer(buff[:])
6651	body := io.TeeReader(response.Body, ringBuffer)
6652	rootDecoder := xml.NewDecoder(body)
6653	t, err := smithyxml.FetchRootElement(rootDecoder)
6654	if err == io.EOF {
6655		return out, metadata, nil
6656	}
6657	if err != nil {
6658		var snapshot bytes.Buffer
6659		io.Copy(&snapshot, ringBuffer)
6660		return out, metadata, &smithy.DeserializationError{
6661			Err:      fmt.Errorf("failed to decode response body, %w", err),
6662			Snapshot: snapshot.Bytes(),
6663		}
6664	}
6665
6666	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
6667	t, err = decoder.GetElement("ModifyUserGroupResult")
6668	if err != nil {
6669		var snapshot bytes.Buffer
6670		io.Copy(&snapshot, ringBuffer)
6671		err = &smithy.DeserializationError{
6672			Err:      fmt.Errorf("failed to decode response body, %w", err),
6673			Snapshot: snapshot.Bytes(),
6674		}
6675		return out, metadata, err
6676	}
6677
6678	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
6679	err = awsAwsquery_deserializeOpDocumentModifyUserGroupOutput(&output, decoder)
6680	if err != nil {
6681		var snapshot bytes.Buffer
6682		io.Copy(&snapshot, ringBuffer)
6683		err = &smithy.DeserializationError{
6684			Err:      fmt.Errorf("failed to decode response body, %w", err),
6685			Snapshot: snapshot.Bytes(),
6686		}
6687		return out, metadata, err
6688	}
6689
6690	return out, metadata, err
6691}
6692
6693func awsAwsquery_deserializeOpErrorModifyUserGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6694	var errorBuffer bytes.Buffer
6695	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6696		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6697	}
6698	errorBody := bytes.NewReader(errorBuffer.Bytes())
6699
6700	errorCode := "UnknownError"
6701	errorMessage := errorCode
6702
6703	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
6704	if err != nil {
6705		return err
6706	}
6707	if reqID := errorComponents.RequestID; len(reqID) != 0 {
6708		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
6709	}
6710	if len(errorComponents.Code) != 0 {
6711		errorCode = errorComponents.Code
6712	}
6713	if len(errorComponents.Message) != 0 {
6714		errorMessage = errorComponents.Message
6715	}
6716	errorBody.Seek(0, io.SeekStart)
6717	switch {
6718	case strings.EqualFold("DefaultUserRequired", errorCode):
6719		return awsAwsquery_deserializeErrorDefaultUserRequired(response, errorBody)
6720
6721	case strings.EqualFold("DuplicateUserNameFault", errorCode):
6722		return awsAwsquery_deserializeErrorDuplicateUserNameFault(response, errorBody)
6723
6724	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
6725		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
6726
6727	case strings.EqualFold("InvalidParameterValueException", errorCode):
6728		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
6729
6730	case strings.EqualFold("InvalidUserGroupStateFault", errorCode):
6731		return awsAwsquery_deserializeErrorInvalidUserGroupStateFault(response, errorBody)
6732
6733	case strings.EqualFold("UserGroupNotFoundFault", errorCode):
6734		return awsAwsquery_deserializeErrorUserGroupNotFoundFault(response, errorBody)
6735
6736	case strings.EqualFold("UserNotFoundFault", errorCode):
6737		return awsAwsquery_deserializeErrorUserNotFoundFault(response, errorBody)
6738
6739	default:
6740		genericError := &smithy.GenericAPIError{
6741			Code:    errorCode,
6742			Message: errorMessage,
6743		}
6744		return genericError
6745
6746	}
6747}
6748
6749type awsAwsquery_deserializeOpPurchaseReservedCacheNodesOffering struct {
6750}
6751
6752func (*awsAwsquery_deserializeOpPurchaseReservedCacheNodesOffering) ID() string {
6753	return "OperationDeserializer"
6754}
6755
6756func (m *awsAwsquery_deserializeOpPurchaseReservedCacheNodesOffering) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6757	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6758) {
6759	out, metadata, err = next.HandleDeserialize(ctx, in)
6760	if err != nil {
6761		return out, metadata, err
6762	}
6763
6764	response, ok := out.RawResponse.(*smithyhttp.Response)
6765	if !ok {
6766		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6767	}
6768
6769	if response.StatusCode < 200 || response.StatusCode >= 300 {
6770		return out, metadata, awsAwsquery_deserializeOpErrorPurchaseReservedCacheNodesOffering(response, &metadata)
6771	}
6772	output := &PurchaseReservedCacheNodesOfferingOutput{}
6773	out.Result = output
6774
6775	var buff [1024]byte
6776	ringBuffer := smithyio.NewRingBuffer(buff[:])
6777	body := io.TeeReader(response.Body, ringBuffer)
6778	rootDecoder := xml.NewDecoder(body)
6779	t, err := smithyxml.FetchRootElement(rootDecoder)
6780	if err == io.EOF {
6781		return out, metadata, nil
6782	}
6783	if err != nil {
6784		var snapshot bytes.Buffer
6785		io.Copy(&snapshot, ringBuffer)
6786		return out, metadata, &smithy.DeserializationError{
6787			Err:      fmt.Errorf("failed to decode response body, %w", err),
6788			Snapshot: snapshot.Bytes(),
6789		}
6790	}
6791
6792	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
6793	t, err = decoder.GetElement("PurchaseReservedCacheNodesOfferingResult")
6794	if err != nil {
6795		var snapshot bytes.Buffer
6796		io.Copy(&snapshot, ringBuffer)
6797		err = &smithy.DeserializationError{
6798			Err:      fmt.Errorf("failed to decode response body, %w", err),
6799			Snapshot: snapshot.Bytes(),
6800		}
6801		return out, metadata, err
6802	}
6803
6804	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
6805	err = awsAwsquery_deserializeOpDocumentPurchaseReservedCacheNodesOfferingOutput(&output, decoder)
6806	if err != nil {
6807		var snapshot bytes.Buffer
6808		io.Copy(&snapshot, ringBuffer)
6809		err = &smithy.DeserializationError{
6810			Err:      fmt.Errorf("failed to decode response body, %w", err),
6811			Snapshot: snapshot.Bytes(),
6812		}
6813		return out, metadata, err
6814	}
6815
6816	return out, metadata, err
6817}
6818
6819func awsAwsquery_deserializeOpErrorPurchaseReservedCacheNodesOffering(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6820	var errorBuffer bytes.Buffer
6821	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6822		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6823	}
6824	errorBody := bytes.NewReader(errorBuffer.Bytes())
6825
6826	errorCode := "UnknownError"
6827	errorMessage := errorCode
6828
6829	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
6830	if err != nil {
6831		return err
6832	}
6833	if reqID := errorComponents.RequestID; len(reqID) != 0 {
6834		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
6835	}
6836	if len(errorComponents.Code) != 0 {
6837		errorCode = errorComponents.Code
6838	}
6839	if len(errorComponents.Message) != 0 {
6840		errorMessage = errorComponents.Message
6841	}
6842	errorBody.Seek(0, io.SeekStart)
6843	switch {
6844	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
6845		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
6846
6847	case strings.EqualFold("InvalidParameterValueException", errorCode):
6848		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
6849
6850	case strings.EqualFold("ReservedCacheNodeAlreadyExistsFault", errorCode):
6851		return awsAwsquery_deserializeErrorReservedCacheNodeAlreadyExistsFault(response, errorBody)
6852
6853	case strings.EqualFold("ReservedCacheNodeQuotaExceededFault", errorCode):
6854		return awsAwsquery_deserializeErrorReservedCacheNodeQuotaExceededFault(response, errorBody)
6855
6856	case strings.EqualFold("ReservedCacheNodesOfferingNotFoundFault", errorCode):
6857		return awsAwsquery_deserializeErrorReservedCacheNodesOfferingNotFoundFault(response, errorBody)
6858
6859	default:
6860		genericError := &smithy.GenericAPIError{
6861			Code:    errorCode,
6862			Message: errorMessage,
6863		}
6864		return genericError
6865
6866	}
6867}
6868
6869type awsAwsquery_deserializeOpRebalanceSlotsInGlobalReplicationGroup struct {
6870}
6871
6872func (*awsAwsquery_deserializeOpRebalanceSlotsInGlobalReplicationGroup) ID() string {
6873	return "OperationDeserializer"
6874}
6875
6876func (m *awsAwsquery_deserializeOpRebalanceSlotsInGlobalReplicationGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6877	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6878) {
6879	out, metadata, err = next.HandleDeserialize(ctx, in)
6880	if err != nil {
6881		return out, metadata, err
6882	}
6883
6884	response, ok := out.RawResponse.(*smithyhttp.Response)
6885	if !ok {
6886		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6887	}
6888
6889	if response.StatusCode < 200 || response.StatusCode >= 300 {
6890		return out, metadata, awsAwsquery_deserializeOpErrorRebalanceSlotsInGlobalReplicationGroup(response, &metadata)
6891	}
6892	output := &RebalanceSlotsInGlobalReplicationGroupOutput{}
6893	out.Result = output
6894
6895	var buff [1024]byte
6896	ringBuffer := smithyio.NewRingBuffer(buff[:])
6897	body := io.TeeReader(response.Body, ringBuffer)
6898	rootDecoder := xml.NewDecoder(body)
6899	t, err := smithyxml.FetchRootElement(rootDecoder)
6900	if err == io.EOF {
6901		return out, metadata, nil
6902	}
6903	if err != nil {
6904		var snapshot bytes.Buffer
6905		io.Copy(&snapshot, ringBuffer)
6906		return out, metadata, &smithy.DeserializationError{
6907			Err:      fmt.Errorf("failed to decode response body, %w", err),
6908			Snapshot: snapshot.Bytes(),
6909		}
6910	}
6911
6912	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
6913	t, err = decoder.GetElement("RebalanceSlotsInGlobalReplicationGroupResult")
6914	if err != nil {
6915		var snapshot bytes.Buffer
6916		io.Copy(&snapshot, ringBuffer)
6917		err = &smithy.DeserializationError{
6918			Err:      fmt.Errorf("failed to decode response body, %w", err),
6919			Snapshot: snapshot.Bytes(),
6920		}
6921		return out, metadata, err
6922	}
6923
6924	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
6925	err = awsAwsquery_deserializeOpDocumentRebalanceSlotsInGlobalReplicationGroupOutput(&output, decoder)
6926	if err != nil {
6927		var snapshot bytes.Buffer
6928		io.Copy(&snapshot, ringBuffer)
6929		err = &smithy.DeserializationError{
6930			Err:      fmt.Errorf("failed to decode response body, %w", err),
6931			Snapshot: snapshot.Bytes(),
6932		}
6933		return out, metadata, err
6934	}
6935
6936	return out, metadata, err
6937}
6938
6939func awsAwsquery_deserializeOpErrorRebalanceSlotsInGlobalReplicationGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6940	var errorBuffer bytes.Buffer
6941	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6942		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6943	}
6944	errorBody := bytes.NewReader(errorBuffer.Bytes())
6945
6946	errorCode := "UnknownError"
6947	errorMessage := errorCode
6948
6949	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
6950	if err != nil {
6951		return err
6952	}
6953	if reqID := errorComponents.RequestID; len(reqID) != 0 {
6954		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
6955	}
6956	if len(errorComponents.Code) != 0 {
6957		errorCode = errorComponents.Code
6958	}
6959	if len(errorComponents.Message) != 0 {
6960		errorMessage = errorComponents.Message
6961	}
6962	errorBody.Seek(0, io.SeekStart)
6963	switch {
6964	case strings.EqualFold("GlobalReplicationGroupNotFoundFault", errorCode):
6965		return awsAwsquery_deserializeErrorGlobalReplicationGroupNotFoundFault(response, errorBody)
6966
6967	case strings.EqualFold("InvalidGlobalReplicationGroupStateFault", errorCode):
6968		return awsAwsquery_deserializeErrorInvalidGlobalReplicationGroupStateFault(response, errorBody)
6969
6970	case strings.EqualFold("InvalidParameterValueException", errorCode):
6971		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
6972
6973	default:
6974		genericError := &smithy.GenericAPIError{
6975			Code:    errorCode,
6976			Message: errorMessage,
6977		}
6978		return genericError
6979
6980	}
6981}
6982
6983type awsAwsquery_deserializeOpRebootCacheCluster struct {
6984}
6985
6986func (*awsAwsquery_deserializeOpRebootCacheCluster) ID() string {
6987	return "OperationDeserializer"
6988}
6989
6990func (m *awsAwsquery_deserializeOpRebootCacheCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6991	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6992) {
6993	out, metadata, err = next.HandleDeserialize(ctx, in)
6994	if err != nil {
6995		return out, metadata, err
6996	}
6997
6998	response, ok := out.RawResponse.(*smithyhttp.Response)
6999	if !ok {
7000		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7001	}
7002
7003	if response.StatusCode < 200 || response.StatusCode >= 300 {
7004		return out, metadata, awsAwsquery_deserializeOpErrorRebootCacheCluster(response, &metadata)
7005	}
7006	output := &RebootCacheClusterOutput{}
7007	out.Result = output
7008
7009	var buff [1024]byte
7010	ringBuffer := smithyio.NewRingBuffer(buff[:])
7011	body := io.TeeReader(response.Body, ringBuffer)
7012	rootDecoder := xml.NewDecoder(body)
7013	t, err := smithyxml.FetchRootElement(rootDecoder)
7014	if err == io.EOF {
7015		return out, metadata, nil
7016	}
7017	if err != nil {
7018		var snapshot bytes.Buffer
7019		io.Copy(&snapshot, ringBuffer)
7020		return out, metadata, &smithy.DeserializationError{
7021			Err:      fmt.Errorf("failed to decode response body, %w", err),
7022			Snapshot: snapshot.Bytes(),
7023		}
7024	}
7025
7026	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
7027	t, err = decoder.GetElement("RebootCacheClusterResult")
7028	if err != nil {
7029		var snapshot bytes.Buffer
7030		io.Copy(&snapshot, ringBuffer)
7031		err = &smithy.DeserializationError{
7032			Err:      fmt.Errorf("failed to decode response body, %w", err),
7033			Snapshot: snapshot.Bytes(),
7034		}
7035		return out, metadata, err
7036	}
7037
7038	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
7039	err = awsAwsquery_deserializeOpDocumentRebootCacheClusterOutput(&output, decoder)
7040	if err != nil {
7041		var snapshot bytes.Buffer
7042		io.Copy(&snapshot, ringBuffer)
7043		err = &smithy.DeserializationError{
7044			Err:      fmt.Errorf("failed to decode response body, %w", err),
7045			Snapshot: snapshot.Bytes(),
7046		}
7047		return out, metadata, err
7048	}
7049
7050	return out, metadata, err
7051}
7052
7053func awsAwsquery_deserializeOpErrorRebootCacheCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7054	var errorBuffer bytes.Buffer
7055	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7056		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7057	}
7058	errorBody := bytes.NewReader(errorBuffer.Bytes())
7059
7060	errorCode := "UnknownError"
7061	errorMessage := errorCode
7062
7063	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
7064	if err != nil {
7065		return err
7066	}
7067	if reqID := errorComponents.RequestID; len(reqID) != 0 {
7068		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
7069	}
7070	if len(errorComponents.Code) != 0 {
7071		errorCode = errorComponents.Code
7072	}
7073	if len(errorComponents.Message) != 0 {
7074		errorMessage = errorComponents.Message
7075	}
7076	errorBody.Seek(0, io.SeekStart)
7077	switch {
7078	case strings.EqualFold("CacheClusterNotFoundFault", errorCode):
7079		return awsAwsquery_deserializeErrorCacheClusterNotFoundFault(response, errorBody)
7080
7081	case strings.EqualFold("InvalidCacheClusterStateFault", errorCode):
7082		return awsAwsquery_deserializeErrorInvalidCacheClusterStateFault(response, errorBody)
7083
7084	default:
7085		genericError := &smithy.GenericAPIError{
7086			Code:    errorCode,
7087			Message: errorMessage,
7088		}
7089		return genericError
7090
7091	}
7092}
7093
7094type awsAwsquery_deserializeOpRemoveTagsFromResource struct {
7095}
7096
7097func (*awsAwsquery_deserializeOpRemoveTagsFromResource) ID() string {
7098	return "OperationDeserializer"
7099}
7100
7101func (m *awsAwsquery_deserializeOpRemoveTagsFromResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7102	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7103) {
7104	out, metadata, err = next.HandleDeserialize(ctx, in)
7105	if err != nil {
7106		return out, metadata, err
7107	}
7108
7109	response, ok := out.RawResponse.(*smithyhttp.Response)
7110	if !ok {
7111		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7112	}
7113
7114	if response.StatusCode < 200 || response.StatusCode >= 300 {
7115		return out, metadata, awsAwsquery_deserializeOpErrorRemoveTagsFromResource(response, &metadata)
7116	}
7117	output := &RemoveTagsFromResourceOutput{}
7118	out.Result = output
7119
7120	var buff [1024]byte
7121	ringBuffer := smithyio.NewRingBuffer(buff[:])
7122	body := io.TeeReader(response.Body, ringBuffer)
7123	rootDecoder := xml.NewDecoder(body)
7124	t, err := smithyxml.FetchRootElement(rootDecoder)
7125	if err == io.EOF {
7126		return out, metadata, nil
7127	}
7128	if err != nil {
7129		var snapshot bytes.Buffer
7130		io.Copy(&snapshot, ringBuffer)
7131		return out, metadata, &smithy.DeserializationError{
7132			Err:      fmt.Errorf("failed to decode response body, %w", err),
7133			Snapshot: snapshot.Bytes(),
7134		}
7135	}
7136
7137	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
7138	t, err = decoder.GetElement("RemoveTagsFromResourceResult")
7139	if err != nil {
7140		var snapshot bytes.Buffer
7141		io.Copy(&snapshot, ringBuffer)
7142		err = &smithy.DeserializationError{
7143			Err:      fmt.Errorf("failed to decode response body, %w", err),
7144			Snapshot: snapshot.Bytes(),
7145		}
7146		return out, metadata, err
7147	}
7148
7149	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
7150	err = awsAwsquery_deserializeOpDocumentRemoveTagsFromResourceOutput(&output, decoder)
7151	if err != nil {
7152		var snapshot bytes.Buffer
7153		io.Copy(&snapshot, ringBuffer)
7154		err = &smithy.DeserializationError{
7155			Err:      fmt.Errorf("failed to decode response body, %w", err),
7156			Snapshot: snapshot.Bytes(),
7157		}
7158		return out, metadata, err
7159	}
7160
7161	return out, metadata, err
7162}
7163
7164func awsAwsquery_deserializeOpErrorRemoveTagsFromResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7165	var errorBuffer bytes.Buffer
7166	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7167		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7168	}
7169	errorBody := bytes.NewReader(errorBuffer.Bytes())
7170
7171	errorCode := "UnknownError"
7172	errorMessage := errorCode
7173
7174	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
7175	if err != nil {
7176		return err
7177	}
7178	if reqID := errorComponents.RequestID; len(reqID) != 0 {
7179		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
7180	}
7181	if len(errorComponents.Code) != 0 {
7182		errorCode = errorComponents.Code
7183	}
7184	if len(errorComponents.Message) != 0 {
7185		errorMessage = errorComponents.Message
7186	}
7187	errorBody.Seek(0, io.SeekStart)
7188	switch {
7189	case strings.EqualFold("CacheClusterNotFoundFault", errorCode):
7190		return awsAwsquery_deserializeErrorCacheClusterNotFoundFault(response, errorBody)
7191
7192	case strings.EqualFold("InvalidARNFault", errorCode):
7193		return awsAwsquery_deserializeErrorInvalidARNFault(response, errorBody)
7194
7195	case strings.EqualFold("SnapshotNotFoundFault", errorCode):
7196		return awsAwsquery_deserializeErrorSnapshotNotFoundFault(response, errorBody)
7197
7198	case strings.EqualFold("TagNotFoundFault", errorCode):
7199		return awsAwsquery_deserializeErrorTagNotFoundFault(response, errorBody)
7200
7201	default:
7202		genericError := &smithy.GenericAPIError{
7203			Code:    errorCode,
7204			Message: errorMessage,
7205		}
7206		return genericError
7207
7208	}
7209}
7210
7211type awsAwsquery_deserializeOpResetCacheParameterGroup struct {
7212}
7213
7214func (*awsAwsquery_deserializeOpResetCacheParameterGroup) ID() string {
7215	return "OperationDeserializer"
7216}
7217
7218func (m *awsAwsquery_deserializeOpResetCacheParameterGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7219	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7220) {
7221	out, metadata, err = next.HandleDeserialize(ctx, in)
7222	if err != nil {
7223		return out, metadata, err
7224	}
7225
7226	response, ok := out.RawResponse.(*smithyhttp.Response)
7227	if !ok {
7228		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7229	}
7230
7231	if response.StatusCode < 200 || response.StatusCode >= 300 {
7232		return out, metadata, awsAwsquery_deserializeOpErrorResetCacheParameterGroup(response, &metadata)
7233	}
7234	output := &ResetCacheParameterGroupOutput{}
7235	out.Result = output
7236
7237	var buff [1024]byte
7238	ringBuffer := smithyio.NewRingBuffer(buff[:])
7239	body := io.TeeReader(response.Body, ringBuffer)
7240	rootDecoder := xml.NewDecoder(body)
7241	t, err := smithyxml.FetchRootElement(rootDecoder)
7242	if err == io.EOF {
7243		return out, metadata, nil
7244	}
7245	if err != nil {
7246		var snapshot bytes.Buffer
7247		io.Copy(&snapshot, ringBuffer)
7248		return out, metadata, &smithy.DeserializationError{
7249			Err:      fmt.Errorf("failed to decode response body, %w", err),
7250			Snapshot: snapshot.Bytes(),
7251		}
7252	}
7253
7254	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
7255	t, err = decoder.GetElement("ResetCacheParameterGroupResult")
7256	if err != nil {
7257		var snapshot bytes.Buffer
7258		io.Copy(&snapshot, ringBuffer)
7259		err = &smithy.DeserializationError{
7260			Err:      fmt.Errorf("failed to decode response body, %w", err),
7261			Snapshot: snapshot.Bytes(),
7262		}
7263		return out, metadata, err
7264	}
7265
7266	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
7267	err = awsAwsquery_deserializeOpDocumentResetCacheParameterGroupOutput(&output, decoder)
7268	if err != nil {
7269		var snapshot bytes.Buffer
7270		io.Copy(&snapshot, ringBuffer)
7271		err = &smithy.DeserializationError{
7272			Err:      fmt.Errorf("failed to decode response body, %w", err),
7273			Snapshot: snapshot.Bytes(),
7274		}
7275		return out, metadata, err
7276	}
7277
7278	return out, metadata, err
7279}
7280
7281func awsAwsquery_deserializeOpErrorResetCacheParameterGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7282	var errorBuffer bytes.Buffer
7283	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7284		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7285	}
7286	errorBody := bytes.NewReader(errorBuffer.Bytes())
7287
7288	errorCode := "UnknownError"
7289	errorMessage := errorCode
7290
7291	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
7292	if err != nil {
7293		return err
7294	}
7295	if reqID := errorComponents.RequestID; len(reqID) != 0 {
7296		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
7297	}
7298	if len(errorComponents.Code) != 0 {
7299		errorCode = errorComponents.Code
7300	}
7301	if len(errorComponents.Message) != 0 {
7302		errorMessage = errorComponents.Message
7303	}
7304	errorBody.Seek(0, io.SeekStart)
7305	switch {
7306	case strings.EqualFold("CacheParameterGroupNotFoundFault", errorCode):
7307		return awsAwsquery_deserializeErrorCacheParameterGroupNotFoundFault(response, errorBody)
7308
7309	case strings.EqualFold("InvalidCacheParameterGroupStateFault", errorCode):
7310		return awsAwsquery_deserializeErrorInvalidCacheParameterGroupStateFault(response, errorBody)
7311
7312	case strings.EqualFold("InvalidGlobalReplicationGroupStateFault", errorCode):
7313		return awsAwsquery_deserializeErrorInvalidGlobalReplicationGroupStateFault(response, errorBody)
7314
7315	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
7316		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
7317
7318	case strings.EqualFold("InvalidParameterValueException", errorCode):
7319		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
7320
7321	default:
7322		genericError := &smithy.GenericAPIError{
7323			Code:    errorCode,
7324			Message: errorMessage,
7325		}
7326		return genericError
7327
7328	}
7329}
7330
7331type awsAwsquery_deserializeOpRevokeCacheSecurityGroupIngress struct {
7332}
7333
7334func (*awsAwsquery_deserializeOpRevokeCacheSecurityGroupIngress) ID() string {
7335	return "OperationDeserializer"
7336}
7337
7338func (m *awsAwsquery_deserializeOpRevokeCacheSecurityGroupIngress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7339	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7340) {
7341	out, metadata, err = next.HandleDeserialize(ctx, in)
7342	if err != nil {
7343		return out, metadata, err
7344	}
7345
7346	response, ok := out.RawResponse.(*smithyhttp.Response)
7347	if !ok {
7348		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7349	}
7350
7351	if response.StatusCode < 200 || response.StatusCode >= 300 {
7352		return out, metadata, awsAwsquery_deserializeOpErrorRevokeCacheSecurityGroupIngress(response, &metadata)
7353	}
7354	output := &RevokeCacheSecurityGroupIngressOutput{}
7355	out.Result = output
7356
7357	var buff [1024]byte
7358	ringBuffer := smithyio.NewRingBuffer(buff[:])
7359	body := io.TeeReader(response.Body, ringBuffer)
7360	rootDecoder := xml.NewDecoder(body)
7361	t, err := smithyxml.FetchRootElement(rootDecoder)
7362	if err == io.EOF {
7363		return out, metadata, nil
7364	}
7365	if err != nil {
7366		var snapshot bytes.Buffer
7367		io.Copy(&snapshot, ringBuffer)
7368		return out, metadata, &smithy.DeserializationError{
7369			Err:      fmt.Errorf("failed to decode response body, %w", err),
7370			Snapshot: snapshot.Bytes(),
7371		}
7372	}
7373
7374	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
7375	t, err = decoder.GetElement("RevokeCacheSecurityGroupIngressResult")
7376	if err != nil {
7377		var snapshot bytes.Buffer
7378		io.Copy(&snapshot, ringBuffer)
7379		err = &smithy.DeserializationError{
7380			Err:      fmt.Errorf("failed to decode response body, %w", err),
7381			Snapshot: snapshot.Bytes(),
7382		}
7383		return out, metadata, err
7384	}
7385
7386	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
7387	err = awsAwsquery_deserializeOpDocumentRevokeCacheSecurityGroupIngressOutput(&output, decoder)
7388	if err != nil {
7389		var snapshot bytes.Buffer
7390		io.Copy(&snapshot, ringBuffer)
7391		err = &smithy.DeserializationError{
7392			Err:      fmt.Errorf("failed to decode response body, %w", err),
7393			Snapshot: snapshot.Bytes(),
7394		}
7395		return out, metadata, err
7396	}
7397
7398	return out, metadata, err
7399}
7400
7401func awsAwsquery_deserializeOpErrorRevokeCacheSecurityGroupIngress(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7402	var errorBuffer bytes.Buffer
7403	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7404		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7405	}
7406	errorBody := bytes.NewReader(errorBuffer.Bytes())
7407
7408	errorCode := "UnknownError"
7409	errorMessage := errorCode
7410
7411	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
7412	if err != nil {
7413		return err
7414	}
7415	if reqID := errorComponents.RequestID; len(reqID) != 0 {
7416		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
7417	}
7418	if len(errorComponents.Code) != 0 {
7419		errorCode = errorComponents.Code
7420	}
7421	if len(errorComponents.Message) != 0 {
7422		errorMessage = errorComponents.Message
7423	}
7424	errorBody.Seek(0, io.SeekStart)
7425	switch {
7426	case strings.EqualFold("AuthorizationNotFoundFault", errorCode):
7427		return awsAwsquery_deserializeErrorAuthorizationNotFoundFault(response, errorBody)
7428
7429	case strings.EqualFold("CacheSecurityGroupNotFoundFault", errorCode):
7430		return awsAwsquery_deserializeErrorCacheSecurityGroupNotFoundFault(response, errorBody)
7431
7432	case strings.EqualFold("InvalidCacheSecurityGroupStateFault", errorCode):
7433		return awsAwsquery_deserializeErrorInvalidCacheSecurityGroupStateFault(response, errorBody)
7434
7435	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
7436		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
7437
7438	case strings.EqualFold("InvalidParameterValueException", errorCode):
7439		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
7440
7441	default:
7442		genericError := &smithy.GenericAPIError{
7443			Code:    errorCode,
7444			Message: errorMessage,
7445		}
7446		return genericError
7447
7448	}
7449}
7450
7451type awsAwsquery_deserializeOpStartMigration struct {
7452}
7453
7454func (*awsAwsquery_deserializeOpStartMigration) ID() string {
7455	return "OperationDeserializer"
7456}
7457
7458func (m *awsAwsquery_deserializeOpStartMigration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7459	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7460) {
7461	out, metadata, err = next.HandleDeserialize(ctx, in)
7462	if err != nil {
7463		return out, metadata, err
7464	}
7465
7466	response, ok := out.RawResponse.(*smithyhttp.Response)
7467	if !ok {
7468		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7469	}
7470
7471	if response.StatusCode < 200 || response.StatusCode >= 300 {
7472		return out, metadata, awsAwsquery_deserializeOpErrorStartMigration(response, &metadata)
7473	}
7474	output := &StartMigrationOutput{}
7475	out.Result = output
7476
7477	var buff [1024]byte
7478	ringBuffer := smithyio.NewRingBuffer(buff[:])
7479	body := io.TeeReader(response.Body, ringBuffer)
7480	rootDecoder := xml.NewDecoder(body)
7481	t, err := smithyxml.FetchRootElement(rootDecoder)
7482	if err == io.EOF {
7483		return out, metadata, nil
7484	}
7485	if err != nil {
7486		var snapshot bytes.Buffer
7487		io.Copy(&snapshot, ringBuffer)
7488		return out, metadata, &smithy.DeserializationError{
7489			Err:      fmt.Errorf("failed to decode response body, %w", err),
7490			Snapshot: snapshot.Bytes(),
7491		}
7492	}
7493
7494	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
7495	t, err = decoder.GetElement("StartMigrationResult")
7496	if err != nil {
7497		var snapshot bytes.Buffer
7498		io.Copy(&snapshot, ringBuffer)
7499		err = &smithy.DeserializationError{
7500			Err:      fmt.Errorf("failed to decode response body, %w", err),
7501			Snapshot: snapshot.Bytes(),
7502		}
7503		return out, metadata, err
7504	}
7505
7506	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
7507	err = awsAwsquery_deserializeOpDocumentStartMigrationOutput(&output, decoder)
7508	if err != nil {
7509		var snapshot bytes.Buffer
7510		io.Copy(&snapshot, ringBuffer)
7511		err = &smithy.DeserializationError{
7512			Err:      fmt.Errorf("failed to decode response body, %w", err),
7513			Snapshot: snapshot.Bytes(),
7514		}
7515		return out, metadata, err
7516	}
7517
7518	return out, metadata, err
7519}
7520
7521func awsAwsquery_deserializeOpErrorStartMigration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7522	var errorBuffer bytes.Buffer
7523	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7524		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7525	}
7526	errorBody := bytes.NewReader(errorBuffer.Bytes())
7527
7528	errorCode := "UnknownError"
7529	errorMessage := errorCode
7530
7531	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
7532	if err != nil {
7533		return err
7534	}
7535	if reqID := errorComponents.RequestID; len(reqID) != 0 {
7536		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
7537	}
7538	if len(errorComponents.Code) != 0 {
7539		errorCode = errorComponents.Code
7540	}
7541	if len(errorComponents.Message) != 0 {
7542		errorMessage = errorComponents.Message
7543	}
7544	errorBody.Seek(0, io.SeekStart)
7545	switch {
7546	case strings.EqualFold("InvalidParameterValueException", errorCode):
7547		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
7548
7549	case strings.EqualFold("InvalidReplicationGroupStateFault", errorCode):
7550		return awsAwsquery_deserializeErrorInvalidReplicationGroupStateFault(response, errorBody)
7551
7552	case strings.EqualFold("ReplicationGroupAlreadyUnderMigrationFault", errorCode):
7553		return awsAwsquery_deserializeErrorReplicationGroupAlreadyUnderMigrationFault(response, errorBody)
7554
7555	case strings.EqualFold("ReplicationGroupNotFoundFault", errorCode):
7556		return awsAwsquery_deserializeErrorReplicationGroupNotFoundFault(response, errorBody)
7557
7558	default:
7559		genericError := &smithy.GenericAPIError{
7560			Code:    errorCode,
7561			Message: errorMessage,
7562		}
7563		return genericError
7564
7565	}
7566}
7567
7568type awsAwsquery_deserializeOpTestFailover struct {
7569}
7570
7571func (*awsAwsquery_deserializeOpTestFailover) ID() string {
7572	return "OperationDeserializer"
7573}
7574
7575func (m *awsAwsquery_deserializeOpTestFailover) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7576	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7577) {
7578	out, metadata, err = next.HandleDeserialize(ctx, in)
7579	if err != nil {
7580		return out, metadata, err
7581	}
7582
7583	response, ok := out.RawResponse.(*smithyhttp.Response)
7584	if !ok {
7585		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7586	}
7587
7588	if response.StatusCode < 200 || response.StatusCode >= 300 {
7589		return out, metadata, awsAwsquery_deserializeOpErrorTestFailover(response, &metadata)
7590	}
7591	output := &TestFailoverOutput{}
7592	out.Result = output
7593
7594	var buff [1024]byte
7595	ringBuffer := smithyio.NewRingBuffer(buff[:])
7596	body := io.TeeReader(response.Body, ringBuffer)
7597	rootDecoder := xml.NewDecoder(body)
7598	t, err := smithyxml.FetchRootElement(rootDecoder)
7599	if err == io.EOF {
7600		return out, metadata, nil
7601	}
7602	if err != nil {
7603		var snapshot bytes.Buffer
7604		io.Copy(&snapshot, ringBuffer)
7605		return out, metadata, &smithy.DeserializationError{
7606			Err:      fmt.Errorf("failed to decode response body, %w", err),
7607			Snapshot: snapshot.Bytes(),
7608		}
7609	}
7610
7611	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
7612	t, err = decoder.GetElement("TestFailoverResult")
7613	if err != nil {
7614		var snapshot bytes.Buffer
7615		io.Copy(&snapshot, ringBuffer)
7616		err = &smithy.DeserializationError{
7617			Err:      fmt.Errorf("failed to decode response body, %w", err),
7618			Snapshot: snapshot.Bytes(),
7619		}
7620		return out, metadata, err
7621	}
7622
7623	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
7624	err = awsAwsquery_deserializeOpDocumentTestFailoverOutput(&output, decoder)
7625	if err != nil {
7626		var snapshot bytes.Buffer
7627		io.Copy(&snapshot, ringBuffer)
7628		err = &smithy.DeserializationError{
7629			Err:      fmt.Errorf("failed to decode response body, %w", err),
7630			Snapshot: snapshot.Bytes(),
7631		}
7632		return out, metadata, err
7633	}
7634
7635	return out, metadata, err
7636}
7637
7638func awsAwsquery_deserializeOpErrorTestFailover(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7639	var errorBuffer bytes.Buffer
7640	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7641		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7642	}
7643	errorBody := bytes.NewReader(errorBuffer.Bytes())
7644
7645	errorCode := "UnknownError"
7646	errorMessage := errorCode
7647
7648	errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
7649	if err != nil {
7650		return err
7651	}
7652	if reqID := errorComponents.RequestID; len(reqID) != 0 {
7653		awsmiddleware.SetRequestIDMetadata(metadata, reqID)
7654	}
7655	if len(errorComponents.Code) != 0 {
7656		errorCode = errorComponents.Code
7657	}
7658	if len(errorComponents.Message) != 0 {
7659		errorMessage = errorComponents.Message
7660	}
7661	errorBody.Seek(0, io.SeekStart)
7662	switch {
7663	case strings.EqualFold("APICallRateForCustomerExceededFault", errorCode):
7664		return awsAwsquery_deserializeErrorAPICallRateForCustomerExceededFault(response, errorBody)
7665
7666	case strings.EqualFold("InvalidCacheClusterStateFault", errorCode):
7667		return awsAwsquery_deserializeErrorInvalidCacheClusterStateFault(response, errorBody)
7668
7669	case strings.EqualFold("InvalidKMSKeyFault", errorCode):
7670		return awsAwsquery_deserializeErrorInvalidKMSKeyFault(response, errorBody)
7671
7672	case strings.EqualFold("InvalidParameterCombinationException", errorCode):
7673		return awsAwsquery_deserializeErrorInvalidParameterCombinationException(response, errorBody)
7674
7675	case strings.EqualFold("InvalidParameterValueException", errorCode):
7676		return awsAwsquery_deserializeErrorInvalidParameterValueException(response, errorBody)
7677
7678	case strings.EqualFold("InvalidReplicationGroupStateFault", errorCode):
7679		return awsAwsquery_deserializeErrorInvalidReplicationGroupStateFault(response, errorBody)
7680
7681	case strings.EqualFold("NodeGroupNotFoundFault", errorCode):
7682		return awsAwsquery_deserializeErrorNodeGroupNotFoundFault(response, errorBody)
7683
7684	case strings.EqualFold("ReplicationGroupNotFoundFault", errorCode):
7685		return awsAwsquery_deserializeErrorReplicationGroupNotFoundFault(response, errorBody)
7686
7687	case strings.EqualFold("TestFailoverNotAvailableFault", errorCode):
7688		return awsAwsquery_deserializeErrorTestFailoverNotAvailableFault(response, errorBody)
7689
7690	default:
7691		genericError := &smithy.GenericAPIError{
7692			Code:    errorCode,
7693			Message: errorMessage,
7694		}
7695		return genericError
7696
7697	}
7698}
7699
7700func awsAwsquery_deserializeErrorAPICallRateForCustomerExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7701	output := &types.APICallRateForCustomerExceededFault{}
7702	var buff [1024]byte
7703	ringBuffer := smithyio.NewRingBuffer(buff[:])
7704	body := io.TeeReader(errorBody, ringBuffer)
7705	rootDecoder := xml.NewDecoder(body)
7706	t, err := smithyxml.FetchRootElement(rootDecoder)
7707	if err == io.EOF {
7708		return output
7709	}
7710	if err != nil {
7711		var snapshot bytes.Buffer
7712		io.Copy(&snapshot, ringBuffer)
7713		return &smithy.DeserializationError{
7714			Err:      fmt.Errorf("failed to decode response body, %w", err),
7715			Snapshot: snapshot.Bytes(),
7716		}
7717	}
7718
7719	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
7720	t, err = decoder.GetElement("Error")
7721	if err != nil {
7722		var snapshot bytes.Buffer
7723		io.Copy(&snapshot, ringBuffer)
7724		return &smithy.DeserializationError{
7725			Err:      fmt.Errorf("failed to decode response body, %w", err),
7726			Snapshot: snapshot.Bytes(),
7727		}
7728	}
7729
7730	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
7731	err = awsAwsquery_deserializeDocumentAPICallRateForCustomerExceededFault(&output, decoder)
7732	if err != nil {
7733		var snapshot bytes.Buffer
7734		io.Copy(&snapshot, ringBuffer)
7735		return &smithy.DeserializationError{
7736			Err:      fmt.Errorf("failed to decode response body, %w", err),
7737			Snapshot: snapshot.Bytes(),
7738		}
7739	}
7740
7741	return output
7742}
7743
7744func awsAwsquery_deserializeErrorAuthorizationAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7745	output := &types.AuthorizationAlreadyExistsFault{}
7746	var buff [1024]byte
7747	ringBuffer := smithyio.NewRingBuffer(buff[:])
7748	body := io.TeeReader(errorBody, ringBuffer)
7749	rootDecoder := xml.NewDecoder(body)
7750	t, err := smithyxml.FetchRootElement(rootDecoder)
7751	if err == io.EOF {
7752		return output
7753	}
7754	if err != nil {
7755		var snapshot bytes.Buffer
7756		io.Copy(&snapshot, ringBuffer)
7757		return &smithy.DeserializationError{
7758			Err:      fmt.Errorf("failed to decode response body, %w", err),
7759			Snapshot: snapshot.Bytes(),
7760		}
7761	}
7762
7763	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
7764	t, err = decoder.GetElement("Error")
7765	if err != nil {
7766		var snapshot bytes.Buffer
7767		io.Copy(&snapshot, ringBuffer)
7768		return &smithy.DeserializationError{
7769			Err:      fmt.Errorf("failed to decode response body, %w", err),
7770			Snapshot: snapshot.Bytes(),
7771		}
7772	}
7773
7774	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
7775	err = awsAwsquery_deserializeDocumentAuthorizationAlreadyExistsFault(&output, decoder)
7776	if err != nil {
7777		var snapshot bytes.Buffer
7778		io.Copy(&snapshot, ringBuffer)
7779		return &smithy.DeserializationError{
7780			Err:      fmt.Errorf("failed to decode response body, %w", err),
7781			Snapshot: snapshot.Bytes(),
7782		}
7783	}
7784
7785	return output
7786}
7787
7788func awsAwsquery_deserializeErrorAuthorizationNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7789	output := &types.AuthorizationNotFoundFault{}
7790	var buff [1024]byte
7791	ringBuffer := smithyio.NewRingBuffer(buff[:])
7792	body := io.TeeReader(errorBody, ringBuffer)
7793	rootDecoder := xml.NewDecoder(body)
7794	t, err := smithyxml.FetchRootElement(rootDecoder)
7795	if err == io.EOF {
7796		return output
7797	}
7798	if err != nil {
7799		var snapshot bytes.Buffer
7800		io.Copy(&snapshot, ringBuffer)
7801		return &smithy.DeserializationError{
7802			Err:      fmt.Errorf("failed to decode response body, %w", err),
7803			Snapshot: snapshot.Bytes(),
7804		}
7805	}
7806
7807	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
7808	t, err = decoder.GetElement("Error")
7809	if err != nil {
7810		var snapshot bytes.Buffer
7811		io.Copy(&snapshot, ringBuffer)
7812		return &smithy.DeserializationError{
7813			Err:      fmt.Errorf("failed to decode response body, %w", err),
7814			Snapshot: snapshot.Bytes(),
7815		}
7816	}
7817
7818	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
7819	err = awsAwsquery_deserializeDocumentAuthorizationNotFoundFault(&output, decoder)
7820	if err != nil {
7821		var snapshot bytes.Buffer
7822		io.Copy(&snapshot, ringBuffer)
7823		return &smithy.DeserializationError{
7824			Err:      fmt.Errorf("failed to decode response body, %w", err),
7825			Snapshot: snapshot.Bytes(),
7826		}
7827	}
7828
7829	return output
7830}
7831
7832func awsAwsquery_deserializeErrorCacheClusterAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7833	output := &types.CacheClusterAlreadyExistsFault{}
7834	var buff [1024]byte
7835	ringBuffer := smithyio.NewRingBuffer(buff[:])
7836	body := io.TeeReader(errorBody, ringBuffer)
7837	rootDecoder := xml.NewDecoder(body)
7838	t, err := smithyxml.FetchRootElement(rootDecoder)
7839	if err == io.EOF {
7840		return output
7841	}
7842	if err != nil {
7843		var snapshot bytes.Buffer
7844		io.Copy(&snapshot, ringBuffer)
7845		return &smithy.DeserializationError{
7846			Err:      fmt.Errorf("failed to decode response body, %w", err),
7847			Snapshot: snapshot.Bytes(),
7848		}
7849	}
7850
7851	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
7852	t, err = decoder.GetElement("Error")
7853	if err != nil {
7854		var snapshot bytes.Buffer
7855		io.Copy(&snapshot, ringBuffer)
7856		return &smithy.DeserializationError{
7857			Err:      fmt.Errorf("failed to decode response body, %w", err),
7858			Snapshot: snapshot.Bytes(),
7859		}
7860	}
7861
7862	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
7863	err = awsAwsquery_deserializeDocumentCacheClusterAlreadyExistsFault(&output, decoder)
7864	if err != nil {
7865		var snapshot bytes.Buffer
7866		io.Copy(&snapshot, ringBuffer)
7867		return &smithy.DeserializationError{
7868			Err:      fmt.Errorf("failed to decode response body, %w", err),
7869			Snapshot: snapshot.Bytes(),
7870		}
7871	}
7872
7873	return output
7874}
7875
7876func awsAwsquery_deserializeErrorCacheClusterNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7877	output := &types.CacheClusterNotFoundFault{}
7878	var buff [1024]byte
7879	ringBuffer := smithyio.NewRingBuffer(buff[:])
7880	body := io.TeeReader(errorBody, ringBuffer)
7881	rootDecoder := xml.NewDecoder(body)
7882	t, err := smithyxml.FetchRootElement(rootDecoder)
7883	if err == io.EOF {
7884		return output
7885	}
7886	if err != nil {
7887		var snapshot bytes.Buffer
7888		io.Copy(&snapshot, ringBuffer)
7889		return &smithy.DeserializationError{
7890			Err:      fmt.Errorf("failed to decode response body, %w", err),
7891			Snapshot: snapshot.Bytes(),
7892		}
7893	}
7894
7895	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
7896	t, err = decoder.GetElement("Error")
7897	if err != nil {
7898		var snapshot bytes.Buffer
7899		io.Copy(&snapshot, ringBuffer)
7900		return &smithy.DeserializationError{
7901			Err:      fmt.Errorf("failed to decode response body, %w", err),
7902			Snapshot: snapshot.Bytes(),
7903		}
7904	}
7905
7906	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
7907	err = awsAwsquery_deserializeDocumentCacheClusterNotFoundFault(&output, decoder)
7908	if err != nil {
7909		var snapshot bytes.Buffer
7910		io.Copy(&snapshot, ringBuffer)
7911		return &smithy.DeserializationError{
7912			Err:      fmt.Errorf("failed to decode response body, %w", err),
7913			Snapshot: snapshot.Bytes(),
7914		}
7915	}
7916
7917	return output
7918}
7919
7920func awsAwsquery_deserializeErrorCacheParameterGroupAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7921	output := &types.CacheParameterGroupAlreadyExistsFault{}
7922	var buff [1024]byte
7923	ringBuffer := smithyio.NewRingBuffer(buff[:])
7924	body := io.TeeReader(errorBody, ringBuffer)
7925	rootDecoder := xml.NewDecoder(body)
7926	t, err := smithyxml.FetchRootElement(rootDecoder)
7927	if err == io.EOF {
7928		return output
7929	}
7930	if err != nil {
7931		var snapshot bytes.Buffer
7932		io.Copy(&snapshot, ringBuffer)
7933		return &smithy.DeserializationError{
7934			Err:      fmt.Errorf("failed to decode response body, %w", err),
7935			Snapshot: snapshot.Bytes(),
7936		}
7937	}
7938
7939	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
7940	t, err = decoder.GetElement("Error")
7941	if err != nil {
7942		var snapshot bytes.Buffer
7943		io.Copy(&snapshot, ringBuffer)
7944		return &smithy.DeserializationError{
7945			Err:      fmt.Errorf("failed to decode response body, %w", err),
7946			Snapshot: snapshot.Bytes(),
7947		}
7948	}
7949
7950	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
7951	err = awsAwsquery_deserializeDocumentCacheParameterGroupAlreadyExistsFault(&output, decoder)
7952	if err != nil {
7953		var snapshot bytes.Buffer
7954		io.Copy(&snapshot, ringBuffer)
7955		return &smithy.DeserializationError{
7956			Err:      fmt.Errorf("failed to decode response body, %w", err),
7957			Snapshot: snapshot.Bytes(),
7958		}
7959	}
7960
7961	return output
7962}
7963
7964func awsAwsquery_deserializeErrorCacheParameterGroupNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7965	output := &types.CacheParameterGroupNotFoundFault{}
7966	var buff [1024]byte
7967	ringBuffer := smithyio.NewRingBuffer(buff[:])
7968	body := io.TeeReader(errorBody, ringBuffer)
7969	rootDecoder := xml.NewDecoder(body)
7970	t, err := smithyxml.FetchRootElement(rootDecoder)
7971	if err == io.EOF {
7972		return output
7973	}
7974	if err != nil {
7975		var snapshot bytes.Buffer
7976		io.Copy(&snapshot, ringBuffer)
7977		return &smithy.DeserializationError{
7978			Err:      fmt.Errorf("failed to decode response body, %w", err),
7979			Snapshot: snapshot.Bytes(),
7980		}
7981	}
7982
7983	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
7984	t, err = decoder.GetElement("Error")
7985	if err != nil {
7986		var snapshot bytes.Buffer
7987		io.Copy(&snapshot, ringBuffer)
7988		return &smithy.DeserializationError{
7989			Err:      fmt.Errorf("failed to decode response body, %w", err),
7990			Snapshot: snapshot.Bytes(),
7991		}
7992	}
7993
7994	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
7995	err = awsAwsquery_deserializeDocumentCacheParameterGroupNotFoundFault(&output, decoder)
7996	if err != nil {
7997		var snapshot bytes.Buffer
7998		io.Copy(&snapshot, ringBuffer)
7999		return &smithy.DeserializationError{
8000			Err:      fmt.Errorf("failed to decode response body, %w", err),
8001			Snapshot: snapshot.Bytes(),
8002		}
8003	}
8004
8005	return output
8006}
8007
8008func awsAwsquery_deserializeErrorCacheParameterGroupQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
8009	output := &types.CacheParameterGroupQuotaExceededFault{}
8010	var buff [1024]byte
8011	ringBuffer := smithyio.NewRingBuffer(buff[:])
8012	body := io.TeeReader(errorBody, ringBuffer)
8013	rootDecoder := xml.NewDecoder(body)
8014	t, err := smithyxml.FetchRootElement(rootDecoder)
8015	if err == io.EOF {
8016		return output
8017	}
8018	if err != nil {
8019		var snapshot bytes.Buffer
8020		io.Copy(&snapshot, ringBuffer)
8021		return &smithy.DeserializationError{
8022			Err:      fmt.Errorf("failed to decode response body, %w", err),
8023			Snapshot: snapshot.Bytes(),
8024		}
8025	}
8026
8027	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8028	t, err = decoder.GetElement("Error")
8029	if err != nil {
8030		var snapshot bytes.Buffer
8031		io.Copy(&snapshot, ringBuffer)
8032		return &smithy.DeserializationError{
8033			Err:      fmt.Errorf("failed to decode response body, %w", err),
8034			Snapshot: snapshot.Bytes(),
8035		}
8036	}
8037
8038	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8039	err = awsAwsquery_deserializeDocumentCacheParameterGroupQuotaExceededFault(&output, decoder)
8040	if err != nil {
8041		var snapshot bytes.Buffer
8042		io.Copy(&snapshot, ringBuffer)
8043		return &smithy.DeserializationError{
8044			Err:      fmt.Errorf("failed to decode response body, %w", err),
8045			Snapshot: snapshot.Bytes(),
8046		}
8047	}
8048
8049	return output
8050}
8051
8052func awsAwsquery_deserializeErrorCacheSecurityGroupAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
8053	output := &types.CacheSecurityGroupAlreadyExistsFault{}
8054	var buff [1024]byte
8055	ringBuffer := smithyio.NewRingBuffer(buff[:])
8056	body := io.TeeReader(errorBody, ringBuffer)
8057	rootDecoder := xml.NewDecoder(body)
8058	t, err := smithyxml.FetchRootElement(rootDecoder)
8059	if err == io.EOF {
8060		return output
8061	}
8062	if err != nil {
8063		var snapshot bytes.Buffer
8064		io.Copy(&snapshot, ringBuffer)
8065		return &smithy.DeserializationError{
8066			Err:      fmt.Errorf("failed to decode response body, %w", err),
8067			Snapshot: snapshot.Bytes(),
8068		}
8069	}
8070
8071	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8072	t, err = decoder.GetElement("Error")
8073	if err != nil {
8074		var snapshot bytes.Buffer
8075		io.Copy(&snapshot, ringBuffer)
8076		return &smithy.DeserializationError{
8077			Err:      fmt.Errorf("failed to decode response body, %w", err),
8078			Snapshot: snapshot.Bytes(),
8079		}
8080	}
8081
8082	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8083	err = awsAwsquery_deserializeDocumentCacheSecurityGroupAlreadyExistsFault(&output, decoder)
8084	if err != nil {
8085		var snapshot bytes.Buffer
8086		io.Copy(&snapshot, ringBuffer)
8087		return &smithy.DeserializationError{
8088			Err:      fmt.Errorf("failed to decode response body, %w", err),
8089			Snapshot: snapshot.Bytes(),
8090		}
8091	}
8092
8093	return output
8094}
8095
8096func awsAwsquery_deserializeErrorCacheSecurityGroupNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
8097	output := &types.CacheSecurityGroupNotFoundFault{}
8098	var buff [1024]byte
8099	ringBuffer := smithyio.NewRingBuffer(buff[:])
8100	body := io.TeeReader(errorBody, ringBuffer)
8101	rootDecoder := xml.NewDecoder(body)
8102	t, err := smithyxml.FetchRootElement(rootDecoder)
8103	if err == io.EOF {
8104		return output
8105	}
8106	if err != nil {
8107		var snapshot bytes.Buffer
8108		io.Copy(&snapshot, ringBuffer)
8109		return &smithy.DeserializationError{
8110			Err:      fmt.Errorf("failed to decode response body, %w", err),
8111			Snapshot: snapshot.Bytes(),
8112		}
8113	}
8114
8115	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8116	t, err = decoder.GetElement("Error")
8117	if err != nil {
8118		var snapshot bytes.Buffer
8119		io.Copy(&snapshot, ringBuffer)
8120		return &smithy.DeserializationError{
8121			Err:      fmt.Errorf("failed to decode response body, %w", err),
8122			Snapshot: snapshot.Bytes(),
8123		}
8124	}
8125
8126	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8127	err = awsAwsquery_deserializeDocumentCacheSecurityGroupNotFoundFault(&output, decoder)
8128	if err != nil {
8129		var snapshot bytes.Buffer
8130		io.Copy(&snapshot, ringBuffer)
8131		return &smithy.DeserializationError{
8132			Err:      fmt.Errorf("failed to decode response body, %w", err),
8133			Snapshot: snapshot.Bytes(),
8134		}
8135	}
8136
8137	return output
8138}
8139
8140func awsAwsquery_deserializeErrorCacheSecurityGroupQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
8141	output := &types.CacheSecurityGroupQuotaExceededFault{}
8142	var buff [1024]byte
8143	ringBuffer := smithyio.NewRingBuffer(buff[:])
8144	body := io.TeeReader(errorBody, ringBuffer)
8145	rootDecoder := xml.NewDecoder(body)
8146	t, err := smithyxml.FetchRootElement(rootDecoder)
8147	if err == io.EOF {
8148		return output
8149	}
8150	if err != nil {
8151		var snapshot bytes.Buffer
8152		io.Copy(&snapshot, ringBuffer)
8153		return &smithy.DeserializationError{
8154			Err:      fmt.Errorf("failed to decode response body, %w", err),
8155			Snapshot: snapshot.Bytes(),
8156		}
8157	}
8158
8159	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8160	t, err = decoder.GetElement("Error")
8161	if err != nil {
8162		var snapshot bytes.Buffer
8163		io.Copy(&snapshot, ringBuffer)
8164		return &smithy.DeserializationError{
8165			Err:      fmt.Errorf("failed to decode response body, %w", err),
8166			Snapshot: snapshot.Bytes(),
8167		}
8168	}
8169
8170	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8171	err = awsAwsquery_deserializeDocumentCacheSecurityGroupQuotaExceededFault(&output, decoder)
8172	if err != nil {
8173		var snapshot bytes.Buffer
8174		io.Copy(&snapshot, ringBuffer)
8175		return &smithy.DeserializationError{
8176			Err:      fmt.Errorf("failed to decode response body, %w", err),
8177			Snapshot: snapshot.Bytes(),
8178		}
8179	}
8180
8181	return output
8182}
8183
8184func awsAwsquery_deserializeErrorCacheSubnetGroupAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
8185	output := &types.CacheSubnetGroupAlreadyExistsFault{}
8186	var buff [1024]byte
8187	ringBuffer := smithyio.NewRingBuffer(buff[:])
8188	body := io.TeeReader(errorBody, ringBuffer)
8189	rootDecoder := xml.NewDecoder(body)
8190	t, err := smithyxml.FetchRootElement(rootDecoder)
8191	if err == io.EOF {
8192		return output
8193	}
8194	if err != nil {
8195		var snapshot bytes.Buffer
8196		io.Copy(&snapshot, ringBuffer)
8197		return &smithy.DeserializationError{
8198			Err:      fmt.Errorf("failed to decode response body, %w", err),
8199			Snapshot: snapshot.Bytes(),
8200		}
8201	}
8202
8203	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8204	t, err = decoder.GetElement("Error")
8205	if err != nil {
8206		var snapshot bytes.Buffer
8207		io.Copy(&snapshot, ringBuffer)
8208		return &smithy.DeserializationError{
8209			Err:      fmt.Errorf("failed to decode response body, %w", err),
8210			Snapshot: snapshot.Bytes(),
8211		}
8212	}
8213
8214	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8215	err = awsAwsquery_deserializeDocumentCacheSubnetGroupAlreadyExistsFault(&output, decoder)
8216	if err != nil {
8217		var snapshot bytes.Buffer
8218		io.Copy(&snapshot, ringBuffer)
8219		return &smithy.DeserializationError{
8220			Err:      fmt.Errorf("failed to decode response body, %w", err),
8221			Snapshot: snapshot.Bytes(),
8222		}
8223	}
8224
8225	return output
8226}
8227
8228func awsAwsquery_deserializeErrorCacheSubnetGroupInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error {
8229	output := &types.CacheSubnetGroupInUse{}
8230	var buff [1024]byte
8231	ringBuffer := smithyio.NewRingBuffer(buff[:])
8232	body := io.TeeReader(errorBody, ringBuffer)
8233	rootDecoder := xml.NewDecoder(body)
8234	t, err := smithyxml.FetchRootElement(rootDecoder)
8235	if err == io.EOF {
8236		return output
8237	}
8238	if err != nil {
8239		var snapshot bytes.Buffer
8240		io.Copy(&snapshot, ringBuffer)
8241		return &smithy.DeserializationError{
8242			Err:      fmt.Errorf("failed to decode response body, %w", err),
8243			Snapshot: snapshot.Bytes(),
8244		}
8245	}
8246
8247	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8248	t, err = decoder.GetElement("Error")
8249	if err != nil {
8250		var snapshot bytes.Buffer
8251		io.Copy(&snapshot, ringBuffer)
8252		return &smithy.DeserializationError{
8253			Err:      fmt.Errorf("failed to decode response body, %w", err),
8254			Snapshot: snapshot.Bytes(),
8255		}
8256	}
8257
8258	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8259	err = awsAwsquery_deserializeDocumentCacheSubnetGroupInUse(&output, decoder)
8260	if err != nil {
8261		var snapshot bytes.Buffer
8262		io.Copy(&snapshot, ringBuffer)
8263		return &smithy.DeserializationError{
8264			Err:      fmt.Errorf("failed to decode response body, %w", err),
8265			Snapshot: snapshot.Bytes(),
8266		}
8267	}
8268
8269	return output
8270}
8271
8272func awsAwsquery_deserializeErrorCacheSubnetGroupNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
8273	output := &types.CacheSubnetGroupNotFoundFault{}
8274	var buff [1024]byte
8275	ringBuffer := smithyio.NewRingBuffer(buff[:])
8276	body := io.TeeReader(errorBody, ringBuffer)
8277	rootDecoder := xml.NewDecoder(body)
8278	t, err := smithyxml.FetchRootElement(rootDecoder)
8279	if err == io.EOF {
8280		return output
8281	}
8282	if err != nil {
8283		var snapshot bytes.Buffer
8284		io.Copy(&snapshot, ringBuffer)
8285		return &smithy.DeserializationError{
8286			Err:      fmt.Errorf("failed to decode response body, %w", err),
8287			Snapshot: snapshot.Bytes(),
8288		}
8289	}
8290
8291	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8292	t, err = decoder.GetElement("Error")
8293	if err != nil {
8294		var snapshot bytes.Buffer
8295		io.Copy(&snapshot, ringBuffer)
8296		return &smithy.DeserializationError{
8297			Err:      fmt.Errorf("failed to decode response body, %w", err),
8298			Snapshot: snapshot.Bytes(),
8299		}
8300	}
8301
8302	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8303	err = awsAwsquery_deserializeDocumentCacheSubnetGroupNotFoundFault(&output, decoder)
8304	if err != nil {
8305		var snapshot bytes.Buffer
8306		io.Copy(&snapshot, ringBuffer)
8307		return &smithy.DeserializationError{
8308			Err:      fmt.Errorf("failed to decode response body, %w", err),
8309			Snapshot: snapshot.Bytes(),
8310		}
8311	}
8312
8313	return output
8314}
8315
8316func awsAwsquery_deserializeErrorCacheSubnetGroupQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
8317	output := &types.CacheSubnetGroupQuotaExceededFault{}
8318	var buff [1024]byte
8319	ringBuffer := smithyio.NewRingBuffer(buff[:])
8320	body := io.TeeReader(errorBody, ringBuffer)
8321	rootDecoder := xml.NewDecoder(body)
8322	t, err := smithyxml.FetchRootElement(rootDecoder)
8323	if err == io.EOF {
8324		return output
8325	}
8326	if err != nil {
8327		var snapshot bytes.Buffer
8328		io.Copy(&snapshot, ringBuffer)
8329		return &smithy.DeserializationError{
8330			Err:      fmt.Errorf("failed to decode response body, %w", err),
8331			Snapshot: snapshot.Bytes(),
8332		}
8333	}
8334
8335	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8336	t, err = decoder.GetElement("Error")
8337	if err != nil {
8338		var snapshot bytes.Buffer
8339		io.Copy(&snapshot, ringBuffer)
8340		return &smithy.DeserializationError{
8341			Err:      fmt.Errorf("failed to decode response body, %w", err),
8342			Snapshot: snapshot.Bytes(),
8343		}
8344	}
8345
8346	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8347	err = awsAwsquery_deserializeDocumentCacheSubnetGroupQuotaExceededFault(&output, decoder)
8348	if err != nil {
8349		var snapshot bytes.Buffer
8350		io.Copy(&snapshot, ringBuffer)
8351		return &smithy.DeserializationError{
8352			Err:      fmt.Errorf("failed to decode response body, %w", err),
8353			Snapshot: snapshot.Bytes(),
8354		}
8355	}
8356
8357	return output
8358}
8359
8360func awsAwsquery_deserializeErrorCacheSubnetQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
8361	output := &types.CacheSubnetQuotaExceededFault{}
8362	var buff [1024]byte
8363	ringBuffer := smithyio.NewRingBuffer(buff[:])
8364	body := io.TeeReader(errorBody, ringBuffer)
8365	rootDecoder := xml.NewDecoder(body)
8366	t, err := smithyxml.FetchRootElement(rootDecoder)
8367	if err == io.EOF {
8368		return output
8369	}
8370	if err != nil {
8371		var snapshot bytes.Buffer
8372		io.Copy(&snapshot, ringBuffer)
8373		return &smithy.DeserializationError{
8374			Err:      fmt.Errorf("failed to decode response body, %w", err),
8375			Snapshot: snapshot.Bytes(),
8376		}
8377	}
8378
8379	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8380	t, err = decoder.GetElement("Error")
8381	if err != nil {
8382		var snapshot bytes.Buffer
8383		io.Copy(&snapshot, ringBuffer)
8384		return &smithy.DeserializationError{
8385			Err:      fmt.Errorf("failed to decode response body, %w", err),
8386			Snapshot: snapshot.Bytes(),
8387		}
8388	}
8389
8390	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8391	err = awsAwsquery_deserializeDocumentCacheSubnetQuotaExceededFault(&output, decoder)
8392	if err != nil {
8393		var snapshot bytes.Buffer
8394		io.Copy(&snapshot, ringBuffer)
8395		return &smithy.DeserializationError{
8396			Err:      fmt.Errorf("failed to decode response body, %w", err),
8397			Snapshot: snapshot.Bytes(),
8398		}
8399	}
8400
8401	return output
8402}
8403
8404func awsAwsquery_deserializeErrorClusterQuotaForCustomerExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
8405	output := &types.ClusterQuotaForCustomerExceededFault{}
8406	var buff [1024]byte
8407	ringBuffer := smithyio.NewRingBuffer(buff[:])
8408	body := io.TeeReader(errorBody, ringBuffer)
8409	rootDecoder := xml.NewDecoder(body)
8410	t, err := smithyxml.FetchRootElement(rootDecoder)
8411	if err == io.EOF {
8412		return output
8413	}
8414	if err != nil {
8415		var snapshot bytes.Buffer
8416		io.Copy(&snapshot, ringBuffer)
8417		return &smithy.DeserializationError{
8418			Err:      fmt.Errorf("failed to decode response body, %w", err),
8419			Snapshot: snapshot.Bytes(),
8420		}
8421	}
8422
8423	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8424	t, err = decoder.GetElement("Error")
8425	if err != nil {
8426		var snapshot bytes.Buffer
8427		io.Copy(&snapshot, ringBuffer)
8428		return &smithy.DeserializationError{
8429			Err:      fmt.Errorf("failed to decode response body, %w", err),
8430			Snapshot: snapshot.Bytes(),
8431		}
8432	}
8433
8434	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8435	err = awsAwsquery_deserializeDocumentClusterQuotaForCustomerExceededFault(&output, decoder)
8436	if err != nil {
8437		var snapshot bytes.Buffer
8438		io.Copy(&snapshot, ringBuffer)
8439		return &smithy.DeserializationError{
8440			Err:      fmt.Errorf("failed to decode response body, %w", err),
8441			Snapshot: snapshot.Bytes(),
8442		}
8443	}
8444
8445	return output
8446}
8447
8448func awsAwsquery_deserializeErrorDefaultUserAssociatedToUserGroupFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
8449	output := &types.DefaultUserAssociatedToUserGroupFault{}
8450	var buff [1024]byte
8451	ringBuffer := smithyio.NewRingBuffer(buff[:])
8452	body := io.TeeReader(errorBody, ringBuffer)
8453	rootDecoder := xml.NewDecoder(body)
8454	t, err := smithyxml.FetchRootElement(rootDecoder)
8455	if err == io.EOF {
8456		return output
8457	}
8458	if err != nil {
8459		var snapshot bytes.Buffer
8460		io.Copy(&snapshot, ringBuffer)
8461		return &smithy.DeserializationError{
8462			Err:      fmt.Errorf("failed to decode response body, %w", err),
8463			Snapshot: snapshot.Bytes(),
8464		}
8465	}
8466
8467	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8468	t, err = decoder.GetElement("Error")
8469	if err != nil {
8470		var snapshot bytes.Buffer
8471		io.Copy(&snapshot, ringBuffer)
8472		return &smithy.DeserializationError{
8473			Err:      fmt.Errorf("failed to decode response body, %w", err),
8474			Snapshot: snapshot.Bytes(),
8475		}
8476	}
8477
8478	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8479	err = awsAwsquery_deserializeDocumentDefaultUserAssociatedToUserGroupFault(&output, decoder)
8480	if err != nil {
8481		var snapshot bytes.Buffer
8482		io.Copy(&snapshot, ringBuffer)
8483		return &smithy.DeserializationError{
8484			Err:      fmt.Errorf("failed to decode response body, %w", err),
8485			Snapshot: snapshot.Bytes(),
8486		}
8487	}
8488
8489	return output
8490}
8491
8492func awsAwsquery_deserializeErrorDefaultUserRequired(response *smithyhttp.Response, errorBody *bytes.Reader) error {
8493	output := &types.DefaultUserRequired{}
8494	var buff [1024]byte
8495	ringBuffer := smithyio.NewRingBuffer(buff[:])
8496	body := io.TeeReader(errorBody, ringBuffer)
8497	rootDecoder := xml.NewDecoder(body)
8498	t, err := smithyxml.FetchRootElement(rootDecoder)
8499	if err == io.EOF {
8500		return output
8501	}
8502	if err != nil {
8503		var snapshot bytes.Buffer
8504		io.Copy(&snapshot, ringBuffer)
8505		return &smithy.DeserializationError{
8506			Err:      fmt.Errorf("failed to decode response body, %w", err),
8507			Snapshot: snapshot.Bytes(),
8508		}
8509	}
8510
8511	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8512	t, err = decoder.GetElement("Error")
8513	if err != nil {
8514		var snapshot bytes.Buffer
8515		io.Copy(&snapshot, ringBuffer)
8516		return &smithy.DeserializationError{
8517			Err:      fmt.Errorf("failed to decode response body, %w", err),
8518			Snapshot: snapshot.Bytes(),
8519		}
8520	}
8521
8522	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8523	err = awsAwsquery_deserializeDocumentDefaultUserRequired(&output, decoder)
8524	if err != nil {
8525		var snapshot bytes.Buffer
8526		io.Copy(&snapshot, ringBuffer)
8527		return &smithy.DeserializationError{
8528			Err:      fmt.Errorf("failed to decode response body, %w", err),
8529			Snapshot: snapshot.Bytes(),
8530		}
8531	}
8532
8533	return output
8534}
8535
8536func awsAwsquery_deserializeErrorDuplicateUserNameFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
8537	output := &types.DuplicateUserNameFault{}
8538	var buff [1024]byte
8539	ringBuffer := smithyio.NewRingBuffer(buff[:])
8540	body := io.TeeReader(errorBody, ringBuffer)
8541	rootDecoder := xml.NewDecoder(body)
8542	t, err := smithyxml.FetchRootElement(rootDecoder)
8543	if err == io.EOF {
8544		return output
8545	}
8546	if err != nil {
8547		var snapshot bytes.Buffer
8548		io.Copy(&snapshot, ringBuffer)
8549		return &smithy.DeserializationError{
8550			Err:      fmt.Errorf("failed to decode response body, %w", err),
8551			Snapshot: snapshot.Bytes(),
8552		}
8553	}
8554
8555	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8556	t, err = decoder.GetElement("Error")
8557	if err != nil {
8558		var snapshot bytes.Buffer
8559		io.Copy(&snapshot, ringBuffer)
8560		return &smithy.DeserializationError{
8561			Err:      fmt.Errorf("failed to decode response body, %w", err),
8562			Snapshot: snapshot.Bytes(),
8563		}
8564	}
8565
8566	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8567	err = awsAwsquery_deserializeDocumentDuplicateUserNameFault(&output, decoder)
8568	if err != nil {
8569		var snapshot bytes.Buffer
8570		io.Copy(&snapshot, ringBuffer)
8571		return &smithy.DeserializationError{
8572			Err:      fmt.Errorf("failed to decode response body, %w", err),
8573			Snapshot: snapshot.Bytes(),
8574		}
8575	}
8576
8577	return output
8578}
8579
8580func awsAwsquery_deserializeErrorGlobalReplicationGroupAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
8581	output := &types.GlobalReplicationGroupAlreadyExistsFault{}
8582	var buff [1024]byte
8583	ringBuffer := smithyio.NewRingBuffer(buff[:])
8584	body := io.TeeReader(errorBody, ringBuffer)
8585	rootDecoder := xml.NewDecoder(body)
8586	t, err := smithyxml.FetchRootElement(rootDecoder)
8587	if err == io.EOF {
8588		return output
8589	}
8590	if err != nil {
8591		var snapshot bytes.Buffer
8592		io.Copy(&snapshot, ringBuffer)
8593		return &smithy.DeserializationError{
8594			Err:      fmt.Errorf("failed to decode response body, %w", err),
8595			Snapshot: snapshot.Bytes(),
8596		}
8597	}
8598
8599	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8600	t, err = decoder.GetElement("Error")
8601	if err != nil {
8602		var snapshot bytes.Buffer
8603		io.Copy(&snapshot, ringBuffer)
8604		return &smithy.DeserializationError{
8605			Err:      fmt.Errorf("failed to decode response body, %w", err),
8606			Snapshot: snapshot.Bytes(),
8607		}
8608	}
8609
8610	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8611	err = awsAwsquery_deserializeDocumentGlobalReplicationGroupAlreadyExistsFault(&output, decoder)
8612	if err != nil {
8613		var snapshot bytes.Buffer
8614		io.Copy(&snapshot, ringBuffer)
8615		return &smithy.DeserializationError{
8616			Err:      fmt.Errorf("failed to decode response body, %w", err),
8617			Snapshot: snapshot.Bytes(),
8618		}
8619	}
8620
8621	return output
8622}
8623
8624func awsAwsquery_deserializeErrorGlobalReplicationGroupNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
8625	output := &types.GlobalReplicationGroupNotFoundFault{}
8626	var buff [1024]byte
8627	ringBuffer := smithyio.NewRingBuffer(buff[:])
8628	body := io.TeeReader(errorBody, ringBuffer)
8629	rootDecoder := xml.NewDecoder(body)
8630	t, err := smithyxml.FetchRootElement(rootDecoder)
8631	if err == io.EOF {
8632		return output
8633	}
8634	if err != nil {
8635		var snapshot bytes.Buffer
8636		io.Copy(&snapshot, ringBuffer)
8637		return &smithy.DeserializationError{
8638			Err:      fmt.Errorf("failed to decode response body, %w", err),
8639			Snapshot: snapshot.Bytes(),
8640		}
8641	}
8642
8643	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8644	t, err = decoder.GetElement("Error")
8645	if err != nil {
8646		var snapshot bytes.Buffer
8647		io.Copy(&snapshot, ringBuffer)
8648		return &smithy.DeserializationError{
8649			Err:      fmt.Errorf("failed to decode response body, %w", err),
8650			Snapshot: snapshot.Bytes(),
8651		}
8652	}
8653
8654	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8655	err = awsAwsquery_deserializeDocumentGlobalReplicationGroupNotFoundFault(&output, decoder)
8656	if err != nil {
8657		var snapshot bytes.Buffer
8658		io.Copy(&snapshot, ringBuffer)
8659		return &smithy.DeserializationError{
8660			Err:      fmt.Errorf("failed to decode response body, %w", err),
8661			Snapshot: snapshot.Bytes(),
8662		}
8663	}
8664
8665	return output
8666}
8667
8668func awsAwsquery_deserializeErrorInsufficientCacheClusterCapacityFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
8669	output := &types.InsufficientCacheClusterCapacityFault{}
8670	var buff [1024]byte
8671	ringBuffer := smithyio.NewRingBuffer(buff[:])
8672	body := io.TeeReader(errorBody, ringBuffer)
8673	rootDecoder := xml.NewDecoder(body)
8674	t, err := smithyxml.FetchRootElement(rootDecoder)
8675	if err == io.EOF {
8676		return output
8677	}
8678	if err != nil {
8679		var snapshot bytes.Buffer
8680		io.Copy(&snapshot, ringBuffer)
8681		return &smithy.DeserializationError{
8682			Err:      fmt.Errorf("failed to decode response body, %w", err),
8683			Snapshot: snapshot.Bytes(),
8684		}
8685	}
8686
8687	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8688	t, err = decoder.GetElement("Error")
8689	if err != nil {
8690		var snapshot bytes.Buffer
8691		io.Copy(&snapshot, ringBuffer)
8692		return &smithy.DeserializationError{
8693			Err:      fmt.Errorf("failed to decode response body, %w", err),
8694			Snapshot: snapshot.Bytes(),
8695		}
8696	}
8697
8698	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8699	err = awsAwsquery_deserializeDocumentInsufficientCacheClusterCapacityFault(&output, decoder)
8700	if err != nil {
8701		var snapshot bytes.Buffer
8702		io.Copy(&snapshot, ringBuffer)
8703		return &smithy.DeserializationError{
8704			Err:      fmt.Errorf("failed to decode response body, %w", err),
8705			Snapshot: snapshot.Bytes(),
8706		}
8707	}
8708
8709	return output
8710}
8711
8712func awsAwsquery_deserializeErrorInvalidARNFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
8713	output := &types.InvalidARNFault{}
8714	var buff [1024]byte
8715	ringBuffer := smithyio.NewRingBuffer(buff[:])
8716	body := io.TeeReader(errorBody, ringBuffer)
8717	rootDecoder := xml.NewDecoder(body)
8718	t, err := smithyxml.FetchRootElement(rootDecoder)
8719	if err == io.EOF {
8720		return output
8721	}
8722	if err != nil {
8723		var snapshot bytes.Buffer
8724		io.Copy(&snapshot, ringBuffer)
8725		return &smithy.DeserializationError{
8726			Err:      fmt.Errorf("failed to decode response body, %w", err),
8727			Snapshot: snapshot.Bytes(),
8728		}
8729	}
8730
8731	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8732	t, err = decoder.GetElement("Error")
8733	if err != nil {
8734		var snapshot bytes.Buffer
8735		io.Copy(&snapshot, ringBuffer)
8736		return &smithy.DeserializationError{
8737			Err:      fmt.Errorf("failed to decode response body, %w", err),
8738			Snapshot: snapshot.Bytes(),
8739		}
8740	}
8741
8742	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8743	err = awsAwsquery_deserializeDocumentInvalidARNFault(&output, decoder)
8744	if err != nil {
8745		var snapshot bytes.Buffer
8746		io.Copy(&snapshot, ringBuffer)
8747		return &smithy.DeserializationError{
8748			Err:      fmt.Errorf("failed to decode response body, %w", err),
8749			Snapshot: snapshot.Bytes(),
8750		}
8751	}
8752
8753	return output
8754}
8755
8756func awsAwsquery_deserializeErrorInvalidCacheClusterStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
8757	output := &types.InvalidCacheClusterStateFault{}
8758	var buff [1024]byte
8759	ringBuffer := smithyio.NewRingBuffer(buff[:])
8760	body := io.TeeReader(errorBody, ringBuffer)
8761	rootDecoder := xml.NewDecoder(body)
8762	t, err := smithyxml.FetchRootElement(rootDecoder)
8763	if err == io.EOF {
8764		return output
8765	}
8766	if err != nil {
8767		var snapshot bytes.Buffer
8768		io.Copy(&snapshot, ringBuffer)
8769		return &smithy.DeserializationError{
8770			Err:      fmt.Errorf("failed to decode response body, %w", err),
8771			Snapshot: snapshot.Bytes(),
8772		}
8773	}
8774
8775	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8776	t, err = decoder.GetElement("Error")
8777	if err != nil {
8778		var snapshot bytes.Buffer
8779		io.Copy(&snapshot, ringBuffer)
8780		return &smithy.DeserializationError{
8781			Err:      fmt.Errorf("failed to decode response body, %w", err),
8782			Snapshot: snapshot.Bytes(),
8783		}
8784	}
8785
8786	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8787	err = awsAwsquery_deserializeDocumentInvalidCacheClusterStateFault(&output, decoder)
8788	if err != nil {
8789		var snapshot bytes.Buffer
8790		io.Copy(&snapshot, ringBuffer)
8791		return &smithy.DeserializationError{
8792			Err:      fmt.Errorf("failed to decode response body, %w", err),
8793			Snapshot: snapshot.Bytes(),
8794		}
8795	}
8796
8797	return output
8798}
8799
8800func awsAwsquery_deserializeErrorInvalidCacheParameterGroupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
8801	output := &types.InvalidCacheParameterGroupStateFault{}
8802	var buff [1024]byte
8803	ringBuffer := smithyio.NewRingBuffer(buff[:])
8804	body := io.TeeReader(errorBody, ringBuffer)
8805	rootDecoder := xml.NewDecoder(body)
8806	t, err := smithyxml.FetchRootElement(rootDecoder)
8807	if err == io.EOF {
8808		return output
8809	}
8810	if err != nil {
8811		var snapshot bytes.Buffer
8812		io.Copy(&snapshot, ringBuffer)
8813		return &smithy.DeserializationError{
8814			Err:      fmt.Errorf("failed to decode response body, %w", err),
8815			Snapshot: snapshot.Bytes(),
8816		}
8817	}
8818
8819	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8820	t, err = decoder.GetElement("Error")
8821	if err != nil {
8822		var snapshot bytes.Buffer
8823		io.Copy(&snapshot, ringBuffer)
8824		return &smithy.DeserializationError{
8825			Err:      fmt.Errorf("failed to decode response body, %w", err),
8826			Snapshot: snapshot.Bytes(),
8827		}
8828	}
8829
8830	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8831	err = awsAwsquery_deserializeDocumentInvalidCacheParameterGroupStateFault(&output, decoder)
8832	if err != nil {
8833		var snapshot bytes.Buffer
8834		io.Copy(&snapshot, ringBuffer)
8835		return &smithy.DeserializationError{
8836			Err:      fmt.Errorf("failed to decode response body, %w", err),
8837			Snapshot: snapshot.Bytes(),
8838		}
8839	}
8840
8841	return output
8842}
8843
8844func awsAwsquery_deserializeErrorInvalidCacheSecurityGroupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
8845	output := &types.InvalidCacheSecurityGroupStateFault{}
8846	var buff [1024]byte
8847	ringBuffer := smithyio.NewRingBuffer(buff[:])
8848	body := io.TeeReader(errorBody, ringBuffer)
8849	rootDecoder := xml.NewDecoder(body)
8850	t, err := smithyxml.FetchRootElement(rootDecoder)
8851	if err == io.EOF {
8852		return output
8853	}
8854	if err != nil {
8855		var snapshot bytes.Buffer
8856		io.Copy(&snapshot, ringBuffer)
8857		return &smithy.DeserializationError{
8858			Err:      fmt.Errorf("failed to decode response body, %w", err),
8859			Snapshot: snapshot.Bytes(),
8860		}
8861	}
8862
8863	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8864	t, err = decoder.GetElement("Error")
8865	if err != nil {
8866		var snapshot bytes.Buffer
8867		io.Copy(&snapshot, ringBuffer)
8868		return &smithy.DeserializationError{
8869			Err:      fmt.Errorf("failed to decode response body, %w", err),
8870			Snapshot: snapshot.Bytes(),
8871		}
8872	}
8873
8874	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8875	err = awsAwsquery_deserializeDocumentInvalidCacheSecurityGroupStateFault(&output, decoder)
8876	if err != nil {
8877		var snapshot bytes.Buffer
8878		io.Copy(&snapshot, ringBuffer)
8879		return &smithy.DeserializationError{
8880			Err:      fmt.Errorf("failed to decode response body, %w", err),
8881			Snapshot: snapshot.Bytes(),
8882		}
8883	}
8884
8885	return output
8886}
8887
8888func awsAwsquery_deserializeErrorInvalidGlobalReplicationGroupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
8889	output := &types.InvalidGlobalReplicationGroupStateFault{}
8890	var buff [1024]byte
8891	ringBuffer := smithyio.NewRingBuffer(buff[:])
8892	body := io.TeeReader(errorBody, ringBuffer)
8893	rootDecoder := xml.NewDecoder(body)
8894	t, err := smithyxml.FetchRootElement(rootDecoder)
8895	if err == io.EOF {
8896		return output
8897	}
8898	if err != nil {
8899		var snapshot bytes.Buffer
8900		io.Copy(&snapshot, ringBuffer)
8901		return &smithy.DeserializationError{
8902			Err:      fmt.Errorf("failed to decode response body, %w", err),
8903			Snapshot: snapshot.Bytes(),
8904		}
8905	}
8906
8907	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8908	t, err = decoder.GetElement("Error")
8909	if err != nil {
8910		var snapshot bytes.Buffer
8911		io.Copy(&snapshot, ringBuffer)
8912		return &smithy.DeserializationError{
8913			Err:      fmt.Errorf("failed to decode response body, %w", err),
8914			Snapshot: snapshot.Bytes(),
8915		}
8916	}
8917
8918	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8919	err = awsAwsquery_deserializeDocumentInvalidGlobalReplicationGroupStateFault(&output, decoder)
8920	if err != nil {
8921		var snapshot bytes.Buffer
8922		io.Copy(&snapshot, ringBuffer)
8923		return &smithy.DeserializationError{
8924			Err:      fmt.Errorf("failed to decode response body, %w", err),
8925			Snapshot: snapshot.Bytes(),
8926		}
8927	}
8928
8929	return output
8930}
8931
8932func awsAwsquery_deserializeErrorInvalidKMSKeyFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
8933	output := &types.InvalidKMSKeyFault{}
8934	var buff [1024]byte
8935	ringBuffer := smithyio.NewRingBuffer(buff[:])
8936	body := io.TeeReader(errorBody, ringBuffer)
8937	rootDecoder := xml.NewDecoder(body)
8938	t, err := smithyxml.FetchRootElement(rootDecoder)
8939	if err == io.EOF {
8940		return output
8941	}
8942	if err != nil {
8943		var snapshot bytes.Buffer
8944		io.Copy(&snapshot, ringBuffer)
8945		return &smithy.DeserializationError{
8946			Err:      fmt.Errorf("failed to decode response body, %w", err),
8947			Snapshot: snapshot.Bytes(),
8948		}
8949	}
8950
8951	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8952	t, err = decoder.GetElement("Error")
8953	if err != nil {
8954		var snapshot bytes.Buffer
8955		io.Copy(&snapshot, ringBuffer)
8956		return &smithy.DeserializationError{
8957			Err:      fmt.Errorf("failed to decode response body, %w", err),
8958			Snapshot: snapshot.Bytes(),
8959		}
8960	}
8961
8962	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
8963	err = awsAwsquery_deserializeDocumentInvalidKMSKeyFault(&output, decoder)
8964	if err != nil {
8965		var snapshot bytes.Buffer
8966		io.Copy(&snapshot, ringBuffer)
8967		return &smithy.DeserializationError{
8968			Err:      fmt.Errorf("failed to decode response body, %w", err),
8969			Snapshot: snapshot.Bytes(),
8970		}
8971	}
8972
8973	return output
8974}
8975
8976func awsAwsquery_deserializeErrorInvalidParameterCombinationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
8977	output := &types.InvalidParameterCombinationException{}
8978	var buff [1024]byte
8979	ringBuffer := smithyio.NewRingBuffer(buff[:])
8980	body := io.TeeReader(errorBody, ringBuffer)
8981	rootDecoder := xml.NewDecoder(body)
8982	t, err := smithyxml.FetchRootElement(rootDecoder)
8983	if err == io.EOF {
8984		return output
8985	}
8986	if err != nil {
8987		var snapshot bytes.Buffer
8988		io.Copy(&snapshot, ringBuffer)
8989		return &smithy.DeserializationError{
8990			Err:      fmt.Errorf("failed to decode response body, %w", err),
8991			Snapshot: snapshot.Bytes(),
8992		}
8993	}
8994
8995	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
8996	t, err = decoder.GetElement("Error")
8997	if err != nil {
8998		var snapshot bytes.Buffer
8999		io.Copy(&snapshot, ringBuffer)
9000		return &smithy.DeserializationError{
9001			Err:      fmt.Errorf("failed to decode response body, %w", err),
9002			Snapshot: snapshot.Bytes(),
9003		}
9004	}
9005
9006	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9007	err = awsAwsquery_deserializeDocumentInvalidParameterCombinationException(&output, decoder)
9008	if err != nil {
9009		var snapshot bytes.Buffer
9010		io.Copy(&snapshot, ringBuffer)
9011		return &smithy.DeserializationError{
9012			Err:      fmt.Errorf("failed to decode response body, %w", err),
9013			Snapshot: snapshot.Bytes(),
9014		}
9015	}
9016
9017	return output
9018}
9019
9020func awsAwsquery_deserializeErrorInvalidParameterValueException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9021	output := &types.InvalidParameterValueException{}
9022	var buff [1024]byte
9023	ringBuffer := smithyio.NewRingBuffer(buff[:])
9024	body := io.TeeReader(errorBody, ringBuffer)
9025	rootDecoder := xml.NewDecoder(body)
9026	t, err := smithyxml.FetchRootElement(rootDecoder)
9027	if err == io.EOF {
9028		return output
9029	}
9030	if err != nil {
9031		var snapshot bytes.Buffer
9032		io.Copy(&snapshot, ringBuffer)
9033		return &smithy.DeserializationError{
9034			Err:      fmt.Errorf("failed to decode response body, %w", err),
9035			Snapshot: snapshot.Bytes(),
9036		}
9037	}
9038
9039	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9040	t, err = decoder.GetElement("Error")
9041	if err != nil {
9042		var snapshot bytes.Buffer
9043		io.Copy(&snapshot, ringBuffer)
9044		return &smithy.DeserializationError{
9045			Err:      fmt.Errorf("failed to decode response body, %w", err),
9046			Snapshot: snapshot.Bytes(),
9047		}
9048	}
9049
9050	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9051	err = awsAwsquery_deserializeDocumentInvalidParameterValueException(&output, decoder)
9052	if err != nil {
9053		var snapshot bytes.Buffer
9054		io.Copy(&snapshot, ringBuffer)
9055		return &smithy.DeserializationError{
9056			Err:      fmt.Errorf("failed to decode response body, %w", err),
9057			Snapshot: snapshot.Bytes(),
9058		}
9059	}
9060
9061	return output
9062}
9063
9064func awsAwsquery_deserializeErrorInvalidReplicationGroupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9065	output := &types.InvalidReplicationGroupStateFault{}
9066	var buff [1024]byte
9067	ringBuffer := smithyio.NewRingBuffer(buff[:])
9068	body := io.TeeReader(errorBody, ringBuffer)
9069	rootDecoder := xml.NewDecoder(body)
9070	t, err := smithyxml.FetchRootElement(rootDecoder)
9071	if err == io.EOF {
9072		return output
9073	}
9074	if err != nil {
9075		var snapshot bytes.Buffer
9076		io.Copy(&snapshot, ringBuffer)
9077		return &smithy.DeserializationError{
9078			Err:      fmt.Errorf("failed to decode response body, %w", err),
9079			Snapshot: snapshot.Bytes(),
9080		}
9081	}
9082
9083	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9084	t, err = decoder.GetElement("Error")
9085	if err != nil {
9086		var snapshot bytes.Buffer
9087		io.Copy(&snapshot, ringBuffer)
9088		return &smithy.DeserializationError{
9089			Err:      fmt.Errorf("failed to decode response body, %w", err),
9090			Snapshot: snapshot.Bytes(),
9091		}
9092	}
9093
9094	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9095	err = awsAwsquery_deserializeDocumentInvalidReplicationGroupStateFault(&output, decoder)
9096	if err != nil {
9097		var snapshot bytes.Buffer
9098		io.Copy(&snapshot, ringBuffer)
9099		return &smithy.DeserializationError{
9100			Err:      fmt.Errorf("failed to decode response body, %w", err),
9101			Snapshot: snapshot.Bytes(),
9102		}
9103	}
9104
9105	return output
9106}
9107
9108func awsAwsquery_deserializeErrorInvalidSnapshotStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9109	output := &types.InvalidSnapshotStateFault{}
9110	var buff [1024]byte
9111	ringBuffer := smithyio.NewRingBuffer(buff[:])
9112	body := io.TeeReader(errorBody, ringBuffer)
9113	rootDecoder := xml.NewDecoder(body)
9114	t, err := smithyxml.FetchRootElement(rootDecoder)
9115	if err == io.EOF {
9116		return output
9117	}
9118	if err != nil {
9119		var snapshot bytes.Buffer
9120		io.Copy(&snapshot, ringBuffer)
9121		return &smithy.DeserializationError{
9122			Err:      fmt.Errorf("failed to decode response body, %w", err),
9123			Snapshot: snapshot.Bytes(),
9124		}
9125	}
9126
9127	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9128	t, err = decoder.GetElement("Error")
9129	if err != nil {
9130		var snapshot bytes.Buffer
9131		io.Copy(&snapshot, ringBuffer)
9132		return &smithy.DeserializationError{
9133			Err:      fmt.Errorf("failed to decode response body, %w", err),
9134			Snapshot: snapshot.Bytes(),
9135		}
9136	}
9137
9138	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9139	err = awsAwsquery_deserializeDocumentInvalidSnapshotStateFault(&output, decoder)
9140	if err != nil {
9141		var snapshot bytes.Buffer
9142		io.Copy(&snapshot, ringBuffer)
9143		return &smithy.DeserializationError{
9144			Err:      fmt.Errorf("failed to decode response body, %w", err),
9145			Snapshot: snapshot.Bytes(),
9146		}
9147	}
9148
9149	return output
9150}
9151
9152func awsAwsquery_deserializeErrorInvalidSubnet(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9153	output := &types.InvalidSubnet{}
9154	var buff [1024]byte
9155	ringBuffer := smithyio.NewRingBuffer(buff[:])
9156	body := io.TeeReader(errorBody, ringBuffer)
9157	rootDecoder := xml.NewDecoder(body)
9158	t, err := smithyxml.FetchRootElement(rootDecoder)
9159	if err == io.EOF {
9160		return output
9161	}
9162	if err != nil {
9163		var snapshot bytes.Buffer
9164		io.Copy(&snapshot, ringBuffer)
9165		return &smithy.DeserializationError{
9166			Err:      fmt.Errorf("failed to decode response body, %w", err),
9167			Snapshot: snapshot.Bytes(),
9168		}
9169	}
9170
9171	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9172	t, err = decoder.GetElement("Error")
9173	if err != nil {
9174		var snapshot bytes.Buffer
9175		io.Copy(&snapshot, ringBuffer)
9176		return &smithy.DeserializationError{
9177			Err:      fmt.Errorf("failed to decode response body, %w", err),
9178			Snapshot: snapshot.Bytes(),
9179		}
9180	}
9181
9182	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9183	err = awsAwsquery_deserializeDocumentInvalidSubnet(&output, decoder)
9184	if err != nil {
9185		var snapshot bytes.Buffer
9186		io.Copy(&snapshot, ringBuffer)
9187		return &smithy.DeserializationError{
9188			Err:      fmt.Errorf("failed to decode response body, %w", err),
9189			Snapshot: snapshot.Bytes(),
9190		}
9191	}
9192
9193	return output
9194}
9195
9196func awsAwsquery_deserializeErrorInvalidUserGroupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9197	output := &types.InvalidUserGroupStateFault{}
9198	var buff [1024]byte
9199	ringBuffer := smithyio.NewRingBuffer(buff[:])
9200	body := io.TeeReader(errorBody, ringBuffer)
9201	rootDecoder := xml.NewDecoder(body)
9202	t, err := smithyxml.FetchRootElement(rootDecoder)
9203	if err == io.EOF {
9204		return output
9205	}
9206	if err != nil {
9207		var snapshot bytes.Buffer
9208		io.Copy(&snapshot, ringBuffer)
9209		return &smithy.DeserializationError{
9210			Err:      fmt.Errorf("failed to decode response body, %w", err),
9211			Snapshot: snapshot.Bytes(),
9212		}
9213	}
9214
9215	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9216	t, err = decoder.GetElement("Error")
9217	if err != nil {
9218		var snapshot bytes.Buffer
9219		io.Copy(&snapshot, ringBuffer)
9220		return &smithy.DeserializationError{
9221			Err:      fmt.Errorf("failed to decode response body, %w", err),
9222			Snapshot: snapshot.Bytes(),
9223		}
9224	}
9225
9226	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9227	err = awsAwsquery_deserializeDocumentInvalidUserGroupStateFault(&output, decoder)
9228	if err != nil {
9229		var snapshot bytes.Buffer
9230		io.Copy(&snapshot, ringBuffer)
9231		return &smithy.DeserializationError{
9232			Err:      fmt.Errorf("failed to decode response body, %w", err),
9233			Snapshot: snapshot.Bytes(),
9234		}
9235	}
9236
9237	return output
9238}
9239
9240func awsAwsquery_deserializeErrorInvalidUserStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9241	output := &types.InvalidUserStateFault{}
9242	var buff [1024]byte
9243	ringBuffer := smithyio.NewRingBuffer(buff[:])
9244	body := io.TeeReader(errorBody, ringBuffer)
9245	rootDecoder := xml.NewDecoder(body)
9246	t, err := smithyxml.FetchRootElement(rootDecoder)
9247	if err == io.EOF {
9248		return output
9249	}
9250	if err != nil {
9251		var snapshot bytes.Buffer
9252		io.Copy(&snapshot, ringBuffer)
9253		return &smithy.DeserializationError{
9254			Err:      fmt.Errorf("failed to decode response body, %w", err),
9255			Snapshot: snapshot.Bytes(),
9256		}
9257	}
9258
9259	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9260	t, err = decoder.GetElement("Error")
9261	if err != nil {
9262		var snapshot bytes.Buffer
9263		io.Copy(&snapshot, ringBuffer)
9264		return &smithy.DeserializationError{
9265			Err:      fmt.Errorf("failed to decode response body, %w", err),
9266			Snapshot: snapshot.Bytes(),
9267		}
9268	}
9269
9270	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9271	err = awsAwsquery_deserializeDocumentInvalidUserStateFault(&output, decoder)
9272	if err != nil {
9273		var snapshot bytes.Buffer
9274		io.Copy(&snapshot, ringBuffer)
9275		return &smithy.DeserializationError{
9276			Err:      fmt.Errorf("failed to decode response body, %w", err),
9277			Snapshot: snapshot.Bytes(),
9278		}
9279	}
9280
9281	return output
9282}
9283
9284func awsAwsquery_deserializeErrorInvalidVPCNetworkStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9285	output := &types.InvalidVPCNetworkStateFault{}
9286	var buff [1024]byte
9287	ringBuffer := smithyio.NewRingBuffer(buff[:])
9288	body := io.TeeReader(errorBody, ringBuffer)
9289	rootDecoder := xml.NewDecoder(body)
9290	t, err := smithyxml.FetchRootElement(rootDecoder)
9291	if err == io.EOF {
9292		return output
9293	}
9294	if err != nil {
9295		var snapshot bytes.Buffer
9296		io.Copy(&snapshot, ringBuffer)
9297		return &smithy.DeserializationError{
9298			Err:      fmt.Errorf("failed to decode response body, %w", err),
9299			Snapshot: snapshot.Bytes(),
9300		}
9301	}
9302
9303	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9304	t, err = decoder.GetElement("Error")
9305	if err != nil {
9306		var snapshot bytes.Buffer
9307		io.Copy(&snapshot, ringBuffer)
9308		return &smithy.DeserializationError{
9309			Err:      fmt.Errorf("failed to decode response body, %w", err),
9310			Snapshot: snapshot.Bytes(),
9311		}
9312	}
9313
9314	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9315	err = awsAwsquery_deserializeDocumentInvalidVPCNetworkStateFault(&output, decoder)
9316	if err != nil {
9317		var snapshot bytes.Buffer
9318		io.Copy(&snapshot, ringBuffer)
9319		return &smithy.DeserializationError{
9320			Err:      fmt.Errorf("failed to decode response body, %w", err),
9321			Snapshot: snapshot.Bytes(),
9322		}
9323	}
9324
9325	return output
9326}
9327
9328func awsAwsquery_deserializeErrorNodeGroupNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9329	output := &types.NodeGroupNotFoundFault{}
9330	var buff [1024]byte
9331	ringBuffer := smithyio.NewRingBuffer(buff[:])
9332	body := io.TeeReader(errorBody, ringBuffer)
9333	rootDecoder := xml.NewDecoder(body)
9334	t, err := smithyxml.FetchRootElement(rootDecoder)
9335	if err == io.EOF {
9336		return output
9337	}
9338	if err != nil {
9339		var snapshot bytes.Buffer
9340		io.Copy(&snapshot, ringBuffer)
9341		return &smithy.DeserializationError{
9342			Err:      fmt.Errorf("failed to decode response body, %w", err),
9343			Snapshot: snapshot.Bytes(),
9344		}
9345	}
9346
9347	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9348	t, err = decoder.GetElement("Error")
9349	if err != nil {
9350		var snapshot bytes.Buffer
9351		io.Copy(&snapshot, ringBuffer)
9352		return &smithy.DeserializationError{
9353			Err:      fmt.Errorf("failed to decode response body, %w", err),
9354			Snapshot: snapshot.Bytes(),
9355		}
9356	}
9357
9358	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9359	err = awsAwsquery_deserializeDocumentNodeGroupNotFoundFault(&output, decoder)
9360	if err != nil {
9361		var snapshot bytes.Buffer
9362		io.Copy(&snapshot, ringBuffer)
9363		return &smithy.DeserializationError{
9364			Err:      fmt.Errorf("failed to decode response body, %w", err),
9365			Snapshot: snapshot.Bytes(),
9366		}
9367	}
9368
9369	return output
9370}
9371
9372func awsAwsquery_deserializeErrorNodeGroupsPerReplicationGroupQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9373	output := &types.NodeGroupsPerReplicationGroupQuotaExceededFault{}
9374	var buff [1024]byte
9375	ringBuffer := smithyio.NewRingBuffer(buff[:])
9376	body := io.TeeReader(errorBody, ringBuffer)
9377	rootDecoder := xml.NewDecoder(body)
9378	t, err := smithyxml.FetchRootElement(rootDecoder)
9379	if err == io.EOF {
9380		return output
9381	}
9382	if err != nil {
9383		var snapshot bytes.Buffer
9384		io.Copy(&snapshot, ringBuffer)
9385		return &smithy.DeserializationError{
9386			Err:      fmt.Errorf("failed to decode response body, %w", err),
9387			Snapshot: snapshot.Bytes(),
9388		}
9389	}
9390
9391	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9392	t, err = decoder.GetElement("Error")
9393	if err != nil {
9394		var snapshot bytes.Buffer
9395		io.Copy(&snapshot, ringBuffer)
9396		return &smithy.DeserializationError{
9397			Err:      fmt.Errorf("failed to decode response body, %w", err),
9398			Snapshot: snapshot.Bytes(),
9399		}
9400	}
9401
9402	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9403	err = awsAwsquery_deserializeDocumentNodeGroupsPerReplicationGroupQuotaExceededFault(&output, decoder)
9404	if err != nil {
9405		var snapshot bytes.Buffer
9406		io.Copy(&snapshot, ringBuffer)
9407		return &smithy.DeserializationError{
9408			Err:      fmt.Errorf("failed to decode response body, %w", err),
9409			Snapshot: snapshot.Bytes(),
9410		}
9411	}
9412
9413	return output
9414}
9415
9416func awsAwsquery_deserializeErrorNodeQuotaForClusterExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9417	output := &types.NodeQuotaForClusterExceededFault{}
9418	var buff [1024]byte
9419	ringBuffer := smithyio.NewRingBuffer(buff[:])
9420	body := io.TeeReader(errorBody, ringBuffer)
9421	rootDecoder := xml.NewDecoder(body)
9422	t, err := smithyxml.FetchRootElement(rootDecoder)
9423	if err == io.EOF {
9424		return output
9425	}
9426	if err != nil {
9427		var snapshot bytes.Buffer
9428		io.Copy(&snapshot, ringBuffer)
9429		return &smithy.DeserializationError{
9430			Err:      fmt.Errorf("failed to decode response body, %w", err),
9431			Snapshot: snapshot.Bytes(),
9432		}
9433	}
9434
9435	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9436	t, err = decoder.GetElement("Error")
9437	if err != nil {
9438		var snapshot bytes.Buffer
9439		io.Copy(&snapshot, ringBuffer)
9440		return &smithy.DeserializationError{
9441			Err:      fmt.Errorf("failed to decode response body, %w", err),
9442			Snapshot: snapshot.Bytes(),
9443		}
9444	}
9445
9446	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9447	err = awsAwsquery_deserializeDocumentNodeQuotaForClusterExceededFault(&output, decoder)
9448	if err != nil {
9449		var snapshot bytes.Buffer
9450		io.Copy(&snapshot, ringBuffer)
9451		return &smithy.DeserializationError{
9452			Err:      fmt.Errorf("failed to decode response body, %w", err),
9453			Snapshot: snapshot.Bytes(),
9454		}
9455	}
9456
9457	return output
9458}
9459
9460func awsAwsquery_deserializeErrorNodeQuotaForCustomerExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9461	output := &types.NodeQuotaForCustomerExceededFault{}
9462	var buff [1024]byte
9463	ringBuffer := smithyio.NewRingBuffer(buff[:])
9464	body := io.TeeReader(errorBody, ringBuffer)
9465	rootDecoder := xml.NewDecoder(body)
9466	t, err := smithyxml.FetchRootElement(rootDecoder)
9467	if err == io.EOF {
9468		return output
9469	}
9470	if err != nil {
9471		var snapshot bytes.Buffer
9472		io.Copy(&snapshot, ringBuffer)
9473		return &smithy.DeserializationError{
9474			Err:      fmt.Errorf("failed to decode response body, %w", err),
9475			Snapshot: snapshot.Bytes(),
9476		}
9477	}
9478
9479	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9480	t, err = decoder.GetElement("Error")
9481	if err != nil {
9482		var snapshot bytes.Buffer
9483		io.Copy(&snapshot, ringBuffer)
9484		return &smithy.DeserializationError{
9485			Err:      fmt.Errorf("failed to decode response body, %w", err),
9486			Snapshot: snapshot.Bytes(),
9487		}
9488	}
9489
9490	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9491	err = awsAwsquery_deserializeDocumentNodeQuotaForCustomerExceededFault(&output, decoder)
9492	if err != nil {
9493		var snapshot bytes.Buffer
9494		io.Copy(&snapshot, ringBuffer)
9495		return &smithy.DeserializationError{
9496			Err:      fmt.Errorf("failed to decode response body, %w", err),
9497			Snapshot: snapshot.Bytes(),
9498		}
9499	}
9500
9501	return output
9502}
9503
9504func awsAwsquery_deserializeErrorNoOperationFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9505	output := &types.NoOperationFault{}
9506	var buff [1024]byte
9507	ringBuffer := smithyio.NewRingBuffer(buff[:])
9508	body := io.TeeReader(errorBody, ringBuffer)
9509	rootDecoder := xml.NewDecoder(body)
9510	t, err := smithyxml.FetchRootElement(rootDecoder)
9511	if err == io.EOF {
9512		return output
9513	}
9514	if err != nil {
9515		var snapshot bytes.Buffer
9516		io.Copy(&snapshot, ringBuffer)
9517		return &smithy.DeserializationError{
9518			Err:      fmt.Errorf("failed to decode response body, %w", err),
9519			Snapshot: snapshot.Bytes(),
9520		}
9521	}
9522
9523	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9524	t, err = decoder.GetElement("Error")
9525	if err != nil {
9526		var snapshot bytes.Buffer
9527		io.Copy(&snapshot, ringBuffer)
9528		return &smithy.DeserializationError{
9529			Err:      fmt.Errorf("failed to decode response body, %w", err),
9530			Snapshot: snapshot.Bytes(),
9531		}
9532	}
9533
9534	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9535	err = awsAwsquery_deserializeDocumentNoOperationFault(&output, decoder)
9536	if err != nil {
9537		var snapshot bytes.Buffer
9538		io.Copy(&snapshot, ringBuffer)
9539		return &smithy.DeserializationError{
9540			Err:      fmt.Errorf("failed to decode response body, %w", err),
9541			Snapshot: snapshot.Bytes(),
9542		}
9543	}
9544
9545	return output
9546}
9547
9548func awsAwsquery_deserializeErrorReplicationGroupAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9549	output := &types.ReplicationGroupAlreadyExistsFault{}
9550	var buff [1024]byte
9551	ringBuffer := smithyio.NewRingBuffer(buff[:])
9552	body := io.TeeReader(errorBody, ringBuffer)
9553	rootDecoder := xml.NewDecoder(body)
9554	t, err := smithyxml.FetchRootElement(rootDecoder)
9555	if err == io.EOF {
9556		return output
9557	}
9558	if err != nil {
9559		var snapshot bytes.Buffer
9560		io.Copy(&snapshot, ringBuffer)
9561		return &smithy.DeserializationError{
9562			Err:      fmt.Errorf("failed to decode response body, %w", err),
9563			Snapshot: snapshot.Bytes(),
9564		}
9565	}
9566
9567	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9568	t, err = decoder.GetElement("Error")
9569	if err != nil {
9570		var snapshot bytes.Buffer
9571		io.Copy(&snapshot, ringBuffer)
9572		return &smithy.DeserializationError{
9573			Err:      fmt.Errorf("failed to decode response body, %w", err),
9574			Snapshot: snapshot.Bytes(),
9575		}
9576	}
9577
9578	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9579	err = awsAwsquery_deserializeDocumentReplicationGroupAlreadyExistsFault(&output, decoder)
9580	if err != nil {
9581		var snapshot bytes.Buffer
9582		io.Copy(&snapshot, ringBuffer)
9583		return &smithy.DeserializationError{
9584			Err:      fmt.Errorf("failed to decode response body, %w", err),
9585			Snapshot: snapshot.Bytes(),
9586		}
9587	}
9588
9589	return output
9590}
9591
9592func awsAwsquery_deserializeErrorReplicationGroupAlreadyUnderMigrationFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9593	output := &types.ReplicationGroupAlreadyUnderMigrationFault{}
9594	var buff [1024]byte
9595	ringBuffer := smithyio.NewRingBuffer(buff[:])
9596	body := io.TeeReader(errorBody, ringBuffer)
9597	rootDecoder := xml.NewDecoder(body)
9598	t, err := smithyxml.FetchRootElement(rootDecoder)
9599	if err == io.EOF {
9600		return output
9601	}
9602	if err != nil {
9603		var snapshot bytes.Buffer
9604		io.Copy(&snapshot, ringBuffer)
9605		return &smithy.DeserializationError{
9606			Err:      fmt.Errorf("failed to decode response body, %w", err),
9607			Snapshot: snapshot.Bytes(),
9608		}
9609	}
9610
9611	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9612	t, err = decoder.GetElement("Error")
9613	if err != nil {
9614		var snapshot bytes.Buffer
9615		io.Copy(&snapshot, ringBuffer)
9616		return &smithy.DeserializationError{
9617			Err:      fmt.Errorf("failed to decode response body, %w", err),
9618			Snapshot: snapshot.Bytes(),
9619		}
9620	}
9621
9622	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9623	err = awsAwsquery_deserializeDocumentReplicationGroupAlreadyUnderMigrationFault(&output, decoder)
9624	if err != nil {
9625		var snapshot bytes.Buffer
9626		io.Copy(&snapshot, ringBuffer)
9627		return &smithy.DeserializationError{
9628			Err:      fmt.Errorf("failed to decode response body, %w", err),
9629			Snapshot: snapshot.Bytes(),
9630		}
9631	}
9632
9633	return output
9634}
9635
9636func awsAwsquery_deserializeErrorReplicationGroupNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9637	output := &types.ReplicationGroupNotFoundFault{}
9638	var buff [1024]byte
9639	ringBuffer := smithyio.NewRingBuffer(buff[:])
9640	body := io.TeeReader(errorBody, ringBuffer)
9641	rootDecoder := xml.NewDecoder(body)
9642	t, err := smithyxml.FetchRootElement(rootDecoder)
9643	if err == io.EOF {
9644		return output
9645	}
9646	if err != nil {
9647		var snapshot bytes.Buffer
9648		io.Copy(&snapshot, ringBuffer)
9649		return &smithy.DeserializationError{
9650			Err:      fmt.Errorf("failed to decode response body, %w", err),
9651			Snapshot: snapshot.Bytes(),
9652		}
9653	}
9654
9655	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9656	t, err = decoder.GetElement("Error")
9657	if err != nil {
9658		var snapshot bytes.Buffer
9659		io.Copy(&snapshot, ringBuffer)
9660		return &smithy.DeserializationError{
9661			Err:      fmt.Errorf("failed to decode response body, %w", err),
9662			Snapshot: snapshot.Bytes(),
9663		}
9664	}
9665
9666	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9667	err = awsAwsquery_deserializeDocumentReplicationGroupNotFoundFault(&output, decoder)
9668	if err != nil {
9669		var snapshot bytes.Buffer
9670		io.Copy(&snapshot, ringBuffer)
9671		return &smithy.DeserializationError{
9672			Err:      fmt.Errorf("failed to decode response body, %w", err),
9673			Snapshot: snapshot.Bytes(),
9674		}
9675	}
9676
9677	return output
9678}
9679
9680func awsAwsquery_deserializeErrorReplicationGroupNotUnderMigrationFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9681	output := &types.ReplicationGroupNotUnderMigrationFault{}
9682	var buff [1024]byte
9683	ringBuffer := smithyio.NewRingBuffer(buff[:])
9684	body := io.TeeReader(errorBody, ringBuffer)
9685	rootDecoder := xml.NewDecoder(body)
9686	t, err := smithyxml.FetchRootElement(rootDecoder)
9687	if err == io.EOF {
9688		return output
9689	}
9690	if err != nil {
9691		var snapshot bytes.Buffer
9692		io.Copy(&snapshot, ringBuffer)
9693		return &smithy.DeserializationError{
9694			Err:      fmt.Errorf("failed to decode response body, %w", err),
9695			Snapshot: snapshot.Bytes(),
9696		}
9697	}
9698
9699	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9700	t, err = decoder.GetElement("Error")
9701	if err != nil {
9702		var snapshot bytes.Buffer
9703		io.Copy(&snapshot, ringBuffer)
9704		return &smithy.DeserializationError{
9705			Err:      fmt.Errorf("failed to decode response body, %w", err),
9706			Snapshot: snapshot.Bytes(),
9707		}
9708	}
9709
9710	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9711	err = awsAwsquery_deserializeDocumentReplicationGroupNotUnderMigrationFault(&output, decoder)
9712	if err != nil {
9713		var snapshot bytes.Buffer
9714		io.Copy(&snapshot, ringBuffer)
9715		return &smithy.DeserializationError{
9716			Err:      fmt.Errorf("failed to decode response body, %w", err),
9717			Snapshot: snapshot.Bytes(),
9718		}
9719	}
9720
9721	return output
9722}
9723
9724func awsAwsquery_deserializeErrorReservedCacheNodeAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9725	output := &types.ReservedCacheNodeAlreadyExistsFault{}
9726	var buff [1024]byte
9727	ringBuffer := smithyio.NewRingBuffer(buff[:])
9728	body := io.TeeReader(errorBody, ringBuffer)
9729	rootDecoder := xml.NewDecoder(body)
9730	t, err := smithyxml.FetchRootElement(rootDecoder)
9731	if err == io.EOF {
9732		return output
9733	}
9734	if err != nil {
9735		var snapshot bytes.Buffer
9736		io.Copy(&snapshot, ringBuffer)
9737		return &smithy.DeserializationError{
9738			Err:      fmt.Errorf("failed to decode response body, %w", err),
9739			Snapshot: snapshot.Bytes(),
9740		}
9741	}
9742
9743	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9744	t, err = decoder.GetElement("Error")
9745	if err != nil {
9746		var snapshot bytes.Buffer
9747		io.Copy(&snapshot, ringBuffer)
9748		return &smithy.DeserializationError{
9749			Err:      fmt.Errorf("failed to decode response body, %w", err),
9750			Snapshot: snapshot.Bytes(),
9751		}
9752	}
9753
9754	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9755	err = awsAwsquery_deserializeDocumentReservedCacheNodeAlreadyExistsFault(&output, decoder)
9756	if err != nil {
9757		var snapshot bytes.Buffer
9758		io.Copy(&snapshot, ringBuffer)
9759		return &smithy.DeserializationError{
9760			Err:      fmt.Errorf("failed to decode response body, %w", err),
9761			Snapshot: snapshot.Bytes(),
9762		}
9763	}
9764
9765	return output
9766}
9767
9768func awsAwsquery_deserializeErrorReservedCacheNodeNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9769	output := &types.ReservedCacheNodeNotFoundFault{}
9770	var buff [1024]byte
9771	ringBuffer := smithyio.NewRingBuffer(buff[:])
9772	body := io.TeeReader(errorBody, ringBuffer)
9773	rootDecoder := xml.NewDecoder(body)
9774	t, err := smithyxml.FetchRootElement(rootDecoder)
9775	if err == io.EOF {
9776		return output
9777	}
9778	if err != nil {
9779		var snapshot bytes.Buffer
9780		io.Copy(&snapshot, ringBuffer)
9781		return &smithy.DeserializationError{
9782			Err:      fmt.Errorf("failed to decode response body, %w", err),
9783			Snapshot: snapshot.Bytes(),
9784		}
9785	}
9786
9787	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9788	t, err = decoder.GetElement("Error")
9789	if err != nil {
9790		var snapshot bytes.Buffer
9791		io.Copy(&snapshot, ringBuffer)
9792		return &smithy.DeserializationError{
9793			Err:      fmt.Errorf("failed to decode response body, %w", err),
9794			Snapshot: snapshot.Bytes(),
9795		}
9796	}
9797
9798	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9799	err = awsAwsquery_deserializeDocumentReservedCacheNodeNotFoundFault(&output, decoder)
9800	if err != nil {
9801		var snapshot bytes.Buffer
9802		io.Copy(&snapshot, ringBuffer)
9803		return &smithy.DeserializationError{
9804			Err:      fmt.Errorf("failed to decode response body, %w", err),
9805			Snapshot: snapshot.Bytes(),
9806		}
9807	}
9808
9809	return output
9810}
9811
9812func awsAwsquery_deserializeErrorReservedCacheNodeQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9813	output := &types.ReservedCacheNodeQuotaExceededFault{}
9814	var buff [1024]byte
9815	ringBuffer := smithyio.NewRingBuffer(buff[:])
9816	body := io.TeeReader(errorBody, ringBuffer)
9817	rootDecoder := xml.NewDecoder(body)
9818	t, err := smithyxml.FetchRootElement(rootDecoder)
9819	if err == io.EOF {
9820		return output
9821	}
9822	if err != nil {
9823		var snapshot bytes.Buffer
9824		io.Copy(&snapshot, ringBuffer)
9825		return &smithy.DeserializationError{
9826			Err:      fmt.Errorf("failed to decode response body, %w", err),
9827			Snapshot: snapshot.Bytes(),
9828		}
9829	}
9830
9831	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9832	t, err = decoder.GetElement("Error")
9833	if err != nil {
9834		var snapshot bytes.Buffer
9835		io.Copy(&snapshot, ringBuffer)
9836		return &smithy.DeserializationError{
9837			Err:      fmt.Errorf("failed to decode response body, %w", err),
9838			Snapshot: snapshot.Bytes(),
9839		}
9840	}
9841
9842	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9843	err = awsAwsquery_deserializeDocumentReservedCacheNodeQuotaExceededFault(&output, decoder)
9844	if err != nil {
9845		var snapshot bytes.Buffer
9846		io.Copy(&snapshot, ringBuffer)
9847		return &smithy.DeserializationError{
9848			Err:      fmt.Errorf("failed to decode response body, %w", err),
9849			Snapshot: snapshot.Bytes(),
9850		}
9851	}
9852
9853	return output
9854}
9855
9856func awsAwsquery_deserializeErrorReservedCacheNodesOfferingNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9857	output := &types.ReservedCacheNodesOfferingNotFoundFault{}
9858	var buff [1024]byte
9859	ringBuffer := smithyio.NewRingBuffer(buff[:])
9860	body := io.TeeReader(errorBody, ringBuffer)
9861	rootDecoder := xml.NewDecoder(body)
9862	t, err := smithyxml.FetchRootElement(rootDecoder)
9863	if err == io.EOF {
9864		return output
9865	}
9866	if err != nil {
9867		var snapshot bytes.Buffer
9868		io.Copy(&snapshot, ringBuffer)
9869		return &smithy.DeserializationError{
9870			Err:      fmt.Errorf("failed to decode response body, %w", err),
9871			Snapshot: snapshot.Bytes(),
9872		}
9873	}
9874
9875	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9876	t, err = decoder.GetElement("Error")
9877	if err != nil {
9878		var snapshot bytes.Buffer
9879		io.Copy(&snapshot, ringBuffer)
9880		return &smithy.DeserializationError{
9881			Err:      fmt.Errorf("failed to decode response body, %w", err),
9882			Snapshot: snapshot.Bytes(),
9883		}
9884	}
9885
9886	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9887	err = awsAwsquery_deserializeDocumentReservedCacheNodesOfferingNotFoundFault(&output, decoder)
9888	if err != nil {
9889		var snapshot bytes.Buffer
9890		io.Copy(&snapshot, ringBuffer)
9891		return &smithy.DeserializationError{
9892			Err:      fmt.Errorf("failed to decode response body, %w", err),
9893			Snapshot: snapshot.Bytes(),
9894		}
9895	}
9896
9897	return output
9898}
9899
9900func awsAwsquery_deserializeErrorServiceLinkedRoleNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9901	output := &types.ServiceLinkedRoleNotFoundFault{}
9902	var buff [1024]byte
9903	ringBuffer := smithyio.NewRingBuffer(buff[:])
9904	body := io.TeeReader(errorBody, ringBuffer)
9905	rootDecoder := xml.NewDecoder(body)
9906	t, err := smithyxml.FetchRootElement(rootDecoder)
9907	if err == io.EOF {
9908		return output
9909	}
9910	if err != nil {
9911		var snapshot bytes.Buffer
9912		io.Copy(&snapshot, ringBuffer)
9913		return &smithy.DeserializationError{
9914			Err:      fmt.Errorf("failed to decode response body, %w", err),
9915			Snapshot: snapshot.Bytes(),
9916		}
9917	}
9918
9919	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9920	t, err = decoder.GetElement("Error")
9921	if err != nil {
9922		var snapshot bytes.Buffer
9923		io.Copy(&snapshot, ringBuffer)
9924		return &smithy.DeserializationError{
9925			Err:      fmt.Errorf("failed to decode response body, %w", err),
9926			Snapshot: snapshot.Bytes(),
9927		}
9928	}
9929
9930	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9931	err = awsAwsquery_deserializeDocumentServiceLinkedRoleNotFoundFault(&output, decoder)
9932	if err != nil {
9933		var snapshot bytes.Buffer
9934		io.Copy(&snapshot, ringBuffer)
9935		return &smithy.DeserializationError{
9936			Err:      fmt.Errorf("failed to decode response body, %w", err),
9937			Snapshot: snapshot.Bytes(),
9938		}
9939	}
9940
9941	return output
9942}
9943
9944func awsAwsquery_deserializeErrorServiceUpdateNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9945	output := &types.ServiceUpdateNotFoundFault{}
9946	var buff [1024]byte
9947	ringBuffer := smithyio.NewRingBuffer(buff[:])
9948	body := io.TeeReader(errorBody, ringBuffer)
9949	rootDecoder := xml.NewDecoder(body)
9950	t, err := smithyxml.FetchRootElement(rootDecoder)
9951	if err == io.EOF {
9952		return output
9953	}
9954	if err != nil {
9955		var snapshot bytes.Buffer
9956		io.Copy(&snapshot, ringBuffer)
9957		return &smithy.DeserializationError{
9958			Err:      fmt.Errorf("failed to decode response body, %w", err),
9959			Snapshot: snapshot.Bytes(),
9960		}
9961	}
9962
9963	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
9964	t, err = decoder.GetElement("Error")
9965	if err != nil {
9966		var snapshot bytes.Buffer
9967		io.Copy(&snapshot, ringBuffer)
9968		return &smithy.DeserializationError{
9969			Err:      fmt.Errorf("failed to decode response body, %w", err),
9970			Snapshot: snapshot.Bytes(),
9971		}
9972	}
9973
9974	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
9975	err = awsAwsquery_deserializeDocumentServiceUpdateNotFoundFault(&output, decoder)
9976	if err != nil {
9977		var snapshot bytes.Buffer
9978		io.Copy(&snapshot, ringBuffer)
9979		return &smithy.DeserializationError{
9980			Err:      fmt.Errorf("failed to decode response body, %w", err),
9981			Snapshot: snapshot.Bytes(),
9982		}
9983	}
9984
9985	return output
9986}
9987
9988func awsAwsquery_deserializeErrorSnapshotAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9989	output := &types.SnapshotAlreadyExistsFault{}
9990	var buff [1024]byte
9991	ringBuffer := smithyio.NewRingBuffer(buff[:])
9992	body := io.TeeReader(errorBody, ringBuffer)
9993	rootDecoder := xml.NewDecoder(body)
9994	t, err := smithyxml.FetchRootElement(rootDecoder)
9995	if err == io.EOF {
9996		return output
9997	}
9998	if err != nil {
9999		var snapshot bytes.Buffer
10000		io.Copy(&snapshot, ringBuffer)
10001		return &smithy.DeserializationError{
10002			Err:      fmt.Errorf("failed to decode response body, %w", err),
10003			Snapshot: snapshot.Bytes(),
10004		}
10005	}
10006
10007	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
10008	t, err = decoder.GetElement("Error")
10009	if err != nil {
10010		var snapshot bytes.Buffer
10011		io.Copy(&snapshot, ringBuffer)
10012		return &smithy.DeserializationError{
10013			Err:      fmt.Errorf("failed to decode response body, %w", err),
10014			Snapshot: snapshot.Bytes(),
10015		}
10016	}
10017
10018	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
10019	err = awsAwsquery_deserializeDocumentSnapshotAlreadyExistsFault(&output, decoder)
10020	if err != nil {
10021		var snapshot bytes.Buffer
10022		io.Copy(&snapshot, ringBuffer)
10023		return &smithy.DeserializationError{
10024			Err:      fmt.Errorf("failed to decode response body, %w", err),
10025			Snapshot: snapshot.Bytes(),
10026		}
10027	}
10028
10029	return output
10030}
10031
10032func awsAwsquery_deserializeErrorSnapshotFeatureNotSupportedFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
10033	output := &types.SnapshotFeatureNotSupportedFault{}
10034	var buff [1024]byte
10035	ringBuffer := smithyio.NewRingBuffer(buff[:])
10036	body := io.TeeReader(errorBody, ringBuffer)
10037	rootDecoder := xml.NewDecoder(body)
10038	t, err := smithyxml.FetchRootElement(rootDecoder)
10039	if err == io.EOF {
10040		return output
10041	}
10042	if err != nil {
10043		var snapshot bytes.Buffer
10044		io.Copy(&snapshot, ringBuffer)
10045		return &smithy.DeserializationError{
10046			Err:      fmt.Errorf("failed to decode response body, %w", err),
10047			Snapshot: snapshot.Bytes(),
10048		}
10049	}
10050
10051	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
10052	t, err = decoder.GetElement("Error")
10053	if err != nil {
10054		var snapshot bytes.Buffer
10055		io.Copy(&snapshot, ringBuffer)
10056		return &smithy.DeserializationError{
10057			Err:      fmt.Errorf("failed to decode response body, %w", err),
10058			Snapshot: snapshot.Bytes(),
10059		}
10060	}
10061
10062	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
10063	err = awsAwsquery_deserializeDocumentSnapshotFeatureNotSupportedFault(&output, decoder)
10064	if err != nil {
10065		var snapshot bytes.Buffer
10066		io.Copy(&snapshot, ringBuffer)
10067		return &smithy.DeserializationError{
10068			Err:      fmt.Errorf("failed to decode response body, %w", err),
10069			Snapshot: snapshot.Bytes(),
10070		}
10071	}
10072
10073	return output
10074}
10075
10076func awsAwsquery_deserializeErrorSnapshotNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
10077	output := &types.SnapshotNotFoundFault{}
10078	var buff [1024]byte
10079	ringBuffer := smithyio.NewRingBuffer(buff[:])
10080	body := io.TeeReader(errorBody, ringBuffer)
10081	rootDecoder := xml.NewDecoder(body)
10082	t, err := smithyxml.FetchRootElement(rootDecoder)
10083	if err == io.EOF {
10084		return output
10085	}
10086	if err != nil {
10087		var snapshot bytes.Buffer
10088		io.Copy(&snapshot, ringBuffer)
10089		return &smithy.DeserializationError{
10090			Err:      fmt.Errorf("failed to decode response body, %w", err),
10091			Snapshot: snapshot.Bytes(),
10092		}
10093	}
10094
10095	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
10096	t, err = decoder.GetElement("Error")
10097	if err != nil {
10098		var snapshot bytes.Buffer
10099		io.Copy(&snapshot, ringBuffer)
10100		return &smithy.DeserializationError{
10101			Err:      fmt.Errorf("failed to decode response body, %w", err),
10102			Snapshot: snapshot.Bytes(),
10103		}
10104	}
10105
10106	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
10107	err = awsAwsquery_deserializeDocumentSnapshotNotFoundFault(&output, decoder)
10108	if err != nil {
10109		var snapshot bytes.Buffer
10110		io.Copy(&snapshot, ringBuffer)
10111		return &smithy.DeserializationError{
10112			Err:      fmt.Errorf("failed to decode response body, %w", err),
10113			Snapshot: snapshot.Bytes(),
10114		}
10115	}
10116
10117	return output
10118}
10119
10120func awsAwsquery_deserializeErrorSnapshotQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
10121	output := &types.SnapshotQuotaExceededFault{}
10122	var buff [1024]byte
10123	ringBuffer := smithyio.NewRingBuffer(buff[:])
10124	body := io.TeeReader(errorBody, ringBuffer)
10125	rootDecoder := xml.NewDecoder(body)
10126	t, err := smithyxml.FetchRootElement(rootDecoder)
10127	if err == io.EOF {
10128		return output
10129	}
10130	if err != nil {
10131		var snapshot bytes.Buffer
10132		io.Copy(&snapshot, ringBuffer)
10133		return &smithy.DeserializationError{
10134			Err:      fmt.Errorf("failed to decode response body, %w", err),
10135			Snapshot: snapshot.Bytes(),
10136		}
10137	}
10138
10139	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
10140	t, err = decoder.GetElement("Error")
10141	if err != nil {
10142		var snapshot bytes.Buffer
10143		io.Copy(&snapshot, ringBuffer)
10144		return &smithy.DeserializationError{
10145			Err:      fmt.Errorf("failed to decode response body, %w", err),
10146			Snapshot: snapshot.Bytes(),
10147		}
10148	}
10149
10150	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
10151	err = awsAwsquery_deserializeDocumentSnapshotQuotaExceededFault(&output, decoder)
10152	if err != nil {
10153		var snapshot bytes.Buffer
10154		io.Copy(&snapshot, ringBuffer)
10155		return &smithy.DeserializationError{
10156			Err:      fmt.Errorf("failed to decode response body, %w", err),
10157			Snapshot: snapshot.Bytes(),
10158		}
10159	}
10160
10161	return output
10162}
10163
10164func awsAwsquery_deserializeErrorSubnetInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error {
10165	output := &types.SubnetInUse{}
10166	var buff [1024]byte
10167	ringBuffer := smithyio.NewRingBuffer(buff[:])
10168	body := io.TeeReader(errorBody, ringBuffer)
10169	rootDecoder := xml.NewDecoder(body)
10170	t, err := smithyxml.FetchRootElement(rootDecoder)
10171	if err == io.EOF {
10172		return output
10173	}
10174	if err != nil {
10175		var snapshot bytes.Buffer
10176		io.Copy(&snapshot, ringBuffer)
10177		return &smithy.DeserializationError{
10178			Err:      fmt.Errorf("failed to decode response body, %w", err),
10179			Snapshot: snapshot.Bytes(),
10180		}
10181	}
10182
10183	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
10184	t, err = decoder.GetElement("Error")
10185	if err != nil {
10186		var snapshot bytes.Buffer
10187		io.Copy(&snapshot, ringBuffer)
10188		return &smithy.DeserializationError{
10189			Err:      fmt.Errorf("failed to decode response body, %w", err),
10190			Snapshot: snapshot.Bytes(),
10191		}
10192	}
10193
10194	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
10195	err = awsAwsquery_deserializeDocumentSubnetInUse(&output, decoder)
10196	if err != nil {
10197		var snapshot bytes.Buffer
10198		io.Copy(&snapshot, ringBuffer)
10199		return &smithy.DeserializationError{
10200			Err:      fmt.Errorf("failed to decode response body, %w", err),
10201			Snapshot: snapshot.Bytes(),
10202		}
10203	}
10204
10205	return output
10206}
10207
10208func awsAwsquery_deserializeErrorSubnetNotAllowedFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
10209	output := &types.SubnetNotAllowedFault{}
10210	var buff [1024]byte
10211	ringBuffer := smithyio.NewRingBuffer(buff[:])
10212	body := io.TeeReader(errorBody, ringBuffer)
10213	rootDecoder := xml.NewDecoder(body)
10214	t, err := smithyxml.FetchRootElement(rootDecoder)
10215	if err == io.EOF {
10216		return output
10217	}
10218	if err != nil {
10219		var snapshot bytes.Buffer
10220		io.Copy(&snapshot, ringBuffer)
10221		return &smithy.DeserializationError{
10222			Err:      fmt.Errorf("failed to decode response body, %w", err),
10223			Snapshot: snapshot.Bytes(),
10224		}
10225	}
10226
10227	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
10228	t, err = decoder.GetElement("Error")
10229	if err != nil {
10230		var snapshot bytes.Buffer
10231		io.Copy(&snapshot, ringBuffer)
10232		return &smithy.DeserializationError{
10233			Err:      fmt.Errorf("failed to decode response body, %w", err),
10234			Snapshot: snapshot.Bytes(),
10235		}
10236	}
10237
10238	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
10239	err = awsAwsquery_deserializeDocumentSubnetNotAllowedFault(&output, decoder)
10240	if err != nil {
10241		var snapshot bytes.Buffer
10242		io.Copy(&snapshot, ringBuffer)
10243		return &smithy.DeserializationError{
10244			Err:      fmt.Errorf("failed to decode response body, %w", err),
10245			Snapshot: snapshot.Bytes(),
10246		}
10247	}
10248
10249	return output
10250}
10251
10252func awsAwsquery_deserializeErrorTagNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
10253	output := &types.TagNotFoundFault{}
10254	var buff [1024]byte
10255	ringBuffer := smithyio.NewRingBuffer(buff[:])
10256	body := io.TeeReader(errorBody, ringBuffer)
10257	rootDecoder := xml.NewDecoder(body)
10258	t, err := smithyxml.FetchRootElement(rootDecoder)
10259	if err == io.EOF {
10260		return output
10261	}
10262	if err != nil {
10263		var snapshot bytes.Buffer
10264		io.Copy(&snapshot, ringBuffer)
10265		return &smithy.DeserializationError{
10266			Err:      fmt.Errorf("failed to decode response body, %w", err),
10267			Snapshot: snapshot.Bytes(),
10268		}
10269	}
10270
10271	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
10272	t, err = decoder.GetElement("Error")
10273	if err != nil {
10274		var snapshot bytes.Buffer
10275		io.Copy(&snapshot, ringBuffer)
10276		return &smithy.DeserializationError{
10277			Err:      fmt.Errorf("failed to decode response body, %w", err),
10278			Snapshot: snapshot.Bytes(),
10279		}
10280	}
10281
10282	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
10283	err = awsAwsquery_deserializeDocumentTagNotFoundFault(&output, decoder)
10284	if err != nil {
10285		var snapshot bytes.Buffer
10286		io.Copy(&snapshot, ringBuffer)
10287		return &smithy.DeserializationError{
10288			Err:      fmt.Errorf("failed to decode response body, %w", err),
10289			Snapshot: snapshot.Bytes(),
10290		}
10291	}
10292
10293	return output
10294}
10295
10296func awsAwsquery_deserializeErrorTagQuotaPerResourceExceeded(response *smithyhttp.Response, errorBody *bytes.Reader) error {
10297	output := &types.TagQuotaPerResourceExceeded{}
10298	var buff [1024]byte
10299	ringBuffer := smithyio.NewRingBuffer(buff[:])
10300	body := io.TeeReader(errorBody, ringBuffer)
10301	rootDecoder := xml.NewDecoder(body)
10302	t, err := smithyxml.FetchRootElement(rootDecoder)
10303	if err == io.EOF {
10304		return output
10305	}
10306	if err != nil {
10307		var snapshot bytes.Buffer
10308		io.Copy(&snapshot, ringBuffer)
10309		return &smithy.DeserializationError{
10310			Err:      fmt.Errorf("failed to decode response body, %w", err),
10311			Snapshot: snapshot.Bytes(),
10312		}
10313	}
10314
10315	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
10316	t, err = decoder.GetElement("Error")
10317	if err != nil {
10318		var snapshot bytes.Buffer
10319		io.Copy(&snapshot, ringBuffer)
10320		return &smithy.DeserializationError{
10321			Err:      fmt.Errorf("failed to decode response body, %w", err),
10322			Snapshot: snapshot.Bytes(),
10323		}
10324	}
10325
10326	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
10327	err = awsAwsquery_deserializeDocumentTagQuotaPerResourceExceeded(&output, decoder)
10328	if err != nil {
10329		var snapshot bytes.Buffer
10330		io.Copy(&snapshot, ringBuffer)
10331		return &smithy.DeserializationError{
10332			Err:      fmt.Errorf("failed to decode response body, %w", err),
10333			Snapshot: snapshot.Bytes(),
10334		}
10335	}
10336
10337	return output
10338}
10339
10340func awsAwsquery_deserializeErrorTestFailoverNotAvailableFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
10341	output := &types.TestFailoverNotAvailableFault{}
10342	var buff [1024]byte
10343	ringBuffer := smithyio.NewRingBuffer(buff[:])
10344	body := io.TeeReader(errorBody, ringBuffer)
10345	rootDecoder := xml.NewDecoder(body)
10346	t, err := smithyxml.FetchRootElement(rootDecoder)
10347	if err == io.EOF {
10348		return output
10349	}
10350	if err != nil {
10351		var snapshot bytes.Buffer
10352		io.Copy(&snapshot, ringBuffer)
10353		return &smithy.DeserializationError{
10354			Err:      fmt.Errorf("failed to decode response body, %w", err),
10355			Snapshot: snapshot.Bytes(),
10356		}
10357	}
10358
10359	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
10360	t, err = decoder.GetElement("Error")
10361	if err != nil {
10362		var snapshot bytes.Buffer
10363		io.Copy(&snapshot, ringBuffer)
10364		return &smithy.DeserializationError{
10365			Err:      fmt.Errorf("failed to decode response body, %w", err),
10366			Snapshot: snapshot.Bytes(),
10367		}
10368	}
10369
10370	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
10371	err = awsAwsquery_deserializeDocumentTestFailoverNotAvailableFault(&output, decoder)
10372	if err != nil {
10373		var snapshot bytes.Buffer
10374		io.Copy(&snapshot, ringBuffer)
10375		return &smithy.DeserializationError{
10376			Err:      fmt.Errorf("failed to decode response body, %w", err),
10377			Snapshot: snapshot.Bytes(),
10378		}
10379	}
10380
10381	return output
10382}
10383
10384func awsAwsquery_deserializeErrorUserAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
10385	output := &types.UserAlreadyExistsFault{}
10386	var buff [1024]byte
10387	ringBuffer := smithyio.NewRingBuffer(buff[:])
10388	body := io.TeeReader(errorBody, ringBuffer)
10389	rootDecoder := xml.NewDecoder(body)
10390	t, err := smithyxml.FetchRootElement(rootDecoder)
10391	if err == io.EOF {
10392		return output
10393	}
10394	if err != nil {
10395		var snapshot bytes.Buffer
10396		io.Copy(&snapshot, ringBuffer)
10397		return &smithy.DeserializationError{
10398			Err:      fmt.Errorf("failed to decode response body, %w", err),
10399			Snapshot: snapshot.Bytes(),
10400		}
10401	}
10402
10403	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
10404	t, err = decoder.GetElement("Error")
10405	if err != nil {
10406		var snapshot bytes.Buffer
10407		io.Copy(&snapshot, ringBuffer)
10408		return &smithy.DeserializationError{
10409			Err:      fmt.Errorf("failed to decode response body, %w", err),
10410			Snapshot: snapshot.Bytes(),
10411		}
10412	}
10413
10414	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
10415	err = awsAwsquery_deserializeDocumentUserAlreadyExistsFault(&output, decoder)
10416	if err != nil {
10417		var snapshot bytes.Buffer
10418		io.Copy(&snapshot, ringBuffer)
10419		return &smithy.DeserializationError{
10420			Err:      fmt.Errorf("failed to decode response body, %w", err),
10421			Snapshot: snapshot.Bytes(),
10422		}
10423	}
10424
10425	return output
10426}
10427
10428func awsAwsquery_deserializeErrorUserGroupAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
10429	output := &types.UserGroupAlreadyExistsFault{}
10430	var buff [1024]byte
10431	ringBuffer := smithyio.NewRingBuffer(buff[:])
10432	body := io.TeeReader(errorBody, ringBuffer)
10433	rootDecoder := xml.NewDecoder(body)
10434	t, err := smithyxml.FetchRootElement(rootDecoder)
10435	if err == io.EOF {
10436		return output
10437	}
10438	if err != nil {
10439		var snapshot bytes.Buffer
10440		io.Copy(&snapshot, ringBuffer)
10441		return &smithy.DeserializationError{
10442			Err:      fmt.Errorf("failed to decode response body, %w", err),
10443			Snapshot: snapshot.Bytes(),
10444		}
10445	}
10446
10447	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
10448	t, err = decoder.GetElement("Error")
10449	if err != nil {
10450		var snapshot bytes.Buffer
10451		io.Copy(&snapshot, ringBuffer)
10452		return &smithy.DeserializationError{
10453			Err:      fmt.Errorf("failed to decode response body, %w", err),
10454			Snapshot: snapshot.Bytes(),
10455		}
10456	}
10457
10458	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
10459	err = awsAwsquery_deserializeDocumentUserGroupAlreadyExistsFault(&output, decoder)
10460	if err != nil {
10461		var snapshot bytes.Buffer
10462		io.Copy(&snapshot, ringBuffer)
10463		return &smithy.DeserializationError{
10464			Err:      fmt.Errorf("failed to decode response body, %w", err),
10465			Snapshot: snapshot.Bytes(),
10466		}
10467	}
10468
10469	return output
10470}
10471
10472func awsAwsquery_deserializeErrorUserGroupNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
10473	output := &types.UserGroupNotFoundFault{}
10474	var buff [1024]byte
10475	ringBuffer := smithyio.NewRingBuffer(buff[:])
10476	body := io.TeeReader(errorBody, ringBuffer)
10477	rootDecoder := xml.NewDecoder(body)
10478	t, err := smithyxml.FetchRootElement(rootDecoder)
10479	if err == io.EOF {
10480		return output
10481	}
10482	if err != nil {
10483		var snapshot bytes.Buffer
10484		io.Copy(&snapshot, ringBuffer)
10485		return &smithy.DeserializationError{
10486			Err:      fmt.Errorf("failed to decode response body, %w", err),
10487			Snapshot: snapshot.Bytes(),
10488		}
10489	}
10490
10491	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
10492	t, err = decoder.GetElement("Error")
10493	if err != nil {
10494		var snapshot bytes.Buffer
10495		io.Copy(&snapshot, ringBuffer)
10496		return &smithy.DeserializationError{
10497			Err:      fmt.Errorf("failed to decode response body, %w", err),
10498			Snapshot: snapshot.Bytes(),
10499		}
10500	}
10501
10502	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
10503	err = awsAwsquery_deserializeDocumentUserGroupNotFoundFault(&output, decoder)
10504	if err != nil {
10505		var snapshot bytes.Buffer
10506		io.Copy(&snapshot, ringBuffer)
10507		return &smithy.DeserializationError{
10508			Err:      fmt.Errorf("failed to decode response body, %w", err),
10509			Snapshot: snapshot.Bytes(),
10510		}
10511	}
10512
10513	return output
10514}
10515
10516func awsAwsquery_deserializeErrorUserGroupQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
10517	output := &types.UserGroupQuotaExceededFault{}
10518	var buff [1024]byte
10519	ringBuffer := smithyio.NewRingBuffer(buff[:])
10520	body := io.TeeReader(errorBody, ringBuffer)
10521	rootDecoder := xml.NewDecoder(body)
10522	t, err := smithyxml.FetchRootElement(rootDecoder)
10523	if err == io.EOF {
10524		return output
10525	}
10526	if err != nil {
10527		var snapshot bytes.Buffer
10528		io.Copy(&snapshot, ringBuffer)
10529		return &smithy.DeserializationError{
10530			Err:      fmt.Errorf("failed to decode response body, %w", err),
10531			Snapshot: snapshot.Bytes(),
10532		}
10533	}
10534
10535	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
10536	t, err = decoder.GetElement("Error")
10537	if err != nil {
10538		var snapshot bytes.Buffer
10539		io.Copy(&snapshot, ringBuffer)
10540		return &smithy.DeserializationError{
10541			Err:      fmt.Errorf("failed to decode response body, %w", err),
10542			Snapshot: snapshot.Bytes(),
10543		}
10544	}
10545
10546	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
10547	err = awsAwsquery_deserializeDocumentUserGroupQuotaExceededFault(&output, decoder)
10548	if err != nil {
10549		var snapshot bytes.Buffer
10550		io.Copy(&snapshot, ringBuffer)
10551		return &smithy.DeserializationError{
10552			Err:      fmt.Errorf("failed to decode response body, %w", err),
10553			Snapshot: snapshot.Bytes(),
10554		}
10555	}
10556
10557	return output
10558}
10559
10560func awsAwsquery_deserializeErrorUserNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
10561	output := &types.UserNotFoundFault{}
10562	var buff [1024]byte
10563	ringBuffer := smithyio.NewRingBuffer(buff[:])
10564	body := io.TeeReader(errorBody, ringBuffer)
10565	rootDecoder := xml.NewDecoder(body)
10566	t, err := smithyxml.FetchRootElement(rootDecoder)
10567	if err == io.EOF {
10568		return output
10569	}
10570	if err != nil {
10571		var snapshot bytes.Buffer
10572		io.Copy(&snapshot, ringBuffer)
10573		return &smithy.DeserializationError{
10574			Err:      fmt.Errorf("failed to decode response body, %w", err),
10575			Snapshot: snapshot.Bytes(),
10576		}
10577	}
10578
10579	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
10580	t, err = decoder.GetElement("Error")
10581	if err != nil {
10582		var snapshot bytes.Buffer
10583		io.Copy(&snapshot, ringBuffer)
10584		return &smithy.DeserializationError{
10585			Err:      fmt.Errorf("failed to decode response body, %w", err),
10586			Snapshot: snapshot.Bytes(),
10587		}
10588	}
10589
10590	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
10591	err = awsAwsquery_deserializeDocumentUserNotFoundFault(&output, decoder)
10592	if err != nil {
10593		var snapshot bytes.Buffer
10594		io.Copy(&snapshot, ringBuffer)
10595		return &smithy.DeserializationError{
10596			Err:      fmt.Errorf("failed to decode response body, %w", err),
10597			Snapshot: snapshot.Bytes(),
10598		}
10599	}
10600
10601	return output
10602}
10603
10604func awsAwsquery_deserializeErrorUserQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
10605	output := &types.UserQuotaExceededFault{}
10606	var buff [1024]byte
10607	ringBuffer := smithyio.NewRingBuffer(buff[:])
10608	body := io.TeeReader(errorBody, ringBuffer)
10609	rootDecoder := xml.NewDecoder(body)
10610	t, err := smithyxml.FetchRootElement(rootDecoder)
10611	if err == io.EOF {
10612		return output
10613	}
10614	if err != nil {
10615		var snapshot bytes.Buffer
10616		io.Copy(&snapshot, ringBuffer)
10617		return &smithy.DeserializationError{
10618			Err:      fmt.Errorf("failed to decode response body, %w", err),
10619			Snapshot: snapshot.Bytes(),
10620		}
10621	}
10622
10623	decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
10624	t, err = decoder.GetElement("Error")
10625	if err != nil {
10626		var snapshot bytes.Buffer
10627		io.Copy(&snapshot, ringBuffer)
10628		return &smithy.DeserializationError{
10629			Err:      fmt.Errorf("failed to decode response body, %w", err),
10630			Snapshot: snapshot.Bytes(),
10631		}
10632	}
10633
10634	decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
10635	err = awsAwsquery_deserializeDocumentUserQuotaExceededFault(&output, decoder)
10636	if err != nil {
10637		var snapshot bytes.Buffer
10638		io.Copy(&snapshot, ringBuffer)
10639		return &smithy.DeserializationError{
10640			Err:      fmt.Errorf("failed to decode response body, %w", err),
10641			Snapshot: snapshot.Bytes(),
10642		}
10643	}
10644
10645	return output
10646}
10647
10648func awsAwsquery_deserializeDocumentAPICallRateForCustomerExceededFault(v **types.APICallRateForCustomerExceededFault, decoder smithyxml.NodeDecoder) error {
10649	if v == nil {
10650		return fmt.Errorf("unexpected nil of type %T", v)
10651	}
10652	var sv *types.APICallRateForCustomerExceededFault
10653	if *v == nil {
10654		sv = &types.APICallRateForCustomerExceededFault{}
10655	} else {
10656		sv = *v
10657	}
10658
10659	for {
10660		t, done, err := decoder.Token()
10661		if err != nil {
10662			return err
10663		}
10664		if done {
10665			break
10666		}
10667		originalDecoder := decoder
10668		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
10669		switch {
10670		case strings.EqualFold("message", t.Name.Local):
10671			val, err := decoder.Value()
10672			if err != nil {
10673				return err
10674			}
10675			if val == nil {
10676				break
10677			}
10678			{
10679				xtv := string(val)
10680				sv.Message = ptr.String(xtv)
10681			}
10682
10683		default:
10684			// Do nothing and ignore the unexpected tag element
10685			err = decoder.Decoder.Skip()
10686			if err != nil {
10687				return err
10688			}
10689
10690		}
10691		decoder = originalDecoder
10692	}
10693	*v = sv
10694	return nil
10695}
10696
10697func awsAwsquery_deserializeDocumentAuthentication(v **types.Authentication, decoder smithyxml.NodeDecoder) error {
10698	if v == nil {
10699		return fmt.Errorf("unexpected nil of type %T", v)
10700	}
10701	var sv *types.Authentication
10702	if *v == nil {
10703		sv = &types.Authentication{}
10704	} else {
10705		sv = *v
10706	}
10707
10708	for {
10709		t, done, err := decoder.Token()
10710		if err != nil {
10711			return err
10712		}
10713		if done {
10714			break
10715		}
10716		originalDecoder := decoder
10717		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
10718		switch {
10719		case strings.EqualFold("PasswordCount", t.Name.Local):
10720			val, err := decoder.Value()
10721			if err != nil {
10722				return err
10723			}
10724			if val == nil {
10725				break
10726			}
10727			{
10728				xtv := string(val)
10729				i64, err := strconv.ParseInt(xtv, 10, 64)
10730				if err != nil {
10731					return err
10732				}
10733				sv.PasswordCount = ptr.Int32(int32(i64))
10734			}
10735
10736		case strings.EqualFold("Type", t.Name.Local):
10737			val, err := decoder.Value()
10738			if err != nil {
10739				return err
10740			}
10741			if val == nil {
10742				break
10743			}
10744			{
10745				xtv := string(val)
10746				sv.Type = types.AuthenticationType(xtv)
10747			}
10748
10749		default:
10750			// Do nothing and ignore the unexpected tag element
10751			err = decoder.Decoder.Skip()
10752			if err != nil {
10753				return err
10754			}
10755
10756		}
10757		decoder = originalDecoder
10758	}
10759	*v = sv
10760	return nil
10761}
10762
10763func awsAwsquery_deserializeDocumentAuthorizationAlreadyExistsFault(v **types.AuthorizationAlreadyExistsFault, decoder smithyxml.NodeDecoder) error {
10764	if v == nil {
10765		return fmt.Errorf("unexpected nil of type %T", v)
10766	}
10767	var sv *types.AuthorizationAlreadyExistsFault
10768	if *v == nil {
10769		sv = &types.AuthorizationAlreadyExistsFault{}
10770	} else {
10771		sv = *v
10772	}
10773
10774	for {
10775		t, done, err := decoder.Token()
10776		if err != nil {
10777			return err
10778		}
10779		if done {
10780			break
10781		}
10782		originalDecoder := decoder
10783		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
10784		switch {
10785		case strings.EqualFold("message", t.Name.Local):
10786			val, err := decoder.Value()
10787			if err != nil {
10788				return err
10789			}
10790			if val == nil {
10791				break
10792			}
10793			{
10794				xtv := string(val)
10795				sv.Message = ptr.String(xtv)
10796			}
10797
10798		default:
10799			// Do nothing and ignore the unexpected tag element
10800			err = decoder.Decoder.Skip()
10801			if err != nil {
10802				return err
10803			}
10804
10805		}
10806		decoder = originalDecoder
10807	}
10808	*v = sv
10809	return nil
10810}
10811
10812func awsAwsquery_deserializeDocumentAuthorizationNotFoundFault(v **types.AuthorizationNotFoundFault, decoder smithyxml.NodeDecoder) error {
10813	if v == nil {
10814		return fmt.Errorf("unexpected nil of type %T", v)
10815	}
10816	var sv *types.AuthorizationNotFoundFault
10817	if *v == nil {
10818		sv = &types.AuthorizationNotFoundFault{}
10819	} else {
10820		sv = *v
10821	}
10822
10823	for {
10824		t, done, err := decoder.Token()
10825		if err != nil {
10826			return err
10827		}
10828		if done {
10829			break
10830		}
10831		originalDecoder := decoder
10832		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
10833		switch {
10834		case strings.EqualFold("message", t.Name.Local):
10835			val, err := decoder.Value()
10836			if err != nil {
10837				return err
10838			}
10839			if val == nil {
10840				break
10841			}
10842			{
10843				xtv := string(val)
10844				sv.Message = ptr.String(xtv)
10845			}
10846
10847		default:
10848			// Do nothing and ignore the unexpected tag element
10849			err = decoder.Decoder.Skip()
10850			if err != nil {
10851				return err
10852			}
10853
10854		}
10855		decoder = originalDecoder
10856	}
10857	*v = sv
10858	return nil
10859}
10860
10861func awsAwsquery_deserializeDocumentAvailabilityZone(v **types.AvailabilityZone, decoder smithyxml.NodeDecoder) error {
10862	if v == nil {
10863		return fmt.Errorf("unexpected nil of type %T", v)
10864	}
10865	var sv *types.AvailabilityZone
10866	if *v == nil {
10867		sv = &types.AvailabilityZone{}
10868	} else {
10869		sv = *v
10870	}
10871
10872	for {
10873		t, done, err := decoder.Token()
10874		if err != nil {
10875			return err
10876		}
10877		if done {
10878			break
10879		}
10880		originalDecoder := decoder
10881		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
10882		switch {
10883		case strings.EqualFold("Name", t.Name.Local):
10884			val, err := decoder.Value()
10885			if err != nil {
10886				return err
10887			}
10888			if val == nil {
10889				break
10890			}
10891			{
10892				xtv := string(val)
10893				sv.Name = ptr.String(xtv)
10894			}
10895
10896		default:
10897			// Do nothing and ignore the unexpected tag element
10898			err = decoder.Decoder.Skip()
10899			if err != nil {
10900				return err
10901			}
10902
10903		}
10904		decoder = originalDecoder
10905	}
10906	*v = sv
10907	return nil
10908}
10909
10910func awsAwsquery_deserializeDocumentAvailabilityZonesList(v *[]string, decoder smithyxml.NodeDecoder) error {
10911	if v == nil {
10912		return fmt.Errorf("unexpected nil of type %T", v)
10913	}
10914	var sv []string
10915	if *v == nil {
10916		sv = make([]string, 0)
10917	} else {
10918		sv = *v
10919	}
10920
10921	originalDecoder := decoder
10922	for {
10923		t, done, err := decoder.Token()
10924		if err != nil {
10925			return err
10926		}
10927		if done {
10928			break
10929		}
10930		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
10931		decoder = memberDecoder
10932		switch {
10933		case strings.EqualFold("AvailabilityZone", t.Name.Local):
10934			var col string
10935			val, err := decoder.Value()
10936			if err != nil {
10937				return err
10938			}
10939			if val == nil {
10940				break
10941			}
10942			{
10943				xtv := string(val)
10944				col = xtv
10945			}
10946			sv = append(sv, col)
10947
10948		default:
10949			err = decoder.Decoder.Skip()
10950			if err != nil {
10951				return err
10952			}
10953
10954		}
10955		decoder = originalDecoder
10956	}
10957	*v = sv
10958	return nil
10959}
10960
10961func awsAwsquery_deserializeDocumentAvailabilityZonesListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
10962	var sv []string
10963	if *v == nil {
10964		sv = make([]string, 0)
10965	} else {
10966		sv = *v
10967	}
10968
10969	switch {
10970	default:
10971		var mv string
10972		t := decoder.StartEl
10973		_ = t
10974		val, err := decoder.Value()
10975		if err != nil {
10976			return err
10977		}
10978		if val == nil {
10979			break
10980		}
10981		{
10982			xtv := string(val)
10983			mv = xtv
10984		}
10985		sv = append(sv, mv)
10986	}
10987	*v = sv
10988	return nil
10989}
10990func awsAwsquery_deserializeDocumentCacheCluster(v **types.CacheCluster, decoder smithyxml.NodeDecoder) error {
10991	if v == nil {
10992		return fmt.Errorf("unexpected nil of type %T", v)
10993	}
10994	var sv *types.CacheCluster
10995	if *v == nil {
10996		sv = &types.CacheCluster{}
10997	} else {
10998		sv = *v
10999	}
11000
11001	for {
11002		t, done, err := decoder.Token()
11003		if err != nil {
11004			return err
11005		}
11006		if done {
11007			break
11008		}
11009		originalDecoder := decoder
11010		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
11011		switch {
11012		case strings.EqualFold("ARN", t.Name.Local):
11013			val, err := decoder.Value()
11014			if err != nil {
11015				return err
11016			}
11017			if val == nil {
11018				break
11019			}
11020			{
11021				xtv := string(val)
11022				sv.ARN = ptr.String(xtv)
11023			}
11024
11025		case strings.EqualFold("AtRestEncryptionEnabled", t.Name.Local):
11026			val, err := decoder.Value()
11027			if err != nil {
11028				return err
11029			}
11030			if val == nil {
11031				break
11032			}
11033			{
11034				xtv, err := strconv.ParseBool(string(val))
11035				if err != nil {
11036					return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", val)
11037				}
11038				sv.AtRestEncryptionEnabled = ptr.Bool(xtv)
11039			}
11040
11041		case strings.EqualFold("AuthTokenEnabled", t.Name.Local):
11042			val, err := decoder.Value()
11043			if err != nil {
11044				return err
11045			}
11046			if val == nil {
11047				break
11048			}
11049			{
11050				xtv, err := strconv.ParseBool(string(val))
11051				if err != nil {
11052					return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", val)
11053				}
11054				sv.AuthTokenEnabled = ptr.Bool(xtv)
11055			}
11056
11057		case strings.EqualFold("AuthTokenLastModifiedDate", t.Name.Local):
11058			val, err := decoder.Value()
11059			if err != nil {
11060				return err
11061			}
11062			if val == nil {
11063				break
11064			}
11065			{
11066				xtv := string(val)
11067				t, err := smithytime.ParseDateTime(xtv)
11068				if err != nil {
11069					return err
11070				}
11071				sv.AuthTokenLastModifiedDate = ptr.Time(t)
11072			}
11073
11074		case strings.EqualFold("AutoMinorVersionUpgrade", t.Name.Local):
11075			val, err := decoder.Value()
11076			if err != nil {
11077				return err
11078			}
11079			if val == nil {
11080				break
11081			}
11082			{
11083				xtv, err := strconv.ParseBool(string(val))
11084				if err != nil {
11085					return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val)
11086				}
11087				sv.AutoMinorVersionUpgrade = xtv
11088			}
11089
11090		case strings.EqualFold("CacheClusterCreateTime", t.Name.Local):
11091			val, err := decoder.Value()
11092			if err != nil {
11093				return err
11094			}
11095			if val == nil {
11096				break
11097			}
11098			{
11099				xtv := string(val)
11100				t, err := smithytime.ParseDateTime(xtv)
11101				if err != nil {
11102					return err
11103				}
11104				sv.CacheClusterCreateTime = ptr.Time(t)
11105			}
11106
11107		case strings.EqualFold("CacheClusterId", t.Name.Local):
11108			val, err := decoder.Value()
11109			if err != nil {
11110				return err
11111			}
11112			if val == nil {
11113				break
11114			}
11115			{
11116				xtv := string(val)
11117				sv.CacheClusterId = ptr.String(xtv)
11118			}
11119
11120		case strings.EqualFold("CacheClusterStatus", t.Name.Local):
11121			val, err := decoder.Value()
11122			if err != nil {
11123				return err
11124			}
11125			if val == nil {
11126				break
11127			}
11128			{
11129				xtv := string(val)
11130				sv.CacheClusterStatus = ptr.String(xtv)
11131			}
11132
11133		case strings.EqualFold("CacheNodes", t.Name.Local):
11134			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11135			if err := awsAwsquery_deserializeDocumentCacheNodeList(&sv.CacheNodes, nodeDecoder); err != nil {
11136				return err
11137			}
11138
11139		case strings.EqualFold("CacheNodeType", t.Name.Local):
11140			val, err := decoder.Value()
11141			if err != nil {
11142				return err
11143			}
11144			if val == nil {
11145				break
11146			}
11147			{
11148				xtv := string(val)
11149				sv.CacheNodeType = ptr.String(xtv)
11150			}
11151
11152		case strings.EqualFold("CacheParameterGroup", t.Name.Local):
11153			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11154			if err := awsAwsquery_deserializeDocumentCacheParameterGroupStatus(&sv.CacheParameterGroup, nodeDecoder); err != nil {
11155				return err
11156			}
11157
11158		case strings.EqualFold("CacheSecurityGroups", t.Name.Local):
11159			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11160			if err := awsAwsquery_deserializeDocumentCacheSecurityGroupMembershipList(&sv.CacheSecurityGroups, nodeDecoder); err != nil {
11161				return err
11162			}
11163
11164		case strings.EqualFold("CacheSubnetGroupName", t.Name.Local):
11165			val, err := decoder.Value()
11166			if err != nil {
11167				return err
11168			}
11169			if val == nil {
11170				break
11171			}
11172			{
11173				xtv := string(val)
11174				sv.CacheSubnetGroupName = ptr.String(xtv)
11175			}
11176
11177		case strings.EqualFold("ClientDownloadLandingPage", t.Name.Local):
11178			val, err := decoder.Value()
11179			if err != nil {
11180				return err
11181			}
11182			if val == nil {
11183				break
11184			}
11185			{
11186				xtv := string(val)
11187				sv.ClientDownloadLandingPage = ptr.String(xtv)
11188			}
11189
11190		case strings.EqualFold("ConfigurationEndpoint", t.Name.Local):
11191			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11192			if err := awsAwsquery_deserializeDocumentEndpoint(&sv.ConfigurationEndpoint, nodeDecoder); err != nil {
11193				return err
11194			}
11195
11196		case strings.EqualFold("Engine", t.Name.Local):
11197			val, err := decoder.Value()
11198			if err != nil {
11199				return err
11200			}
11201			if val == nil {
11202				break
11203			}
11204			{
11205				xtv := string(val)
11206				sv.Engine = ptr.String(xtv)
11207			}
11208
11209		case strings.EqualFold("EngineVersion", t.Name.Local):
11210			val, err := decoder.Value()
11211			if err != nil {
11212				return err
11213			}
11214			if val == nil {
11215				break
11216			}
11217			{
11218				xtv := string(val)
11219				sv.EngineVersion = ptr.String(xtv)
11220			}
11221
11222		case strings.EqualFold("NotificationConfiguration", t.Name.Local):
11223			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11224			if err := awsAwsquery_deserializeDocumentNotificationConfiguration(&sv.NotificationConfiguration, nodeDecoder); err != nil {
11225				return err
11226			}
11227
11228		case strings.EqualFold("NumCacheNodes", t.Name.Local):
11229			val, err := decoder.Value()
11230			if err != nil {
11231				return err
11232			}
11233			if val == nil {
11234				break
11235			}
11236			{
11237				xtv := string(val)
11238				i64, err := strconv.ParseInt(xtv, 10, 64)
11239				if err != nil {
11240					return err
11241				}
11242				sv.NumCacheNodes = ptr.Int32(int32(i64))
11243			}
11244
11245		case strings.EqualFold("PendingModifiedValues", t.Name.Local):
11246			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11247			if err := awsAwsquery_deserializeDocumentPendingModifiedValues(&sv.PendingModifiedValues, nodeDecoder); err != nil {
11248				return err
11249			}
11250
11251		case strings.EqualFold("PreferredAvailabilityZone", t.Name.Local):
11252			val, err := decoder.Value()
11253			if err != nil {
11254				return err
11255			}
11256			if val == nil {
11257				break
11258			}
11259			{
11260				xtv := string(val)
11261				sv.PreferredAvailabilityZone = ptr.String(xtv)
11262			}
11263
11264		case strings.EqualFold("PreferredMaintenanceWindow", t.Name.Local):
11265			val, err := decoder.Value()
11266			if err != nil {
11267				return err
11268			}
11269			if val == nil {
11270				break
11271			}
11272			{
11273				xtv := string(val)
11274				sv.PreferredMaintenanceWindow = ptr.String(xtv)
11275			}
11276
11277		case strings.EqualFold("PreferredOutpostArn", t.Name.Local):
11278			val, err := decoder.Value()
11279			if err != nil {
11280				return err
11281			}
11282			if val == nil {
11283				break
11284			}
11285			{
11286				xtv := string(val)
11287				sv.PreferredOutpostArn = ptr.String(xtv)
11288			}
11289
11290		case strings.EqualFold("ReplicationGroupId", t.Name.Local):
11291			val, err := decoder.Value()
11292			if err != nil {
11293				return err
11294			}
11295			if val == nil {
11296				break
11297			}
11298			{
11299				xtv := string(val)
11300				sv.ReplicationGroupId = ptr.String(xtv)
11301			}
11302
11303		case strings.EqualFold("SecurityGroups", t.Name.Local):
11304			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11305			if err := awsAwsquery_deserializeDocumentSecurityGroupMembershipList(&sv.SecurityGroups, nodeDecoder); err != nil {
11306				return err
11307			}
11308
11309		case strings.EqualFold("SnapshotRetentionLimit", t.Name.Local):
11310			val, err := decoder.Value()
11311			if err != nil {
11312				return err
11313			}
11314			if val == nil {
11315				break
11316			}
11317			{
11318				xtv := string(val)
11319				i64, err := strconv.ParseInt(xtv, 10, 64)
11320				if err != nil {
11321					return err
11322				}
11323				sv.SnapshotRetentionLimit = ptr.Int32(int32(i64))
11324			}
11325
11326		case strings.EqualFold("SnapshotWindow", t.Name.Local):
11327			val, err := decoder.Value()
11328			if err != nil {
11329				return err
11330			}
11331			if val == nil {
11332				break
11333			}
11334			{
11335				xtv := string(val)
11336				sv.SnapshotWindow = ptr.String(xtv)
11337			}
11338
11339		case strings.EqualFold("TransitEncryptionEnabled", t.Name.Local):
11340			val, err := decoder.Value()
11341			if err != nil {
11342				return err
11343			}
11344			if val == nil {
11345				break
11346			}
11347			{
11348				xtv, err := strconv.ParseBool(string(val))
11349				if err != nil {
11350					return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", val)
11351				}
11352				sv.TransitEncryptionEnabled = ptr.Bool(xtv)
11353			}
11354
11355		default:
11356			// Do nothing and ignore the unexpected tag element
11357			err = decoder.Decoder.Skip()
11358			if err != nil {
11359				return err
11360			}
11361
11362		}
11363		decoder = originalDecoder
11364	}
11365	*v = sv
11366	return nil
11367}
11368
11369func awsAwsquery_deserializeDocumentCacheClusterAlreadyExistsFault(v **types.CacheClusterAlreadyExistsFault, decoder smithyxml.NodeDecoder) error {
11370	if v == nil {
11371		return fmt.Errorf("unexpected nil of type %T", v)
11372	}
11373	var sv *types.CacheClusterAlreadyExistsFault
11374	if *v == nil {
11375		sv = &types.CacheClusterAlreadyExistsFault{}
11376	} else {
11377		sv = *v
11378	}
11379
11380	for {
11381		t, done, err := decoder.Token()
11382		if err != nil {
11383			return err
11384		}
11385		if done {
11386			break
11387		}
11388		originalDecoder := decoder
11389		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
11390		switch {
11391		case strings.EqualFold("message", t.Name.Local):
11392			val, err := decoder.Value()
11393			if err != nil {
11394				return err
11395			}
11396			if val == nil {
11397				break
11398			}
11399			{
11400				xtv := string(val)
11401				sv.Message = ptr.String(xtv)
11402			}
11403
11404		default:
11405			// Do nothing and ignore the unexpected tag element
11406			err = decoder.Decoder.Skip()
11407			if err != nil {
11408				return err
11409			}
11410
11411		}
11412		decoder = originalDecoder
11413	}
11414	*v = sv
11415	return nil
11416}
11417
11418func awsAwsquery_deserializeDocumentCacheClusterList(v *[]types.CacheCluster, decoder smithyxml.NodeDecoder) error {
11419	if v == nil {
11420		return fmt.Errorf("unexpected nil of type %T", v)
11421	}
11422	var sv []types.CacheCluster
11423	if *v == nil {
11424		sv = make([]types.CacheCluster, 0)
11425	} else {
11426		sv = *v
11427	}
11428
11429	originalDecoder := decoder
11430	for {
11431		t, done, err := decoder.Token()
11432		if err != nil {
11433			return err
11434		}
11435		if done {
11436			break
11437		}
11438		switch {
11439		case strings.EqualFold("CacheCluster", t.Name.Local):
11440			var col types.CacheCluster
11441			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11442			destAddr := &col
11443			if err := awsAwsquery_deserializeDocumentCacheCluster(&destAddr, nodeDecoder); err != nil {
11444				return err
11445			}
11446			col = *destAddr
11447			sv = append(sv, col)
11448
11449		default:
11450			err = decoder.Decoder.Skip()
11451			if err != nil {
11452				return err
11453			}
11454
11455		}
11456		decoder = originalDecoder
11457	}
11458	*v = sv
11459	return nil
11460}
11461
11462func awsAwsquery_deserializeDocumentCacheClusterListUnwrapped(v *[]types.CacheCluster, decoder smithyxml.NodeDecoder) error {
11463	var sv []types.CacheCluster
11464	if *v == nil {
11465		sv = make([]types.CacheCluster, 0)
11466	} else {
11467		sv = *v
11468	}
11469
11470	switch {
11471	default:
11472		var mv types.CacheCluster
11473		t := decoder.StartEl
11474		_ = t
11475		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11476		destAddr := &mv
11477		if err := awsAwsquery_deserializeDocumentCacheCluster(&destAddr, nodeDecoder); err != nil {
11478			return err
11479		}
11480		mv = *destAddr
11481		sv = append(sv, mv)
11482	}
11483	*v = sv
11484	return nil
11485}
11486func awsAwsquery_deserializeDocumentCacheClusterNotFoundFault(v **types.CacheClusterNotFoundFault, decoder smithyxml.NodeDecoder) error {
11487	if v == nil {
11488		return fmt.Errorf("unexpected nil of type %T", v)
11489	}
11490	var sv *types.CacheClusterNotFoundFault
11491	if *v == nil {
11492		sv = &types.CacheClusterNotFoundFault{}
11493	} else {
11494		sv = *v
11495	}
11496
11497	for {
11498		t, done, err := decoder.Token()
11499		if err != nil {
11500			return err
11501		}
11502		if done {
11503			break
11504		}
11505		originalDecoder := decoder
11506		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
11507		switch {
11508		case strings.EqualFold("message", t.Name.Local):
11509			val, err := decoder.Value()
11510			if err != nil {
11511				return err
11512			}
11513			if val == nil {
11514				break
11515			}
11516			{
11517				xtv := string(val)
11518				sv.Message = ptr.String(xtv)
11519			}
11520
11521		default:
11522			// Do nothing and ignore the unexpected tag element
11523			err = decoder.Decoder.Skip()
11524			if err != nil {
11525				return err
11526			}
11527
11528		}
11529		decoder = originalDecoder
11530	}
11531	*v = sv
11532	return nil
11533}
11534
11535func awsAwsquery_deserializeDocumentCacheEngineVersion(v **types.CacheEngineVersion, decoder smithyxml.NodeDecoder) error {
11536	if v == nil {
11537		return fmt.Errorf("unexpected nil of type %T", v)
11538	}
11539	var sv *types.CacheEngineVersion
11540	if *v == nil {
11541		sv = &types.CacheEngineVersion{}
11542	} else {
11543		sv = *v
11544	}
11545
11546	for {
11547		t, done, err := decoder.Token()
11548		if err != nil {
11549			return err
11550		}
11551		if done {
11552			break
11553		}
11554		originalDecoder := decoder
11555		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
11556		switch {
11557		case strings.EqualFold("CacheEngineDescription", t.Name.Local):
11558			val, err := decoder.Value()
11559			if err != nil {
11560				return err
11561			}
11562			if val == nil {
11563				break
11564			}
11565			{
11566				xtv := string(val)
11567				sv.CacheEngineDescription = ptr.String(xtv)
11568			}
11569
11570		case strings.EqualFold("CacheEngineVersionDescription", t.Name.Local):
11571			val, err := decoder.Value()
11572			if err != nil {
11573				return err
11574			}
11575			if val == nil {
11576				break
11577			}
11578			{
11579				xtv := string(val)
11580				sv.CacheEngineVersionDescription = ptr.String(xtv)
11581			}
11582
11583		case strings.EqualFold("CacheParameterGroupFamily", t.Name.Local):
11584			val, err := decoder.Value()
11585			if err != nil {
11586				return err
11587			}
11588			if val == nil {
11589				break
11590			}
11591			{
11592				xtv := string(val)
11593				sv.CacheParameterGroupFamily = ptr.String(xtv)
11594			}
11595
11596		case strings.EqualFold("Engine", t.Name.Local):
11597			val, err := decoder.Value()
11598			if err != nil {
11599				return err
11600			}
11601			if val == nil {
11602				break
11603			}
11604			{
11605				xtv := string(val)
11606				sv.Engine = ptr.String(xtv)
11607			}
11608
11609		case strings.EqualFold("EngineVersion", t.Name.Local):
11610			val, err := decoder.Value()
11611			if err != nil {
11612				return err
11613			}
11614			if val == nil {
11615				break
11616			}
11617			{
11618				xtv := string(val)
11619				sv.EngineVersion = ptr.String(xtv)
11620			}
11621
11622		default:
11623			// Do nothing and ignore the unexpected tag element
11624			err = decoder.Decoder.Skip()
11625			if err != nil {
11626				return err
11627			}
11628
11629		}
11630		decoder = originalDecoder
11631	}
11632	*v = sv
11633	return nil
11634}
11635
11636func awsAwsquery_deserializeDocumentCacheEngineVersionList(v *[]types.CacheEngineVersion, decoder smithyxml.NodeDecoder) error {
11637	if v == nil {
11638		return fmt.Errorf("unexpected nil of type %T", v)
11639	}
11640	var sv []types.CacheEngineVersion
11641	if *v == nil {
11642		sv = make([]types.CacheEngineVersion, 0)
11643	} else {
11644		sv = *v
11645	}
11646
11647	originalDecoder := decoder
11648	for {
11649		t, done, err := decoder.Token()
11650		if err != nil {
11651			return err
11652		}
11653		if done {
11654			break
11655		}
11656		switch {
11657		case strings.EqualFold("CacheEngineVersion", t.Name.Local):
11658			var col types.CacheEngineVersion
11659			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11660			destAddr := &col
11661			if err := awsAwsquery_deserializeDocumentCacheEngineVersion(&destAddr, nodeDecoder); err != nil {
11662				return err
11663			}
11664			col = *destAddr
11665			sv = append(sv, col)
11666
11667		default:
11668			err = decoder.Decoder.Skip()
11669			if err != nil {
11670				return err
11671			}
11672
11673		}
11674		decoder = originalDecoder
11675	}
11676	*v = sv
11677	return nil
11678}
11679
11680func awsAwsquery_deserializeDocumentCacheEngineVersionListUnwrapped(v *[]types.CacheEngineVersion, decoder smithyxml.NodeDecoder) error {
11681	var sv []types.CacheEngineVersion
11682	if *v == nil {
11683		sv = make([]types.CacheEngineVersion, 0)
11684	} else {
11685		sv = *v
11686	}
11687
11688	switch {
11689	default:
11690		var mv types.CacheEngineVersion
11691		t := decoder.StartEl
11692		_ = t
11693		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11694		destAddr := &mv
11695		if err := awsAwsquery_deserializeDocumentCacheEngineVersion(&destAddr, nodeDecoder); err != nil {
11696			return err
11697		}
11698		mv = *destAddr
11699		sv = append(sv, mv)
11700	}
11701	*v = sv
11702	return nil
11703}
11704func awsAwsquery_deserializeDocumentCacheNode(v **types.CacheNode, decoder smithyxml.NodeDecoder) error {
11705	if v == nil {
11706		return fmt.Errorf("unexpected nil of type %T", v)
11707	}
11708	var sv *types.CacheNode
11709	if *v == nil {
11710		sv = &types.CacheNode{}
11711	} else {
11712		sv = *v
11713	}
11714
11715	for {
11716		t, done, err := decoder.Token()
11717		if err != nil {
11718			return err
11719		}
11720		if done {
11721			break
11722		}
11723		originalDecoder := decoder
11724		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
11725		switch {
11726		case strings.EqualFold("CacheNodeCreateTime", t.Name.Local):
11727			val, err := decoder.Value()
11728			if err != nil {
11729				return err
11730			}
11731			if val == nil {
11732				break
11733			}
11734			{
11735				xtv := string(val)
11736				t, err := smithytime.ParseDateTime(xtv)
11737				if err != nil {
11738					return err
11739				}
11740				sv.CacheNodeCreateTime = ptr.Time(t)
11741			}
11742
11743		case strings.EqualFold("CacheNodeId", t.Name.Local):
11744			val, err := decoder.Value()
11745			if err != nil {
11746				return err
11747			}
11748			if val == nil {
11749				break
11750			}
11751			{
11752				xtv := string(val)
11753				sv.CacheNodeId = ptr.String(xtv)
11754			}
11755
11756		case strings.EqualFold("CacheNodeStatus", t.Name.Local):
11757			val, err := decoder.Value()
11758			if err != nil {
11759				return err
11760			}
11761			if val == nil {
11762				break
11763			}
11764			{
11765				xtv := string(val)
11766				sv.CacheNodeStatus = ptr.String(xtv)
11767			}
11768
11769		case strings.EqualFold("CustomerAvailabilityZone", t.Name.Local):
11770			val, err := decoder.Value()
11771			if err != nil {
11772				return err
11773			}
11774			if val == nil {
11775				break
11776			}
11777			{
11778				xtv := string(val)
11779				sv.CustomerAvailabilityZone = ptr.String(xtv)
11780			}
11781
11782		case strings.EqualFold("CustomerOutpostArn", t.Name.Local):
11783			val, err := decoder.Value()
11784			if err != nil {
11785				return err
11786			}
11787			if val == nil {
11788				break
11789			}
11790			{
11791				xtv := string(val)
11792				sv.CustomerOutpostArn = ptr.String(xtv)
11793			}
11794
11795		case strings.EqualFold("Endpoint", t.Name.Local):
11796			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11797			if err := awsAwsquery_deserializeDocumentEndpoint(&sv.Endpoint, nodeDecoder); err != nil {
11798				return err
11799			}
11800
11801		case strings.EqualFold("ParameterGroupStatus", t.Name.Local):
11802			val, err := decoder.Value()
11803			if err != nil {
11804				return err
11805			}
11806			if val == nil {
11807				break
11808			}
11809			{
11810				xtv := string(val)
11811				sv.ParameterGroupStatus = ptr.String(xtv)
11812			}
11813
11814		case strings.EqualFold("SourceCacheNodeId", t.Name.Local):
11815			val, err := decoder.Value()
11816			if err != nil {
11817				return err
11818			}
11819			if val == nil {
11820				break
11821			}
11822			{
11823				xtv := string(val)
11824				sv.SourceCacheNodeId = ptr.String(xtv)
11825			}
11826
11827		default:
11828			// Do nothing and ignore the unexpected tag element
11829			err = decoder.Decoder.Skip()
11830			if err != nil {
11831				return err
11832			}
11833
11834		}
11835		decoder = originalDecoder
11836	}
11837	*v = sv
11838	return nil
11839}
11840
11841func awsAwsquery_deserializeDocumentCacheNodeIdsList(v *[]string, decoder smithyxml.NodeDecoder) error {
11842	if v == nil {
11843		return fmt.Errorf("unexpected nil of type %T", v)
11844	}
11845	var sv []string
11846	if *v == nil {
11847		sv = make([]string, 0)
11848	} else {
11849		sv = *v
11850	}
11851
11852	originalDecoder := decoder
11853	for {
11854		t, done, err := decoder.Token()
11855		if err != nil {
11856			return err
11857		}
11858		if done {
11859			break
11860		}
11861		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11862		decoder = memberDecoder
11863		switch {
11864		case strings.EqualFold("CacheNodeId", t.Name.Local):
11865			var col string
11866			val, err := decoder.Value()
11867			if err != nil {
11868				return err
11869			}
11870			if val == nil {
11871				break
11872			}
11873			{
11874				xtv := string(val)
11875				col = xtv
11876			}
11877			sv = append(sv, col)
11878
11879		default:
11880			err = decoder.Decoder.Skip()
11881			if err != nil {
11882				return err
11883			}
11884
11885		}
11886		decoder = originalDecoder
11887	}
11888	*v = sv
11889	return nil
11890}
11891
11892func awsAwsquery_deserializeDocumentCacheNodeIdsListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
11893	var sv []string
11894	if *v == nil {
11895		sv = make([]string, 0)
11896	} else {
11897		sv = *v
11898	}
11899
11900	switch {
11901	default:
11902		var mv string
11903		t := decoder.StartEl
11904		_ = t
11905		val, err := decoder.Value()
11906		if err != nil {
11907			return err
11908		}
11909		if val == nil {
11910			break
11911		}
11912		{
11913			xtv := string(val)
11914			mv = xtv
11915		}
11916		sv = append(sv, mv)
11917	}
11918	*v = sv
11919	return nil
11920}
11921func awsAwsquery_deserializeDocumentCacheNodeList(v *[]types.CacheNode, decoder smithyxml.NodeDecoder) error {
11922	if v == nil {
11923		return fmt.Errorf("unexpected nil of type %T", v)
11924	}
11925	var sv []types.CacheNode
11926	if *v == nil {
11927		sv = make([]types.CacheNode, 0)
11928	} else {
11929		sv = *v
11930	}
11931
11932	originalDecoder := decoder
11933	for {
11934		t, done, err := decoder.Token()
11935		if err != nil {
11936			return err
11937		}
11938		if done {
11939			break
11940		}
11941		switch {
11942		case strings.EqualFold("CacheNode", t.Name.Local):
11943			var col types.CacheNode
11944			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11945			destAddr := &col
11946			if err := awsAwsquery_deserializeDocumentCacheNode(&destAddr, nodeDecoder); err != nil {
11947				return err
11948			}
11949			col = *destAddr
11950			sv = append(sv, col)
11951
11952		default:
11953			err = decoder.Decoder.Skip()
11954			if err != nil {
11955				return err
11956			}
11957
11958		}
11959		decoder = originalDecoder
11960	}
11961	*v = sv
11962	return nil
11963}
11964
11965func awsAwsquery_deserializeDocumentCacheNodeListUnwrapped(v *[]types.CacheNode, decoder smithyxml.NodeDecoder) error {
11966	var sv []types.CacheNode
11967	if *v == nil {
11968		sv = make([]types.CacheNode, 0)
11969	} else {
11970		sv = *v
11971	}
11972
11973	switch {
11974	default:
11975		var mv types.CacheNode
11976		t := decoder.StartEl
11977		_ = t
11978		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
11979		destAddr := &mv
11980		if err := awsAwsquery_deserializeDocumentCacheNode(&destAddr, nodeDecoder); err != nil {
11981			return err
11982		}
11983		mv = *destAddr
11984		sv = append(sv, mv)
11985	}
11986	*v = sv
11987	return nil
11988}
11989func awsAwsquery_deserializeDocumentCacheNodeTypeSpecificParameter(v **types.CacheNodeTypeSpecificParameter, decoder smithyxml.NodeDecoder) error {
11990	if v == nil {
11991		return fmt.Errorf("unexpected nil of type %T", v)
11992	}
11993	var sv *types.CacheNodeTypeSpecificParameter
11994	if *v == nil {
11995		sv = &types.CacheNodeTypeSpecificParameter{}
11996	} else {
11997		sv = *v
11998	}
11999
12000	for {
12001		t, done, err := decoder.Token()
12002		if err != nil {
12003			return err
12004		}
12005		if done {
12006			break
12007		}
12008		originalDecoder := decoder
12009		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
12010		switch {
12011		case strings.EqualFold("AllowedValues", t.Name.Local):
12012			val, err := decoder.Value()
12013			if err != nil {
12014				return err
12015			}
12016			if val == nil {
12017				break
12018			}
12019			{
12020				xtv := string(val)
12021				sv.AllowedValues = ptr.String(xtv)
12022			}
12023
12024		case strings.EqualFold("CacheNodeTypeSpecificValues", t.Name.Local):
12025			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12026			if err := awsAwsquery_deserializeDocumentCacheNodeTypeSpecificValueList(&sv.CacheNodeTypeSpecificValues, nodeDecoder); err != nil {
12027				return err
12028			}
12029
12030		case strings.EqualFold("ChangeType", t.Name.Local):
12031			val, err := decoder.Value()
12032			if err != nil {
12033				return err
12034			}
12035			if val == nil {
12036				break
12037			}
12038			{
12039				xtv := string(val)
12040				sv.ChangeType = types.ChangeType(xtv)
12041			}
12042
12043		case strings.EqualFold("DataType", t.Name.Local):
12044			val, err := decoder.Value()
12045			if err != nil {
12046				return err
12047			}
12048			if val == nil {
12049				break
12050			}
12051			{
12052				xtv := string(val)
12053				sv.DataType = ptr.String(xtv)
12054			}
12055
12056		case strings.EqualFold("Description", t.Name.Local):
12057			val, err := decoder.Value()
12058			if err != nil {
12059				return err
12060			}
12061			if val == nil {
12062				break
12063			}
12064			{
12065				xtv := string(val)
12066				sv.Description = ptr.String(xtv)
12067			}
12068
12069		case strings.EqualFold("IsModifiable", t.Name.Local):
12070			val, err := decoder.Value()
12071			if err != nil {
12072				return err
12073			}
12074			if val == nil {
12075				break
12076			}
12077			{
12078				xtv, err := strconv.ParseBool(string(val))
12079				if err != nil {
12080					return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val)
12081				}
12082				sv.IsModifiable = xtv
12083			}
12084
12085		case strings.EqualFold("MinimumEngineVersion", t.Name.Local):
12086			val, err := decoder.Value()
12087			if err != nil {
12088				return err
12089			}
12090			if val == nil {
12091				break
12092			}
12093			{
12094				xtv := string(val)
12095				sv.MinimumEngineVersion = ptr.String(xtv)
12096			}
12097
12098		case strings.EqualFold("ParameterName", t.Name.Local):
12099			val, err := decoder.Value()
12100			if err != nil {
12101				return err
12102			}
12103			if val == nil {
12104				break
12105			}
12106			{
12107				xtv := string(val)
12108				sv.ParameterName = ptr.String(xtv)
12109			}
12110
12111		case strings.EqualFold("Source", t.Name.Local):
12112			val, err := decoder.Value()
12113			if err != nil {
12114				return err
12115			}
12116			if val == nil {
12117				break
12118			}
12119			{
12120				xtv := string(val)
12121				sv.Source = ptr.String(xtv)
12122			}
12123
12124		default:
12125			// Do nothing and ignore the unexpected tag element
12126			err = decoder.Decoder.Skip()
12127			if err != nil {
12128				return err
12129			}
12130
12131		}
12132		decoder = originalDecoder
12133	}
12134	*v = sv
12135	return nil
12136}
12137
12138func awsAwsquery_deserializeDocumentCacheNodeTypeSpecificParametersList(v *[]types.CacheNodeTypeSpecificParameter, decoder smithyxml.NodeDecoder) error {
12139	if v == nil {
12140		return fmt.Errorf("unexpected nil of type %T", v)
12141	}
12142	var sv []types.CacheNodeTypeSpecificParameter
12143	if *v == nil {
12144		sv = make([]types.CacheNodeTypeSpecificParameter, 0)
12145	} else {
12146		sv = *v
12147	}
12148
12149	originalDecoder := decoder
12150	for {
12151		t, done, err := decoder.Token()
12152		if err != nil {
12153			return err
12154		}
12155		if done {
12156			break
12157		}
12158		switch {
12159		case strings.EqualFold("CacheNodeTypeSpecificParameter", t.Name.Local):
12160			var col types.CacheNodeTypeSpecificParameter
12161			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12162			destAddr := &col
12163			if err := awsAwsquery_deserializeDocumentCacheNodeTypeSpecificParameter(&destAddr, nodeDecoder); err != nil {
12164				return err
12165			}
12166			col = *destAddr
12167			sv = append(sv, col)
12168
12169		default:
12170			err = decoder.Decoder.Skip()
12171			if err != nil {
12172				return err
12173			}
12174
12175		}
12176		decoder = originalDecoder
12177	}
12178	*v = sv
12179	return nil
12180}
12181
12182func awsAwsquery_deserializeDocumentCacheNodeTypeSpecificParametersListUnwrapped(v *[]types.CacheNodeTypeSpecificParameter, decoder smithyxml.NodeDecoder) error {
12183	var sv []types.CacheNodeTypeSpecificParameter
12184	if *v == nil {
12185		sv = make([]types.CacheNodeTypeSpecificParameter, 0)
12186	} else {
12187		sv = *v
12188	}
12189
12190	switch {
12191	default:
12192		var mv types.CacheNodeTypeSpecificParameter
12193		t := decoder.StartEl
12194		_ = t
12195		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12196		destAddr := &mv
12197		if err := awsAwsquery_deserializeDocumentCacheNodeTypeSpecificParameter(&destAddr, nodeDecoder); err != nil {
12198			return err
12199		}
12200		mv = *destAddr
12201		sv = append(sv, mv)
12202	}
12203	*v = sv
12204	return nil
12205}
12206func awsAwsquery_deserializeDocumentCacheNodeTypeSpecificValue(v **types.CacheNodeTypeSpecificValue, decoder smithyxml.NodeDecoder) error {
12207	if v == nil {
12208		return fmt.Errorf("unexpected nil of type %T", v)
12209	}
12210	var sv *types.CacheNodeTypeSpecificValue
12211	if *v == nil {
12212		sv = &types.CacheNodeTypeSpecificValue{}
12213	} else {
12214		sv = *v
12215	}
12216
12217	for {
12218		t, done, err := decoder.Token()
12219		if err != nil {
12220			return err
12221		}
12222		if done {
12223			break
12224		}
12225		originalDecoder := decoder
12226		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
12227		switch {
12228		case strings.EqualFold("CacheNodeType", t.Name.Local):
12229			val, err := decoder.Value()
12230			if err != nil {
12231				return err
12232			}
12233			if val == nil {
12234				break
12235			}
12236			{
12237				xtv := string(val)
12238				sv.CacheNodeType = ptr.String(xtv)
12239			}
12240
12241		case strings.EqualFold("Value", t.Name.Local):
12242			val, err := decoder.Value()
12243			if err != nil {
12244				return err
12245			}
12246			if val == nil {
12247				break
12248			}
12249			{
12250				xtv := string(val)
12251				sv.Value = ptr.String(xtv)
12252			}
12253
12254		default:
12255			// Do nothing and ignore the unexpected tag element
12256			err = decoder.Decoder.Skip()
12257			if err != nil {
12258				return err
12259			}
12260
12261		}
12262		decoder = originalDecoder
12263	}
12264	*v = sv
12265	return nil
12266}
12267
12268func awsAwsquery_deserializeDocumentCacheNodeTypeSpecificValueList(v *[]types.CacheNodeTypeSpecificValue, decoder smithyxml.NodeDecoder) error {
12269	if v == nil {
12270		return fmt.Errorf("unexpected nil of type %T", v)
12271	}
12272	var sv []types.CacheNodeTypeSpecificValue
12273	if *v == nil {
12274		sv = make([]types.CacheNodeTypeSpecificValue, 0)
12275	} else {
12276		sv = *v
12277	}
12278
12279	originalDecoder := decoder
12280	for {
12281		t, done, err := decoder.Token()
12282		if err != nil {
12283			return err
12284		}
12285		if done {
12286			break
12287		}
12288		switch {
12289		case strings.EqualFold("CacheNodeTypeSpecificValue", t.Name.Local):
12290			var col types.CacheNodeTypeSpecificValue
12291			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12292			destAddr := &col
12293			if err := awsAwsquery_deserializeDocumentCacheNodeTypeSpecificValue(&destAddr, nodeDecoder); err != nil {
12294				return err
12295			}
12296			col = *destAddr
12297			sv = append(sv, col)
12298
12299		default:
12300			err = decoder.Decoder.Skip()
12301			if err != nil {
12302				return err
12303			}
12304
12305		}
12306		decoder = originalDecoder
12307	}
12308	*v = sv
12309	return nil
12310}
12311
12312func awsAwsquery_deserializeDocumentCacheNodeTypeSpecificValueListUnwrapped(v *[]types.CacheNodeTypeSpecificValue, decoder smithyxml.NodeDecoder) error {
12313	var sv []types.CacheNodeTypeSpecificValue
12314	if *v == nil {
12315		sv = make([]types.CacheNodeTypeSpecificValue, 0)
12316	} else {
12317		sv = *v
12318	}
12319
12320	switch {
12321	default:
12322		var mv types.CacheNodeTypeSpecificValue
12323		t := decoder.StartEl
12324		_ = t
12325		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12326		destAddr := &mv
12327		if err := awsAwsquery_deserializeDocumentCacheNodeTypeSpecificValue(&destAddr, nodeDecoder); err != nil {
12328			return err
12329		}
12330		mv = *destAddr
12331		sv = append(sv, mv)
12332	}
12333	*v = sv
12334	return nil
12335}
12336func awsAwsquery_deserializeDocumentCacheNodeUpdateStatus(v **types.CacheNodeUpdateStatus, decoder smithyxml.NodeDecoder) error {
12337	if v == nil {
12338		return fmt.Errorf("unexpected nil of type %T", v)
12339	}
12340	var sv *types.CacheNodeUpdateStatus
12341	if *v == nil {
12342		sv = &types.CacheNodeUpdateStatus{}
12343	} else {
12344		sv = *v
12345	}
12346
12347	for {
12348		t, done, err := decoder.Token()
12349		if err != nil {
12350			return err
12351		}
12352		if done {
12353			break
12354		}
12355		originalDecoder := decoder
12356		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
12357		switch {
12358		case strings.EqualFold("CacheNodeId", t.Name.Local):
12359			val, err := decoder.Value()
12360			if err != nil {
12361				return err
12362			}
12363			if val == nil {
12364				break
12365			}
12366			{
12367				xtv := string(val)
12368				sv.CacheNodeId = ptr.String(xtv)
12369			}
12370
12371		case strings.EqualFold("NodeDeletionDate", t.Name.Local):
12372			val, err := decoder.Value()
12373			if err != nil {
12374				return err
12375			}
12376			if val == nil {
12377				break
12378			}
12379			{
12380				xtv := string(val)
12381				t, err := smithytime.ParseDateTime(xtv)
12382				if err != nil {
12383					return err
12384				}
12385				sv.NodeDeletionDate = ptr.Time(t)
12386			}
12387
12388		case strings.EqualFold("NodeUpdateEndDate", t.Name.Local):
12389			val, err := decoder.Value()
12390			if err != nil {
12391				return err
12392			}
12393			if val == nil {
12394				break
12395			}
12396			{
12397				xtv := string(val)
12398				t, err := smithytime.ParseDateTime(xtv)
12399				if err != nil {
12400					return err
12401				}
12402				sv.NodeUpdateEndDate = ptr.Time(t)
12403			}
12404
12405		case strings.EqualFold("NodeUpdateInitiatedBy", t.Name.Local):
12406			val, err := decoder.Value()
12407			if err != nil {
12408				return err
12409			}
12410			if val == nil {
12411				break
12412			}
12413			{
12414				xtv := string(val)
12415				sv.NodeUpdateInitiatedBy = types.NodeUpdateInitiatedBy(xtv)
12416			}
12417
12418		case strings.EqualFold("NodeUpdateInitiatedDate", t.Name.Local):
12419			val, err := decoder.Value()
12420			if err != nil {
12421				return err
12422			}
12423			if val == nil {
12424				break
12425			}
12426			{
12427				xtv := string(val)
12428				t, err := smithytime.ParseDateTime(xtv)
12429				if err != nil {
12430					return err
12431				}
12432				sv.NodeUpdateInitiatedDate = ptr.Time(t)
12433			}
12434
12435		case strings.EqualFold("NodeUpdateStartDate", t.Name.Local):
12436			val, err := decoder.Value()
12437			if err != nil {
12438				return err
12439			}
12440			if val == nil {
12441				break
12442			}
12443			{
12444				xtv := string(val)
12445				t, err := smithytime.ParseDateTime(xtv)
12446				if err != nil {
12447					return err
12448				}
12449				sv.NodeUpdateStartDate = ptr.Time(t)
12450			}
12451
12452		case strings.EqualFold("NodeUpdateStatus", t.Name.Local):
12453			val, err := decoder.Value()
12454			if err != nil {
12455				return err
12456			}
12457			if val == nil {
12458				break
12459			}
12460			{
12461				xtv := string(val)
12462				sv.NodeUpdateStatus = types.NodeUpdateStatus(xtv)
12463			}
12464
12465		case strings.EqualFold("NodeUpdateStatusModifiedDate", t.Name.Local):
12466			val, err := decoder.Value()
12467			if err != nil {
12468				return err
12469			}
12470			if val == nil {
12471				break
12472			}
12473			{
12474				xtv := string(val)
12475				t, err := smithytime.ParseDateTime(xtv)
12476				if err != nil {
12477					return err
12478				}
12479				sv.NodeUpdateStatusModifiedDate = ptr.Time(t)
12480			}
12481
12482		default:
12483			// Do nothing and ignore the unexpected tag element
12484			err = decoder.Decoder.Skip()
12485			if err != nil {
12486				return err
12487			}
12488
12489		}
12490		decoder = originalDecoder
12491	}
12492	*v = sv
12493	return nil
12494}
12495
12496func awsAwsquery_deserializeDocumentCacheNodeUpdateStatusList(v *[]types.CacheNodeUpdateStatus, decoder smithyxml.NodeDecoder) error {
12497	if v == nil {
12498		return fmt.Errorf("unexpected nil of type %T", v)
12499	}
12500	var sv []types.CacheNodeUpdateStatus
12501	if *v == nil {
12502		sv = make([]types.CacheNodeUpdateStatus, 0)
12503	} else {
12504		sv = *v
12505	}
12506
12507	originalDecoder := decoder
12508	for {
12509		t, done, err := decoder.Token()
12510		if err != nil {
12511			return err
12512		}
12513		if done {
12514			break
12515		}
12516		switch {
12517		case strings.EqualFold("CacheNodeUpdateStatus", t.Name.Local):
12518			var col types.CacheNodeUpdateStatus
12519			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12520			destAddr := &col
12521			if err := awsAwsquery_deserializeDocumentCacheNodeUpdateStatus(&destAddr, nodeDecoder); err != nil {
12522				return err
12523			}
12524			col = *destAddr
12525			sv = append(sv, col)
12526
12527		default:
12528			err = decoder.Decoder.Skip()
12529			if err != nil {
12530				return err
12531			}
12532
12533		}
12534		decoder = originalDecoder
12535	}
12536	*v = sv
12537	return nil
12538}
12539
12540func awsAwsquery_deserializeDocumentCacheNodeUpdateStatusListUnwrapped(v *[]types.CacheNodeUpdateStatus, decoder smithyxml.NodeDecoder) error {
12541	var sv []types.CacheNodeUpdateStatus
12542	if *v == nil {
12543		sv = make([]types.CacheNodeUpdateStatus, 0)
12544	} else {
12545		sv = *v
12546	}
12547
12548	switch {
12549	default:
12550		var mv types.CacheNodeUpdateStatus
12551		t := decoder.StartEl
12552		_ = t
12553		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12554		destAddr := &mv
12555		if err := awsAwsquery_deserializeDocumentCacheNodeUpdateStatus(&destAddr, nodeDecoder); err != nil {
12556			return err
12557		}
12558		mv = *destAddr
12559		sv = append(sv, mv)
12560	}
12561	*v = sv
12562	return nil
12563}
12564func awsAwsquery_deserializeDocumentCacheParameterGroup(v **types.CacheParameterGroup, decoder smithyxml.NodeDecoder) error {
12565	if v == nil {
12566		return fmt.Errorf("unexpected nil of type %T", v)
12567	}
12568	var sv *types.CacheParameterGroup
12569	if *v == nil {
12570		sv = &types.CacheParameterGroup{}
12571	} else {
12572		sv = *v
12573	}
12574
12575	for {
12576		t, done, err := decoder.Token()
12577		if err != nil {
12578			return err
12579		}
12580		if done {
12581			break
12582		}
12583		originalDecoder := decoder
12584		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
12585		switch {
12586		case strings.EqualFold("ARN", t.Name.Local):
12587			val, err := decoder.Value()
12588			if err != nil {
12589				return err
12590			}
12591			if val == nil {
12592				break
12593			}
12594			{
12595				xtv := string(val)
12596				sv.ARN = ptr.String(xtv)
12597			}
12598
12599		case strings.EqualFold("CacheParameterGroupFamily", t.Name.Local):
12600			val, err := decoder.Value()
12601			if err != nil {
12602				return err
12603			}
12604			if val == nil {
12605				break
12606			}
12607			{
12608				xtv := string(val)
12609				sv.CacheParameterGroupFamily = ptr.String(xtv)
12610			}
12611
12612		case strings.EqualFold("CacheParameterGroupName", t.Name.Local):
12613			val, err := decoder.Value()
12614			if err != nil {
12615				return err
12616			}
12617			if val == nil {
12618				break
12619			}
12620			{
12621				xtv := string(val)
12622				sv.CacheParameterGroupName = ptr.String(xtv)
12623			}
12624
12625		case strings.EqualFold("Description", t.Name.Local):
12626			val, err := decoder.Value()
12627			if err != nil {
12628				return err
12629			}
12630			if val == nil {
12631				break
12632			}
12633			{
12634				xtv := string(val)
12635				sv.Description = ptr.String(xtv)
12636			}
12637
12638		case strings.EqualFold("IsGlobal", t.Name.Local):
12639			val, err := decoder.Value()
12640			if err != nil {
12641				return err
12642			}
12643			if val == nil {
12644				break
12645			}
12646			{
12647				xtv, err := strconv.ParseBool(string(val))
12648				if err != nil {
12649					return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val)
12650				}
12651				sv.IsGlobal = xtv
12652			}
12653
12654		default:
12655			// Do nothing and ignore the unexpected tag element
12656			err = decoder.Decoder.Skip()
12657			if err != nil {
12658				return err
12659			}
12660
12661		}
12662		decoder = originalDecoder
12663	}
12664	*v = sv
12665	return nil
12666}
12667
12668func awsAwsquery_deserializeDocumentCacheParameterGroupAlreadyExistsFault(v **types.CacheParameterGroupAlreadyExistsFault, decoder smithyxml.NodeDecoder) error {
12669	if v == nil {
12670		return fmt.Errorf("unexpected nil of type %T", v)
12671	}
12672	var sv *types.CacheParameterGroupAlreadyExistsFault
12673	if *v == nil {
12674		sv = &types.CacheParameterGroupAlreadyExistsFault{}
12675	} else {
12676		sv = *v
12677	}
12678
12679	for {
12680		t, done, err := decoder.Token()
12681		if err != nil {
12682			return err
12683		}
12684		if done {
12685			break
12686		}
12687		originalDecoder := decoder
12688		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
12689		switch {
12690		case strings.EqualFold("message", t.Name.Local):
12691			val, err := decoder.Value()
12692			if err != nil {
12693				return err
12694			}
12695			if val == nil {
12696				break
12697			}
12698			{
12699				xtv := string(val)
12700				sv.Message = ptr.String(xtv)
12701			}
12702
12703		default:
12704			// Do nothing and ignore the unexpected tag element
12705			err = decoder.Decoder.Skip()
12706			if err != nil {
12707				return err
12708			}
12709
12710		}
12711		decoder = originalDecoder
12712	}
12713	*v = sv
12714	return nil
12715}
12716
12717func awsAwsquery_deserializeDocumentCacheParameterGroupList(v *[]types.CacheParameterGroup, decoder smithyxml.NodeDecoder) error {
12718	if v == nil {
12719		return fmt.Errorf("unexpected nil of type %T", v)
12720	}
12721	var sv []types.CacheParameterGroup
12722	if *v == nil {
12723		sv = make([]types.CacheParameterGroup, 0)
12724	} else {
12725		sv = *v
12726	}
12727
12728	originalDecoder := decoder
12729	for {
12730		t, done, err := decoder.Token()
12731		if err != nil {
12732			return err
12733		}
12734		if done {
12735			break
12736		}
12737		switch {
12738		case strings.EqualFold("CacheParameterGroup", t.Name.Local):
12739			var col types.CacheParameterGroup
12740			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12741			destAddr := &col
12742			if err := awsAwsquery_deserializeDocumentCacheParameterGroup(&destAddr, nodeDecoder); err != nil {
12743				return err
12744			}
12745			col = *destAddr
12746			sv = append(sv, col)
12747
12748		default:
12749			err = decoder.Decoder.Skip()
12750			if err != nil {
12751				return err
12752			}
12753
12754		}
12755		decoder = originalDecoder
12756	}
12757	*v = sv
12758	return nil
12759}
12760
12761func awsAwsquery_deserializeDocumentCacheParameterGroupListUnwrapped(v *[]types.CacheParameterGroup, decoder smithyxml.NodeDecoder) error {
12762	var sv []types.CacheParameterGroup
12763	if *v == nil {
12764		sv = make([]types.CacheParameterGroup, 0)
12765	} else {
12766		sv = *v
12767	}
12768
12769	switch {
12770	default:
12771		var mv types.CacheParameterGroup
12772		t := decoder.StartEl
12773		_ = t
12774		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12775		destAddr := &mv
12776		if err := awsAwsquery_deserializeDocumentCacheParameterGroup(&destAddr, nodeDecoder); err != nil {
12777			return err
12778		}
12779		mv = *destAddr
12780		sv = append(sv, mv)
12781	}
12782	*v = sv
12783	return nil
12784}
12785func awsAwsquery_deserializeDocumentCacheParameterGroupNotFoundFault(v **types.CacheParameterGroupNotFoundFault, decoder smithyxml.NodeDecoder) error {
12786	if v == nil {
12787		return fmt.Errorf("unexpected nil of type %T", v)
12788	}
12789	var sv *types.CacheParameterGroupNotFoundFault
12790	if *v == nil {
12791		sv = &types.CacheParameterGroupNotFoundFault{}
12792	} else {
12793		sv = *v
12794	}
12795
12796	for {
12797		t, done, err := decoder.Token()
12798		if err != nil {
12799			return err
12800		}
12801		if done {
12802			break
12803		}
12804		originalDecoder := decoder
12805		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
12806		switch {
12807		case strings.EqualFold("message", t.Name.Local):
12808			val, err := decoder.Value()
12809			if err != nil {
12810				return err
12811			}
12812			if val == nil {
12813				break
12814			}
12815			{
12816				xtv := string(val)
12817				sv.Message = ptr.String(xtv)
12818			}
12819
12820		default:
12821			// Do nothing and ignore the unexpected tag element
12822			err = decoder.Decoder.Skip()
12823			if err != nil {
12824				return err
12825			}
12826
12827		}
12828		decoder = originalDecoder
12829	}
12830	*v = sv
12831	return nil
12832}
12833
12834func awsAwsquery_deserializeDocumentCacheParameterGroupQuotaExceededFault(v **types.CacheParameterGroupQuotaExceededFault, decoder smithyxml.NodeDecoder) error {
12835	if v == nil {
12836		return fmt.Errorf("unexpected nil of type %T", v)
12837	}
12838	var sv *types.CacheParameterGroupQuotaExceededFault
12839	if *v == nil {
12840		sv = &types.CacheParameterGroupQuotaExceededFault{}
12841	} else {
12842		sv = *v
12843	}
12844
12845	for {
12846		t, done, err := decoder.Token()
12847		if err != nil {
12848			return err
12849		}
12850		if done {
12851			break
12852		}
12853		originalDecoder := decoder
12854		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
12855		switch {
12856		case strings.EqualFold("message", t.Name.Local):
12857			val, err := decoder.Value()
12858			if err != nil {
12859				return err
12860			}
12861			if val == nil {
12862				break
12863			}
12864			{
12865				xtv := string(val)
12866				sv.Message = ptr.String(xtv)
12867			}
12868
12869		default:
12870			// Do nothing and ignore the unexpected tag element
12871			err = decoder.Decoder.Skip()
12872			if err != nil {
12873				return err
12874			}
12875
12876		}
12877		decoder = originalDecoder
12878	}
12879	*v = sv
12880	return nil
12881}
12882
12883func awsAwsquery_deserializeDocumentCacheParameterGroupStatus(v **types.CacheParameterGroupStatus, decoder smithyxml.NodeDecoder) error {
12884	if v == nil {
12885		return fmt.Errorf("unexpected nil of type %T", v)
12886	}
12887	var sv *types.CacheParameterGroupStatus
12888	if *v == nil {
12889		sv = &types.CacheParameterGroupStatus{}
12890	} else {
12891		sv = *v
12892	}
12893
12894	for {
12895		t, done, err := decoder.Token()
12896		if err != nil {
12897			return err
12898		}
12899		if done {
12900			break
12901		}
12902		originalDecoder := decoder
12903		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
12904		switch {
12905		case strings.EqualFold("CacheNodeIdsToReboot", t.Name.Local):
12906			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
12907			if err := awsAwsquery_deserializeDocumentCacheNodeIdsList(&sv.CacheNodeIdsToReboot, nodeDecoder); err != nil {
12908				return err
12909			}
12910
12911		case strings.EqualFold("CacheParameterGroupName", t.Name.Local):
12912			val, err := decoder.Value()
12913			if err != nil {
12914				return err
12915			}
12916			if val == nil {
12917				break
12918			}
12919			{
12920				xtv := string(val)
12921				sv.CacheParameterGroupName = ptr.String(xtv)
12922			}
12923
12924		case strings.EqualFold("ParameterApplyStatus", t.Name.Local):
12925			val, err := decoder.Value()
12926			if err != nil {
12927				return err
12928			}
12929			if val == nil {
12930				break
12931			}
12932			{
12933				xtv := string(val)
12934				sv.ParameterApplyStatus = ptr.String(xtv)
12935			}
12936
12937		default:
12938			// Do nothing and ignore the unexpected tag element
12939			err = decoder.Decoder.Skip()
12940			if err != nil {
12941				return err
12942			}
12943
12944		}
12945		decoder = originalDecoder
12946	}
12947	*v = sv
12948	return nil
12949}
12950
12951func awsAwsquery_deserializeDocumentCacheSecurityGroup(v **types.CacheSecurityGroup, decoder smithyxml.NodeDecoder) error {
12952	if v == nil {
12953		return fmt.Errorf("unexpected nil of type %T", v)
12954	}
12955	var sv *types.CacheSecurityGroup
12956	if *v == nil {
12957		sv = &types.CacheSecurityGroup{}
12958	} else {
12959		sv = *v
12960	}
12961
12962	for {
12963		t, done, err := decoder.Token()
12964		if err != nil {
12965			return err
12966		}
12967		if done {
12968			break
12969		}
12970		originalDecoder := decoder
12971		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
12972		switch {
12973		case strings.EqualFold("ARN", t.Name.Local):
12974			val, err := decoder.Value()
12975			if err != nil {
12976				return err
12977			}
12978			if val == nil {
12979				break
12980			}
12981			{
12982				xtv := string(val)
12983				sv.ARN = ptr.String(xtv)
12984			}
12985
12986		case strings.EqualFold("CacheSecurityGroupName", t.Name.Local):
12987			val, err := decoder.Value()
12988			if err != nil {
12989				return err
12990			}
12991			if val == nil {
12992				break
12993			}
12994			{
12995				xtv := string(val)
12996				sv.CacheSecurityGroupName = ptr.String(xtv)
12997			}
12998
12999		case strings.EqualFold("Description", t.Name.Local):
13000			val, err := decoder.Value()
13001			if err != nil {
13002				return err
13003			}
13004			if val == nil {
13005				break
13006			}
13007			{
13008				xtv := string(val)
13009				sv.Description = ptr.String(xtv)
13010			}
13011
13012		case strings.EqualFold("EC2SecurityGroups", t.Name.Local):
13013			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13014			if err := awsAwsquery_deserializeDocumentEC2SecurityGroupList(&sv.EC2SecurityGroups, nodeDecoder); err != nil {
13015				return err
13016			}
13017
13018		case strings.EqualFold("OwnerId", t.Name.Local):
13019			val, err := decoder.Value()
13020			if err != nil {
13021				return err
13022			}
13023			if val == nil {
13024				break
13025			}
13026			{
13027				xtv := string(val)
13028				sv.OwnerId = ptr.String(xtv)
13029			}
13030
13031		default:
13032			// Do nothing and ignore the unexpected tag element
13033			err = decoder.Decoder.Skip()
13034			if err != nil {
13035				return err
13036			}
13037
13038		}
13039		decoder = originalDecoder
13040	}
13041	*v = sv
13042	return nil
13043}
13044
13045func awsAwsquery_deserializeDocumentCacheSecurityGroupAlreadyExistsFault(v **types.CacheSecurityGroupAlreadyExistsFault, decoder smithyxml.NodeDecoder) error {
13046	if v == nil {
13047		return fmt.Errorf("unexpected nil of type %T", v)
13048	}
13049	var sv *types.CacheSecurityGroupAlreadyExistsFault
13050	if *v == nil {
13051		sv = &types.CacheSecurityGroupAlreadyExistsFault{}
13052	} else {
13053		sv = *v
13054	}
13055
13056	for {
13057		t, done, err := decoder.Token()
13058		if err != nil {
13059			return err
13060		}
13061		if done {
13062			break
13063		}
13064		originalDecoder := decoder
13065		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
13066		switch {
13067		case strings.EqualFold("message", t.Name.Local):
13068			val, err := decoder.Value()
13069			if err != nil {
13070				return err
13071			}
13072			if val == nil {
13073				break
13074			}
13075			{
13076				xtv := string(val)
13077				sv.Message = ptr.String(xtv)
13078			}
13079
13080		default:
13081			// Do nothing and ignore the unexpected tag element
13082			err = decoder.Decoder.Skip()
13083			if err != nil {
13084				return err
13085			}
13086
13087		}
13088		decoder = originalDecoder
13089	}
13090	*v = sv
13091	return nil
13092}
13093
13094func awsAwsquery_deserializeDocumentCacheSecurityGroupMembership(v **types.CacheSecurityGroupMembership, decoder smithyxml.NodeDecoder) error {
13095	if v == nil {
13096		return fmt.Errorf("unexpected nil of type %T", v)
13097	}
13098	var sv *types.CacheSecurityGroupMembership
13099	if *v == nil {
13100		sv = &types.CacheSecurityGroupMembership{}
13101	} else {
13102		sv = *v
13103	}
13104
13105	for {
13106		t, done, err := decoder.Token()
13107		if err != nil {
13108			return err
13109		}
13110		if done {
13111			break
13112		}
13113		originalDecoder := decoder
13114		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
13115		switch {
13116		case strings.EqualFold("CacheSecurityGroupName", t.Name.Local):
13117			val, err := decoder.Value()
13118			if err != nil {
13119				return err
13120			}
13121			if val == nil {
13122				break
13123			}
13124			{
13125				xtv := string(val)
13126				sv.CacheSecurityGroupName = ptr.String(xtv)
13127			}
13128
13129		case strings.EqualFold("Status", t.Name.Local):
13130			val, err := decoder.Value()
13131			if err != nil {
13132				return err
13133			}
13134			if val == nil {
13135				break
13136			}
13137			{
13138				xtv := string(val)
13139				sv.Status = ptr.String(xtv)
13140			}
13141
13142		default:
13143			// Do nothing and ignore the unexpected tag element
13144			err = decoder.Decoder.Skip()
13145			if err != nil {
13146				return err
13147			}
13148
13149		}
13150		decoder = originalDecoder
13151	}
13152	*v = sv
13153	return nil
13154}
13155
13156func awsAwsquery_deserializeDocumentCacheSecurityGroupMembershipList(v *[]types.CacheSecurityGroupMembership, decoder smithyxml.NodeDecoder) error {
13157	if v == nil {
13158		return fmt.Errorf("unexpected nil of type %T", v)
13159	}
13160	var sv []types.CacheSecurityGroupMembership
13161	if *v == nil {
13162		sv = make([]types.CacheSecurityGroupMembership, 0)
13163	} else {
13164		sv = *v
13165	}
13166
13167	originalDecoder := decoder
13168	for {
13169		t, done, err := decoder.Token()
13170		if err != nil {
13171			return err
13172		}
13173		if done {
13174			break
13175		}
13176		switch {
13177		case strings.EqualFold("CacheSecurityGroup", t.Name.Local):
13178			var col types.CacheSecurityGroupMembership
13179			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13180			destAddr := &col
13181			if err := awsAwsquery_deserializeDocumentCacheSecurityGroupMembership(&destAddr, nodeDecoder); err != nil {
13182				return err
13183			}
13184			col = *destAddr
13185			sv = append(sv, col)
13186
13187		default:
13188			err = decoder.Decoder.Skip()
13189			if err != nil {
13190				return err
13191			}
13192
13193		}
13194		decoder = originalDecoder
13195	}
13196	*v = sv
13197	return nil
13198}
13199
13200func awsAwsquery_deserializeDocumentCacheSecurityGroupMembershipListUnwrapped(v *[]types.CacheSecurityGroupMembership, decoder smithyxml.NodeDecoder) error {
13201	var sv []types.CacheSecurityGroupMembership
13202	if *v == nil {
13203		sv = make([]types.CacheSecurityGroupMembership, 0)
13204	} else {
13205		sv = *v
13206	}
13207
13208	switch {
13209	default:
13210		var mv types.CacheSecurityGroupMembership
13211		t := decoder.StartEl
13212		_ = t
13213		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13214		destAddr := &mv
13215		if err := awsAwsquery_deserializeDocumentCacheSecurityGroupMembership(&destAddr, nodeDecoder); err != nil {
13216			return err
13217		}
13218		mv = *destAddr
13219		sv = append(sv, mv)
13220	}
13221	*v = sv
13222	return nil
13223}
13224func awsAwsquery_deserializeDocumentCacheSecurityGroupNotFoundFault(v **types.CacheSecurityGroupNotFoundFault, decoder smithyxml.NodeDecoder) error {
13225	if v == nil {
13226		return fmt.Errorf("unexpected nil of type %T", v)
13227	}
13228	var sv *types.CacheSecurityGroupNotFoundFault
13229	if *v == nil {
13230		sv = &types.CacheSecurityGroupNotFoundFault{}
13231	} else {
13232		sv = *v
13233	}
13234
13235	for {
13236		t, done, err := decoder.Token()
13237		if err != nil {
13238			return err
13239		}
13240		if done {
13241			break
13242		}
13243		originalDecoder := decoder
13244		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
13245		switch {
13246		case strings.EqualFold("message", t.Name.Local):
13247			val, err := decoder.Value()
13248			if err != nil {
13249				return err
13250			}
13251			if val == nil {
13252				break
13253			}
13254			{
13255				xtv := string(val)
13256				sv.Message = ptr.String(xtv)
13257			}
13258
13259		default:
13260			// Do nothing and ignore the unexpected tag element
13261			err = decoder.Decoder.Skip()
13262			if err != nil {
13263				return err
13264			}
13265
13266		}
13267		decoder = originalDecoder
13268	}
13269	*v = sv
13270	return nil
13271}
13272
13273func awsAwsquery_deserializeDocumentCacheSecurityGroupQuotaExceededFault(v **types.CacheSecurityGroupQuotaExceededFault, decoder smithyxml.NodeDecoder) error {
13274	if v == nil {
13275		return fmt.Errorf("unexpected nil of type %T", v)
13276	}
13277	var sv *types.CacheSecurityGroupQuotaExceededFault
13278	if *v == nil {
13279		sv = &types.CacheSecurityGroupQuotaExceededFault{}
13280	} else {
13281		sv = *v
13282	}
13283
13284	for {
13285		t, done, err := decoder.Token()
13286		if err != nil {
13287			return err
13288		}
13289		if done {
13290			break
13291		}
13292		originalDecoder := decoder
13293		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
13294		switch {
13295		case strings.EqualFold("message", t.Name.Local):
13296			val, err := decoder.Value()
13297			if err != nil {
13298				return err
13299			}
13300			if val == nil {
13301				break
13302			}
13303			{
13304				xtv := string(val)
13305				sv.Message = ptr.String(xtv)
13306			}
13307
13308		default:
13309			// Do nothing and ignore the unexpected tag element
13310			err = decoder.Decoder.Skip()
13311			if err != nil {
13312				return err
13313			}
13314
13315		}
13316		decoder = originalDecoder
13317	}
13318	*v = sv
13319	return nil
13320}
13321
13322func awsAwsquery_deserializeDocumentCacheSecurityGroups(v *[]types.CacheSecurityGroup, decoder smithyxml.NodeDecoder) error {
13323	if v == nil {
13324		return fmt.Errorf("unexpected nil of type %T", v)
13325	}
13326	var sv []types.CacheSecurityGroup
13327	if *v == nil {
13328		sv = make([]types.CacheSecurityGroup, 0)
13329	} else {
13330		sv = *v
13331	}
13332
13333	originalDecoder := decoder
13334	for {
13335		t, done, err := decoder.Token()
13336		if err != nil {
13337			return err
13338		}
13339		if done {
13340			break
13341		}
13342		switch {
13343		case strings.EqualFold("CacheSecurityGroup", t.Name.Local):
13344			var col types.CacheSecurityGroup
13345			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13346			destAddr := &col
13347			if err := awsAwsquery_deserializeDocumentCacheSecurityGroup(&destAddr, nodeDecoder); err != nil {
13348				return err
13349			}
13350			col = *destAddr
13351			sv = append(sv, col)
13352
13353		default:
13354			err = decoder.Decoder.Skip()
13355			if err != nil {
13356				return err
13357			}
13358
13359		}
13360		decoder = originalDecoder
13361	}
13362	*v = sv
13363	return nil
13364}
13365
13366func awsAwsquery_deserializeDocumentCacheSecurityGroupsUnwrapped(v *[]types.CacheSecurityGroup, decoder smithyxml.NodeDecoder) error {
13367	var sv []types.CacheSecurityGroup
13368	if *v == nil {
13369		sv = make([]types.CacheSecurityGroup, 0)
13370	} else {
13371		sv = *v
13372	}
13373
13374	switch {
13375	default:
13376		var mv types.CacheSecurityGroup
13377		t := decoder.StartEl
13378		_ = t
13379		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13380		destAddr := &mv
13381		if err := awsAwsquery_deserializeDocumentCacheSecurityGroup(&destAddr, nodeDecoder); err != nil {
13382			return err
13383		}
13384		mv = *destAddr
13385		sv = append(sv, mv)
13386	}
13387	*v = sv
13388	return nil
13389}
13390func awsAwsquery_deserializeDocumentCacheSubnetGroup(v **types.CacheSubnetGroup, decoder smithyxml.NodeDecoder) error {
13391	if v == nil {
13392		return fmt.Errorf("unexpected nil of type %T", v)
13393	}
13394	var sv *types.CacheSubnetGroup
13395	if *v == nil {
13396		sv = &types.CacheSubnetGroup{}
13397	} else {
13398		sv = *v
13399	}
13400
13401	for {
13402		t, done, err := decoder.Token()
13403		if err != nil {
13404			return err
13405		}
13406		if done {
13407			break
13408		}
13409		originalDecoder := decoder
13410		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
13411		switch {
13412		case strings.EqualFold("ARN", t.Name.Local):
13413			val, err := decoder.Value()
13414			if err != nil {
13415				return err
13416			}
13417			if val == nil {
13418				break
13419			}
13420			{
13421				xtv := string(val)
13422				sv.ARN = ptr.String(xtv)
13423			}
13424
13425		case strings.EqualFold("CacheSubnetGroupDescription", t.Name.Local):
13426			val, err := decoder.Value()
13427			if err != nil {
13428				return err
13429			}
13430			if val == nil {
13431				break
13432			}
13433			{
13434				xtv := string(val)
13435				sv.CacheSubnetGroupDescription = ptr.String(xtv)
13436			}
13437
13438		case strings.EqualFold("CacheSubnetGroupName", t.Name.Local):
13439			val, err := decoder.Value()
13440			if err != nil {
13441				return err
13442			}
13443			if val == nil {
13444				break
13445			}
13446			{
13447				xtv := string(val)
13448				sv.CacheSubnetGroupName = ptr.String(xtv)
13449			}
13450
13451		case strings.EqualFold("Subnets", t.Name.Local):
13452			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13453			if err := awsAwsquery_deserializeDocumentSubnetList(&sv.Subnets, nodeDecoder); err != nil {
13454				return err
13455			}
13456
13457		case strings.EqualFold("VpcId", t.Name.Local):
13458			val, err := decoder.Value()
13459			if err != nil {
13460				return err
13461			}
13462			if val == nil {
13463				break
13464			}
13465			{
13466				xtv := string(val)
13467				sv.VpcId = ptr.String(xtv)
13468			}
13469
13470		default:
13471			// Do nothing and ignore the unexpected tag element
13472			err = decoder.Decoder.Skip()
13473			if err != nil {
13474				return err
13475			}
13476
13477		}
13478		decoder = originalDecoder
13479	}
13480	*v = sv
13481	return nil
13482}
13483
13484func awsAwsquery_deserializeDocumentCacheSubnetGroupAlreadyExistsFault(v **types.CacheSubnetGroupAlreadyExistsFault, decoder smithyxml.NodeDecoder) error {
13485	if v == nil {
13486		return fmt.Errorf("unexpected nil of type %T", v)
13487	}
13488	var sv *types.CacheSubnetGroupAlreadyExistsFault
13489	if *v == nil {
13490		sv = &types.CacheSubnetGroupAlreadyExistsFault{}
13491	} else {
13492		sv = *v
13493	}
13494
13495	for {
13496		t, done, err := decoder.Token()
13497		if err != nil {
13498			return err
13499		}
13500		if done {
13501			break
13502		}
13503		originalDecoder := decoder
13504		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
13505		switch {
13506		case strings.EqualFold("message", t.Name.Local):
13507			val, err := decoder.Value()
13508			if err != nil {
13509				return err
13510			}
13511			if val == nil {
13512				break
13513			}
13514			{
13515				xtv := string(val)
13516				sv.Message = ptr.String(xtv)
13517			}
13518
13519		default:
13520			// Do nothing and ignore the unexpected tag element
13521			err = decoder.Decoder.Skip()
13522			if err != nil {
13523				return err
13524			}
13525
13526		}
13527		decoder = originalDecoder
13528	}
13529	*v = sv
13530	return nil
13531}
13532
13533func awsAwsquery_deserializeDocumentCacheSubnetGroupInUse(v **types.CacheSubnetGroupInUse, decoder smithyxml.NodeDecoder) error {
13534	if v == nil {
13535		return fmt.Errorf("unexpected nil of type %T", v)
13536	}
13537	var sv *types.CacheSubnetGroupInUse
13538	if *v == nil {
13539		sv = &types.CacheSubnetGroupInUse{}
13540	} else {
13541		sv = *v
13542	}
13543
13544	for {
13545		t, done, err := decoder.Token()
13546		if err != nil {
13547			return err
13548		}
13549		if done {
13550			break
13551		}
13552		originalDecoder := decoder
13553		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
13554		switch {
13555		case strings.EqualFold("message", t.Name.Local):
13556			val, err := decoder.Value()
13557			if err != nil {
13558				return err
13559			}
13560			if val == nil {
13561				break
13562			}
13563			{
13564				xtv := string(val)
13565				sv.Message = ptr.String(xtv)
13566			}
13567
13568		default:
13569			// Do nothing and ignore the unexpected tag element
13570			err = decoder.Decoder.Skip()
13571			if err != nil {
13572				return err
13573			}
13574
13575		}
13576		decoder = originalDecoder
13577	}
13578	*v = sv
13579	return nil
13580}
13581
13582func awsAwsquery_deserializeDocumentCacheSubnetGroupNotFoundFault(v **types.CacheSubnetGroupNotFoundFault, decoder smithyxml.NodeDecoder) error {
13583	if v == nil {
13584		return fmt.Errorf("unexpected nil of type %T", v)
13585	}
13586	var sv *types.CacheSubnetGroupNotFoundFault
13587	if *v == nil {
13588		sv = &types.CacheSubnetGroupNotFoundFault{}
13589	} else {
13590		sv = *v
13591	}
13592
13593	for {
13594		t, done, err := decoder.Token()
13595		if err != nil {
13596			return err
13597		}
13598		if done {
13599			break
13600		}
13601		originalDecoder := decoder
13602		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
13603		switch {
13604		case strings.EqualFold("message", t.Name.Local):
13605			val, err := decoder.Value()
13606			if err != nil {
13607				return err
13608			}
13609			if val == nil {
13610				break
13611			}
13612			{
13613				xtv := string(val)
13614				sv.Message = ptr.String(xtv)
13615			}
13616
13617		default:
13618			// Do nothing and ignore the unexpected tag element
13619			err = decoder.Decoder.Skip()
13620			if err != nil {
13621				return err
13622			}
13623
13624		}
13625		decoder = originalDecoder
13626	}
13627	*v = sv
13628	return nil
13629}
13630
13631func awsAwsquery_deserializeDocumentCacheSubnetGroupQuotaExceededFault(v **types.CacheSubnetGroupQuotaExceededFault, decoder smithyxml.NodeDecoder) error {
13632	if v == nil {
13633		return fmt.Errorf("unexpected nil of type %T", v)
13634	}
13635	var sv *types.CacheSubnetGroupQuotaExceededFault
13636	if *v == nil {
13637		sv = &types.CacheSubnetGroupQuotaExceededFault{}
13638	} else {
13639		sv = *v
13640	}
13641
13642	for {
13643		t, done, err := decoder.Token()
13644		if err != nil {
13645			return err
13646		}
13647		if done {
13648			break
13649		}
13650		originalDecoder := decoder
13651		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
13652		switch {
13653		case strings.EqualFold("message", t.Name.Local):
13654			val, err := decoder.Value()
13655			if err != nil {
13656				return err
13657			}
13658			if val == nil {
13659				break
13660			}
13661			{
13662				xtv := string(val)
13663				sv.Message = ptr.String(xtv)
13664			}
13665
13666		default:
13667			// Do nothing and ignore the unexpected tag element
13668			err = decoder.Decoder.Skip()
13669			if err != nil {
13670				return err
13671			}
13672
13673		}
13674		decoder = originalDecoder
13675	}
13676	*v = sv
13677	return nil
13678}
13679
13680func awsAwsquery_deserializeDocumentCacheSubnetGroups(v *[]types.CacheSubnetGroup, decoder smithyxml.NodeDecoder) error {
13681	if v == nil {
13682		return fmt.Errorf("unexpected nil of type %T", v)
13683	}
13684	var sv []types.CacheSubnetGroup
13685	if *v == nil {
13686		sv = make([]types.CacheSubnetGroup, 0)
13687	} else {
13688		sv = *v
13689	}
13690
13691	originalDecoder := decoder
13692	for {
13693		t, done, err := decoder.Token()
13694		if err != nil {
13695			return err
13696		}
13697		if done {
13698			break
13699		}
13700		switch {
13701		case strings.EqualFold("CacheSubnetGroup", t.Name.Local):
13702			var col types.CacheSubnetGroup
13703			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13704			destAddr := &col
13705			if err := awsAwsquery_deserializeDocumentCacheSubnetGroup(&destAddr, nodeDecoder); err != nil {
13706				return err
13707			}
13708			col = *destAddr
13709			sv = append(sv, col)
13710
13711		default:
13712			err = decoder.Decoder.Skip()
13713			if err != nil {
13714				return err
13715			}
13716
13717		}
13718		decoder = originalDecoder
13719	}
13720	*v = sv
13721	return nil
13722}
13723
13724func awsAwsquery_deserializeDocumentCacheSubnetGroupsUnwrapped(v *[]types.CacheSubnetGroup, decoder smithyxml.NodeDecoder) error {
13725	var sv []types.CacheSubnetGroup
13726	if *v == nil {
13727		sv = make([]types.CacheSubnetGroup, 0)
13728	} else {
13729		sv = *v
13730	}
13731
13732	switch {
13733	default:
13734		var mv types.CacheSubnetGroup
13735		t := decoder.StartEl
13736		_ = t
13737		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13738		destAddr := &mv
13739		if err := awsAwsquery_deserializeDocumentCacheSubnetGroup(&destAddr, nodeDecoder); err != nil {
13740			return err
13741		}
13742		mv = *destAddr
13743		sv = append(sv, mv)
13744	}
13745	*v = sv
13746	return nil
13747}
13748func awsAwsquery_deserializeDocumentCacheSubnetQuotaExceededFault(v **types.CacheSubnetQuotaExceededFault, decoder smithyxml.NodeDecoder) error {
13749	if v == nil {
13750		return fmt.Errorf("unexpected nil of type %T", v)
13751	}
13752	var sv *types.CacheSubnetQuotaExceededFault
13753	if *v == nil {
13754		sv = &types.CacheSubnetQuotaExceededFault{}
13755	} else {
13756		sv = *v
13757	}
13758
13759	for {
13760		t, done, err := decoder.Token()
13761		if err != nil {
13762			return err
13763		}
13764		if done {
13765			break
13766		}
13767		originalDecoder := decoder
13768		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
13769		switch {
13770		case strings.EqualFold("message", t.Name.Local):
13771			val, err := decoder.Value()
13772			if err != nil {
13773				return err
13774			}
13775			if val == nil {
13776				break
13777			}
13778			{
13779				xtv := string(val)
13780				sv.Message = ptr.String(xtv)
13781			}
13782
13783		default:
13784			// Do nothing and ignore the unexpected tag element
13785			err = decoder.Decoder.Skip()
13786			if err != nil {
13787				return err
13788			}
13789
13790		}
13791		decoder = originalDecoder
13792	}
13793	*v = sv
13794	return nil
13795}
13796
13797func awsAwsquery_deserializeDocumentClusterIdList(v *[]string, decoder smithyxml.NodeDecoder) error {
13798	if v == nil {
13799		return fmt.Errorf("unexpected nil of type %T", v)
13800	}
13801	var sv []string
13802	if *v == nil {
13803		sv = make([]string, 0)
13804	} else {
13805		sv = *v
13806	}
13807
13808	originalDecoder := decoder
13809	for {
13810		t, done, err := decoder.Token()
13811		if err != nil {
13812			return err
13813		}
13814		if done {
13815			break
13816		}
13817		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
13818		decoder = memberDecoder
13819		switch {
13820		case strings.EqualFold("ClusterId", t.Name.Local):
13821			var col string
13822			val, err := decoder.Value()
13823			if err != nil {
13824				return err
13825			}
13826			if val == nil {
13827				break
13828			}
13829			{
13830				xtv := string(val)
13831				col = xtv
13832			}
13833			sv = append(sv, col)
13834
13835		default:
13836			err = decoder.Decoder.Skip()
13837			if err != nil {
13838				return err
13839			}
13840
13841		}
13842		decoder = originalDecoder
13843	}
13844	*v = sv
13845	return nil
13846}
13847
13848func awsAwsquery_deserializeDocumentClusterIdListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
13849	var sv []string
13850	if *v == nil {
13851		sv = make([]string, 0)
13852	} else {
13853		sv = *v
13854	}
13855
13856	switch {
13857	default:
13858		var mv string
13859		t := decoder.StartEl
13860		_ = t
13861		val, err := decoder.Value()
13862		if err != nil {
13863			return err
13864		}
13865		if val == nil {
13866			break
13867		}
13868		{
13869			xtv := string(val)
13870			mv = xtv
13871		}
13872		sv = append(sv, mv)
13873	}
13874	*v = sv
13875	return nil
13876}
13877func awsAwsquery_deserializeDocumentClusterQuotaForCustomerExceededFault(v **types.ClusterQuotaForCustomerExceededFault, decoder smithyxml.NodeDecoder) error {
13878	if v == nil {
13879		return fmt.Errorf("unexpected nil of type %T", v)
13880	}
13881	var sv *types.ClusterQuotaForCustomerExceededFault
13882	if *v == nil {
13883		sv = &types.ClusterQuotaForCustomerExceededFault{}
13884	} else {
13885		sv = *v
13886	}
13887
13888	for {
13889		t, done, err := decoder.Token()
13890		if err != nil {
13891			return err
13892		}
13893		if done {
13894			break
13895		}
13896		originalDecoder := decoder
13897		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
13898		switch {
13899		case strings.EqualFold("message", t.Name.Local):
13900			val, err := decoder.Value()
13901			if err != nil {
13902				return err
13903			}
13904			if val == nil {
13905				break
13906			}
13907			{
13908				xtv := string(val)
13909				sv.Message = ptr.String(xtv)
13910			}
13911
13912		default:
13913			// Do nothing and ignore the unexpected tag element
13914			err = decoder.Decoder.Skip()
13915			if err != nil {
13916				return err
13917			}
13918
13919		}
13920		decoder = originalDecoder
13921	}
13922	*v = sv
13923	return nil
13924}
13925
13926func awsAwsquery_deserializeDocumentDefaultUserAssociatedToUserGroupFault(v **types.DefaultUserAssociatedToUserGroupFault, decoder smithyxml.NodeDecoder) error {
13927	if v == nil {
13928		return fmt.Errorf("unexpected nil of type %T", v)
13929	}
13930	var sv *types.DefaultUserAssociatedToUserGroupFault
13931	if *v == nil {
13932		sv = &types.DefaultUserAssociatedToUserGroupFault{}
13933	} else {
13934		sv = *v
13935	}
13936
13937	for {
13938		t, done, err := decoder.Token()
13939		if err != nil {
13940			return err
13941		}
13942		if done {
13943			break
13944		}
13945		originalDecoder := decoder
13946		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
13947		switch {
13948		case strings.EqualFold("message", t.Name.Local):
13949			val, err := decoder.Value()
13950			if err != nil {
13951				return err
13952			}
13953			if val == nil {
13954				break
13955			}
13956			{
13957				xtv := string(val)
13958				sv.Message = ptr.String(xtv)
13959			}
13960
13961		default:
13962			// Do nothing and ignore the unexpected tag element
13963			err = decoder.Decoder.Skip()
13964			if err != nil {
13965				return err
13966			}
13967
13968		}
13969		decoder = originalDecoder
13970	}
13971	*v = sv
13972	return nil
13973}
13974
13975func awsAwsquery_deserializeDocumentDefaultUserRequired(v **types.DefaultUserRequired, decoder smithyxml.NodeDecoder) error {
13976	if v == nil {
13977		return fmt.Errorf("unexpected nil of type %T", v)
13978	}
13979	var sv *types.DefaultUserRequired
13980	if *v == nil {
13981		sv = &types.DefaultUserRequired{}
13982	} else {
13983		sv = *v
13984	}
13985
13986	for {
13987		t, done, err := decoder.Token()
13988		if err != nil {
13989			return err
13990		}
13991		if done {
13992			break
13993		}
13994		originalDecoder := decoder
13995		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
13996		switch {
13997		case strings.EqualFold("message", t.Name.Local):
13998			val, err := decoder.Value()
13999			if err != nil {
14000				return err
14001			}
14002			if val == nil {
14003				break
14004			}
14005			{
14006				xtv := string(val)
14007				sv.Message = ptr.String(xtv)
14008			}
14009
14010		default:
14011			// Do nothing and ignore the unexpected tag element
14012			err = decoder.Decoder.Skip()
14013			if err != nil {
14014				return err
14015			}
14016
14017		}
14018		decoder = originalDecoder
14019	}
14020	*v = sv
14021	return nil
14022}
14023
14024func awsAwsquery_deserializeDocumentDuplicateUserNameFault(v **types.DuplicateUserNameFault, decoder smithyxml.NodeDecoder) error {
14025	if v == nil {
14026		return fmt.Errorf("unexpected nil of type %T", v)
14027	}
14028	var sv *types.DuplicateUserNameFault
14029	if *v == nil {
14030		sv = &types.DuplicateUserNameFault{}
14031	} else {
14032		sv = *v
14033	}
14034
14035	for {
14036		t, done, err := decoder.Token()
14037		if err != nil {
14038			return err
14039		}
14040		if done {
14041			break
14042		}
14043		originalDecoder := decoder
14044		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
14045		switch {
14046		case strings.EqualFold("message", t.Name.Local):
14047			val, err := decoder.Value()
14048			if err != nil {
14049				return err
14050			}
14051			if val == nil {
14052				break
14053			}
14054			{
14055				xtv := string(val)
14056				sv.Message = ptr.String(xtv)
14057			}
14058
14059		default:
14060			// Do nothing and ignore the unexpected tag element
14061			err = decoder.Decoder.Skip()
14062			if err != nil {
14063				return err
14064			}
14065
14066		}
14067		decoder = originalDecoder
14068	}
14069	*v = sv
14070	return nil
14071}
14072
14073func awsAwsquery_deserializeDocumentEC2SecurityGroup(v **types.EC2SecurityGroup, decoder smithyxml.NodeDecoder) error {
14074	if v == nil {
14075		return fmt.Errorf("unexpected nil of type %T", v)
14076	}
14077	var sv *types.EC2SecurityGroup
14078	if *v == nil {
14079		sv = &types.EC2SecurityGroup{}
14080	} else {
14081		sv = *v
14082	}
14083
14084	for {
14085		t, done, err := decoder.Token()
14086		if err != nil {
14087			return err
14088		}
14089		if done {
14090			break
14091		}
14092		originalDecoder := decoder
14093		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
14094		switch {
14095		case strings.EqualFold("EC2SecurityGroupName", t.Name.Local):
14096			val, err := decoder.Value()
14097			if err != nil {
14098				return err
14099			}
14100			if val == nil {
14101				break
14102			}
14103			{
14104				xtv := string(val)
14105				sv.EC2SecurityGroupName = ptr.String(xtv)
14106			}
14107
14108		case strings.EqualFold("EC2SecurityGroupOwnerId", t.Name.Local):
14109			val, err := decoder.Value()
14110			if err != nil {
14111				return err
14112			}
14113			if val == nil {
14114				break
14115			}
14116			{
14117				xtv := string(val)
14118				sv.EC2SecurityGroupOwnerId = ptr.String(xtv)
14119			}
14120
14121		case strings.EqualFold("Status", t.Name.Local):
14122			val, err := decoder.Value()
14123			if err != nil {
14124				return err
14125			}
14126			if val == nil {
14127				break
14128			}
14129			{
14130				xtv := string(val)
14131				sv.Status = ptr.String(xtv)
14132			}
14133
14134		default:
14135			// Do nothing and ignore the unexpected tag element
14136			err = decoder.Decoder.Skip()
14137			if err != nil {
14138				return err
14139			}
14140
14141		}
14142		decoder = originalDecoder
14143	}
14144	*v = sv
14145	return nil
14146}
14147
14148func awsAwsquery_deserializeDocumentEC2SecurityGroupList(v *[]types.EC2SecurityGroup, decoder smithyxml.NodeDecoder) error {
14149	if v == nil {
14150		return fmt.Errorf("unexpected nil of type %T", v)
14151	}
14152	var sv []types.EC2SecurityGroup
14153	if *v == nil {
14154		sv = make([]types.EC2SecurityGroup, 0)
14155	} else {
14156		sv = *v
14157	}
14158
14159	originalDecoder := decoder
14160	for {
14161		t, done, err := decoder.Token()
14162		if err != nil {
14163			return err
14164		}
14165		if done {
14166			break
14167		}
14168		switch {
14169		case strings.EqualFold("EC2SecurityGroup", t.Name.Local):
14170			var col types.EC2SecurityGroup
14171			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
14172			destAddr := &col
14173			if err := awsAwsquery_deserializeDocumentEC2SecurityGroup(&destAddr, nodeDecoder); err != nil {
14174				return err
14175			}
14176			col = *destAddr
14177			sv = append(sv, col)
14178
14179		default:
14180			err = decoder.Decoder.Skip()
14181			if err != nil {
14182				return err
14183			}
14184
14185		}
14186		decoder = originalDecoder
14187	}
14188	*v = sv
14189	return nil
14190}
14191
14192func awsAwsquery_deserializeDocumentEC2SecurityGroupListUnwrapped(v *[]types.EC2SecurityGroup, decoder smithyxml.NodeDecoder) error {
14193	var sv []types.EC2SecurityGroup
14194	if *v == nil {
14195		sv = make([]types.EC2SecurityGroup, 0)
14196	} else {
14197		sv = *v
14198	}
14199
14200	switch {
14201	default:
14202		var mv types.EC2SecurityGroup
14203		t := decoder.StartEl
14204		_ = t
14205		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
14206		destAddr := &mv
14207		if err := awsAwsquery_deserializeDocumentEC2SecurityGroup(&destAddr, nodeDecoder); err != nil {
14208			return err
14209		}
14210		mv = *destAddr
14211		sv = append(sv, mv)
14212	}
14213	*v = sv
14214	return nil
14215}
14216func awsAwsquery_deserializeDocumentEndpoint(v **types.Endpoint, decoder smithyxml.NodeDecoder) error {
14217	if v == nil {
14218		return fmt.Errorf("unexpected nil of type %T", v)
14219	}
14220	var sv *types.Endpoint
14221	if *v == nil {
14222		sv = &types.Endpoint{}
14223	} else {
14224		sv = *v
14225	}
14226
14227	for {
14228		t, done, err := decoder.Token()
14229		if err != nil {
14230			return err
14231		}
14232		if done {
14233			break
14234		}
14235		originalDecoder := decoder
14236		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
14237		switch {
14238		case strings.EqualFold("Address", t.Name.Local):
14239			val, err := decoder.Value()
14240			if err != nil {
14241				return err
14242			}
14243			if val == nil {
14244				break
14245			}
14246			{
14247				xtv := string(val)
14248				sv.Address = ptr.String(xtv)
14249			}
14250
14251		case strings.EqualFold("Port", t.Name.Local):
14252			val, err := decoder.Value()
14253			if err != nil {
14254				return err
14255			}
14256			if val == nil {
14257				break
14258			}
14259			{
14260				xtv := string(val)
14261				i64, err := strconv.ParseInt(xtv, 10, 64)
14262				if err != nil {
14263					return err
14264				}
14265				sv.Port = int32(i64)
14266			}
14267
14268		default:
14269			// Do nothing and ignore the unexpected tag element
14270			err = decoder.Decoder.Skip()
14271			if err != nil {
14272				return err
14273			}
14274
14275		}
14276		decoder = originalDecoder
14277	}
14278	*v = sv
14279	return nil
14280}
14281
14282func awsAwsquery_deserializeDocumentEngineDefaults(v **types.EngineDefaults, decoder smithyxml.NodeDecoder) error {
14283	if v == nil {
14284		return fmt.Errorf("unexpected nil of type %T", v)
14285	}
14286	var sv *types.EngineDefaults
14287	if *v == nil {
14288		sv = &types.EngineDefaults{}
14289	} else {
14290		sv = *v
14291	}
14292
14293	for {
14294		t, done, err := decoder.Token()
14295		if err != nil {
14296			return err
14297		}
14298		if done {
14299			break
14300		}
14301		originalDecoder := decoder
14302		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
14303		switch {
14304		case strings.EqualFold("CacheNodeTypeSpecificParameters", t.Name.Local):
14305			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
14306			if err := awsAwsquery_deserializeDocumentCacheNodeTypeSpecificParametersList(&sv.CacheNodeTypeSpecificParameters, nodeDecoder); err != nil {
14307				return err
14308			}
14309
14310		case strings.EqualFold("CacheParameterGroupFamily", t.Name.Local):
14311			val, err := decoder.Value()
14312			if err != nil {
14313				return err
14314			}
14315			if val == nil {
14316				break
14317			}
14318			{
14319				xtv := string(val)
14320				sv.CacheParameterGroupFamily = ptr.String(xtv)
14321			}
14322
14323		case strings.EqualFold("Marker", t.Name.Local):
14324			val, err := decoder.Value()
14325			if err != nil {
14326				return err
14327			}
14328			if val == nil {
14329				break
14330			}
14331			{
14332				xtv := string(val)
14333				sv.Marker = ptr.String(xtv)
14334			}
14335
14336		case strings.EqualFold("Parameters", t.Name.Local):
14337			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
14338			if err := awsAwsquery_deserializeDocumentParametersList(&sv.Parameters, nodeDecoder); err != nil {
14339				return err
14340			}
14341
14342		default:
14343			// Do nothing and ignore the unexpected tag element
14344			err = decoder.Decoder.Skip()
14345			if err != nil {
14346				return err
14347			}
14348
14349		}
14350		decoder = originalDecoder
14351	}
14352	*v = sv
14353	return nil
14354}
14355
14356func awsAwsquery_deserializeDocumentEvent(v **types.Event, decoder smithyxml.NodeDecoder) error {
14357	if v == nil {
14358		return fmt.Errorf("unexpected nil of type %T", v)
14359	}
14360	var sv *types.Event
14361	if *v == nil {
14362		sv = &types.Event{}
14363	} else {
14364		sv = *v
14365	}
14366
14367	for {
14368		t, done, err := decoder.Token()
14369		if err != nil {
14370			return err
14371		}
14372		if done {
14373			break
14374		}
14375		originalDecoder := decoder
14376		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
14377		switch {
14378		case strings.EqualFold("Date", t.Name.Local):
14379			val, err := decoder.Value()
14380			if err != nil {
14381				return err
14382			}
14383			if val == nil {
14384				break
14385			}
14386			{
14387				xtv := string(val)
14388				t, err := smithytime.ParseDateTime(xtv)
14389				if err != nil {
14390					return err
14391				}
14392				sv.Date = ptr.Time(t)
14393			}
14394
14395		case strings.EqualFold("Message", t.Name.Local):
14396			val, err := decoder.Value()
14397			if err != nil {
14398				return err
14399			}
14400			if val == nil {
14401				break
14402			}
14403			{
14404				xtv := string(val)
14405				sv.Message = ptr.String(xtv)
14406			}
14407
14408		case strings.EqualFold("SourceIdentifier", t.Name.Local):
14409			val, err := decoder.Value()
14410			if err != nil {
14411				return err
14412			}
14413			if val == nil {
14414				break
14415			}
14416			{
14417				xtv := string(val)
14418				sv.SourceIdentifier = ptr.String(xtv)
14419			}
14420
14421		case strings.EqualFold("SourceType", t.Name.Local):
14422			val, err := decoder.Value()
14423			if err != nil {
14424				return err
14425			}
14426			if val == nil {
14427				break
14428			}
14429			{
14430				xtv := string(val)
14431				sv.SourceType = types.SourceType(xtv)
14432			}
14433
14434		default:
14435			// Do nothing and ignore the unexpected tag element
14436			err = decoder.Decoder.Skip()
14437			if err != nil {
14438				return err
14439			}
14440
14441		}
14442		decoder = originalDecoder
14443	}
14444	*v = sv
14445	return nil
14446}
14447
14448func awsAwsquery_deserializeDocumentEventList(v *[]types.Event, decoder smithyxml.NodeDecoder) error {
14449	if v == nil {
14450		return fmt.Errorf("unexpected nil of type %T", v)
14451	}
14452	var sv []types.Event
14453	if *v == nil {
14454		sv = make([]types.Event, 0)
14455	} else {
14456		sv = *v
14457	}
14458
14459	originalDecoder := decoder
14460	for {
14461		t, done, err := decoder.Token()
14462		if err != nil {
14463			return err
14464		}
14465		if done {
14466			break
14467		}
14468		switch {
14469		case strings.EqualFold("Event", t.Name.Local):
14470			var col types.Event
14471			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
14472			destAddr := &col
14473			if err := awsAwsquery_deserializeDocumentEvent(&destAddr, nodeDecoder); err != nil {
14474				return err
14475			}
14476			col = *destAddr
14477			sv = append(sv, col)
14478
14479		default:
14480			err = decoder.Decoder.Skip()
14481			if err != nil {
14482				return err
14483			}
14484
14485		}
14486		decoder = originalDecoder
14487	}
14488	*v = sv
14489	return nil
14490}
14491
14492func awsAwsquery_deserializeDocumentEventListUnwrapped(v *[]types.Event, decoder smithyxml.NodeDecoder) error {
14493	var sv []types.Event
14494	if *v == nil {
14495		sv = make([]types.Event, 0)
14496	} else {
14497		sv = *v
14498	}
14499
14500	switch {
14501	default:
14502		var mv types.Event
14503		t := decoder.StartEl
14504		_ = t
14505		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
14506		destAddr := &mv
14507		if err := awsAwsquery_deserializeDocumentEvent(&destAddr, nodeDecoder); err != nil {
14508			return err
14509		}
14510		mv = *destAddr
14511		sv = append(sv, mv)
14512	}
14513	*v = sv
14514	return nil
14515}
14516func awsAwsquery_deserializeDocumentGlobalNodeGroup(v **types.GlobalNodeGroup, decoder smithyxml.NodeDecoder) error {
14517	if v == nil {
14518		return fmt.Errorf("unexpected nil of type %T", v)
14519	}
14520	var sv *types.GlobalNodeGroup
14521	if *v == nil {
14522		sv = &types.GlobalNodeGroup{}
14523	} else {
14524		sv = *v
14525	}
14526
14527	for {
14528		t, done, err := decoder.Token()
14529		if err != nil {
14530			return err
14531		}
14532		if done {
14533			break
14534		}
14535		originalDecoder := decoder
14536		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
14537		switch {
14538		case strings.EqualFold("GlobalNodeGroupId", t.Name.Local):
14539			val, err := decoder.Value()
14540			if err != nil {
14541				return err
14542			}
14543			if val == nil {
14544				break
14545			}
14546			{
14547				xtv := string(val)
14548				sv.GlobalNodeGroupId = ptr.String(xtv)
14549			}
14550
14551		case strings.EqualFold("Slots", t.Name.Local):
14552			val, err := decoder.Value()
14553			if err != nil {
14554				return err
14555			}
14556			if val == nil {
14557				break
14558			}
14559			{
14560				xtv := string(val)
14561				sv.Slots = ptr.String(xtv)
14562			}
14563
14564		default:
14565			// Do nothing and ignore the unexpected tag element
14566			err = decoder.Decoder.Skip()
14567			if err != nil {
14568				return err
14569			}
14570
14571		}
14572		decoder = originalDecoder
14573	}
14574	*v = sv
14575	return nil
14576}
14577
14578func awsAwsquery_deserializeDocumentGlobalNodeGroupList(v *[]types.GlobalNodeGroup, decoder smithyxml.NodeDecoder) error {
14579	if v == nil {
14580		return fmt.Errorf("unexpected nil of type %T", v)
14581	}
14582	var sv []types.GlobalNodeGroup
14583	if *v == nil {
14584		sv = make([]types.GlobalNodeGroup, 0)
14585	} else {
14586		sv = *v
14587	}
14588
14589	originalDecoder := decoder
14590	for {
14591		t, done, err := decoder.Token()
14592		if err != nil {
14593			return err
14594		}
14595		if done {
14596			break
14597		}
14598		switch {
14599		case strings.EqualFold("GlobalNodeGroup", t.Name.Local):
14600			var col types.GlobalNodeGroup
14601			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
14602			destAddr := &col
14603			if err := awsAwsquery_deserializeDocumentGlobalNodeGroup(&destAddr, nodeDecoder); err != nil {
14604				return err
14605			}
14606			col = *destAddr
14607			sv = append(sv, col)
14608
14609		default:
14610			err = decoder.Decoder.Skip()
14611			if err != nil {
14612				return err
14613			}
14614
14615		}
14616		decoder = originalDecoder
14617	}
14618	*v = sv
14619	return nil
14620}
14621
14622func awsAwsquery_deserializeDocumentGlobalNodeGroupListUnwrapped(v *[]types.GlobalNodeGroup, decoder smithyxml.NodeDecoder) error {
14623	var sv []types.GlobalNodeGroup
14624	if *v == nil {
14625		sv = make([]types.GlobalNodeGroup, 0)
14626	} else {
14627		sv = *v
14628	}
14629
14630	switch {
14631	default:
14632		var mv types.GlobalNodeGroup
14633		t := decoder.StartEl
14634		_ = t
14635		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
14636		destAddr := &mv
14637		if err := awsAwsquery_deserializeDocumentGlobalNodeGroup(&destAddr, nodeDecoder); err != nil {
14638			return err
14639		}
14640		mv = *destAddr
14641		sv = append(sv, mv)
14642	}
14643	*v = sv
14644	return nil
14645}
14646func awsAwsquery_deserializeDocumentGlobalReplicationGroup(v **types.GlobalReplicationGroup, decoder smithyxml.NodeDecoder) error {
14647	if v == nil {
14648		return fmt.Errorf("unexpected nil of type %T", v)
14649	}
14650	var sv *types.GlobalReplicationGroup
14651	if *v == nil {
14652		sv = &types.GlobalReplicationGroup{}
14653	} else {
14654		sv = *v
14655	}
14656
14657	for {
14658		t, done, err := decoder.Token()
14659		if err != nil {
14660			return err
14661		}
14662		if done {
14663			break
14664		}
14665		originalDecoder := decoder
14666		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
14667		switch {
14668		case strings.EqualFold("ARN", t.Name.Local):
14669			val, err := decoder.Value()
14670			if err != nil {
14671				return err
14672			}
14673			if val == nil {
14674				break
14675			}
14676			{
14677				xtv := string(val)
14678				sv.ARN = ptr.String(xtv)
14679			}
14680
14681		case strings.EqualFold("AtRestEncryptionEnabled", t.Name.Local):
14682			val, err := decoder.Value()
14683			if err != nil {
14684				return err
14685			}
14686			if val == nil {
14687				break
14688			}
14689			{
14690				xtv, err := strconv.ParseBool(string(val))
14691				if err != nil {
14692					return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", val)
14693				}
14694				sv.AtRestEncryptionEnabled = ptr.Bool(xtv)
14695			}
14696
14697		case strings.EqualFold("AuthTokenEnabled", t.Name.Local):
14698			val, err := decoder.Value()
14699			if err != nil {
14700				return err
14701			}
14702			if val == nil {
14703				break
14704			}
14705			{
14706				xtv, err := strconv.ParseBool(string(val))
14707				if err != nil {
14708					return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", val)
14709				}
14710				sv.AuthTokenEnabled = ptr.Bool(xtv)
14711			}
14712
14713		case strings.EqualFold("CacheNodeType", t.Name.Local):
14714			val, err := decoder.Value()
14715			if err != nil {
14716				return err
14717			}
14718			if val == nil {
14719				break
14720			}
14721			{
14722				xtv := string(val)
14723				sv.CacheNodeType = ptr.String(xtv)
14724			}
14725
14726		case strings.EqualFold("ClusterEnabled", t.Name.Local):
14727			val, err := decoder.Value()
14728			if err != nil {
14729				return err
14730			}
14731			if val == nil {
14732				break
14733			}
14734			{
14735				xtv, err := strconv.ParseBool(string(val))
14736				if err != nil {
14737					return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", val)
14738				}
14739				sv.ClusterEnabled = ptr.Bool(xtv)
14740			}
14741
14742		case strings.EqualFold("Engine", t.Name.Local):
14743			val, err := decoder.Value()
14744			if err != nil {
14745				return err
14746			}
14747			if val == nil {
14748				break
14749			}
14750			{
14751				xtv := string(val)
14752				sv.Engine = ptr.String(xtv)
14753			}
14754
14755		case strings.EqualFold("EngineVersion", t.Name.Local):
14756			val, err := decoder.Value()
14757			if err != nil {
14758				return err
14759			}
14760			if val == nil {
14761				break
14762			}
14763			{
14764				xtv := string(val)
14765				sv.EngineVersion = ptr.String(xtv)
14766			}
14767
14768		case strings.EqualFold("GlobalNodeGroups", t.Name.Local):
14769			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
14770			if err := awsAwsquery_deserializeDocumentGlobalNodeGroupList(&sv.GlobalNodeGroups, nodeDecoder); err != nil {
14771				return err
14772			}
14773
14774		case strings.EqualFold("GlobalReplicationGroupDescription", t.Name.Local):
14775			val, err := decoder.Value()
14776			if err != nil {
14777				return err
14778			}
14779			if val == nil {
14780				break
14781			}
14782			{
14783				xtv := string(val)
14784				sv.GlobalReplicationGroupDescription = ptr.String(xtv)
14785			}
14786
14787		case strings.EqualFold("GlobalReplicationGroupId", t.Name.Local):
14788			val, err := decoder.Value()
14789			if err != nil {
14790				return err
14791			}
14792			if val == nil {
14793				break
14794			}
14795			{
14796				xtv := string(val)
14797				sv.GlobalReplicationGroupId = ptr.String(xtv)
14798			}
14799
14800		case strings.EqualFold("Members", t.Name.Local):
14801			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
14802			if err := awsAwsquery_deserializeDocumentGlobalReplicationGroupMemberList(&sv.Members, nodeDecoder); err != nil {
14803				return err
14804			}
14805
14806		case strings.EqualFold("Status", t.Name.Local):
14807			val, err := decoder.Value()
14808			if err != nil {
14809				return err
14810			}
14811			if val == nil {
14812				break
14813			}
14814			{
14815				xtv := string(val)
14816				sv.Status = ptr.String(xtv)
14817			}
14818
14819		case strings.EqualFold("TransitEncryptionEnabled", t.Name.Local):
14820			val, err := decoder.Value()
14821			if err != nil {
14822				return err
14823			}
14824			if val == nil {
14825				break
14826			}
14827			{
14828				xtv, err := strconv.ParseBool(string(val))
14829				if err != nil {
14830					return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", val)
14831				}
14832				sv.TransitEncryptionEnabled = ptr.Bool(xtv)
14833			}
14834
14835		default:
14836			// Do nothing and ignore the unexpected tag element
14837			err = decoder.Decoder.Skip()
14838			if err != nil {
14839				return err
14840			}
14841
14842		}
14843		decoder = originalDecoder
14844	}
14845	*v = sv
14846	return nil
14847}
14848
14849func awsAwsquery_deserializeDocumentGlobalReplicationGroupAlreadyExistsFault(v **types.GlobalReplicationGroupAlreadyExistsFault, decoder smithyxml.NodeDecoder) error {
14850	if v == nil {
14851		return fmt.Errorf("unexpected nil of type %T", v)
14852	}
14853	var sv *types.GlobalReplicationGroupAlreadyExistsFault
14854	if *v == nil {
14855		sv = &types.GlobalReplicationGroupAlreadyExistsFault{}
14856	} else {
14857		sv = *v
14858	}
14859
14860	for {
14861		t, done, err := decoder.Token()
14862		if err != nil {
14863			return err
14864		}
14865		if done {
14866			break
14867		}
14868		originalDecoder := decoder
14869		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
14870		switch {
14871		case strings.EqualFold("message", t.Name.Local):
14872			val, err := decoder.Value()
14873			if err != nil {
14874				return err
14875			}
14876			if val == nil {
14877				break
14878			}
14879			{
14880				xtv := string(val)
14881				sv.Message = ptr.String(xtv)
14882			}
14883
14884		default:
14885			// Do nothing and ignore the unexpected tag element
14886			err = decoder.Decoder.Skip()
14887			if err != nil {
14888				return err
14889			}
14890
14891		}
14892		decoder = originalDecoder
14893	}
14894	*v = sv
14895	return nil
14896}
14897
14898func awsAwsquery_deserializeDocumentGlobalReplicationGroupInfo(v **types.GlobalReplicationGroupInfo, decoder smithyxml.NodeDecoder) error {
14899	if v == nil {
14900		return fmt.Errorf("unexpected nil of type %T", v)
14901	}
14902	var sv *types.GlobalReplicationGroupInfo
14903	if *v == nil {
14904		sv = &types.GlobalReplicationGroupInfo{}
14905	} else {
14906		sv = *v
14907	}
14908
14909	for {
14910		t, done, err := decoder.Token()
14911		if err != nil {
14912			return err
14913		}
14914		if done {
14915			break
14916		}
14917		originalDecoder := decoder
14918		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
14919		switch {
14920		case strings.EqualFold("GlobalReplicationGroupId", t.Name.Local):
14921			val, err := decoder.Value()
14922			if err != nil {
14923				return err
14924			}
14925			if val == nil {
14926				break
14927			}
14928			{
14929				xtv := string(val)
14930				sv.GlobalReplicationGroupId = ptr.String(xtv)
14931			}
14932
14933		case strings.EqualFold("GlobalReplicationGroupMemberRole", t.Name.Local):
14934			val, err := decoder.Value()
14935			if err != nil {
14936				return err
14937			}
14938			if val == nil {
14939				break
14940			}
14941			{
14942				xtv := string(val)
14943				sv.GlobalReplicationGroupMemberRole = ptr.String(xtv)
14944			}
14945
14946		default:
14947			// Do nothing and ignore the unexpected tag element
14948			err = decoder.Decoder.Skip()
14949			if err != nil {
14950				return err
14951			}
14952
14953		}
14954		decoder = originalDecoder
14955	}
14956	*v = sv
14957	return nil
14958}
14959
14960func awsAwsquery_deserializeDocumentGlobalReplicationGroupList(v *[]types.GlobalReplicationGroup, decoder smithyxml.NodeDecoder) error {
14961	if v == nil {
14962		return fmt.Errorf("unexpected nil of type %T", v)
14963	}
14964	var sv []types.GlobalReplicationGroup
14965	if *v == nil {
14966		sv = make([]types.GlobalReplicationGroup, 0)
14967	} else {
14968		sv = *v
14969	}
14970
14971	originalDecoder := decoder
14972	for {
14973		t, done, err := decoder.Token()
14974		if err != nil {
14975			return err
14976		}
14977		if done {
14978			break
14979		}
14980		switch {
14981		case strings.EqualFold("GlobalReplicationGroup", t.Name.Local):
14982			var col types.GlobalReplicationGroup
14983			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
14984			destAddr := &col
14985			if err := awsAwsquery_deserializeDocumentGlobalReplicationGroup(&destAddr, nodeDecoder); err != nil {
14986				return err
14987			}
14988			col = *destAddr
14989			sv = append(sv, col)
14990
14991		default:
14992			err = decoder.Decoder.Skip()
14993			if err != nil {
14994				return err
14995			}
14996
14997		}
14998		decoder = originalDecoder
14999	}
15000	*v = sv
15001	return nil
15002}
15003
15004func awsAwsquery_deserializeDocumentGlobalReplicationGroupListUnwrapped(v *[]types.GlobalReplicationGroup, decoder smithyxml.NodeDecoder) error {
15005	var sv []types.GlobalReplicationGroup
15006	if *v == nil {
15007		sv = make([]types.GlobalReplicationGroup, 0)
15008	} else {
15009		sv = *v
15010	}
15011
15012	switch {
15013	default:
15014		var mv types.GlobalReplicationGroup
15015		t := decoder.StartEl
15016		_ = t
15017		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
15018		destAddr := &mv
15019		if err := awsAwsquery_deserializeDocumentGlobalReplicationGroup(&destAddr, nodeDecoder); err != nil {
15020			return err
15021		}
15022		mv = *destAddr
15023		sv = append(sv, mv)
15024	}
15025	*v = sv
15026	return nil
15027}
15028func awsAwsquery_deserializeDocumentGlobalReplicationGroupMember(v **types.GlobalReplicationGroupMember, decoder smithyxml.NodeDecoder) error {
15029	if v == nil {
15030		return fmt.Errorf("unexpected nil of type %T", v)
15031	}
15032	var sv *types.GlobalReplicationGroupMember
15033	if *v == nil {
15034		sv = &types.GlobalReplicationGroupMember{}
15035	} else {
15036		sv = *v
15037	}
15038
15039	for {
15040		t, done, err := decoder.Token()
15041		if err != nil {
15042			return err
15043		}
15044		if done {
15045			break
15046		}
15047		originalDecoder := decoder
15048		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15049		switch {
15050		case strings.EqualFold("AutomaticFailover", t.Name.Local):
15051			val, err := decoder.Value()
15052			if err != nil {
15053				return err
15054			}
15055			if val == nil {
15056				break
15057			}
15058			{
15059				xtv := string(val)
15060				sv.AutomaticFailover = types.AutomaticFailoverStatus(xtv)
15061			}
15062
15063		case strings.EqualFold("ReplicationGroupId", t.Name.Local):
15064			val, err := decoder.Value()
15065			if err != nil {
15066				return err
15067			}
15068			if val == nil {
15069				break
15070			}
15071			{
15072				xtv := string(val)
15073				sv.ReplicationGroupId = ptr.String(xtv)
15074			}
15075
15076		case strings.EqualFold("ReplicationGroupRegion", t.Name.Local):
15077			val, err := decoder.Value()
15078			if err != nil {
15079				return err
15080			}
15081			if val == nil {
15082				break
15083			}
15084			{
15085				xtv := string(val)
15086				sv.ReplicationGroupRegion = ptr.String(xtv)
15087			}
15088
15089		case strings.EqualFold("Role", t.Name.Local):
15090			val, err := decoder.Value()
15091			if err != nil {
15092				return err
15093			}
15094			if val == nil {
15095				break
15096			}
15097			{
15098				xtv := string(val)
15099				sv.Role = ptr.String(xtv)
15100			}
15101
15102		case strings.EqualFold("Status", t.Name.Local):
15103			val, err := decoder.Value()
15104			if err != nil {
15105				return err
15106			}
15107			if val == nil {
15108				break
15109			}
15110			{
15111				xtv := string(val)
15112				sv.Status = ptr.String(xtv)
15113			}
15114
15115		default:
15116			// Do nothing and ignore the unexpected tag element
15117			err = decoder.Decoder.Skip()
15118			if err != nil {
15119				return err
15120			}
15121
15122		}
15123		decoder = originalDecoder
15124	}
15125	*v = sv
15126	return nil
15127}
15128
15129func awsAwsquery_deserializeDocumentGlobalReplicationGroupMemberList(v *[]types.GlobalReplicationGroupMember, decoder smithyxml.NodeDecoder) error {
15130	if v == nil {
15131		return fmt.Errorf("unexpected nil of type %T", v)
15132	}
15133	var sv []types.GlobalReplicationGroupMember
15134	if *v == nil {
15135		sv = make([]types.GlobalReplicationGroupMember, 0)
15136	} else {
15137		sv = *v
15138	}
15139
15140	originalDecoder := decoder
15141	for {
15142		t, done, err := decoder.Token()
15143		if err != nil {
15144			return err
15145		}
15146		if done {
15147			break
15148		}
15149		switch {
15150		case strings.EqualFold("GlobalReplicationGroupMember", t.Name.Local):
15151			var col types.GlobalReplicationGroupMember
15152			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
15153			destAddr := &col
15154			if err := awsAwsquery_deserializeDocumentGlobalReplicationGroupMember(&destAddr, nodeDecoder); err != nil {
15155				return err
15156			}
15157			col = *destAddr
15158			sv = append(sv, col)
15159
15160		default:
15161			err = decoder.Decoder.Skip()
15162			if err != nil {
15163				return err
15164			}
15165
15166		}
15167		decoder = originalDecoder
15168	}
15169	*v = sv
15170	return nil
15171}
15172
15173func awsAwsquery_deserializeDocumentGlobalReplicationGroupMemberListUnwrapped(v *[]types.GlobalReplicationGroupMember, decoder smithyxml.NodeDecoder) error {
15174	var sv []types.GlobalReplicationGroupMember
15175	if *v == nil {
15176		sv = make([]types.GlobalReplicationGroupMember, 0)
15177	} else {
15178		sv = *v
15179	}
15180
15181	switch {
15182	default:
15183		var mv types.GlobalReplicationGroupMember
15184		t := decoder.StartEl
15185		_ = t
15186		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
15187		destAddr := &mv
15188		if err := awsAwsquery_deserializeDocumentGlobalReplicationGroupMember(&destAddr, nodeDecoder); err != nil {
15189			return err
15190		}
15191		mv = *destAddr
15192		sv = append(sv, mv)
15193	}
15194	*v = sv
15195	return nil
15196}
15197func awsAwsquery_deserializeDocumentGlobalReplicationGroupNotFoundFault(v **types.GlobalReplicationGroupNotFoundFault, decoder smithyxml.NodeDecoder) error {
15198	if v == nil {
15199		return fmt.Errorf("unexpected nil of type %T", v)
15200	}
15201	var sv *types.GlobalReplicationGroupNotFoundFault
15202	if *v == nil {
15203		sv = &types.GlobalReplicationGroupNotFoundFault{}
15204	} else {
15205		sv = *v
15206	}
15207
15208	for {
15209		t, done, err := decoder.Token()
15210		if err != nil {
15211			return err
15212		}
15213		if done {
15214			break
15215		}
15216		originalDecoder := decoder
15217		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15218		switch {
15219		case strings.EqualFold("message", t.Name.Local):
15220			val, err := decoder.Value()
15221			if err != nil {
15222				return err
15223			}
15224			if val == nil {
15225				break
15226			}
15227			{
15228				xtv := string(val)
15229				sv.Message = ptr.String(xtv)
15230			}
15231
15232		default:
15233			// Do nothing and ignore the unexpected tag element
15234			err = decoder.Decoder.Skip()
15235			if err != nil {
15236				return err
15237			}
15238
15239		}
15240		decoder = originalDecoder
15241	}
15242	*v = sv
15243	return nil
15244}
15245
15246func awsAwsquery_deserializeDocumentInsufficientCacheClusterCapacityFault(v **types.InsufficientCacheClusterCapacityFault, decoder smithyxml.NodeDecoder) error {
15247	if v == nil {
15248		return fmt.Errorf("unexpected nil of type %T", v)
15249	}
15250	var sv *types.InsufficientCacheClusterCapacityFault
15251	if *v == nil {
15252		sv = &types.InsufficientCacheClusterCapacityFault{}
15253	} else {
15254		sv = *v
15255	}
15256
15257	for {
15258		t, done, err := decoder.Token()
15259		if err != nil {
15260			return err
15261		}
15262		if done {
15263			break
15264		}
15265		originalDecoder := decoder
15266		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15267		switch {
15268		case strings.EqualFold("message", t.Name.Local):
15269			val, err := decoder.Value()
15270			if err != nil {
15271				return err
15272			}
15273			if val == nil {
15274				break
15275			}
15276			{
15277				xtv := string(val)
15278				sv.Message = ptr.String(xtv)
15279			}
15280
15281		default:
15282			// Do nothing and ignore the unexpected tag element
15283			err = decoder.Decoder.Skip()
15284			if err != nil {
15285				return err
15286			}
15287
15288		}
15289		decoder = originalDecoder
15290	}
15291	*v = sv
15292	return nil
15293}
15294
15295func awsAwsquery_deserializeDocumentInvalidARNFault(v **types.InvalidARNFault, decoder smithyxml.NodeDecoder) error {
15296	if v == nil {
15297		return fmt.Errorf("unexpected nil of type %T", v)
15298	}
15299	var sv *types.InvalidARNFault
15300	if *v == nil {
15301		sv = &types.InvalidARNFault{}
15302	} else {
15303		sv = *v
15304	}
15305
15306	for {
15307		t, done, err := decoder.Token()
15308		if err != nil {
15309			return err
15310		}
15311		if done {
15312			break
15313		}
15314		originalDecoder := decoder
15315		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15316		switch {
15317		case strings.EqualFold("message", t.Name.Local):
15318			val, err := decoder.Value()
15319			if err != nil {
15320				return err
15321			}
15322			if val == nil {
15323				break
15324			}
15325			{
15326				xtv := string(val)
15327				sv.Message = ptr.String(xtv)
15328			}
15329
15330		default:
15331			// Do nothing and ignore the unexpected tag element
15332			err = decoder.Decoder.Skip()
15333			if err != nil {
15334				return err
15335			}
15336
15337		}
15338		decoder = originalDecoder
15339	}
15340	*v = sv
15341	return nil
15342}
15343
15344func awsAwsquery_deserializeDocumentInvalidCacheClusterStateFault(v **types.InvalidCacheClusterStateFault, decoder smithyxml.NodeDecoder) error {
15345	if v == nil {
15346		return fmt.Errorf("unexpected nil of type %T", v)
15347	}
15348	var sv *types.InvalidCacheClusterStateFault
15349	if *v == nil {
15350		sv = &types.InvalidCacheClusterStateFault{}
15351	} else {
15352		sv = *v
15353	}
15354
15355	for {
15356		t, done, err := decoder.Token()
15357		if err != nil {
15358			return err
15359		}
15360		if done {
15361			break
15362		}
15363		originalDecoder := decoder
15364		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15365		switch {
15366		case strings.EqualFold("message", t.Name.Local):
15367			val, err := decoder.Value()
15368			if err != nil {
15369				return err
15370			}
15371			if val == nil {
15372				break
15373			}
15374			{
15375				xtv := string(val)
15376				sv.Message = ptr.String(xtv)
15377			}
15378
15379		default:
15380			// Do nothing and ignore the unexpected tag element
15381			err = decoder.Decoder.Skip()
15382			if err != nil {
15383				return err
15384			}
15385
15386		}
15387		decoder = originalDecoder
15388	}
15389	*v = sv
15390	return nil
15391}
15392
15393func awsAwsquery_deserializeDocumentInvalidCacheParameterGroupStateFault(v **types.InvalidCacheParameterGroupStateFault, decoder smithyxml.NodeDecoder) error {
15394	if v == nil {
15395		return fmt.Errorf("unexpected nil of type %T", v)
15396	}
15397	var sv *types.InvalidCacheParameterGroupStateFault
15398	if *v == nil {
15399		sv = &types.InvalidCacheParameterGroupStateFault{}
15400	} else {
15401		sv = *v
15402	}
15403
15404	for {
15405		t, done, err := decoder.Token()
15406		if err != nil {
15407			return err
15408		}
15409		if done {
15410			break
15411		}
15412		originalDecoder := decoder
15413		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15414		switch {
15415		case strings.EqualFold("message", t.Name.Local):
15416			val, err := decoder.Value()
15417			if err != nil {
15418				return err
15419			}
15420			if val == nil {
15421				break
15422			}
15423			{
15424				xtv := string(val)
15425				sv.Message = ptr.String(xtv)
15426			}
15427
15428		default:
15429			// Do nothing and ignore the unexpected tag element
15430			err = decoder.Decoder.Skip()
15431			if err != nil {
15432				return err
15433			}
15434
15435		}
15436		decoder = originalDecoder
15437	}
15438	*v = sv
15439	return nil
15440}
15441
15442func awsAwsquery_deserializeDocumentInvalidCacheSecurityGroupStateFault(v **types.InvalidCacheSecurityGroupStateFault, decoder smithyxml.NodeDecoder) error {
15443	if v == nil {
15444		return fmt.Errorf("unexpected nil of type %T", v)
15445	}
15446	var sv *types.InvalidCacheSecurityGroupStateFault
15447	if *v == nil {
15448		sv = &types.InvalidCacheSecurityGroupStateFault{}
15449	} else {
15450		sv = *v
15451	}
15452
15453	for {
15454		t, done, err := decoder.Token()
15455		if err != nil {
15456			return err
15457		}
15458		if done {
15459			break
15460		}
15461		originalDecoder := decoder
15462		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15463		switch {
15464		case strings.EqualFold("message", t.Name.Local):
15465			val, err := decoder.Value()
15466			if err != nil {
15467				return err
15468			}
15469			if val == nil {
15470				break
15471			}
15472			{
15473				xtv := string(val)
15474				sv.Message = ptr.String(xtv)
15475			}
15476
15477		default:
15478			// Do nothing and ignore the unexpected tag element
15479			err = decoder.Decoder.Skip()
15480			if err != nil {
15481				return err
15482			}
15483
15484		}
15485		decoder = originalDecoder
15486	}
15487	*v = sv
15488	return nil
15489}
15490
15491func awsAwsquery_deserializeDocumentInvalidGlobalReplicationGroupStateFault(v **types.InvalidGlobalReplicationGroupStateFault, decoder smithyxml.NodeDecoder) error {
15492	if v == nil {
15493		return fmt.Errorf("unexpected nil of type %T", v)
15494	}
15495	var sv *types.InvalidGlobalReplicationGroupStateFault
15496	if *v == nil {
15497		sv = &types.InvalidGlobalReplicationGroupStateFault{}
15498	} else {
15499		sv = *v
15500	}
15501
15502	for {
15503		t, done, err := decoder.Token()
15504		if err != nil {
15505			return err
15506		}
15507		if done {
15508			break
15509		}
15510		originalDecoder := decoder
15511		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15512		switch {
15513		case strings.EqualFold("message", t.Name.Local):
15514			val, err := decoder.Value()
15515			if err != nil {
15516				return err
15517			}
15518			if val == nil {
15519				break
15520			}
15521			{
15522				xtv := string(val)
15523				sv.Message = ptr.String(xtv)
15524			}
15525
15526		default:
15527			// Do nothing and ignore the unexpected tag element
15528			err = decoder.Decoder.Skip()
15529			if err != nil {
15530				return err
15531			}
15532
15533		}
15534		decoder = originalDecoder
15535	}
15536	*v = sv
15537	return nil
15538}
15539
15540func awsAwsquery_deserializeDocumentInvalidKMSKeyFault(v **types.InvalidKMSKeyFault, decoder smithyxml.NodeDecoder) error {
15541	if v == nil {
15542		return fmt.Errorf("unexpected nil of type %T", v)
15543	}
15544	var sv *types.InvalidKMSKeyFault
15545	if *v == nil {
15546		sv = &types.InvalidKMSKeyFault{}
15547	} else {
15548		sv = *v
15549	}
15550
15551	for {
15552		t, done, err := decoder.Token()
15553		if err != nil {
15554			return err
15555		}
15556		if done {
15557			break
15558		}
15559		originalDecoder := decoder
15560		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15561		switch {
15562		case strings.EqualFold("message", t.Name.Local):
15563			val, err := decoder.Value()
15564			if err != nil {
15565				return err
15566			}
15567			if val == nil {
15568				break
15569			}
15570			{
15571				xtv := string(val)
15572				sv.Message = ptr.String(xtv)
15573			}
15574
15575		default:
15576			// Do nothing and ignore the unexpected tag element
15577			err = decoder.Decoder.Skip()
15578			if err != nil {
15579				return err
15580			}
15581
15582		}
15583		decoder = originalDecoder
15584	}
15585	*v = sv
15586	return nil
15587}
15588
15589func awsAwsquery_deserializeDocumentInvalidParameterCombinationException(v **types.InvalidParameterCombinationException, decoder smithyxml.NodeDecoder) error {
15590	if v == nil {
15591		return fmt.Errorf("unexpected nil of type %T", v)
15592	}
15593	var sv *types.InvalidParameterCombinationException
15594	if *v == nil {
15595		sv = &types.InvalidParameterCombinationException{}
15596	} else {
15597		sv = *v
15598	}
15599
15600	for {
15601		t, done, err := decoder.Token()
15602		if err != nil {
15603			return err
15604		}
15605		if done {
15606			break
15607		}
15608		originalDecoder := decoder
15609		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15610		switch {
15611		case strings.EqualFold("message", t.Name.Local):
15612			val, err := decoder.Value()
15613			if err != nil {
15614				return err
15615			}
15616			if val == nil {
15617				break
15618			}
15619			{
15620				xtv := string(val)
15621				sv.Message = ptr.String(xtv)
15622			}
15623
15624		default:
15625			// Do nothing and ignore the unexpected tag element
15626			err = decoder.Decoder.Skip()
15627			if err != nil {
15628				return err
15629			}
15630
15631		}
15632		decoder = originalDecoder
15633	}
15634	*v = sv
15635	return nil
15636}
15637
15638func awsAwsquery_deserializeDocumentInvalidParameterValueException(v **types.InvalidParameterValueException, decoder smithyxml.NodeDecoder) error {
15639	if v == nil {
15640		return fmt.Errorf("unexpected nil of type %T", v)
15641	}
15642	var sv *types.InvalidParameterValueException
15643	if *v == nil {
15644		sv = &types.InvalidParameterValueException{}
15645	} else {
15646		sv = *v
15647	}
15648
15649	for {
15650		t, done, err := decoder.Token()
15651		if err != nil {
15652			return err
15653		}
15654		if done {
15655			break
15656		}
15657		originalDecoder := decoder
15658		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15659		switch {
15660		case strings.EqualFold("message", t.Name.Local):
15661			val, err := decoder.Value()
15662			if err != nil {
15663				return err
15664			}
15665			if val == nil {
15666				break
15667			}
15668			{
15669				xtv := string(val)
15670				sv.Message = ptr.String(xtv)
15671			}
15672
15673		default:
15674			// Do nothing and ignore the unexpected tag element
15675			err = decoder.Decoder.Skip()
15676			if err != nil {
15677				return err
15678			}
15679
15680		}
15681		decoder = originalDecoder
15682	}
15683	*v = sv
15684	return nil
15685}
15686
15687func awsAwsquery_deserializeDocumentInvalidReplicationGroupStateFault(v **types.InvalidReplicationGroupStateFault, decoder smithyxml.NodeDecoder) error {
15688	if v == nil {
15689		return fmt.Errorf("unexpected nil of type %T", v)
15690	}
15691	var sv *types.InvalidReplicationGroupStateFault
15692	if *v == nil {
15693		sv = &types.InvalidReplicationGroupStateFault{}
15694	} else {
15695		sv = *v
15696	}
15697
15698	for {
15699		t, done, err := decoder.Token()
15700		if err != nil {
15701			return err
15702		}
15703		if done {
15704			break
15705		}
15706		originalDecoder := decoder
15707		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15708		switch {
15709		case strings.EqualFold("message", t.Name.Local):
15710			val, err := decoder.Value()
15711			if err != nil {
15712				return err
15713			}
15714			if val == nil {
15715				break
15716			}
15717			{
15718				xtv := string(val)
15719				sv.Message = ptr.String(xtv)
15720			}
15721
15722		default:
15723			// Do nothing and ignore the unexpected tag element
15724			err = decoder.Decoder.Skip()
15725			if err != nil {
15726				return err
15727			}
15728
15729		}
15730		decoder = originalDecoder
15731	}
15732	*v = sv
15733	return nil
15734}
15735
15736func awsAwsquery_deserializeDocumentInvalidSnapshotStateFault(v **types.InvalidSnapshotStateFault, decoder smithyxml.NodeDecoder) error {
15737	if v == nil {
15738		return fmt.Errorf("unexpected nil of type %T", v)
15739	}
15740	var sv *types.InvalidSnapshotStateFault
15741	if *v == nil {
15742		sv = &types.InvalidSnapshotStateFault{}
15743	} else {
15744		sv = *v
15745	}
15746
15747	for {
15748		t, done, err := decoder.Token()
15749		if err != nil {
15750			return err
15751		}
15752		if done {
15753			break
15754		}
15755		originalDecoder := decoder
15756		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15757		switch {
15758		case strings.EqualFold("message", t.Name.Local):
15759			val, err := decoder.Value()
15760			if err != nil {
15761				return err
15762			}
15763			if val == nil {
15764				break
15765			}
15766			{
15767				xtv := string(val)
15768				sv.Message = ptr.String(xtv)
15769			}
15770
15771		default:
15772			// Do nothing and ignore the unexpected tag element
15773			err = decoder.Decoder.Skip()
15774			if err != nil {
15775				return err
15776			}
15777
15778		}
15779		decoder = originalDecoder
15780	}
15781	*v = sv
15782	return nil
15783}
15784
15785func awsAwsquery_deserializeDocumentInvalidSubnet(v **types.InvalidSubnet, decoder smithyxml.NodeDecoder) error {
15786	if v == nil {
15787		return fmt.Errorf("unexpected nil of type %T", v)
15788	}
15789	var sv *types.InvalidSubnet
15790	if *v == nil {
15791		sv = &types.InvalidSubnet{}
15792	} else {
15793		sv = *v
15794	}
15795
15796	for {
15797		t, done, err := decoder.Token()
15798		if err != nil {
15799			return err
15800		}
15801		if done {
15802			break
15803		}
15804		originalDecoder := decoder
15805		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15806		switch {
15807		case strings.EqualFold("message", t.Name.Local):
15808			val, err := decoder.Value()
15809			if err != nil {
15810				return err
15811			}
15812			if val == nil {
15813				break
15814			}
15815			{
15816				xtv := string(val)
15817				sv.Message = ptr.String(xtv)
15818			}
15819
15820		default:
15821			// Do nothing and ignore the unexpected tag element
15822			err = decoder.Decoder.Skip()
15823			if err != nil {
15824				return err
15825			}
15826
15827		}
15828		decoder = originalDecoder
15829	}
15830	*v = sv
15831	return nil
15832}
15833
15834func awsAwsquery_deserializeDocumentInvalidUserGroupStateFault(v **types.InvalidUserGroupStateFault, decoder smithyxml.NodeDecoder) error {
15835	if v == nil {
15836		return fmt.Errorf("unexpected nil of type %T", v)
15837	}
15838	var sv *types.InvalidUserGroupStateFault
15839	if *v == nil {
15840		sv = &types.InvalidUserGroupStateFault{}
15841	} else {
15842		sv = *v
15843	}
15844
15845	for {
15846		t, done, err := decoder.Token()
15847		if err != nil {
15848			return err
15849		}
15850		if done {
15851			break
15852		}
15853		originalDecoder := decoder
15854		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15855		switch {
15856		case strings.EqualFold("message", t.Name.Local):
15857			val, err := decoder.Value()
15858			if err != nil {
15859				return err
15860			}
15861			if val == nil {
15862				break
15863			}
15864			{
15865				xtv := string(val)
15866				sv.Message = ptr.String(xtv)
15867			}
15868
15869		default:
15870			// Do nothing and ignore the unexpected tag element
15871			err = decoder.Decoder.Skip()
15872			if err != nil {
15873				return err
15874			}
15875
15876		}
15877		decoder = originalDecoder
15878	}
15879	*v = sv
15880	return nil
15881}
15882
15883func awsAwsquery_deserializeDocumentInvalidUserStateFault(v **types.InvalidUserStateFault, decoder smithyxml.NodeDecoder) error {
15884	if v == nil {
15885		return fmt.Errorf("unexpected nil of type %T", v)
15886	}
15887	var sv *types.InvalidUserStateFault
15888	if *v == nil {
15889		sv = &types.InvalidUserStateFault{}
15890	} else {
15891		sv = *v
15892	}
15893
15894	for {
15895		t, done, err := decoder.Token()
15896		if err != nil {
15897			return err
15898		}
15899		if done {
15900			break
15901		}
15902		originalDecoder := decoder
15903		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15904		switch {
15905		case strings.EqualFold("message", t.Name.Local):
15906			val, err := decoder.Value()
15907			if err != nil {
15908				return err
15909			}
15910			if val == nil {
15911				break
15912			}
15913			{
15914				xtv := string(val)
15915				sv.Message = ptr.String(xtv)
15916			}
15917
15918		default:
15919			// Do nothing and ignore the unexpected tag element
15920			err = decoder.Decoder.Skip()
15921			if err != nil {
15922				return err
15923			}
15924
15925		}
15926		decoder = originalDecoder
15927	}
15928	*v = sv
15929	return nil
15930}
15931
15932func awsAwsquery_deserializeDocumentInvalidVPCNetworkStateFault(v **types.InvalidVPCNetworkStateFault, decoder smithyxml.NodeDecoder) error {
15933	if v == nil {
15934		return fmt.Errorf("unexpected nil of type %T", v)
15935	}
15936	var sv *types.InvalidVPCNetworkStateFault
15937	if *v == nil {
15938		sv = &types.InvalidVPCNetworkStateFault{}
15939	} else {
15940		sv = *v
15941	}
15942
15943	for {
15944		t, done, err := decoder.Token()
15945		if err != nil {
15946			return err
15947		}
15948		if done {
15949			break
15950		}
15951		originalDecoder := decoder
15952		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
15953		switch {
15954		case strings.EqualFold("message", t.Name.Local):
15955			val, err := decoder.Value()
15956			if err != nil {
15957				return err
15958			}
15959			if val == nil {
15960				break
15961			}
15962			{
15963				xtv := string(val)
15964				sv.Message = ptr.String(xtv)
15965			}
15966
15967		default:
15968			// Do nothing and ignore the unexpected tag element
15969			err = decoder.Decoder.Skip()
15970			if err != nil {
15971				return err
15972			}
15973
15974		}
15975		decoder = originalDecoder
15976	}
15977	*v = sv
15978	return nil
15979}
15980
15981func awsAwsquery_deserializeDocumentNodeGroup(v **types.NodeGroup, decoder smithyxml.NodeDecoder) error {
15982	if v == nil {
15983		return fmt.Errorf("unexpected nil of type %T", v)
15984	}
15985	var sv *types.NodeGroup
15986	if *v == nil {
15987		sv = &types.NodeGroup{}
15988	} else {
15989		sv = *v
15990	}
15991
15992	for {
15993		t, done, err := decoder.Token()
15994		if err != nil {
15995			return err
15996		}
15997		if done {
15998			break
15999		}
16000		originalDecoder := decoder
16001		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
16002		switch {
16003		case strings.EqualFold("NodeGroupId", t.Name.Local):
16004			val, err := decoder.Value()
16005			if err != nil {
16006				return err
16007			}
16008			if val == nil {
16009				break
16010			}
16011			{
16012				xtv := string(val)
16013				sv.NodeGroupId = ptr.String(xtv)
16014			}
16015
16016		case strings.EqualFold("NodeGroupMembers", t.Name.Local):
16017			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16018			if err := awsAwsquery_deserializeDocumentNodeGroupMemberList(&sv.NodeGroupMembers, nodeDecoder); err != nil {
16019				return err
16020			}
16021
16022		case strings.EqualFold("PrimaryEndpoint", t.Name.Local):
16023			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16024			if err := awsAwsquery_deserializeDocumentEndpoint(&sv.PrimaryEndpoint, nodeDecoder); err != nil {
16025				return err
16026			}
16027
16028		case strings.EqualFold("ReaderEndpoint", t.Name.Local):
16029			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16030			if err := awsAwsquery_deserializeDocumentEndpoint(&sv.ReaderEndpoint, nodeDecoder); err != nil {
16031				return err
16032			}
16033
16034		case strings.EqualFold("Slots", t.Name.Local):
16035			val, err := decoder.Value()
16036			if err != nil {
16037				return err
16038			}
16039			if val == nil {
16040				break
16041			}
16042			{
16043				xtv := string(val)
16044				sv.Slots = ptr.String(xtv)
16045			}
16046
16047		case strings.EqualFold("Status", t.Name.Local):
16048			val, err := decoder.Value()
16049			if err != nil {
16050				return err
16051			}
16052			if val == nil {
16053				break
16054			}
16055			{
16056				xtv := string(val)
16057				sv.Status = ptr.String(xtv)
16058			}
16059
16060		default:
16061			// Do nothing and ignore the unexpected tag element
16062			err = decoder.Decoder.Skip()
16063			if err != nil {
16064				return err
16065			}
16066
16067		}
16068		decoder = originalDecoder
16069	}
16070	*v = sv
16071	return nil
16072}
16073
16074func awsAwsquery_deserializeDocumentNodeGroupConfiguration(v **types.NodeGroupConfiguration, decoder smithyxml.NodeDecoder) error {
16075	if v == nil {
16076		return fmt.Errorf("unexpected nil of type %T", v)
16077	}
16078	var sv *types.NodeGroupConfiguration
16079	if *v == nil {
16080		sv = &types.NodeGroupConfiguration{}
16081	} else {
16082		sv = *v
16083	}
16084
16085	for {
16086		t, done, err := decoder.Token()
16087		if err != nil {
16088			return err
16089		}
16090		if done {
16091			break
16092		}
16093		originalDecoder := decoder
16094		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
16095		switch {
16096		case strings.EqualFold("NodeGroupId", t.Name.Local):
16097			val, err := decoder.Value()
16098			if err != nil {
16099				return err
16100			}
16101			if val == nil {
16102				break
16103			}
16104			{
16105				xtv := string(val)
16106				sv.NodeGroupId = ptr.String(xtv)
16107			}
16108
16109		case strings.EqualFold("PrimaryAvailabilityZone", t.Name.Local):
16110			val, err := decoder.Value()
16111			if err != nil {
16112				return err
16113			}
16114			if val == nil {
16115				break
16116			}
16117			{
16118				xtv := string(val)
16119				sv.PrimaryAvailabilityZone = ptr.String(xtv)
16120			}
16121
16122		case strings.EqualFold("PrimaryOutpostArn", t.Name.Local):
16123			val, err := decoder.Value()
16124			if err != nil {
16125				return err
16126			}
16127			if val == nil {
16128				break
16129			}
16130			{
16131				xtv := string(val)
16132				sv.PrimaryOutpostArn = ptr.String(xtv)
16133			}
16134
16135		case strings.EqualFold("ReplicaAvailabilityZones", t.Name.Local):
16136			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16137			if err := awsAwsquery_deserializeDocumentAvailabilityZonesList(&sv.ReplicaAvailabilityZones, nodeDecoder); err != nil {
16138				return err
16139			}
16140
16141		case strings.EqualFold("ReplicaCount", t.Name.Local):
16142			val, err := decoder.Value()
16143			if err != nil {
16144				return err
16145			}
16146			if val == nil {
16147				break
16148			}
16149			{
16150				xtv := string(val)
16151				i64, err := strconv.ParseInt(xtv, 10, 64)
16152				if err != nil {
16153					return err
16154				}
16155				sv.ReplicaCount = ptr.Int32(int32(i64))
16156			}
16157
16158		case strings.EqualFold("ReplicaOutpostArns", t.Name.Local):
16159			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16160			if err := awsAwsquery_deserializeDocumentOutpostArnsList(&sv.ReplicaOutpostArns, nodeDecoder); err != nil {
16161				return err
16162			}
16163
16164		case strings.EqualFold("Slots", t.Name.Local):
16165			val, err := decoder.Value()
16166			if err != nil {
16167				return err
16168			}
16169			if val == nil {
16170				break
16171			}
16172			{
16173				xtv := string(val)
16174				sv.Slots = ptr.String(xtv)
16175			}
16176
16177		default:
16178			// Do nothing and ignore the unexpected tag element
16179			err = decoder.Decoder.Skip()
16180			if err != nil {
16181				return err
16182			}
16183
16184		}
16185		decoder = originalDecoder
16186	}
16187	*v = sv
16188	return nil
16189}
16190
16191func awsAwsquery_deserializeDocumentNodeGroupList(v *[]types.NodeGroup, decoder smithyxml.NodeDecoder) error {
16192	if v == nil {
16193		return fmt.Errorf("unexpected nil of type %T", v)
16194	}
16195	var sv []types.NodeGroup
16196	if *v == nil {
16197		sv = make([]types.NodeGroup, 0)
16198	} else {
16199		sv = *v
16200	}
16201
16202	originalDecoder := decoder
16203	for {
16204		t, done, err := decoder.Token()
16205		if err != nil {
16206			return err
16207		}
16208		if done {
16209			break
16210		}
16211		switch {
16212		case strings.EqualFold("NodeGroup", t.Name.Local):
16213			var col types.NodeGroup
16214			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16215			destAddr := &col
16216			if err := awsAwsquery_deserializeDocumentNodeGroup(&destAddr, nodeDecoder); err != nil {
16217				return err
16218			}
16219			col = *destAddr
16220			sv = append(sv, col)
16221
16222		default:
16223			err = decoder.Decoder.Skip()
16224			if err != nil {
16225				return err
16226			}
16227
16228		}
16229		decoder = originalDecoder
16230	}
16231	*v = sv
16232	return nil
16233}
16234
16235func awsAwsquery_deserializeDocumentNodeGroupListUnwrapped(v *[]types.NodeGroup, decoder smithyxml.NodeDecoder) error {
16236	var sv []types.NodeGroup
16237	if *v == nil {
16238		sv = make([]types.NodeGroup, 0)
16239	} else {
16240		sv = *v
16241	}
16242
16243	switch {
16244	default:
16245		var mv types.NodeGroup
16246		t := decoder.StartEl
16247		_ = t
16248		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16249		destAddr := &mv
16250		if err := awsAwsquery_deserializeDocumentNodeGroup(&destAddr, nodeDecoder); err != nil {
16251			return err
16252		}
16253		mv = *destAddr
16254		sv = append(sv, mv)
16255	}
16256	*v = sv
16257	return nil
16258}
16259func awsAwsquery_deserializeDocumentNodeGroupMember(v **types.NodeGroupMember, decoder smithyxml.NodeDecoder) error {
16260	if v == nil {
16261		return fmt.Errorf("unexpected nil of type %T", v)
16262	}
16263	var sv *types.NodeGroupMember
16264	if *v == nil {
16265		sv = &types.NodeGroupMember{}
16266	} else {
16267		sv = *v
16268	}
16269
16270	for {
16271		t, done, err := decoder.Token()
16272		if err != nil {
16273			return err
16274		}
16275		if done {
16276			break
16277		}
16278		originalDecoder := decoder
16279		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
16280		switch {
16281		case strings.EqualFold("CacheClusterId", t.Name.Local):
16282			val, err := decoder.Value()
16283			if err != nil {
16284				return err
16285			}
16286			if val == nil {
16287				break
16288			}
16289			{
16290				xtv := string(val)
16291				sv.CacheClusterId = ptr.String(xtv)
16292			}
16293
16294		case strings.EqualFold("CacheNodeId", t.Name.Local):
16295			val, err := decoder.Value()
16296			if err != nil {
16297				return err
16298			}
16299			if val == nil {
16300				break
16301			}
16302			{
16303				xtv := string(val)
16304				sv.CacheNodeId = ptr.String(xtv)
16305			}
16306
16307		case strings.EqualFold("CurrentRole", t.Name.Local):
16308			val, err := decoder.Value()
16309			if err != nil {
16310				return err
16311			}
16312			if val == nil {
16313				break
16314			}
16315			{
16316				xtv := string(val)
16317				sv.CurrentRole = ptr.String(xtv)
16318			}
16319
16320		case strings.EqualFold("PreferredAvailabilityZone", t.Name.Local):
16321			val, err := decoder.Value()
16322			if err != nil {
16323				return err
16324			}
16325			if val == nil {
16326				break
16327			}
16328			{
16329				xtv := string(val)
16330				sv.PreferredAvailabilityZone = ptr.String(xtv)
16331			}
16332
16333		case strings.EqualFold("PreferredOutpostArn", t.Name.Local):
16334			val, err := decoder.Value()
16335			if err != nil {
16336				return err
16337			}
16338			if val == nil {
16339				break
16340			}
16341			{
16342				xtv := string(val)
16343				sv.PreferredOutpostArn = ptr.String(xtv)
16344			}
16345
16346		case strings.EqualFold("ReadEndpoint", t.Name.Local):
16347			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16348			if err := awsAwsquery_deserializeDocumentEndpoint(&sv.ReadEndpoint, nodeDecoder); err != nil {
16349				return err
16350			}
16351
16352		default:
16353			// Do nothing and ignore the unexpected tag element
16354			err = decoder.Decoder.Skip()
16355			if err != nil {
16356				return err
16357			}
16358
16359		}
16360		decoder = originalDecoder
16361	}
16362	*v = sv
16363	return nil
16364}
16365
16366func awsAwsquery_deserializeDocumentNodeGroupMemberList(v *[]types.NodeGroupMember, decoder smithyxml.NodeDecoder) error {
16367	if v == nil {
16368		return fmt.Errorf("unexpected nil of type %T", v)
16369	}
16370	var sv []types.NodeGroupMember
16371	if *v == nil {
16372		sv = make([]types.NodeGroupMember, 0)
16373	} else {
16374		sv = *v
16375	}
16376
16377	originalDecoder := decoder
16378	for {
16379		t, done, err := decoder.Token()
16380		if err != nil {
16381			return err
16382		}
16383		if done {
16384			break
16385		}
16386		switch {
16387		case strings.EqualFold("NodeGroupMember", t.Name.Local):
16388			var col types.NodeGroupMember
16389			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16390			destAddr := &col
16391			if err := awsAwsquery_deserializeDocumentNodeGroupMember(&destAddr, nodeDecoder); err != nil {
16392				return err
16393			}
16394			col = *destAddr
16395			sv = append(sv, col)
16396
16397		default:
16398			err = decoder.Decoder.Skip()
16399			if err != nil {
16400				return err
16401			}
16402
16403		}
16404		decoder = originalDecoder
16405	}
16406	*v = sv
16407	return nil
16408}
16409
16410func awsAwsquery_deserializeDocumentNodeGroupMemberListUnwrapped(v *[]types.NodeGroupMember, decoder smithyxml.NodeDecoder) error {
16411	var sv []types.NodeGroupMember
16412	if *v == nil {
16413		sv = make([]types.NodeGroupMember, 0)
16414	} else {
16415		sv = *v
16416	}
16417
16418	switch {
16419	default:
16420		var mv types.NodeGroupMember
16421		t := decoder.StartEl
16422		_ = t
16423		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16424		destAddr := &mv
16425		if err := awsAwsquery_deserializeDocumentNodeGroupMember(&destAddr, nodeDecoder); err != nil {
16426			return err
16427		}
16428		mv = *destAddr
16429		sv = append(sv, mv)
16430	}
16431	*v = sv
16432	return nil
16433}
16434func awsAwsquery_deserializeDocumentNodeGroupMemberUpdateStatus(v **types.NodeGroupMemberUpdateStatus, decoder smithyxml.NodeDecoder) error {
16435	if v == nil {
16436		return fmt.Errorf("unexpected nil of type %T", v)
16437	}
16438	var sv *types.NodeGroupMemberUpdateStatus
16439	if *v == nil {
16440		sv = &types.NodeGroupMemberUpdateStatus{}
16441	} else {
16442		sv = *v
16443	}
16444
16445	for {
16446		t, done, err := decoder.Token()
16447		if err != nil {
16448			return err
16449		}
16450		if done {
16451			break
16452		}
16453		originalDecoder := decoder
16454		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
16455		switch {
16456		case strings.EqualFold("CacheClusterId", t.Name.Local):
16457			val, err := decoder.Value()
16458			if err != nil {
16459				return err
16460			}
16461			if val == nil {
16462				break
16463			}
16464			{
16465				xtv := string(val)
16466				sv.CacheClusterId = ptr.String(xtv)
16467			}
16468
16469		case strings.EqualFold("CacheNodeId", t.Name.Local):
16470			val, err := decoder.Value()
16471			if err != nil {
16472				return err
16473			}
16474			if val == nil {
16475				break
16476			}
16477			{
16478				xtv := string(val)
16479				sv.CacheNodeId = ptr.String(xtv)
16480			}
16481
16482		case strings.EqualFold("NodeDeletionDate", t.Name.Local):
16483			val, err := decoder.Value()
16484			if err != nil {
16485				return err
16486			}
16487			if val == nil {
16488				break
16489			}
16490			{
16491				xtv := string(val)
16492				t, err := smithytime.ParseDateTime(xtv)
16493				if err != nil {
16494					return err
16495				}
16496				sv.NodeDeletionDate = ptr.Time(t)
16497			}
16498
16499		case strings.EqualFold("NodeUpdateEndDate", t.Name.Local):
16500			val, err := decoder.Value()
16501			if err != nil {
16502				return err
16503			}
16504			if val == nil {
16505				break
16506			}
16507			{
16508				xtv := string(val)
16509				t, err := smithytime.ParseDateTime(xtv)
16510				if err != nil {
16511					return err
16512				}
16513				sv.NodeUpdateEndDate = ptr.Time(t)
16514			}
16515
16516		case strings.EqualFold("NodeUpdateInitiatedBy", t.Name.Local):
16517			val, err := decoder.Value()
16518			if err != nil {
16519				return err
16520			}
16521			if val == nil {
16522				break
16523			}
16524			{
16525				xtv := string(val)
16526				sv.NodeUpdateInitiatedBy = types.NodeUpdateInitiatedBy(xtv)
16527			}
16528
16529		case strings.EqualFold("NodeUpdateInitiatedDate", t.Name.Local):
16530			val, err := decoder.Value()
16531			if err != nil {
16532				return err
16533			}
16534			if val == nil {
16535				break
16536			}
16537			{
16538				xtv := string(val)
16539				t, err := smithytime.ParseDateTime(xtv)
16540				if err != nil {
16541					return err
16542				}
16543				sv.NodeUpdateInitiatedDate = ptr.Time(t)
16544			}
16545
16546		case strings.EqualFold("NodeUpdateStartDate", t.Name.Local):
16547			val, err := decoder.Value()
16548			if err != nil {
16549				return err
16550			}
16551			if val == nil {
16552				break
16553			}
16554			{
16555				xtv := string(val)
16556				t, err := smithytime.ParseDateTime(xtv)
16557				if err != nil {
16558					return err
16559				}
16560				sv.NodeUpdateStartDate = ptr.Time(t)
16561			}
16562
16563		case strings.EqualFold("NodeUpdateStatus", t.Name.Local):
16564			val, err := decoder.Value()
16565			if err != nil {
16566				return err
16567			}
16568			if val == nil {
16569				break
16570			}
16571			{
16572				xtv := string(val)
16573				sv.NodeUpdateStatus = types.NodeUpdateStatus(xtv)
16574			}
16575
16576		case strings.EqualFold("NodeUpdateStatusModifiedDate", t.Name.Local):
16577			val, err := decoder.Value()
16578			if err != nil {
16579				return err
16580			}
16581			if val == nil {
16582				break
16583			}
16584			{
16585				xtv := string(val)
16586				t, err := smithytime.ParseDateTime(xtv)
16587				if err != nil {
16588					return err
16589				}
16590				sv.NodeUpdateStatusModifiedDate = ptr.Time(t)
16591			}
16592
16593		default:
16594			// Do nothing and ignore the unexpected tag element
16595			err = decoder.Decoder.Skip()
16596			if err != nil {
16597				return err
16598			}
16599
16600		}
16601		decoder = originalDecoder
16602	}
16603	*v = sv
16604	return nil
16605}
16606
16607func awsAwsquery_deserializeDocumentNodeGroupMemberUpdateStatusList(v *[]types.NodeGroupMemberUpdateStatus, decoder smithyxml.NodeDecoder) error {
16608	if v == nil {
16609		return fmt.Errorf("unexpected nil of type %T", v)
16610	}
16611	var sv []types.NodeGroupMemberUpdateStatus
16612	if *v == nil {
16613		sv = make([]types.NodeGroupMemberUpdateStatus, 0)
16614	} else {
16615		sv = *v
16616	}
16617
16618	originalDecoder := decoder
16619	for {
16620		t, done, err := decoder.Token()
16621		if err != nil {
16622			return err
16623		}
16624		if done {
16625			break
16626		}
16627		switch {
16628		case strings.EqualFold("NodeGroupMemberUpdateStatus", t.Name.Local):
16629			var col types.NodeGroupMemberUpdateStatus
16630			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16631			destAddr := &col
16632			if err := awsAwsquery_deserializeDocumentNodeGroupMemberUpdateStatus(&destAddr, nodeDecoder); err != nil {
16633				return err
16634			}
16635			col = *destAddr
16636			sv = append(sv, col)
16637
16638		default:
16639			err = decoder.Decoder.Skip()
16640			if err != nil {
16641				return err
16642			}
16643
16644		}
16645		decoder = originalDecoder
16646	}
16647	*v = sv
16648	return nil
16649}
16650
16651func awsAwsquery_deserializeDocumentNodeGroupMemberUpdateStatusListUnwrapped(v *[]types.NodeGroupMemberUpdateStatus, decoder smithyxml.NodeDecoder) error {
16652	var sv []types.NodeGroupMemberUpdateStatus
16653	if *v == nil {
16654		sv = make([]types.NodeGroupMemberUpdateStatus, 0)
16655	} else {
16656		sv = *v
16657	}
16658
16659	switch {
16660	default:
16661		var mv types.NodeGroupMemberUpdateStatus
16662		t := decoder.StartEl
16663		_ = t
16664		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16665		destAddr := &mv
16666		if err := awsAwsquery_deserializeDocumentNodeGroupMemberUpdateStatus(&destAddr, nodeDecoder); err != nil {
16667			return err
16668		}
16669		mv = *destAddr
16670		sv = append(sv, mv)
16671	}
16672	*v = sv
16673	return nil
16674}
16675func awsAwsquery_deserializeDocumentNodeGroupNotFoundFault(v **types.NodeGroupNotFoundFault, decoder smithyxml.NodeDecoder) error {
16676	if v == nil {
16677		return fmt.Errorf("unexpected nil of type %T", v)
16678	}
16679	var sv *types.NodeGroupNotFoundFault
16680	if *v == nil {
16681		sv = &types.NodeGroupNotFoundFault{}
16682	} else {
16683		sv = *v
16684	}
16685
16686	for {
16687		t, done, err := decoder.Token()
16688		if err != nil {
16689			return err
16690		}
16691		if done {
16692			break
16693		}
16694		originalDecoder := decoder
16695		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
16696		switch {
16697		case strings.EqualFold("message", t.Name.Local):
16698			val, err := decoder.Value()
16699			if err != nil {
16700				return err
16701			}
16702			if val == nil {
16703				break
16704			}
16705			{
16706				xtv := string(val)
16707				sv.Message = ptr.String(xtv)
16708			}
16709
16710		default:
16711			// Do nothing and ignore the unexpected tag element
16712			err = decoder.Decoder.Skip()
16713			if err != nil {
16714				return err
16715			}
16716
16717		}
16718		decoder = originalDecoder
16719	}
16720	*v = sv
16721	return nil
16722}
16723
16724func awsAwsquery_deserializeDocumentNodeGroupsPerReplicationGroupQuotaExceededFault(v **types.NodeGroupsPerReplicationGroupQuotaExceededFault, decoder smithyxml.NodeDecoder) error {
16725	if v == nil {
16726		return fmt.Errorf("unexpected nil of type %T", v)
16727	}
16728	var sv *types.NodeGroupsPerReplicationGroupQuotaExceededFault
16729	if *v == nil {
16730		sv = &types.NodeGroupsPerReplicationGroupQuotaExceededFault{}
16731	} else {
16732		sv = *v
16733	}
16734
16735	for {
16736		t, done, err := decoder.Token()
16737		if err != nil {
16738			return err
16739		}
16740		if done {
16741			break
16742		}
16743		originalDecoder := decoder
16744		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
16745		switch {
16746		case strings.EqualFold("message", t.Name.Local):
16747			val, err := decoder.Value()
16748			if err != nil {
16749				return err
16750			}
16751			if val == nil {
16752				break
16753			}
16754			{
16755				xtv := string(val)
16756				sv.Message = ptr.String(xtv)
16757			}
16758
16759		default:
16760			// Do nothing and ignore the unexpected tag element
16761			err = decoder.Decoder.Skip()
16762			if err != nil {
16763				return err
16764			}
16765
16766		}
16767		decoder = originalDecoder
16768	}
16769	*v = sv
16770	return nil
16771}
16772
16773func awsAwsquery_deserializeDocumentNodeGroupUpdateStatus(v **types.NodeGroupUpdateStatus, decoder smithyxml.NodeDecoder) error {
16774	if v == nil {
16775		return fmt.Errorf("unexpected nil of type %T", v)
16776	}
16777	var sv *types.NodeGroupUpdateStatus
16778	if *v == nil {
16779		sv = &types.NodeGroupUpdateStatus{}
16780	} else {
16781		sv = *v
16782	}
16783
16784	for {
16785		t, done, err := decoder.Token()
16786		if err != nil {
16787			return err
16788		}
16789		if done {
16790			break
16791		}
16792		originalDecoder := decoder
16793		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
16794		switch {
16795		case strings.EqualFold("NodeGroupId", t.Name.Local):
16796			val, err := decoder.Value()
16797			if err != nil {
16798				return err
16799			}
16800			if val == nil {
16801				break
16802			}
16803			{
16804				xtv := string(val)
16805				sv.NodeGroupId = ptr.String(xtv)
16806			}
16807
16808		case strings.EqualFold("NodeGroupMemberUpdateStatus", t.Name.Local):
16809			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16810			if err := awsAwsquery_deserializeDocumentNodeGroupMemberUpdateStatusList(&sv.NodeGroupMemberUpdateStatus, nodeDecoder); err != nil {
16811				return err
16812			}
16813
16814		default:
16815			// Do nothing and ignore the unexpected tag element
16816			err = decoder.Decoder.Skip()
16817			if err != nil {
16818				return err
16819			}
16820
16821		}
16822		decoder = originalDecoder
16823	}
16824	*v = sv
16825	return nil
16826}
16827
16828func awsAwsquery_deserializeDocumentNodeGroupUpdateStatusList(v *[]types.NodeGroupUpdateStatus, decoder smithyxml.NodeDecoder) error {
16829	if v == nil {
16830		return fmt.Errorf("unexpected nil of type %T", v)
16831	}
16832	var sv []types.NodeGroupUpdateStatus
16833	if *v == nil {
16834		sv = make([]types.NodeGroupUpdateStatus, 0)
16835	} else {
16836		sv = *v
16837	}
16838
16839	originalDecoder := decoder
16840	for {
16841		t, done, err := decoder.Token()
16842		if err != nil {
16843			return err
16844		}
16845		if done {
16846			break
16847		}
16848		switch {
16849		case strings.EqualFold("NodeGroupUpdateStatus", t.Name.Local):
16850			var col types.NodeGroupUpdateStatus
16851			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16852			destAddr := &col
16853			if err := awsAwsquery_deserializeDocumentNodeGroupUpdateStatus(&destAddr, nodeDecoder); err != nil {
16854				return err
16855			}
16856			col = *destAddr
16857			sv = append(sv, col)
16858
16859		default:
16860			err = decoder.Decoder.Skip()
16861			if err != nil {
16862				return err
16863			}
16864
16865		}
16866		decoder = originalDecoder
16867	}
16868	*v = sv
16869	return nil
16870}
16871
16872func awsAwsquery_deserializeDocumentNodeGroupUpdateStatusListUnwrapped(v *[]types.NodeGroupUpdateStatus, decoder smithyxml.NodeDecoder) error {
16873	var sv []types.NodeGroupUpdateStatus
16874	if *v == nil {
16875		sv = make([]types.NodeGroupUpdateStatus, 0)
16876	} else {
16877		sv = *v
16878	}
16879
16880	switch {
16881	default:
16882		var mv types.NodeGroupUpdateStatus
16883		t := decoder.StartEl
16884		_ = t
16885		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
16886		destAddr := &mv
16887		if err := awsAwsquery_deserializeDocumentNodeGroupUpdateStatus(&destAddr, nodeDecoder); err != nil {
16888			return err
16889		}
16890		mv = *destAddr
16891		sv = append(sv, mv)
16892	}
16893	*v = sv
16894	return nil
16895}
16896func awsAwsquery_deserializeDocumentNodeQuotaForClusterExceededFault(v **types.NodeQuotaForClusterExceededFault, decoder smithyxml.NodeDecoder) error {
16897	if v == nil {
16898		return fmt.Errorf("unexpected nil of type %T", v)
16899	}
16900	var sv *types.NodeQuotaForClusterExceededFault
16901	if *v == nil {
16902		sv = &types.NodeQuotaForClusterExceededFault{}
16903	} else {
16904		sv = *v
16905	}
16906
16907	for {
16908		t, done, err := decoder.Token()
16909		if err != nil {
16910			return err
16911		}
16912		if done {
16913			break
16914		}
16915		originalDecoder := decoder
16916		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
16917		switch {
16918		case strings.EqualFold("message", t.Name.Local):
16919			val, err := decoder.Value()
16920			if err != nil {
16921				return err
16922			}
16923			if val == nil {
16924				break
16925			}
16926			{
16927				xtv := string(val)
16928				sv.Message = ptr.String(xtv)
16929			}
16930
16931		default:
16932			// Do nothing and ignore the unexpected tag element
16933			err = decoder.Decoder.Skip()
16934			if err != nil {
16935				return err
16936			}
16937
16938		}
16939		decoder = originalDecoder
16940	}
16941	*v = sv
16942	return nil
16943}
16944
16945func awsAwsquery_deserializeDocumentNodeQuotaForCustomerExceededFault(v **types.NodeQuotaForCustomerExceededFault, decoder smithyxml.NodeDecoder) error {
16946	if v == nil {
16947		return fmt.Errorf("unexpected nil of type %T", v)
16948	}
16949	var sv *types.NodeQuotaForCustomerExceededFault
16950	if *v == nil {
16951		sv = &types.NodeQuotaForCustomerExceededFault{}
16952	} else {
16953		sv = *v
16954	}
16955
16956	for {
16957		t, done, err := decoder.Token()
16958		if err != nil {
16959			return err
16960		}
16961		if done {
16962			break
16963		}
16964		originalDecoder := decoder
16965		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
16966		switch {
16967		case strings.EqualFold("message", t.Name.Local):
16968			val, err := decoder.Value()
16969			if err != nil {
16970				return err
16971			}
16972			if val == nil {
16973				break
16974			}
16975			{
16976				xtv := string(val)
16977				sv.Message = ptr.String(xtv)
16978			}
16979
16980		default:
16981			// Do nothing and ignore the unexpected tag element
16982			err = decoder.Decoder.Skip()
16983			if err != nil {
16984				return err
16985			}
16986
16987		}
16988		decoder = originalDecoder
16989	}
16990	*v = sv
16991	return nil
16992}
16993
16994func awsAwsquery_deserializeDocumentNodeSnapshot(v **types.NodeSnapshot, decoder smithyxml.NodeDecoder) error {
16995	if v == nil {
16996		return fmt.Errorf("unexpected nil of type %T", v)
16997	}
16998	var sv *types.NodeSnapshot
16999	if *v == nil {
17000		sv = &types.NodeSnapshot{}
17001	} else {
17002		sv = *v
17003	}
17004
17005	for {
17006		t, done, err := decoder.Token()
17007		if err != nil {
17008			return err
17009		}
17010		if done {
17011			break
17012		}
17013		originalDecoder := decoder
17014		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
17015		switch {
17016		case strings.EqualFold("CacheClusterId", t.Name.Local):
17017			val, err := decoder.Value()
17018			if err != nil {
17019				return err
17020			}
17021			if val == nil {
17022				break
17023			}
17024			{
17025				xtv := string(val)
17026				sv.CacheClusterId = ptr.String(xtv)
17027			}
17028
17029		case strings.EqualFold("CacheNodeCreateTime", t.Name.Local):
17030			val, err := decoder.Value()
17031			if err != nil {
17032				return err
17033			}
17034			if val == nil {
17035				break
17036			}
17037			{
17038				xtv := string(val)
17039				t, err := smithytime.ParseDateTime(xtv)
17040				if err != nil {
17041					return err
17042				}
17043				sv.CacheNodeCreateTime = ptr.Time(t)
17044			}
17045
17046		case strings.EqualFold("CacheNodeId", t.Name.Local):
17047			val, err := decoder.Value()
17048			if err != nil {
17049				return err
17050			}
17051			if val == nil {
17052				break
17053			}
17054			{
17055				xtv := string(val)
17056				sv.CacheNodeId = ptr.String(xtv)
17057			}
17058
17059		case strings.EqualFold("CacheSize", t.Name.Local):
17060			val, err := decoder.Value()
17061			if err != nil {
17062				return err
17063			}
17064			if val == nil {
17065				break
17066			}
17067			{
17068				xtv := string(val)
17069				sv.CacheSize = ptr.String(xtv)
17070			}
17071
17072		case strings.EqualFold("NodeGroupConfiguration", t.Name.Local):
17073			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
17074			if err := awsAwsquery_deserializeDocumentNodeGroupConfiguration(&sv.NodeGroupConfiguration, nodeDecoder); err != nil {
17075				return err
17076			}
17077
17078		case strings.EqualFold("NodeGroupId", t.Name.Local):
17079			val, err := decoder.Value()
17080			if err != nil {
17081				return err
17082			}
17083			if val == nil {
17084				break
17085			}
17086			{
17087				xtv := string(val)
17088				sv.NodeGroupId = ptr.String(xtv)
17089			}
17090
17091		case strings.EqualFold("SnapshotCreateTime", t.Name.Local):
17092			val, err := decoder.Value()
17093			if err != nil {
17094				return err
17095			}
17096			if val == nil {
17097				break
17098			}
17099			{
17100				xtv := string(val)
17101				t, err := smithytime.ParseDateTime(xtv)
17102				if err != nil {
17103					return err
17104				}
17105				sv.SnapshotCreateTime = ptr.Time(t)
17106			}
17107
17108		default:
17109			// Do nothing and ignore the unexpected tag element
17110			err = decoder.Decoder.Skip()
17111			if err != nil {
17112				return err
17113			}
17114
17115		}
17116		decoder = originalDecoder
17117	}
17118	*v = sv
17119	return nil
17120}
17121
17122func awsAwsquery_deserializeDocumentNodeSnapshotList(v *[]types.NodeSnapshot, decoder smithyxml.NodeDecoder) error {
17123	if v == nil {
17124		return fmt.Errorf("unexpected nil of type %T", v)
17125	}
17126	var sv []types.NodeSnapshot
17127	if *v == nil {
17128		sv = make([]types.NodeSnapshot, 0)
17129	} else {
17130		sv = *v
17131	}
17132
17133	originalDecoder := decoder
17134	for {
17135		t, done, err := decoder.Token()
17136		if err != nil {
17137			return err
17138		}
17139		if done {
17140			break
17141		}
17142		switch {
17143		case strings.EqualFold("NodeSnapshot", t.Name.Local):
17144			var col types.NodeSnapshot
17145			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
17146			destAddr := &col
17147			if err := awsAwsquery_deserializeDocumentNodeSnapshot(&destAddr, nodeDecoder); err != nil {
17148				return err
17149			}
17150			col = *destAddr
17151			sv = append(sv, col)
17152
17153		default:
17154			err = decoder.Decoder.Skip()
17155			if err != nil {
17156				return err
17157			}
17158
17159		}
17160		decoder = originalDecoder
17161	}
17162	*v = sv
17163	return nil
17164}
17165
17166func awsAwsquery_deserializeDocumentNodeSnapshotListUnwrapped(v *[]types.NodeSnapshot, decoder smithyxml.NodeDecoder) error {
17167	var sv []types.NodeSnapshot
17168	if *v == nil {
17169		sv = make([]types.NodeSnapshot, 0)
17170	} else {
17171		sv = *v
17172	}
17173
17174	switch {
17175	default:
17176		var mv types.NodeSnapshot
17177		t := decoder.StartEl
17178		_ = t
17179		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
17180		destAddr := &mv
17181		if err := awsAwsquery_deserializeDocumentNodeSnapshot(&destAddr, nodeDecoder); err != nil {
17182			return err
17183		}
17184		mv = *destAddr
17185		sv = append(sv, mv)
17186	}
17187	*v = sv
17188	return nil
17189}
17190func awsAwsquery_deserializeDocumentNodeTypeList(v *[]string, decoder smithyxml.NodeDecoder) error {
17191	if v == nil {
17192		return fmt.Errorf("unexpected nil of type %T", v)
17193	}
17194	var sv []string
17195	if *v == nil {
17196		sv = make([]string, 0)
17197	} else {
17198		sv = *v
17199	}
17200
17201	originalDecoder := decoder
17202	for {
17203		t, done, err := decoder.Token()
17204		if err != nil {
17205			return err
17206		}
17207		if done {
17208			break
17209		}
17210		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
17211		decoder = memberDecoder
17212		switch {
17213		case strings.EqualFold("member", t.Name.Local):
17214			var col string
17215			val, err := decoder.Value()
17216			if err != nil {
17217				return err
17218			}
17219			if val == nil {
17220				break
17221			}
17222			{
17223				xtv := string(val)
17224				col = xtv
17225			}
17226			sv = append(sv, col)
17227
17228		default:
17229			err = decoder.Decoder.Skip()
17230			if err != nil {
17231				return err
17232			}
17233
17234		}
17235		decoder = originalDecoder
17236	}
17237	*v = sv
17238	return nil
17239}
17240
17241func awsAwsquery_deserializeDocumentNodeTypeListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
17242	var sv []string
17243	if *v == nil {
17244		sv = make([]string, 0)
17245	} else {
17246		sv = *v
17247	}
17248
17249	switch {
17250	default:
17251		var mv string
17252		t := decoder.StartEl
17253		_ = t
17254		val, err := decoder.Value()
17255		if err != nil {
17256			return err
17257		}
17258		if val == nil {
17259			break
17260		}
17261		{
17262			xtv := string(val)
17263			mv = xtv
17264		}
17265		sv = append(sv, mv)
17266	}
17267	*v = sv
17268	return nil
17269}
17270func awsAwsquery_deserializeDocumentNoOperationFault(v **types.NoOperationFault, decoder smithyxml.NodeDecoder) error {
17271	if v == nil {
17272		return fmt.Errorf("unexpected nil of type %T", v)
17273	}
17274	var sv *types.NoOperationFault
17275	if *v == nil {
17276		sv = &types.NoOperationFault{}
17277	} else {
17278		sv = *v
17279	}
17280
17281	for {
17282		t, done, err := decoder.Token()
17283		if err != nil {
17284			return err
17285		}
17286		if done {
17287			break
17288		}
17289		originalDecoder := decoder
17290		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
17291		switch {
17292		case strings.EqualFold("message", t.Name.Local):
17293			val, err := decoder.Value()
17294			if err != nil {
17295				return err
17296			}
17297			if val == nil {
17298				break
17299			}
17300			{
17301				xtv := string(val)
17302				sv.Message = ptr.String(xtv)
17303			}
17304
17305		default:
17306			// Do nothing and ignore the unexpected tag element
17307			err = decoder.Decoder.Skip()
17308			if err != nil {
17309				return err
17310			}
17311
17312		}
17313		decoder = originalDecoder
17314	}
17315	*v = sv
17316	return nil
17317}
17318
17319func awsAwsquery_deserializeDocumentNotificationConfiguration(v **types.NotificationConfiguration, decoder smithyxml.NodeDecoder) error {
17320	if v == nil {
17321		return fmt.Errorf("unexpected nil of type %T", v)
17322	}
17323	var sv *types.NotificationConfiguration
17324	if *v == nil {
17325		sv = &types.NotificationConfiguration{}
17326	} else {
17327		sv = *v
17328	}
17329
17330	for {
17331		t, done, err := decoder.Token()
17332		if err != nil {
17333			return err
17334		}
17335		if done {
17336			break
17337		}
17338		originalDecoder := decoder
17339		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
17340		switch {
17341		case strings.EqualFold("TopicArn", t.Name.Local):
17342			val, err := decoder.Value()
17343			if err != nil {
17344				return err
17345			}
17346			if val == nil {
17347				break
17348			}
17349			{
17350				xtv := string(val)
17351				sv.TopicArn = ptr.String(xtv)
17352			}
17353
17354		case strings.EqualFold("TopicStatus", t.Name.Local):
17355			val, err := decoder.Value()
17356			if err != nil {
17357				return err
17358			}
17359			if val == nil {
17360				break
17361			}
17362			{
17363				xtv := string(val)
17364				sv.TopicStatus = ptr.String(xtv)
17365			}
17366
17367		default:
17368			// Do nothing and ignore the unexpected tag element
17369			err = decoder.Decoder.Skip()
17370			if err != nil {
17371				return err
17372			}
17373
17374		}
17375		decoder = originalDecoder
17376	}
17377	*v = sv
17378	return nil
17379}
17380
17381func awsAwsquery_deserializeDocumentOutpostArnsList(v *[]string, decoder smithyxml.NodeDecoder) error {
17382	if v == nil {
17383		return fmt.Errorf("unexpected nil of type %T", v)
17384	}
17385	var sv []string
17386	if *v == nil {
17387		sv = make([]string, 0)
17388	} else {
17389		sv = *v
17390	}
17391
17392	originalDecoder := decoder
17393	for {
17394		t, done, err := decoder.Token()
17395		if err != nil {
17396			return err
17397		}
17398		if done {
17399			break
17400		}
17401		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
17402		decoder = memberDecoder
17403		switch {
17404		case strings.EqualFold("OutpostArn", t.Name.Local):
17405			var col string
17406			val, err := decoder.Value()
17407			if err != nil {
17408				return err
17409			}
17410			if val == nil {
17411				break
17412			}
17413			{
17414				xtv := string(val)
17415				col = xtv
17416			}
17417			sv = append(sv, col)
17418
17419		default:
17420			err = decoder.Decoder.Skip()
17421			if err != nil {
17422				return err
17423			}
17424
17425		}
17426		decoder = originalDecoder
17427	}
17428	*v = sv
17429	return nil
17430}
17431
17432func awsAwsquery_deserializeDocumentOutpostArnsListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
17433	var sv []string
17434	if *v == nil {
17435		sv = make([]string, 0)
17436	} else {
17437		sv = *v
17438	}
17439
17440	switch {
17441	default:
17442		var mv string
17443		t := decoder.StartEl
17444		_ = t
17445		val, err := decoder.Value()
17446		if err != nil {
17447			return err
17448		}
17449		if val == nil {
17450			break
17451		}
17452		{
17453			xtv := string(val)
17454			mv = xtv
17455		}
17456		sv = append(sv, mv)
17457	}
17458	*v = sv
17459	return nil
17460}
17461func awsAwsquery_deserializeDocumentParameter(v **types.Parameter, decoder smithyxml.NodeDecoder) error {
17462	if v == nil {
17463		return fmt.Errorf("unexpected nil of type %T", v)
17464	}
17465	var sv *types.Parameter
17466	if *v == nil {
17467		sv = &types.Parameter{}
17468	} else {
17469		sv = *v
17470	}
17471
17472	for {
17473		t, done, err := decoder.Token()
17474		if err != nil {
17475			return err
17476		}
17477		if done {
17478			break
17479		}
17480		originalDecoder := decoder
17481		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
17482		switch {
17483		case strings.EqualFold("AllowedValues", t.Name.Local):
17484			val, err := decoder.Value()
17485			if err != nil {
17486				return err
17487			}
17488			if val == nil {
17489				break
17490			}
17491			{
17492				xtv := string(val)
17493				sv.AllowedValues = ptr.String(xtv)
17494			}
17495
17496		case strings.EqualFold("ChangeType", t.Name.Local):
17497			val, err := decoder.Value()
17498			if err != nil {
17499				return err
17500			}
17501			if val == nil {
17502				break
17503			}
17504			{
17505				xtv := string(val)
17506				sv.ChangeType = types.ChangeType(xtv)
17507			}
17508
17509		case strings.EqualFold("DataType", t.Name.Local):
17510			val, err := decoder.Value()
17511			if err != nil {
17512				return err
17513			}
17514			if val == nil {
17515				break
17516			}
17517			{
17518				xtv := string(val)
17519				sv.DataType = ptr.String(xtv)
17520			}
17521
17522		case strings.EqualFold("Description", t.Name.Local):
17523			val, err := decoder.Value()
17524			if err != nil {
17525				return err
17526			}
17527			if val == nil {
17528				break
17529			}
17530			{
17531				xtv := string(val)
17532				sv.Description = ptr.String(xtv)
17533			}
17534
17535		case strings.EqualFold("IsModifiable", t.Name.Local):
17536			val, err := decoder.Value()
17537			if err != nil {
17538				return err
17539			}
17540			if val == nil {
17541				break
17542			}
17543			{
17544				xtv, err := strconv.ParseBool(string(val))
17545				if err != nil {
17546					return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val)
17547				}
17548				sv.IsModifiable = xtv
17549			}
17550
17551		case strings.EqualFold("MinimumEngineVersion", t.Name.Local):
17552			val, err := decoder.Value()
17553			if err != nil {
17554				return err
17555			}
17556			if val == nil {
17557				break
17558			}
17559			{
17560				xtv := string(val)
17561				sv.MinimumEngineVersion = ptr.String(xtv)
17562			}
17563
17564		case strings.EqualFold("ParameterName", t.Name.Local):
17565			val, err := decoder.Value()
17566			if err != nil {
17567				return err
17568			}
17569			if val == nil {
17570				break
17571			}
17572			{
17573				xtv := string(val)
17574				sv.ParameterName = ptr.String(xtv)
17575			}
17576
17577		case strings.EqualFold("ParameterValue", t.Name.Local):
17578			val, err := decoder.Value()
17579			if err != nil {
17580				return err
17581			}
17582			if val == nil {
17583				break
17584			}
17585			{
17586				xtv := string(val)
17587				sv.ParameterValue = ptr.String(xtv)
17588			}
17589
17590		case strings.EqualFold("Source", t.Name.Local):
17591			val, err := decoder.Value()
17592			if err != nil {
17593				return err
17594			}
17595			if val == nil {
17596				break
17597			}
17598			{
17599				xtv := string(val)
17600				sv.Source = ptr.String(xtv)
17601			}
17602
17603		default:
17604			// Do nothing and ignore the unexpected tag element
17605			err = decoder.Decoder.Skip()
17606			if err != nil {
17607				return err
17608			}
17609
17610		}
17611		decoder = originalDecoder
17612	}
17613	*v = sv
17614	return nil
17615}
17616
17617func awsAwsquery_deserializeDocumentParametersList(v *[]types.Parameter, decoder smithyxml.NodeDecoder) error {
17618	if v == nil {
17619		return fmt.Errorf("unexpected nil of type %T", v)
17620	}
17621	var sv []types.Parameter
17622	if *v == nil {
17623		sv = make([]types.Parameter, 0)
17624	} else {
17625		sv = *v
17626	}
17627
17628	originalDecoder := decoder
17629	for {
17630		t, done, err := decoder.Token()
17631		if err != nil {
17632			return err
17633		}
17634		if done {
17635			break
17636		}
17637		switch {
17638		case strings.EqualFold("Parameter", t.Name.Local):
17639			var col types.Parameter
17640			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
17641			destAddr := &col
17642			if err := awsAwsquery_deserializeDocumentParameter(&destAddr, nodeDecoder); err != nil {
17643				return err
17644			}
17645			col = *destAddr
17646			sv = append(sv, col)
17647
17648		default:
17649			err = decoder.Decoder.Skip()
17650			if err != nil {
17651				return err
17652			}
17653
17654		}
17655		decoder = originalDecoder
17656	}
17657	*v = sv
17658	return nil
17659}
17660
17661func awsAwsquery_deserializeDocumentParametersListUnwrapped(v *[]types.Parameter, decoder smithyxml.NodeDecoder) error {
17662	var sv []types.Parameter
17663	if *v == nil {
17664		sv = make([]types.Parameter, 0)
17665	} else {
17666		sv = *v
17667	}
17668
17669	switch {
17670	default:
17671		var mv types.Parameter
17672		t := decoder.StartEl
17673		_ = t
17674		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
17675		destAddr := &mv
17676		if err := awsAwsquery_deserializeDocumentParameter(&destAddr, nodeDecoder); err != nil {
17677			return err
17678		}
17679		mv = *destAddr
17680		sv = append(sv, mv)
17681	}
17682	*v = sv
17683	return nil
17684}
17685func awsAwsquery_deserializeDocumentPendingModifiedValues(v **types.PendingModifiedValues, decoder smithyxml.NodeDecoder) error {
17686	if v == nil {
17687		return fmt.Errorf("unexpected nil of type %T", v)
17688	}
17689	var sv *types.PendingModifiedValues
17690	if *v == nil {
17691		sv = &types.PendingModifiedValues{}
17692	} else {
17693		sv = *v
17694	}
17695
17696	for {
17697		t, done, err := decoder.Token()
17698		if err != nil {
17699			return err
17700		}
17701		if done {
17702			break
17703		}
17704		originalDecoder := decoder
17705		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
17706		switch {
17707		case strings.EqualFold("AuthTokenStatus", t.Name.Local):
17708			val, err := decoder.Value()
17709			if err != nil {
17710				return err
17711			}
17712			if val == nil {
17713				break
17714			}
17715			{
17716				xtv := string(val)
17717				sv.AuthTokenStatus = types.AuthTokenUpdateStatus(xtv)
17718			}
17719
17720		case strings.EqualFold("CacheNodeIdsToRemove", t.Name.Local):
17721			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
17722			if err := awsAwsquery_deserializeDocumentCacheNodeIdsList(&sv.CacheNodeIdsToRemove, nodeDecoder); err != nil {
17723				return err
17724			}
17725
17726		case strings.EqualFold("CacheNodeType", t.Name.Local):
17727			val, err := decoder.Value()
17728			if err != nil {
17729				return err
17730			}
17731			if val == nil {
17732				break
17733			}
17734			{
17735				xtv := string(val)
17736				sv.CacheNodeType = ptr.String(xtv)
17737			}
17738
17739		case strings.EqualFold("EngineVersion", t.Name.Local):
17740			val, err := decoder.Value()
17741			if err != nil {
17742				return err
17743			}
17744			if val == nil {
17745				break
17746			}
17747			{
17748				xtv := string(val)
17749				sv.EngineVersion = ptr.String(xtv)
17750			}
17751
17752		case strings.EqualFold("NumCacheNodes", t.Name.Local):
17753			val, err := decoder.Value()
17754			if err != nil {
17755				return err
17756			}
17757			if val == nil {
17758				break
17759			}
17760			{
17761				xtv := string(val)
17762				i64, err := strconv.ParseInt(xtv, 10, 64)
17763				if err != nil {
17764					return err
17765				}
17766				sv.NumCacheNodes = ptr.Int32(int32(i64))
17767			}
17768
17769		default:
17770			// Do nothing and ignore the unexpected tag element
17771			err = decoder.Decoder.Skip()
17772			if err != nil {
17773				return err
17774			}
17775
17776		}
17777		decoder = originalDecoder
17778	}
17779	*v = sv
17780	return nil
17781}
17782
17783func awsAwsquery_deserializeDocumentProcessedUpdateAction(v **types.ProcessedUpdateAction, decoder smithyxml.NodeDecoder) error {
17784	if v == nil {
17785		return fmt.Errorf("unexpected nil of type %T", v)
17786	}
17787	var sv *types.ProcessedUpdateAction
17788	if *v == nil {
17789		sv = &types.ProcessedUpdateAction{}
17790	} else {
17791		sv = *v
17792	}
17793
17794	for {
17795		t, done, err := decoder.Token()
17796		if err != nil {
17797			return err
17798		}
17799		if done {
17800			break
17801		}
17802		originalDecoder := decoder
17803		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
17804		switch {
17805		case strings.EqualFold("CacheClusterId", t.Name.Local):
17806			val, err := decoder.Value()
17807			if err != nil {
17808				return err
17809			}
17810			if val == nil {
17811				break
17812			}
17813			{
17814				xtv := string(val)
17815				sv.CacheClusterId = ptr.String(xtv)
17816			}
17817
17818		case strings.EqualFold("ReplicationGroupId", t.Name.Local):
17819			val, err := decoder.Value()
17820			if err != nil {
17821				return err
17822			}
17823			if val == nil {
17824				break
17825			}
17826			{
17827				xtv := string(val)
17828				sv.ReplicationGroupId = ptr.String(xtv)
17829			}
17830
17831		case strings.EqualFold("ServiceUpdateName", t.Name.Local):
17832			val, err := decoder.Value()
17833			if err != nil {
17834				return err
17835			}
17836			if val == nil {
17837				break
17838			}
17839			{
17840				xtv := string(val)
17841				sv.ServiceUpdateName = ptr.String(xtv)
17842			}
17843
17844		case strings.EqualFold("UpdateActionStatus", t.Name.Local):
17845			val, err := decoder.Value()
17846			if err != nil {
17847				return err
17848			}
17849			if val == nil {
17850				break
17851			}
17852			{
17853				xtv := string(val)
17854				sv.UpdateActionStatus = types.UpdateActionStatus(xtv)
17855			}
17856
17857		default:
17858			// Do nothing and ignore the unexpected tag element
17859			err = decoder.Decoder.Skip()
17860			if err != nil {
17861				return err
17862			}
17863
17864		}
17865		decoder = originalDecoder
17866	}
17867	*v = sv
17868	return nil
17869}
17870
17871func awsAwsquery_deserializeDocumentProcessedUpdateActionList(v *[]types.ProcessedUpdateAction, decoder smithyxml.NodeDecoder) error {
17872	if v == nil {
17873		return fmt.Errorf("unexpected nil of type %T", v)
17874	}
17875	var sv []types.ProcessedUpdateAction
17876	if *v == nil {
17877		sv = make([]types.ProcessedUpdateAction, 0)
17878	} else {
17879		sv = *v
17880	}
17881
17882	originalDecoder := decoder
17883	for {
17884		t, done, err := decoder.Token()
17885		if err != nil {
17886			return err
17887		}
17888		if done {
17889			break
17890		}
17891		switch {
17892		case strings.EqualFold("ProcessedUpdateAction", t.Name.Local):
17893			var col types.ProcessedUpdateAction
17894			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
17895			destAddr := &col
17896			if err := awsAwsquery_deserializeDocumentProcessedUpdateAction(&destAddr, nodeDecoder); err != nil {
17897				return err
17898			}
17899			col = *destAddr
17900			sv = append(sv, col)
17901
17902		default:
17903			err = decoder.Decoder.Skip()
17904			if err != nil {
17905				return err
17906			}
17907
17908		}
17909		decoder = originalDecoder
17910	}
17911	*v = sv
17912	return nil
17913}
17914
17915func awsAwsquery_deserializeDocumentProcessedUpdateActionListUnwrapped(v *[]types.ProcessedUpdateAction, decoder smithyxml.NodeDecoder) error {
17916	var sv []types.ProcessedUpdateAction
17917	if *v == nil {
17918		sv = make([]types.ProcessedUpdateAction, 0)
17919	} else {
17920		sv = *v
17921	}
17922
17923	switch {
17924	default:
17925		var mv types.ProcessedUpdateAction
17926		t := decoder.StartEl
17927		_ = t
17928		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
17929		destAddr := &mv
17930		if err := awsAwsquery_deserializeDocumentProcessedUpdateAction(&destAddr, nodeDecoder); err != nil {
17931			return err
17932		}
17933		mv = *destAddr
17934		sv = append(sv, mv)
17935	}
17936	*v = sv
17937	return nil
17938}
17939func awsAwsquery_deserializeDocumentRecurringCharge(v **types.RecurringCharge, decoder smithyxml.NodeDecoder) error {
17940	if v == nil {
17941		return fmt.Errorf("unexpected nil of type %T", v)
17942	}
17943	var sv *types.RecurringCharge
17944	if *v == nil {
17945		sv = &types.RecurringCharge{}
17946	} else {
17947		sv = *v
17948	}
17949
17950	for {
17951		t, done, err := decoder.Token()
17952		if err != nil {
17953			return err
17954		}
17955		if done {
17956			break
17957		}
17958		originalDecoder := decoder
17959		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
17960		switch {
17961		case strings.EqualFold("RecurringChargeAmount", t.Name.Local):
17962			val, err := decoder.Value()
17963			if err != nil {
17964				return err
17965			}
17966			if val == nil {
17967				break
17968			}
17969			{
17970				xtv := string(val)
17971				f64, err := strconv.ParseFloat(xtv, 64)
17972				if err != nil {
17973					return err
17974				}
17975				sv.RecurringChargeAmount = f64
17976			}
17977
17978		case strings.EqualFold("RecurringChargeFrequency", t.Name.Local):
17979			val, err := decoder.Value()
17980			if err != nil {
17981				return err
17982			}
17983			if val == nil {
17984				break
17985			}
17986			{
17987				xtv := string(val)
17988				sv.RecurringChargeFrequency = ptr.String(xtv)
17989			}
17990
17991		default:
17992			// Do nothing and ignore the unexpected tag element
17993			err = decoder.Decoder.Skip()
17994			if err != nil {
17995				return err
17996			}
17997
17998		}
17999		decoder = originalDecoder
18000	}
18001	*v = sv
18002	return nil
18003}
18004
18005func awsAwsquery_deserializeDocumentRecurringChargeList(v *[]types.RecurringCharge, decoder smithyxml.NodeDecoder) error {
18006	if v == nil {
18007		return fmt.Errorf("unexpected nil of type %T", v)
18008	}
18009	var sv []types.RecurringCharge
18010	if *v == nil {
18011		sv = make([]types.RecurringCharge, 0)
18012	} else {
18013		sv = *v
18014	}
18015
18016	originalDecoder := decoder
18017	for {
18018		t, done, err := decoder.Token()
18019		if err != nil {
18020			return err
18021		}
18022		if done {
18023			break
18024		}
18025		switch {
18026		case strings.EqualFold("RecurringCharge", t.Name.Local):
18027			var col types.RecurringCharge
18028			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
18029			destAddr := &col
18030			if err := awsAwsquery_deserializeDocumentRecurringCharge(&destAddr, nodeDecoder); err != nil {
18031				return err
18032			}
18033			col = *destAddr
18034			sv = append(sv, col)
18035
18036		default:
18037			err = decoder.Decoder.Skip()
18038			if err != nil {
18039				return err
18040			}
18041
18042		}
18043		decoder = originalDecoder
18044	}
18045	*v = sv
18046	return nil
18047}
18048
18049func awsAwsquery_deserializeDocumentRecurringChargeListUnwrapped(v *[]types.RecurringCharge, decoder smithyxml.NodeDecoder) error {
18050	var sv []types.RecurringCharge
18051	if *v == nil {
18052		sv = make([]types.RecurringCharge, 0)
18053	} else {
18054		sv = *v
18055	}
18056
18057	switch {
18058	default:
18059		var mv types.RecurringCharge
18060		t := decoder.StartEl
18061		_ = t
18062		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
18063		destAddr := &mv
18064		if err := awsAwsquery_deserializeDocumentRecurringCharge(&destAddr, nodeDecoder); err != nil {
18065			return err
18066		}
18067		mv = *destAddr
18068		sv = append(sv, mv)
18069	}
18070	*v = sv
18071	return nil
18072}
18073func awsAwsquery_deserializeDocumentReplicationGroup(v **types.ReplicationGroup, decoder smithyxml.NodeDecoder) error {
18074	if v == nil {
18075		return fmt.Errorf("unexpected nil of type %T", v)
18076	}
18077	var sv *types.ReplicationGroup
18078	if *v == nil {
18079		sv = &types.ReplicationGroup{}
18080	} else {
18081		sv = *v
18082	}
18083
18084	for {
18085		t, done, err := decoder.Token()
18086		if err != nil {
18087			return err
18088		}
18089		if done {
18090			break
18091		}
18092		originalDecoder := decoder
18093		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
18094		switch {
18095		case strings.EqualFold("ARN", t.Name.Local):
18096			val, err := decoder.Value()
18097			if err != nil {
18098				return err
18099			}
18100			if val == nil {
18101				break
18102			}
18103			{
18104				xtv := string(val)
18105				sv.ARN = ptr.String(xtv)
18106			}
18107
18108		case strings.EqualFold("AtRestEncryptionEnabled", t.Name.Local):
18109			val, err := decoder.Value()
18110			if err != nil {
18111				return err
18112			}
18113			if val == nil {
18114				break
18115			}
18116			{
18117				xtv, err := strconv.ParseBool(string(val))
18118				if err != nil {
18119					return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", val)
18120				}
18121				sv.AtRestEncryptionEnabled = ptr.Bool(xtv)
18122			}
18123
18124		case strings.EqualFold("AuthTokenEnabled", t.Name.Local):
18125			val, err := decoder.Value()
18126			if err != nil {
18127				return err
18128			}
18129			if val == nil {
18130				break
18131			}
18132			{
18133				xtv, err := strconv.ParseBool(string(val))
18134				if err != nil {
18135					return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", val)
18136				}
18137				sv.AuthTokenEnabled = ptr.Bool(xtv)
18138			}
18139
18140		case strings.EqualFold("AuthTokenLastModifiedDate", t.Name.Local):
18141			val, err := decoder.Value()
18142			if err != nil {
18143				return err
18144			}
18145			if val == nil {
18146				break
18147			}
18148			{
18149				xtv := string(val)
18150				t, err := smithytime.ParseDateTime(xtv)
18151				if err != nil {
18152					return err
18153				}
18154				sv.AuthTokenLastModifiedDate = ptr.Time(t)
18155			}
18156
18157		case strings.EqualFold("AutomaticFailover", t.Name.Local):
18158			val, err := decoder.Value()
18159			if err != nil {
18160				return err
18161			}
18162			if val == nil {
18163				break
18164			}
18165			{
18166				xtv := string(val)
18167				sv.AutomaticFailover = types.AutomaticFailoverStatus(xtv)
18168			}
18169
18170		case strings.EqualFold("CacheNodeType", t.Name.Local):
18171			val, err := decoder.Value()
18172			if err != nil {
18173				return err
18174			}
18175			if val == nil {
18176				break
18177			}
18178			{
18179				xtv := string(val)
18180				sv.CacheNodeType = ptr.String(xtv)
18181			}
18182
18183		case strings.EqualFold("ClusterEnabled", t.Name.Local):
18184			val, err := decoder.Value()
18185			if err != nil {
18186				return err
18187			}
18188			if val == nil {
18189				break
18190			}
18191			{
18192				xtv, err := strconv.ParseBool(string(val))
18193				if err != nil {
18194					return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", val)
18195				}
18196				sv.ClusterEnabled = ptr.Bool(xtv)
18197			}
18198
18199		case strings.EqualFold("ConfigurationEndpoint", t.Name.Local):
18200			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
18201			if err := awsAwsquery_deserializeDocumentEndpoint(&sv.ConfigurationEndpoint, nodeDecoder); err != nil {
18202				return err
18203			}
18204
18205		case strings.EqualFold("Description", t.Name.Local):
18206			val, err := decoder.Value()
18207			if err != nil {
18208				return err
18209			}
18210			if val == nil {
18211				break
18212			}
18213			{
18214				xtv := string(val)
18215				sv.Description = ptr.String(xtv)
18216			}
18217
18218		case strings.EqualFold("GlobalReplicationGroupInfo", t.Name.Local):
18219			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
18220			if err := awsAwsquery_deserializeDocumentGlobalReplicationGroupInfo(&sv.GlobalReplicationGroupInfo, nodeDecoder); err != nil {
18221				return err
18222			}
18223
18224		case strings.EqualFold("KmsKeyId", t.Name.Local):
18225			val, err := decoder.Value()
18226			if err != nil {
18227				return err
18228			}
18229			if val == nil {
18230				break
18231			}
18232			{
18233				xtv := string(val)
18234				sv.KmsKeyId = ptr.String(xtv)
18235			}
18236
18237		case strings.EqualFold("MemberClusters", t.Name.Local):
18238			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
18239			if err := awsAwsquery_deserializeDocumentClusterIdList(&sv.MemberClusters, nodeDecoder); err != nil {
18240				return err
18241			}
18242
18243		case strings.EqualFold("MemberClustersOutpostArns", t.Name.Local):
18244			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
18245			if err := awsAwsquery_deserializeDocumentReplicationGroupOutpostArnList(&sv.MemberClustersOutpostArns, nodeDecoder); err != nil {
18246				return err
18247			}
18248
18249		case strings.EqualFold("MultiAZ", t.Name.Local):
18250			val, err := decoder.Value()
18251			if err != nil {
18252				return err
18253			}
18254			if val == nil {
18255				break
18256			}
18257			{
18258				xtv := string(val)
18259				sv.MultiAZ = types.MultiAZStatus(xtv)
18260			}
18261
18262		case strings.EqualFold("NodeGroups", t.Name.Local):
18263			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
18264			if err := awsAwsquery_deserializeDocumentNodeGroupList(&sv.NodeGroups, nodeDecoder); err != nil {
18265				return err
18266			}
18267
18268		case strings.EqualFold("PendingModifiedValues", t.Name.Local):
18269			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
18270			if err := awsAwsquery_deserializeDocumentReplicationGroupPendingModifiedValues(&sv.PendingModifiedValues, nodeDecoder); err != nil {
18271				return err
18272			}
18273
18274		case strings.EqualFold("ReplicationGroupId", t.Name.Local):
18275			val, err := decoder.Value()
18276			if err != nil {
18277				return err
18278			}
18279			if val == nil {
18280				break
18281			}
18282			{
18283				xtv := string(val)
18284				sv.ReplicationGroupId = ptr.String(xtv)
18285			}
18286
18287		case strings.EqualFold("SnapshotRetentionLimit", t.Name.Local):
18288			val, err := decoder.Value()
18289			if err != nil {
18290				return err
18291			}
18292			if val == nil {
18293				break
18294			}
18295			{
18296				xtv := string(val)
18297				i64, err := strconv.ParseInt(xtv, 10, 64)
18298				if err != nil {
18299					return err
18300				}
18301				sv.SnapshotRetentionLimit = ptr.Int32(int32(i64))
18302			}
18303
18304		case strings.EqualFold("SnapshottingClusterId", t.Name.Local):
18305			val, err := decoder.Value()
18306			if err != nil {
18307				return err
18308			}
18309			if val == nil {
18310				break
18311			}
18312			{
18313				xtv := string(val)
18314				sv.SnapshottingClusterId = ptr.String(xtv)
18315			}
18316
18317		case strings.EqualFold("SnapshotWindow", t.Name.Local):
18318			val, err := decoder.Value()
18319			if err != nil {
18320				return err
18321			}
18322			if val == nil {
18323				break
18324			}
18325			{
18326				xtv := string(val)
18327				sv.SnapshotWindow = ptr.String(xtv)
18328			}
18329
18330		case strings.EqualFold("Status", t.Name.Local):
18331			val, err := decoder.Value()
18332			if err != nil {
18333				return err
18334			}
18335			if val == nil {
18336				break
18337			}
18338			{
18339				xtv := string(val)
18340				sv.Status = ptr.String(xtv)
18341			}
18342
18343		case strings.EqualFold("TransitEncryptionEnabled", t.Name.Local):
18344			val, err := decoder.Value()
18345			if err != nil {
18346				return err
18347			}
18348			if val == nil {
18349				break
18350			}
18351			{
18352				xtv, err := strconv.ParseBool(string(val))
18353				if err != nil {
18354					return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", val)
18355				}
18356				sv.TransitEncryptionEnabled = ptr.Bool(xtv)
18357			}
18358
18359		case strings.EqualFold("UserGroupIds", t.Name.Local):
18360			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
18361			if err := awsAwsquery_deserializeDocumentUserGroupIdList(&sv.UserGroupIds, nodeDecoder); err != nil {
18362				return err
18363			}
18364
18365		default:
18366			// Do nothing and ignore the unexpected tag element
18367			err = decoder.Decoder.Skip()
18368			if err != nil {
18369				return err
18370			}
18371
18372		}
18373		decoder = originalDecoder
18374	}
18375	*v = sv
18376	return nil
18377}
18378
18379func awsAwsquery_deserializeDocumentReplicationGroupAlreadyExistsFault(v **types.ReplicationGroupAlreadyExistsFault, decoder smithyxml.NodeDecoder) error {
18380	if v == nil {
18381		return fmt.Errorf("unexpected nil of type %T", v)
18382	}
18383	var sv *types.ReplicationGroupAlreadyExistsFault
18384	if *v == nil {
18385		sv = &types.ReplicationGroupAlreadyExistsFault{}
18386	} else {
18387		sv = *v
18388	}
18389
18390	for {
18391		t, done, err := decoder.Token()
18392		if err != nil {
18393			return err
18394		}
18395		if done {
18396			break
18397		}
18398		originalDecoder := decoder
18399		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
18400		switch {
18401		case strings.EqualFold("message", t.Name.Local):
18402			val, err := decoder.Value()
18403			if err != nil {
18404				return err
18405			}
18406			if val == nil {
18407				break
18408			}
18409			{
18410				xtv := string(val)
18411				sv.Message = ptr.String(xtv)
18412			}
18413
18414		default:
18415			// Do nothing and ignore the unexpected tag element
18416			err = decoder.Decoder.Skip()
18417			if err != nil {
18418				return err
18419			}
18420
18421		}
18422		decoder = originalDecoder
18423	}
18424	*v = sv
18425	return nil
18426}
18427
18428func awsAwsquery_deserializeDocumentReplicationGroupAlreadyUnderMigrationFault(v **types.ReplicationGroupAlreadyUnderMigrationFault, decoder smithyxml.NodeDecoder) error {
18429	if v == nil {
18430		return fmt.Errorf("unexpected nil of type %T", v)
18431	}
18432	var sv *types.ReplicationGroupAlreadyUnderMigrationFault
18433	if *v == nil {
18434		sv = &types.ReplicationGroupAlreadyUnderMigrationFault{}
18435	} else {
18436		sv = *v
18437	}
18438
18439	for {
18440		t, done, err := decoder.Token()
18441		if err != nil {
18442			return err
18443		}
18444		if done {
18445			break
18446		}
18447		originalDecoder := decoder
18448		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
18449		switch {
18450		case strings.EqualFold("message", t.Name.Local):
18451			val, err := decoder.Value()
18452			if err != nil {
18453				return err
18454			}
18455			if val == nil {
18456				break
18457			}
18458			{
18459				xtv := string(val)
18460				sv.Message = ptr.String(xtv)
18461			}
18462
18463		default:
18464			// Do nothing and ignore the unexpected tag element
18465			err = decoder.Decoder.Skip()
18466			if err != nil {
18467				return err
18468			}
18469
18470		}
18471		decoder = originalDecoder
18472	}
18473	*v = sv
18474	return nil
18475}
18476
18477func awsAwsquery_deserializeDocumentReplicationGroupList(v *[]types.ReplicationGroup, decoder smithyxml.NodeDecoder) error {
18478	if v == nil {
18479		return fmt.Errorf("unexpected nil of type %T", v)
18480	}
18481	var sv []types.ReplicationGroup
18482	if *v == nil {
18483		sv = make([]types.ReplicationGroup, 0)
18484	} else {
18485		sv = *v
18486	}
18487
18488	originalDecoder := decoder
18489	for {
18490		t, done, err := decoder.Token()
18491		if err != nil {
18492			return err
18493		}
18494		if done {
18495			break
18496		}
18497		switch {
18498		case strings.EqualFold("ReplicationGroup", t.Name.Local):
18499			var col types.ReplicationGroup
18500			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
18501			destAddr := &col
18502			if err := awsAwsquery_deserializeDocumentReplicationGroup(&destAddr, nodeDecoder); err != nil {
18503				return err
18504			}
18505			col = *destAddr
18506			sv = append(sv, col)
18507
18508		default:
18509			err = decoder.Decoder.Skip()
18510			if err != nil {
18511				return err
18512			}
18513
18514		}
18515		decoder = originalDecoder
18516	}
18517	*v = sv
18518	return nil
18519}
18520
18521func awsAwsquery_deserializeDocumentReplicationGroupListUnwrapped(v *[]types.ReplicationGroup, decoder smithyxml.NodeDecoder) error {
18522	var sv []types.ReplicationGroup
18523	if *v == nil {
18524		sv = make([]types.ReplicationGroup, 0)
18525	} else {
18526		sv = *v
18527	}
18528
18529	switch {
18530	default:
18531		var mv types.ReplicationGroup
18532		t := decoder.StartEl
18533		_ = t
18534		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
18535		destAddr := &mv
18536		if err := awsAwsquery_deserializeDocumentReplicationGroup(&destAddr, nodeDecoder); err != nil {
18537			return err
18538		}
18539		mv = *destAddr
18540		sv = append(sv, mv)
18541	}
18542	*v = sv
18543	return nil
18544}
18545func awsAwsquery_deserializeDocumentReplicationGroupNotFoundFault(v **types.ReplicationGroupNotFoundFault, decoder smithyxml.NodeDecoder) error {
18546	if v == nil {
18547		return fmt.Errorf("unexpected nil of type %T", v)
18548	}
18549	var sv *types.ReplicationGroupNotFoundFault
18550	if *v == nil {
18551		sv = &types.ReplicationGroupNotFoundFault{}
18552	} else {
18553		sv = *v
18554	}
18555
18556	for {
18557		t, done, err := decoder.Token()
18558		if err != nil {
18559			return err
18560		}
18561		if done {
18562			break
18563		}
18564		originalDecoder := decoder
18565		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
18566		switch {
18567		case strings.EqualFold("message", t.Name.Local):
18568			val, err := decoder.Value()
18569			if err != nil {
18570				return err
18571			}
18572			if val == nil {
18573				break
18574			}
18575			{
18576				xtv := string(val)
18577				sv.Message = ptr.String(xtv)
18578			}
18579
18580		default:
18581			// Do nothing and ignore the unexpected tag element
18582			err = decoder.Decoder.Skip()
18583			if err != nil {
18584				return err
18585			}
18586
18587		}
18588		decoder = originalDecoder
18589	}
18590	*v = sv
18591	return nil
18592}
18593
18594func awsAwsquery_deserializeDocumentReplicationGroupNotUnderMigrationFault(v **types.ReplicationGroupNotUnderMigrationFault, decoder smithyxml.NodeDecoder) error {
18595	if v == nil {
18596		return fmt.Errorf("unexpected nil of type %T", v)
18597	}
18598	var sv *types.ReplicationGroupNotUnderMigrationFault
18599	if *v == nil {
18600		sv = &types.ReplicationGroupNotUnderMigrationFault{}
18601	} else {
18602		sv = *v
18603	}
18604
18605	for {
18606		t, done, err := decoder.Token()
18607		if err != nil {
18608			return err
18609		}
18610		if done {
18611			break
18612		}
18613		originalDecoder := decoder
18614		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
18615		switch {
18616		case strings.EqualFold("message", t.Name.Local):
18617			val, err := decoder.Value()
18618			if err != nil {
18619				return err
18620			}
18621			if val == nil {
18622				break
18623			}
18624			{
18625				xtv := string(val)
18626				sv.Message = ptr.String(xtv)
18627			}
18628
18629		default:
18630			// Do nothing and ignore the unexpected tag element
18631			err = decoder.Decoder.Skip()
18632			if err != nil {
18633				return err
18634			}
18635
18636		}
18637		decoder = originalDecoder
18638	}
18639	*v = sv
18640	return nil
18641}
18642
18643func awsAwsquery_deserializeDocumentReplicationGroupOutpostArnList(v *[]string, decoder smithyxml.NodeDecoder) error {
18644	if v == nil {
18645		return fmt.Errorf("unexpected nil of type %T", v)
18646	}
18647	var sv []string
18648	if *v == nil {
18649		sv = make([]string, 0)
18650	} else {
18651		sv = *v
18652	}
18653
18654	originalDecoder := decoder
18655	for {
18656		t, done, err := decoder.Token()
18657		if err != nil {
18658			return err
18659		}
18660		if done {
18661			break
18662		}
18663		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
18664		decoder = memberDecoder
18665		switch {
18666		case strings.EqualFold("ReplicationGroupOutpostArn", t.Name.Local):
18667			var col string
18668			val, err := decoder.Value()
18669			if err != nil {
18670				return err
18671			}
18672			if val == nil {
18673				break
18674			}
18675			{
18676				xtv := string(val)
18677				col = xtv
18678			}
18679			sv = append(sv, col)
18680
18681		default:
18682			err = decoder.Decoder.Skip()
18683			if err != nil {
18684				return err
18685			}
18686
18687		}
18688		decoder = originalDecoder
18689	}
18690	*v = sv
18691	return nil
18692}
18693
18694func awsAwsquery_deserializeDocumentReplicationGroupOutpostArnListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
18695	var sv []string
18696	if *v == nil {
18697		sv = make([]string, 0)
18698	} else {
18699		sv = *v
18700	}
18701
18702	switch {
18703	default:
18704		var mv string
18705		t := decoder.StartEl
18706		_ = t
18707		val, err := decoder.Value()
18708		if err != nil {
18709			return err
18710		}
18711		if val == nil {
18712			break
18713		}
18714		{
18715			xtv := string(val)
18716			mv = xtv
18717		}
18718		sv = append(sv, mv)
18719	}
18720	*v = sv
18721	return nil
18722}
18723func awsAwsquery_deserializeDocumentReplicationGroupPendingModifiedValues(v **types.ReplicationGroupPendingModifiedValues, decoder smithyxml.NodeDecoder) error {
18724	if v == nil {
18725		return fmt.Errorf("unexpected nil of type %T", v)
18726	}
18727	var sv *types.ReplicationGroupPendingModifiedValues
18728	if *v == nil {
18729		sv = &types.ReplicationGroupPendingModifiedValues{}
18730	} else {
18731		sv = *v
18732	}
18733
18734	for {
18735		t, done, err := decoder.Token()
18736		if err != nil {
18737			return err
18738		}
18739		if done {
18740			break
18741		}
18742		originalDecoder := decoder
18743		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
18744		switch {
18745		case strings.EqualFold("AuthTokenStatus", t.Name.Local):
18746			val, err := decoder.Value()
18747			if err != nil {
18748				return err
18749			}
18750			if val == nil {
18751				break
18752			}
18753			{
18754				xtv := string(val)
18755				sv.AuthTokenStatus = types.AuthTokenUpdateStatus(xtv)
18756			}
18757
18758		case strings.EqualFold("AutomaticFailoverStatus", t.Name.Local):
18759			val, err := decoder.Value()
18760			if err != nil {
18761				return err
18762			}
18763			if val == nil {
18764				break
18765			}
18766			{
18767				xtv := string(val)
18768				sv.AutomaticFailoverStatus = types.PendingAutomaticFailoverStatus(xtv)
18769			}
18770
18771		case strings.EqualFold("PrimaryClusterId", t.Name.Local):
18772			val, err := decoder.Value()
18773			if err != nil {
18774				return err
18775			}
18776			if val == nil {
18777				break
18778			}
18779			{
18780				xtv := string(val)
18781				sv.PrimaryClusterId = ptr.String(xtv)
18782			}
18783
18784		case strings.EqualFold("Resharding", t.Name.Local):
18785			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
18786			if err := awsAwsquery_deserializeDocumentReshardingStatus(&sv.Resharding, nodeDecoder); err != nil {
18787				return err
18788			}
18789
18790		case strings.EqualFold("UserGroups", t.Name.Local):
18791			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
18792			if err := awsAwsquery_deserializeDocumentUserGroupsUpdateStatus(&sv.UserGroups, nodeDecoder); err != nil {
18793				return err
18794			}
18795
18796		default:
18797			// Do nothing and ignore the unexpected tag element
18798			err = decoder.Decoder.Skip()
18799			if err != nil {
18800				return err
18801			}
18802
18803		}
18804		decoder = originalDecoder
18805	}
18806	*v = sv
18807	return nil
18808}
18809
18810func awsAwsquery_deserializeDocumentReservedCacheNode(v **types.ReservedCacheNode, decoder smithyxml.NodeDecoder) error {
18811	if v == nil {
18812		return fmt.Errorf("unexpected nil of type %T", v)
18813	}
18814	var sv *types.ReservedCacheNode
18815	if *v == nil {
18816		sv = &types.ReservedCacheNode{}
18817	} else {
18818		sv = *v
18819	}
18820
18821	for {
18822		t, done, err := decoder.Token()
18823		if err != nil {
18824			return err
18825		}
18826		if done {
18827			break
18828		}
18829		originalDecoder := decoder
18830		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
18831		switch {
18832		case strings.EqualFold("CacheNodeCount", t.Name.Local):
18833			val, err := decoder.Value()
18834			if err != nil {
18835				return err
18836			}
18837			if val == nil {
18838				break
18839			}
18840			{
18841				xtv := string(val)
18842				i64, err := strconv.ParseInt(xtv, 10, 64)
18843				if err != nil {
18844					return err
18845				}
18846				sv.CacheNodeCount = int32(i64)
18847			}
18848
18849		case strings.EqualFold("CacheNodeType", t.Name.Local):
18850			val, err := decoder.Value()
18851			if err != nil {
18852				return err
18853			}
18854			if val == nil {
18855				break
18856			}
18857			{
18858				xtv := string(val)
18859				sv.CacheNodeType = ptr.String(xtv)
18860			}
18861
18862		case strings.EqualFold("Duration", t.Name.Local):
18863			val, err := decoder.Value()
18864			if err != nil {
18865				return err
18866			}
18867			if val == nil {
18868				break
18869			}
18870			{
18871				xtv := string(val)
18872				i64, err := strconv.ParseInt(xtv, 10, 64)
18873				if err != nil {
18874					return err
18875				}
18876				sv.Duration = int32(i64)
18877			}
18878
18879		case strings.EqualFold("FixedPrice", t.Name.Local):
18880			val, err := decoder.Value()
18881			if err != nil {
18882				return err
18883			}
18884			if val == nil {
18885				break
18886			}
18887			{
18888				xtv := string(val)
18889				f64, err := strconv.ParseFloat(xtv, 64)
18890				if err != nil {
18891					return err
18892				}
18893				sv.FixedPrice = f64
18894			}
18895
18896		case strings.EqualFold("OfferingType", t.Name.Local):
18897			val, err := decoder.Value()
18898			if err != nil {
18899				return err
18900			}
18901			if val == nil {
18902				break
18903			}
18904			{
18905				xtv := string(val)
18906				sv.OfferingType = ptr.String(xtv)
18907			}
18908
18909		case strings.EqualFold("ProductDescription", t.Name.Local):
18910			val, err := decoder.Value()
18911			if err != nil {
18912				return err
18913			}
18914			if val == nil {
18915				break
18916			}
18917			{
18918				xtv := string(val)
18919				sv.ProductDescription = ptr.String(xtv)
18920			}
18921
18922		case strings.EqualFold("RecurringCharges", t.Name.Local):
18923			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
18924			if err := awsAwsquery_deserializeDocumentRecurringChargeList(&sv.RecurringCharges, nodeDecoder); err != nil {
18925				return err
18926			}
18927
18928		case strings.EqualFold("ReservationARN", t.Name.Local):
18929			val, err := decoder.Value()
18930			if err != nil {
18931				return err
18932			}
18933			if val == nil {
18934				break
18935			}
18936			{
18937				xtv := string(val)
18938				sv.ReservationARN = ptr.String(xtv)
18939			}
18940
18941		case strings.EqualFold("ReservedCacheNodeId", t.Name.Local):
18942			val, err := decoder.Value()
18943			if err != nil {
18944				return err
18945			}
18946			if val == nil {
18947				break
18948			}
18949			{
18950				xtv := string(val)
18951				sv.ReservedCacheNodeId = ptr.String(xtv)
18952			}
18953
18954		case strings.EqualFold("ReservedCacheNodesOfferingId", t.Name.Local):
18955			val, err := decoder.Value()
18956			if err != nil {
18957				return err
18958			}
18959			if val == nil {
18960				break
18961			}
18962			{
18963				xtv := string(val)
18964				sv.ReservedCacheNodesOfferingId = ptr.String(xtv)
18965			}
18966
18967		case strings.EqualFold("StartTime", t.Name.Local):
18968			val, err := decoder.Value()
18969			if err != nil {
18970				return err
18971			}
18972			if val == nil {
18973				break
18974			}
18975			{
18976				xtv := string(val)
18977				t, err := smithytime.ParseDateTime(xtv)
18978				if err != nil {
18979					return err
18980				}
18981				sv.StartTime = ptr.Time(t)
18982			}
18983
18984		case strings.EqualFold("State", t.Name.Local):
18985			val, err := decoder.Value()
18986			if err != nil {
18987				return err
18988			}
18989			if val == nil {
18990				break
18991			}
18992			{
18993				xtv := string(val)
18994				sv.State = ptr.String(xtv)
18995			}
18996
18997		case strings.EqualFold("UsagePrice", t.Name.Local):
18998			val, err := decoder.Value()
18999			if err != nil {
19000				return err
19001			}
19002			if val == nil {
19003				break
19004			}
19005			{
19006				xtv := string(val)
19007				f64, err := strconv.ParseFloat(xtv, 64)
19008				if err != nil {
19009					return err
19010				}
19011				sv.UsagePrice = f64
19012			}
19013
19014		default:
19015			// Do nothing and ignore the unexpected tag element
19016			err = decoder.Decoder.Skip()
19017			if err != nil {
19018				return err
19019			}
19020
19021		}
19022		decoder = originalDecoder
19023	}
19024	*v = sv
19025	return nil
19026}
19027
19028func awsAwsquery_deserializeDocumentReservedCacheNodeAlreadyExistsFault(v **types.ReservedCacheNodeAlreadyExistsFault, decoder smithyxml.NodeDecoder) error {
19029	if v == nil {
19030		return fmt.Errorf("unexpected nil of type %T", v)
19031	}
19032	var sv *types.ReservedCacheNodeAlreadyExistsFault
19033	if *v == nil {
19034		sv = &types.ReservedCacheNodeAlreadyExistsFault{}
19035	} else {
19036		sv = *v
19037	}
19038
19039	for {
19040		t, done, err := decoder.Token()
19041		if err != nil {
19042			return err
19043		}
19044		if done {
19045			break
19046		}
19047		originalDecoder := decoder
19048		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
19049		switch {
19050		case strings.EqualFold("message", t.Name.Local):
19051			val, err := decoder.Value()
19052			if err != nil {
19053				return err
19054			}
19055			if val == nil {
19056				break
19057			}
19058			{
19059				xtv := string(val)
19060				sv.Message = ptr.String(xtv)
19061			}
19062
19063		default:
19064			// Do nothing and ignore the unexpected tag element
19065			err = decoder.Decoder.Skip()
19066			if err != nil {
19067				return err
19068			}
19069
19070		}
19071		decoder = originalDecoder
19072	}
19073	*v = sv
19074	return nil
19075}
19076
19077func awsAwsquery_deserializeDocumentReservedCacheNodeList(v *[]types.ReservedCacheNode, decoder smithyxml.NodeDecoder) error {
19078	if v == nil {
19079		return fmt.Errorf("unexpected nil of type %T", v)
19080	}
19081	var sv []types.ReservedCacheNode
19082	if *v == nil {
19083		sv = make([]types.ReservedCacheNode, 0)
19084	} else {
19085		sv = *v
19086	}
19087
19088	originalDecoder := decoder
19089	for {
19090		t, done, err := decoder.Token()
19091		if err != nil {
19092			return err
19093		}
19094		if done {
19095			break
19096		}
19097		switch {
19098		case strings.EqualFold("ReservedCacheNode", t.Name.Local):
19099			var col types.ReservedCacheNode
19100			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
19101			destAddr := &col
19102			if err := awsAwsquery_deserializeDocumentReservedCacheNode(&destAddr, nodeDecoder); err != nil {
19103				return err
19104			}
19105			col = *destAddr
19106			sv = append(sv, col)
19107
19108		default:
19109			err = decoder.Decoder.Skip()
19110			if err != nil {
19111				return err
19112			}
19113
19114		}
19115		decoder = originalDecoder
19116	}
19117	*v = sv
19118	return nil
19119}
19120
19121func awsAwsquery_deserializeDocumentReservedCacheNodeListUnwrapped(v *[]types.ReservedCacheNode, decoder smithyxml.NodeDecoder) error {
19122	var sv []types.ReservedCacheNode
19123	if *v == nil {
19124		sv = make([]types.ReservedCacheNode, 0)
19125	} else {
19126		sv = *v
19127	}
19128
19129	switch {
19130	default:
19131		var mv types.ReservedCacheNode
19132		t := decoder.StartEl
19133		_ = t
19134		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
19135		destAddr := &mv
19136		if err := awsAwsquery_deserializeDocumentReservedCacheNode(&destAddr, nodeDecoder); err != nil {
19137			return err
19138		}
19139		mv = *destAddr
19140		sv = append(sv, mv)
19141	}
19142	*v = sv
19143	return nil
19144}
19145func awsAwsquery_deserializeDocumentReservedCacheNodeNotFoundFault(v **types.ReservedCacheNodeNotFoundFault, decoder smithyxml.NodeDecoder) error {
19146	if v == nil {
19147		return fmt.Errorf("unexpected nil of type %T", v)
19148	}
19149	var sv *types.ReservedCacheNodeNotFoundFault
19150	if *v == nil {
19151		sv = &types.ReservedCacheNodeNotFoundFault{}
19152	} else {
19153		sv = *v
19154	}
19155
19156	for {
19157		t, done, err := decoder.Token()
19158		if err != nil {
19159			return err
19160		}
19161		if done {
19162			break
19163		}
19164		originalDecoder := decoder
19165		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
19166		switch {
19167		case strings.EqualFold("message", t.Name.Local):
19168			val, err := decoder.Value()
19169			if err != nil {
19170				return err
19171			}
19172			if val == nil {
19173				break
19174			}
19175			{
19176				xtv := string(val)
19177				sv.Message = ptr.String(xtv)
19178			}
19179
19180		default:
19181			// Do nothing and ignore the unexpected tag element
19182			err = decoder.Decoder.Skip()
19183			if err != nil {
19184				return err
19185			}
19186
19187		}
19188		decoder = originalDecoder
19189	}
19190	*v = sv
19191	return nil
19192}
19193
19194func awsAwsquery_deserializeDocumentReservedCacheNodeQuotaExceededFault(v **types.ReservedCacheNodeQuotaExceededFault, decoder smithyxml.NodeDecoder) error {
19195	if v == nil {
19196		return fmt.Errorf("unexpected nil of type %T", v)
19197	}
19198	var sv *types.ReservedCacheNodeQuotaExceededFault
19199	if *v == nil {
19200		sv = &types.ReservedCacheNodeQuotaExceededFault{}
19201	} else {
19202		sv = *v
19203	}
19204
19205	for {
19206		t, done, err := decoder.Token()
19207		if err != nil {
19208			return err
19209		}
19210		if done {
19211			break
19212		}
19213		originalDecoder := decoder
19214		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
19215		switch {
19216		case strings.EqualFold("message", t.Name.Local):
19217			val, err := decoder.Value()
19218			if err != nil {
19219				return err
19220			}
19221			if val == nil {
19222				break
19223			}
19224			{
19225				xtv := string(val)
19226				sv.Message = ptr.String(xtv)
19227			}
19228
19229		default:
19230			// Do nothing and ignore the unexpected tag element
19231			err = decoder.Decoder.Skip()
19232			if err != nil {
19233				return err
19234			}
19235
19236		}
19237		decoder = originalDecoder
19238	}
19239	*v = sv
19240	return nil
19241}
19242
19243func awsAwsquery_deserializeDocumentReservedCacheNodesOffering(v **types.ReservedCacheNodesOffering, decoder smithyxml.NodeDecoder) error {
19244	if v == nil {
19245		return fmt.Errorf("unexpected nil of type %T", v)
19246	}
19247	var sv *types.ReservedCacheNodesOffering
19248	if *v == nil {
19249		sv = &types.ReservedCacheNodesOffering{}
19250	} else {
19251		sv = *v
19252	}
19253
19254	for {
19255		t, done, err := decoder.Token()
19256		if err != nil {
19257			return err
19258		}
19259		if done {
19260			break
19261		}
19262		originalDecoder := decoder
19263		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
19264		switch {
19265		case strings.EqualFold("CacheNodeType", t.Name.Local):
19266			val, err := decoder.Value()
19267			if err != nil {
19268				return err
19269			}
19270			if val == nil {
19271				break
19272			}
19273			{
19274				xtv := string(val)
19275				sv.CacheNodeType = ptr.String(xtv)
19276			}
19277
19278		case strings.EqualFold("Duration", t.Name.Local):
19279			val, err := decoder.Value()
19280			if err != nil {
19281				return err
19282			}
19283			if val == nil {
19284				break
19285			}
19286			{
19287				xtv := string(val)
19288				i64, err := strconv.ParseInt(xtv, 10, 64)
19289				if err != nil {
19290					return err
19291				}
19292				sv.Duration = int32(i64)
19293			}
19294
19295		case strings.EqualFold("FixedPrice", t.Name.Local):
19296			val, err := decoder.Value()
19297			if err != nil {
19298				return err
19299			}
19300			if val == nil {
19301				break
19302			}
19303			{
19304				xtv := string(val)
19305				f64, err := strconv.ParseFloat(xtv, 64)
19306				if err != nil {
19307					return err
19308				}
19309				sv.FixedPrice = f64
19310			}
19311
19312		case strings.EqualFold("OfferingType", t.Name.Local):
19313			val, err := decoder.Value()
19314			if err != nil {
19315				return err
19316			}
19317			if val == nil {
19318				break
19319			}
19320			{
19321				xtv := string(val)
19322				sv.OfferingType = ptr.String(xtv)
19323			}
19324
19325		case strings.EqualFold("ProductDescription", t.Name.Local):
19326			val, err := decoder.Value()
19327			if err != nil {
19328				return err
19329			}
19330			if val == nil {
19331				break
19332			}
19333			{
19334				xtv := string(val)
19335				sv.ProductDescription = ptr.String(xtv)
19336			}
19337
19338		case strings.EqualFold("RecurringCharges", t.Name.Local):
19339			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
19340			if err := awsAwsquery_deserializeDocumentRecurringChargeList(&sv.RecurringCharges, nodeDecoder); err != nil {
19341				return err
19342			}
19343
19344		case strings.EqualFold("ReservedCacheNodesOfferingId", t.Name.Local):
19345			val, err := decoder.Value()
19346			if err != nil {
19347				return err
19348			}
19349			if val == nil {
19350				break
19351			}
19352			{
19353				xtv := string(val)
19354				sv.ReservedCacheNodesOfferingId = ptr.String(xtv)
19355			}
19356
19357		case strings.EqualFold("UsagePrice", t.Name.Local):
19358			val, err := decoder.Value()
19359			if err != nil {
19360				return err
19361			}
19362			if val == nil {
19363				break
19364			}
19365			{
19366				xtv := string(val)
19367				f64, err := strconv.ParseFloat(xtv, 64)
19368				if err != nil {
19369					return err
19370				}
19371				sv.UsagePrice = f64
19372			}
19373
19374		default:
19375			// Do nothing and ignore the unexpected tag element
19376			err = decoder.Decoder.Skip()
19377			if err != nil {
19378				return err
19379			}
19380
19381		}
19382		decoder = originalDecoder
19383	}
19384	*v = sv
19385	return nil
19386}
19387
19388func awsAwsquery_deserializeDocumentReservedCacheNodesOfferingList(v *[]types.ReservedCacheNodesOffering, decoder smithyxml.NodeDecoder) error {
19389	if v == nil {
19390		return fmt.Errorf("unexpected nil of type %T", v)
19391	}
19392	var sv []types.ReservedCacheNodesOffering
19393	if *v == nil {
19394		sv = make([]types.ReservedCacheNodesOffering, 0)
19395	} else {
19396		sv = *v
19397	}
19398
19399	originalDecoder := decoder
19400	for {
19401		t, done, err := decoder.Token()
19402		if err != nil {
19403			return err
19404		}
19405		if done {
19406			break
19407		}
19408		switch {
19409		case strings.EqualFold("ReservedCacheNodesOffering", t.Name.Local):
19410			var col types.ReservedCacheNodesOffering
19411			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
19412			destAddr := &col
19413			if err := awsAwsquery_deserializeDocumentReservedCacheNodesOffering(&destAddr, nodeDecoder); err != nil {
19414				return err
19415			}
19416			col = *destAddr
19417			sv = append(sv, col)
19418
19419		default:
19420			err = decoder.Decoder.Skip()
19421			if err != nil {
19422				return err
19423			}
19424
19425		}
19426		decoder = originalDecoder
19427	}
19428	*v = sv
19429	return nil
19430}
19431
19432func awsAwsquery_deserializeDocumentReservedCacheNodesOfferingListUnwrapped(v *[]types.ReservedCacheNodesOffering, decoder smithyxml.NodeDecoder) error {
19433	var sv []types.ReservedCacheNodesOffering
19434	if *v == nil {
19435		sv = make([]types.ReservedCacheNodesOffering, 0)
19436	} else {
19437		sv = *v
19438	}
19439
19440	switch {
19441	default:
19442		var mv types.ReservedCacheNodesOffering
19443		t := decoder.StartEl
19444		_ = t
19445		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
19446		destAddr := &mv
19447		if err := awsAwsquery_deserializeDocumentReservedCacheNodesOffering(&destAddr, nodeDecoder); err != nil {
19448			return err
19449		}
19450		mv = *destAddr
19451		sv = append(sv, mv)
19452	}
19453	*v = sv
19454	return nil
19455}
19456func awsAwsquery_deserializeDocumentReservedCacheNodesOfferingNotFoundFault(v **types.ReservedCacheNodesOfferingNotFoundFault, decoder smithyxml.NodeDecoder) error {
19457	if v == nil {
19458		return fmt.Errorf("unexpected nil of type %T", v)
19459	}
19460	var sv *types.ReservedCacheNodesOfferingNotFoundFault
19461	if *v == nil {
19462		sv = &types.ReservedCacheNodesOfferingNotFoundFault{}
19463	} else {
19464		sv = *v
19465	}
19466
19467	for {
19468		t, done, err := decoder.Token()
19469		if err != nil {
19470			return err
19471		}
19472		if done {
19473			break
19474		}
19475		originalDecoder := decoder
19476		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
19477		switch {
19478		case strings.EqualFold("message", t.Name.Local):
19479			val, err := decoder.Value()
19480			if err != nil {
19481				return err
19482			}
19483			if val == nil {
19484				break
19485			}
19486			{
19487				xtv := string(val)
19488				sv.Message = ptr.String(xtv)
19489			}
19490
19491		default:
19492			// Do nothing and ignore the unexpected tag element
19493			err = decoder.Decoder.Skip()
19494			if err != nil {
19495				return err
19496			}
19497
19498		}
19499		decoder = originalDecoder
19500	}
19501	*v = sv
19502	return nil
19503}
19504
19505func awsAwsquery_deserializeDocumentReshardingStatus(v **types.ReshardingStatus, decoder smithyxml.NodeDecoder) error {
19506	if v == nil {
19507		return fmt.Errorf("unexpected nil of type %T", v)
19508	}
19509	var sv *types.ReshardingStatus
19510	if *v == nil {
19511		sv = &types.ReshardingStatus{}
19512	} else {
19513		sv = *v
19514	}
19515
19516	for {
19517		t, done, err := decoder.Token()
19518		if err != nil {
19519			return err
19520		}
19521		if done {
19522			break
19523		}
19524		originalDecoder := decoder
19525		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
19526		switch {
19527		case strings.EqualFold("SlotMigration", t.Name.Local):
19528			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
19529			if err := awsAwsquery_deserializeDocumentSlotMigration(&sv.SlotMigration, nodeDecoder); err != nil {
19530				return err
19531			}
19532
19533		default:
19534			// Do nothing and ignore the unexpected tag element
19535			err = decoder.Decoder.Skip()
19536			if err != nil {
19537				return err
19538			}
19539
19540		}
19541		decoder = originalDecoder
19542	}
19543	*v = sv
19544	return nil
19545}
19546
19547func awsAwsquery_deserializeDocumentSecurityGroupMembership(v **types.SecurityGroupMembership, decoder smithyxml.NodeDecoder) error {
19548	if v == nil {
19549		return fmt.Errorf("unexpected nil of type %T", v)
19550	}
19551	var sv *types.SecurityGroupMembership
19552	if *v == nil {
19553		sv = &types.SecurityGroupMembership{}
19554	} else {
19555		sv = *v
19556	}
19557
19558	for {
19559		t, done, err := decoder.Token()
19560		if err != nil {
19561			return err
19562		}
19563		if done {
19564			break
19565		}
19566		originalDecoder := decoder
19567		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
19568		switch {
19569		case strings.EqualFold("SecurityGroupId", t.Name.Local):
19570			val, err := decoder.Value()
19571			if err != nil {
19572				return err
19573			}
19574			if val == nil {
19575				break
19576			}
19577			{
19578				xtv := string(val)
19579				sv.SecurityGroupId = ptr.String(xtv)
19580			}
19581
19582		case strings.EqualFold("Status", t.Name.Local):
19583			val, err := decoder.Value()
19584			if err != nil {
19585				return err
19586			}
19587			if val == nil {
19588				break
19589			}
19590			{
19591				xtv := string(val)
19592				sv.Status = ptr.String(xtv)
19593			}
19594
19595		default:
19596			// Do nothing and ignore the unexpected tag element
19597			err = decoder.Decoder.Skip()
19598			if err != nil {
19599				return err
19600			}
19601
19602		}
19603		decoder = originalDecoder
19604	}
19605	*v = sv
19606	return nil
19607}
19608
19609func awsAwsquery_deserializeDocumentSecurityGroupMembershipList(v *[]types.SecurityGroupMembership, decoder smithyxml.NodeDecoder) error {
19610	if v == nil {
19611		return fmt.Errorf("unexpected nil of type %T", v)
19612	}
19613	var sv []types.SecurityGroupMembership
19614	if *v == nil {
19615		sv = make([]types.SecurityGroupMembership, 0)
19616	} else {
19617		sv = *v
19618	}
19619
19620	originalDecoder := decoder
19621	for {
19622		t, done, err := decoder.Token()
19623		if err != nil {
19624			return err
19625		}
19626		if done {
19627			break
19628		}
19629		switch {
19630		case strings.EqualFold("member", t.Name.Local):
19631			var col types.SecurityGroupMembership
19632			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
19633			destAddr := &col
19634			if err := awsAwsquery_deserializeDocumentSecurityGroupMembership(&destAddr, nodeDecoder); err != nil {
19635				return err
19636			}
19637			col = *destAddr
19638			sv = append(sv, col)
19639
19640		default:
19641			err = decoder.Decoder.Skip()
19642			if err != nil {
19643				return err
19644			}
19645
19646		}
19647		decoder = originalDecoder
19648	}
19649	*v = sv
19650	return nil
19651}
19652
19653func awsAwsquery_deserializeDocumentSecurityGroupMembershipListUnwrapped(v *[]types.SecurityGroupMembership, decoder smithyxml.NodeDecoder) error {
19654	var sv []types.SecurityGroupMembership
19655	if *v == nil {
19656		sv = make([]types.SecurityGroupMembership, 0)
19657	} else {
19658		sv = *v
19659	}
19660
19661	switch {
19662	default:
19663		var mv types.SecurityGroupMembership
19664		t := decoder.StartEl
19665		_ = t
19666		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
19667		destAddr := &mv
19668		if err := awsAwsquery_deserializeDocumentSecurityGroupMembership(&destAddr, nodeDecoder); err != nil {
19669			return err
19670		}
19671		mv = *destAddr
19672		sv = append(sv, mv)
19673	}
19674	*v = sv
19675	return nil
19676}
19677func awsAwsquery_deserializeDocumentServiceLinkedRoleNotFoundFault(v **types.ServiceLinkedRoleNotFoundFault, decoder smithyxml.NodeDecoder) error {
19678	if v == nil {
19679		return fmt.Errorf("unexpected nil of type %T", v)
19680	}
19681	var sv *types.ServiceLinkedRoleNotFoundFault
19682	if *v == nil {
19683		sv = &types.ServiceLinkedRoleNotFoundFault{}
19684	} else {
19685		sv = *v
19686	}
19687
19688	for {
19689		t, done, err := decoder.Token()
19690		if err != nil {
19691			return err
19692		}
19693		if done {
19694			break
19695		}
19696		originalDecoder := decoder
19697		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
19698		switch {
19699		case strings.EqualFold("message", t.Name.Local):
19700			val, err := decoder.Value()
19701			if err != nil {
19702				return err
19703			}
19704			if val == nil {
19705				break
19706			}
19707			{
19708				xtv := string(val)
19709				sv.Message = ptr.String(xtv)
19710			}
19711
19712		default:
19713			// Do nothing and ignore the unexpected tag element
19714			err = decoder.Decoder.Skip()
19715			if err != nil {
19716				return err
19717			}
19718
19719		}
19720		decoder = originalDecoder
19721	}
19722	*v = sv
19723	return nil
19724}
19725
19726func awsAwsquery_deserializeDocumentServiceUpdate(v **types.ServiceUpdate, decoder smithyxml.NodeDecoder) error {
19727	if v == nil {
19728		return fmt.Errorf("unexpected nil of type %T", v)
19729	}
19730	var sv *types.ServiceUpdate
19731	if *v == nil {
19732		sv = &types.ServiceUpdate{}
19733	} else {
19734		sv = *v
19735	}
19736
19737	for {
19738		t, done, err := decoder.Token()
19739		if err != nil {
19740			return err
19741		}
19742		if done {
19743			break
19744		}
19745		originalDecoder := decoder
19746		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
19747		switch {
19748		case strings.EqualFold("AutoUpdateAfterRecommendedApplyByDate", t.Name.Local):
19749			val, err := decoder.Value()
19750			if err != nil {
19751				return err
19752			}
19753			if val == nil {
19754				break
19755			}
19756			{
19757				xtv, err := strconv.ParseBool(string(val))
19758				if err != nil {
19759					return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", val)
19760				}
19761				sv.AutoUpdateAfterRecommendedApplyByDate = ptr.Bool(xtv)
19762			}
19763
19764		case strings.EqualFold("Engine", t.Name.Local):
19765			val, err := decoder.Value()
19766			if err != nil {
19767				return err
19768			}
19769			if val == nil {
19770				break
19771			}
19772			{
19773				xtv := string(val)
19774				sv.Engine = ptr.String(xtv)
19775			}
19776
19777		case strings.EqualFold("EngineVersion", t.Name.Local):
19778			val, err := decoder.Value()
19779			if err != nil {
19780				return err
19781			}
19782			if val == nil {
19783				break
19784			}
19785			{
19786				xtv := string(val)
19787				sv.EngineVersion = ptr.String(xtv)
19788			}
19789
19790		case strings.EqualFold("EstimatedUpdateTime", t.Name.Local):
19791			val, err := decoder.Value()
19792			if err != nil {
19793				return err
19794			}
19795			if val == nil {
19796				break
19797			}
19798			{
19799				xtv := string(val)
19800				sv.EstimatedUpdateTime = ptr.String(xtv)
19801			}
19802
19803		case strings.EqualFold("ServiceUpdateDescription", t.Name.Local):
19804			val, err := decoder.Value()
19805			if err != nil {
19806				return err
19807			}
19808			if val == nil {
19809				break
19810			}
19811			{
19812				xtv := string(val)
19813				sv.ServiceUpdateDescription = ptr.String(xtv)
19814			}
19815
19816		case strings.EqualFold("ServiceUpdateEndDate", t.Name.Local):
19817			val, err := decoder.Value()
19818			if err != nil {
19819				return err
19820			}
19821			if val == nil {
19822				break
19823			}
19824			{
19825				xtv := string(val)
19826				t, err := smithytime.ParseDateTime(xtv)
19827				if err != nil {
19828					return err
19829				}
19830				sv.ServiceUpdateEndDate = ptr.Time(t)
19831			}
19832
19833		case strings.EqualFold("ServiceUpdateName", t.Name.Local):
19834			val, err := decoder.Value()
19835			if err != nil {
19836				return err
19837			}
19838			if val == nil {
19839				break
19840			}
19841			{
19842				xtv := string(val)
19843				sv.ServiceUpdateName = ptr.String(xtv)
19844			}
19845
19846		case strings.EqualFold("ServiceUpdateRecommendedApplyByDate", t.Name.Local):
19847			val, err := decoder.Value()
19848			if err != nil {
19849				return err
19850			}
19851			if val == nil {
19852				break
19853			}
19854			{
19855				xtv := string(val)
19856				t, err := smithytime.ParseDateTime(xtv)
19857				if err != nil {
19858					return err
19859				}
19860				sv.ServiceUpdateRecommendedApplyByDate = ptr.Time(t)
19861			}
19862
19863		case strings.EqualFold("ServiceUpdateReleaseDate", t.Name.Local):
19864			val, err := decoder.Value()
19865			if err != nil {
19866				return err
19867			}
19868			if val == nil {
19869				break
19870			}
19871			{
19872				xtv := string(val)
19873				t, err := smithytime.ParseDateTime(xtv)
19874				if err != nil {
19875					return err
19876				}
19877				sv.ServiceUpdateReleaseDate = ptr.Time(t)
19878			}
19879
19880		case strings.EqualFold("ServiceUpdateSeverity", t.Name.Local):
19881			val, err := decoder.Value()
19882			if err != nil {
19883				return err
19884			}
19885			if val == nil {
19886				break
19887			}
19888			{
19889				xtv := string(val)
19890				sv.ServiceUpdateSeverity = types.ServiceUpdateSeverity(xtv)
19891			}
19892
19893		case strings.EqualFold("ServiceUpdateStatus", t.Name.Local):
19894			val, err := decoder.Value()
19895			if err != nil {
19896				return err
19897			}
19898			if val == nil {
19899				break
19900			}
19901			{
19902				xtv := string(val)
19903				sv.ServiceUpdateStatus = types.ServiceUpdateStatus(xtv)
19904			}
19905
19906		case strings.EqualFold("ServiceUpdateType", t.Name.Local):
19907			val, err := decoder.Value()
19908			if err != nil {
19909				return err
19910			}
19911			if val == nil {
19912				break
19913			}
19914			{
19915				xtv := string(val)
19916				sv.ServiceUpdateType = types.ServiceUpdateType(xtv)
19917			}
19918
19919		default:
19920			// Do nothing and ignore the unexpected tag element
19921			err = decoder.Decoder.Skip()
19922			if err != nil {
19923				return err
19924			}
19925
19926		}
19927		decoder = originalDecoder
19928	}
19929	*v = sv
19930	return nil
19931}
19932
19933func awsAwsquery_deserializeDocumentServiceUpdateList(v *[]types.ServiceUpdate, decoder smithyxml.NodeDecoder) error {
19934	if v == nil {
19935		return fmt.Errorf("unexpected nil of type %T", v)
19936	}
19937	var sv []types.ServiceUpdate
19938	if *v == nil {
19939		sv = make([]types.ServiceUpdate, 0)
19940	} else {
19941		sv = *v
19942	}
19943
19944	originalDecoder := decoder
19945	for {
19946		t, done, err := decoder.Token()
19947		if err != nil {
19948			return err
19949		}
19950		if done {
19951			break
19952		}
19953		switch {
19954		case strings.EqualFold("ServiceUpdate", t.Name.Local):
19955			var col types.ServiceUpdate
19956			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
19957			destAddr := &col
19958			if err := awsAwsquery_deserializeDocumentServiceUpdate(&destAddr, nodeDecoder); err != nil {
19959				return err
19960			}
19961			col = *destAddr
19962			sv = append(sv, col)
19963
19964		default:
19965			err = decoder.Decoder.Skip()
19966			if err != nil {
19967				return err
19968			}
19969
19970		}
19971		decoder = originalDecoder
19972	}
19973	*v = sv
19974	return nil
19975}
19976
19977func awsAwsquery_deserializeDocumentServiceUpdateListUnwrapped(v *[]types.ServiceUpdate, decoder smithyxml.NodeDecoder) error {
19978	var sv []types.ServiceUpdate
19979	if *v == nil {
19980		sv = make([]types.ServiceUpdate, 0)
19981	} else {
19982		sv = *v
19983	}
19984
19985	switch {
19986	default:
19987		var mv types.ServiceUpdate
19988		t := decoder.StartEl
19989		_ = t
19990		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
19991		destAddr := &mv
19992		if err := awsAwsquery_deserializeDocumentServiceUpdate(&destAddr, nodeDecoder); err != nil {
19993			return err
19994		}
19995		mv = *destAddr
19996		sv = append(sv, mv)
19997	}
19998	*v = sv
19999	return nil
20000}
20001func awsAwsquery_deserializeDocumentServiceUpdateNotFoundFault(v **types.ServiceUpdateNotFoundFault, decoder smithyxml.NodeDecoder) error {
20002	if v == nil {
20003		return fmt.Errorf("unexpected nil of type %T", v)
20004	}
20005	var sv *types.ServiceUpdateNotFoundFault
20006	if *v == nil {
20007		sv = &types.ServiceUpdateNotFoundFault{}
20008	} else {
20009		sv = *v
20010	}
20011
20012	for {
20013		t, done, err := decoder.Token()
20014		if err != nil {
20015			return err
20016		}
20017		if done {
20018			break
20019		}
20020		originalDecoder := decoder
20021		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
20022		switch {
20023		case strings.EqualFold("message", t.Name.Local):
20024			val, err := decoder.Value()
20025			if err != nil {
20026				return err
20027			}
20028			if val == nil {
20029				break
20030			}
20031			{
20032				xtv := string(val)
20033				sv.Message = ptr.String(xtv)
20034			}
20035
20036		default:
20037			// Do nothing and ignore the unexpected tag element
20038			err = decoder.Decoder.Skip()
20039			if err != nil {
20040				return err
20041			}
20042
20043		}
20044		decoder = originalDecoder
20045	}
20046	*v = sv
20047	return nil
20048}
20049
20050func awsAwsquery_deserializeDocumentSlotMigration(v **types.SlotMigration, decoder smithyxml.NodeDecoder) error {
20051	if v == nil {
20052		return fmt.Errorf("unexpected nil of type %T", v)
20053	}
20054	var sv *types.SlotMigration
20055	if *v == nil {
20056		sv = &types.SlotMigration{}
20057	} else {
20058		sv = *v
20059	}
20060
20061	for {
20062		t, done, err := decoder.Token()
20063		if err != nil {
20064			return err
20065		}
20066		if done {
20067			break
20068		}
20069		originalDecoder := decoder
20070		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
20071		switch {
20072		case strings.EqualFold("ProgressPercentage", t.Name.Local):
20073			val, err := decoder.Value()
20074			if err != nil {
20075				return err
20076			}
20077			if val == nil {
20078				break
20079			}
20080			{
20081				xtv := string(val)
20082				f64, err := strconv.ParseFloat(xtv, 64)
20083				if err != nil {
20084					return err
20085				}
20086				sv.ProgressPercentage = f64
20087			}
20088
20089		default:
20090			// Do nothing and ignore the unexpected tag element
20091			err = decoder.Decoder.Skip()
20092			if err != nil {
20093				return err
20094			}
20095
20096		}
20097		decoder = originalDecoder
20098	}
20099	*v = sv
20100	return nil
20101}
20102
20103func awsAwsquery_deserializeDocumentSnapshot(v **types.Snapshot, decoder smithyxml.NodeDecoder) error {
20104	if v == nil {
20105		return fmt.Errorf("unexpected nil of type %T", v)
20106	}
20107	var sv *types.Snapshot
20108	if *v == nil {
20109		sv = &types.Snapshot{}
20110	} else {
20111		sv = *v
20112	}
20113
20114	for {
20115		t, done, err := decoder.Token()
20116		if err != nil {
20117			return err
20118		}
20119		if done {
20120			break
20121		}
20122		originalDecoder := decoder
20123		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
20124		switch {
20125		case strings.EqualFold("ARN", t.Name.Local):
20126			val, err := decoder.Value()
20127			if err != nil {
20128				return err
20129			}
20130			if val == nil {
20131				break
20132			}
20133			{
20134				xtv := string(val)
20135				sv.ARN = ptr.String(xtv)
20136			}
20137
20138		case strings.EqualFold("AutomaticFailover", t.Name.Local):
20139			val, err := decoder.Value()
20140			if err != nil {
20141				return err
20142			}
20143			if val == nil {
20144				break
20145			}
20146			{
20147				xtv := string(val)
20148				sv.AutomaticFailover = types.AutomaticFailoverStatus(xtv)
20149			}
20150
20151		case strings.EqualFold("AutoMinorVersionUpgrade", t.Name.Local):
20152			val, err := decoder.Value()
20153			if err != nil {
20154				return err
20155			}
20156			if val == nil {
20157				break
20158			}
20159			{
20160				xtv, err := strconv.ParseBool(string(val))
20161				if err != nil {
20162					return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val)
20163				}
20164				sv.AutoMinorVersionUpgrade = xtv
20165			}
20166
20167		case strings.EqualFold("CacheClusterCreateTime", t.Name.Local):
20168			val, err := decoder.Value()
20169			if err != nil {
20170				return err
20171			}
20172			if val == nil {
20173				break
20174			}
20175			{
20176				xtv := string(val)
20177				t, err := smithytime.ParseDateTime(xtv)
20178				if err != nil {
20179					return err
20180				}
20181				sv.CacheClusterCreateTime = ptr.Time(t)
20182			}
20183
20184		case strings.EqualFold("CacheClusterId", t.Name.Local):
20185			val, err := decoder.Value()
20186			if err != nil {
20187				return err
20188			}
20189			if val == nil {
20190				break
20191			}
20192			{
20193				xtv := string(val)
20194				sv.CacheClusterId = ptr.String(xtv)
20195			}
20196
20197		case strings.EqualFold("CacheNodeType", t.Name.Local):
20198			val, err := decoder.Value()
20199			if err != nil {
20200				return err
20201			}
20202			if val == nil {
20203				break
20204			}
20205			{
20206				xtv := string(val)
20207				sv.CacheNodeType = ptr.String(xtv)
20208			}
20209
20210		case strings.EqualFold("CacheParameterGroupName", t.Name.Local):
20211			val, err := decoder.Value()
20212			if err != nil {
20213				return err
20214			}
20215			if val == nil {
20216				break
20217			}
20218			{
20219				xtv := string(val)
20220				sv.CacheParameterGroupName = ptr.String(xtv)
20221			}
20222
20223		case strings.EqualFold("CacheSubnetGroupName", t.Name.Local):
20224			val, err := decoder.Value()
20225			if err != nil {
20226				return err
20227			}
20228			if val == nil {
20229				break
20230			}
20231			{
20232				xtv := string(val)
20233				sv.CacheSubnetGroupName = ptr.String(xtv)
20234			}
20235
20236		case strings.EqualFold("Engine", t.Name.Local):
20237			val, err := decoder.Value()
20238			if err != nil {
20239				return err
20240			}
20241			if val == nil {
20242				break
20243			}
20244			{
20245				xtv := string(val)
20246				sv.Engine = ptr.String(xtv)
20247			}
20248
20249		case strings.EqualFold("EngineVersion", t.Name.Local):
20250			val, err := decoder.Value()
20251			if err != nil {
20252				return err
20253			}
20254			if val == nil {
20255				break
20256			}
20257			{
20258				xtv := string(val)
20259				sv.EngineVersion = ptr.String(xtv)
20260			}
20261
20262		case strings.EqualFold("KmsKeyId", t.Name.Local):
20263			val, err := decoder.Value()
20264			if err != nil {
20265				return err
20266			}
20267			if val == nil {
20268				break
20269			}
20270			{
20271				xtv := string(val)
20272				sv.KmsKeyId = ptr.String(xtv)
20273			}
20274
20275		case strings.EqualFold("NodeSnapshots", t.Name.Local):
20276			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
20277			if err := awsAwsquery_deserializeDocumentNodeSnapshotList(&sv.NodeSnapshots, nodeDecoder); err != nil {
20278				return err
20279			}
20280
20281		case strings.EqualFold("NumCacheNodes", t.Name.Local):
20282			val, err := decoder.Value()
20283			if err != nil {
20284				return err
20285			}
20286			if val == nil {
20287				break
20288			}
20289			{
20290				xtv := string(val)
20291				i64, err := strconv.ParseInt(xtv, 10, 64)
20292				if err != nil {
20293					return err
20294				}
20295				sv.NumCacheNodes = ptr.Int32(int32(i64))
20296			}
20297
20298		case strings.EqualFold("NumNodeGroups", t.Name.Local):
20299			val, err := decoder.Value()
20300			if err != nil {
20301				return err
20302			}
20303			if val == nil {
20304				break
20305			}
20306			{
20307				xtv := string(val)
20308				i64, err := strconv.ParseInt(xtv, 10, 64)
20309				if err != nil {
20310					return err
20311				}
20312				sv.NumNodeGroups = ptr.Int32(int32(i64))
20313			}
20314
20315		case strings.EqualFold("Port", t.Name.Local):
20316			val, err := decoder.Value()
20317			if err != nil {
20318				return err
20319			}
20320			if val == nil {
20321				break
20322			}
20323			{
20324				xtv := string(val)
20325				i64, err := strconv.ParseInt(xtv, 10, 64)
20326				if err != nil {
20327					return err
20328				}
20329				sv.Port = ptr.Int32(int32(i64))
20330			}
20331
20332		case strings.EqualFold("PreferredAvailabilityZone", t.Name.Local):
20333			val, err := decoder.Value()
20334			if err != nil {
20335				return err
20336			}
20337			if val == nil {
20338				break
20339			}
20340			{
20341				xtv := string(val)
20342				sv.PreferredAvailabilityZone = ptr.String(xtv)
20343			}
20344
20345		case strings.EqualFold("PreferredMaintenanceWindow", t.Name.Local):
20346			val, err := decoder.Value()
20347			if err != nil {
20348				return err
20349			}
20350			if val == nil {
20351				break
20352			}
20353			{
20354				xtv := string(val)
20355				sv.PreferredMaintenanceWindow = ptr.String(xtv)
20356			}
20357
20358		case strings.EqualFold("PreferredOutpostArn", t.Name.Local):
20359			val, err := decoder.Value()
20360			if err != nil {
20361				return err
20362			}
20363			if val == nil {
20364				break
20365			}
20366			{
20367				xtv := string(val)
20368				sv.PreferredOutpostArn = ptr.String(xtv)
20369			}
20370
20371		case strings.EqualFold("ReplicationGroupDescription", t.Name.Local):
20372			val, err := decoder.Value()
20373			if err != nil {
20374				return err
20375			}
20376			if val == nil {
20377				break
20378			}
20379			{
20380				xtv := string(val)
20381				sv.ReplicationGroupDescription = ptr.String(xtv)
20382			}
20383
20384		case strings.EqualFold("ReplicationGroupId", t.Name.Local):
20385			val, err := decoder.Value()
20386			if err != nil {
20387				return err
20388			}
20389			if val == nil {
20390				break
20391			}
20392			{
20393				xtv := string(val)
20394				sv.ReplicationGroupId = ptr.String(xtv)
20395			}
20396
20397		case strings.EqualFold("SnapshotName", t.Name.Local):
20398			val, err := decoder.Value()
20399			if err != nil {
20400				return err
20401			}
20402			if val == nil {
20403				break
20404			}
20405			{
20406				xtv := string(val)
20407				sv.SnapshotName = ptr.String(xtv)
20408			}
20409
20410		case strings.EqualFold("SnapshotRetentionLimit", t.Name.Local):
20411			val, err := decoder.Value()
20412			if err != nil {
20413				return err
20414			}
20415			if val == nil {
20416				break
20417			}
20418			{
20419				xtv := string(val)
20420				i64, err := strconv.ParseInt(xtv, 10, 64)
20421				if err != nil {
20422					return err
20423				}
20424				sv.SnapshotRetentionLimit = ptr.Int32(int32(i64))
20425			}
20426
20427		case strings.EqualFold("SnapshotSource", t.Name.Local):
20428			val, err := decoder.Value()
20429			if err != nil {
20430				return err
20431			}
20432			if val == nil {
20433				break
20434			}
20435			{
20436				xtv := string(val)
20437				sv.SnapshotSource = ptr.String(xtv)
20438			}
20439
20440		case strings.EqualFold("SnapshotStatus", t.Name.Local):
20441			val, err := decoder.Value()
20442			if err != nil {
20443				return err
20444			}
20445			if val == nil {
20446				break
20447			}
20448			{
20449				xtv := string(val)
20450				sv.SnapshotStatus = ptr.String(xtv)
20451			}
20452
20453		case strings.EqualFold("SnapshotWindow", t.Name.Local):
20454			val, err := decoder.Value()
20455			if err != nil {
20456				return err
20457			}
20458			if val == nil {
20459				break
20460			}
20461			{
20462				xtv := string(val)
20463				sv.SnapshotWindow = ptr.String(xtv)
20464			}
20465
20466		case strings.EqualFold("TopicArn", t.Name.Local):
20467			val, err := decoder.Value()
20468			if err != nil {
20469				return err
20470			}
20471			if val == nil {
20472				break
20473			}
20474			{
20475				xtv := string(val)
20476				sv.TopicArn = ptr.String(xtv)
20477			}
20478
20479		case strings.EqualFold("VpcId", t.Name.Local):
20480			val, err := decoder.Value()
20481			if err != nil {
20482				return err
20483			}
20484			if val == nil {
20485				break
20486			}
20487			{
20488				xtv := string(val)
20489				sv.VpcId = ptr.String(xtv)
20490			}
20491
20492		default:
20493			// Do nothing and ignore the unexpected tag element
20494			err = decoder.Decoder.Skip()
20495			if err != nil {
20496				return err
20497			}
20498
20499		}
20500		decoder = originalDecoder
20501	}
20502	*v = sv
20503	return nil
20504}
20505
20506func awsAwsquery_deserializeDocumentSnapshotAlreadyExistsFault(v **types.SnapshotAlreadyExistsFault, decoder smithyxml.NodeDecoder) error {
20507	if v == nil {
20508		return fmt.Errorf("unexpected nil of type %T", v)
20509	}
20510	var sv *types.SnapshotAlreadyExistsFault
20511	if *v == nil {
20512		sv = &types.SnapshotAlreadyExistsFault{}
20513	} else {
20514		sv = *v
20515	}
20516
20517	for {
20518		t, done, err := decoder.Token()
20519		if err != nil {
20520			return err
20521		}
20522		if done {
20523			break
20524		}
20525		originalDecoder := decoder
20526		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
20527		switch {
20528		case strings.EqualFold("message", t.Name.Local):
20529			val, err := decoder.Value()
20530			if err != nil {
20531				return err
20532			}
20533			if val == nil {
20534				break
20535			}
20536			{
20537				xtv := string(val)
20538				sv.Message = ptr.String(xtv)
20539			}
20540
20541		default:
20542			// Do nothing and ignore the unexpected tag element
20543			err = decoder.Decoder.Skip()
20544			if err != nil {
20545				return err
20546			}
20547
20548		}
20549		decoder = originalDecoder
20550	}
20551	*v = sv
20552	return nil
20553}
20554
20555func awsAwsquery_deserializeDocumentSnapshotFeatureNotSupportedFault(v **types.SnapshotFeatureNotSupportedFault, decoder smithyxml.NodeDecoder) error {
20556	if v == nil {
20557		return fmt.Errorf("unexpected nil of type %T", v)
20558	}
20559	var sv *types.SnapshotFeatureNotSupportedFault
20560	if *v == nil {
20561		sv = &types.SnapshotFeatureNotSupportedFault{}
20562	} else {
20563		sv = *v
20564	}
20565
20566	for {
20567		t, done, err := decoder.Token()
20568		if err != nil {
20569			return err
20570		}
20571		if done {
20572			break
20573		}
20574		originalDecoder := decoder
20575		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
20576		switch {
20577		case strings.EqualFold("message", t.Name.Local):
20578			val, err := decoder.Value()
20579			if err != nil {
20580				return err
20581			}
20582			if val == nil {
20583				break
20584			}
20585			{
20586				xtv := string(val)
20587				sv.Message = ptr.String(xtv)
20588			}
20589
20590		default:
20591			// Do nothing and ignore the unexpected tag element
20592			err = decoder.Decoder.Skip()
20593			if err != nil {
20594				return err
20595			}
20596
20597		}
20598		decoder = originalDecoder
20599	}
20600	*v = sv
20601	return nil
20602}
20603
20604func awsAwsquery_deserializeDocumentSnapshotList(v *[]types.Snapshot, decoder smithyxml.NodeDecoder) error {
20605	if v == nil {
20606		return fmt.Errorf("unexpected nil of type %T", v)
20607	}
20608	var sv []types.Snapshot
20609	if *v == nil {
20610		sv = make([]types.Snapshot, 0)
20611	} else {
20612		sv = *v
20613	}
20614
20615	originalDecoder := decoder
20616	for {
20617		t, done, err := decoder.Token()
20618		if err != nil {
20619			return err
20620		}
20621		if done {
20622			break
20623		}
20624		switch {
20625		case strings.EqualFold("Snapshot", t.Name.Local):
20626			var col types.Snapshot
20627			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
20628			destAddr := &col
20629			if err := awsAwsquery_deserializeDocumentSnapshot(&destAddr, nodeDecoder); err != nil {
20630				return err
20631			}
20632			col = *destAddr
20633			sv = append(sv, col)
20634
20635		default:
20636			err = decoder.Decoder.Skip()
20637			if err != nil {
20638				return err
20639			}
20640
20641		}
20642		decoder = originalDecoder
20643	}
20644	*v = sv
20645	return nil
20646}
20647
20648func awsAwsquery_deserializeDocumentSnapshotListUnwrapped(v *[]types.Snapshot, decoder smithyxml.NodeDecoder) error {
20649	var sv []types.Snapshot
20650	if *v == nil {
20651		sv = make([]types.Snapshot, 0)
20652	} else {
20653		sv = *v
20654	}
20655
20656	switch {
20657	default:
20658		var mv types.Snapshot
20659		t := decoder.StartEl
20660		_ = t
20661		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
20662		destAddr := &mv
20663		if err := awsAwsquery_deserializeDocumentSnapshot(&destAddr, nodeDecoder); err != nil {
20664			return err
20665		}
20666		mv = *destAddr
20667		sv = append(sv, mv)
20668	}
20669	*v = sv
20670	return nil
20671}
20672func awsAwsquery_deserializeDocumentSnapshotNotFoundFault(v **types.SnapshotNotFoundFault, decoder smithyxml.NodeDecoder) error {
20673	if v == nil {
20674		return fmt.Errorf("unexpected nil of type %T", v)
20675	}
20676	var sv *types.SnapshotNotFoundFault
20677	if *v == nil {
20678		sv = &types.SnapshotNotFoundFault{}
20679	} else {
20680		sv = *v
20681	}
20682
20683	for {
20684		t, done, err := decoder.Token()
20685		if err != nil {
20686			return err
20687		}
20688		if done {
20689			break
20690		}
20691		originalDecoder := decoder
20692		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
20693		switch {
20694		case strings.EqualFold("message", t.Name.Local):
20695			val, err := decoder.Value()
20696			if err != nil {
20697				return err
20698			}
20699			if val == nil {
20700				break
20701			}
20702			{
20703				xtv := string(val)
20704				sv.Message = ptr.String(xtv)
20705			}
20706
20707		default:
20708			// Do nothing and ignore the unexpected tag element
20709			err = decoder.Decoder.Skip()
20710			if err != nil {
20711				return err
20712			}
20713
20714		}
20715		decoder = originalDecoder
20716	}
20717	*v = sv
20718	return nil
20719}
20720
20721func awsAwsquery_deserializeDocumentSnapshotQuotaExceededFault(v **types.SnapshotQuotaExceededFault, decoder smithyxml.NodeDecoder) error {
20722	if v == nil {
20723		return fmt.Errorf("unexpected nil of type %T", v)
20724	}
20725	var sv *types.SnapshotQuotaExceededFault
20726	if *v == nil {
20727		sv = &types.SnapshotQuotaExceededFault{}
20728	} else {
20729		sv = *v
20730	}
20731
20732	for {
20733		t, done, err := decoder.Token()
20734		if err != nil {
20735			return err
20736		}
20737		if done {
20738			break
20739		}
20740		originalDecoder := decoder
20741		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
20742		switch {
20743		case strings.EqualFold("message", t.Name.Local):
20744			val, err := decoder.Value()
20745			if err != nil {
20746				return err
20747			}
20748			if val == nil {
20749				break
20750			}
20751			{
20752				xtv := string(val)
20753				sv.Message = ptr.String(xtv)
20754			}
20755
20756		default:
20757			// Do nothing and ignore the unexpected tag element
20758			err = decoder.Decoder.Skip()
20759			if err != nil {
20760				return err
20761			}
20762
20763		}
20764		decoder = originalDecoder
20765	}
20766	*v = sv
20767	return nil
20768}
20769
20770func awsAwsquery_deserializeDocumentSubnet(v **types.Subnet, decoder smithyxml.NodeDecoder) error {
20771	if v == nil {
20772		return fmt.Errorf("unexpected nil of type %T", v)
20773	}
20774	var sv *types.Subnet
20775	if *v == nil {
20776		sv = &types.Subnet{}
20777	} else {
20778		sv = *v
20779	}
20780
20781	for {
20782		t, done, err := decoder.Token()
20783		if err != nil {
20784			return err
20785		}
20786		if done {
20787			break
20788		}
20789		originalDecoder := decoder
20790		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
20791		switch {
20792		case strings.EqualFold("SubnetAvailabilityZone", t.Name.Local):
20793			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
20794			if err := awsAwsquery_deserializeDocumentAvailabilityZone(&sv.SubnetAvailabilityZone, nodeDecoder); err != nil {
20795				return err
20796			}
20797
20798		case strings.EqualFold("SubnetIdentifier", t.Name.Local):
20799			val, err := decoder.Value()
20800			if err != nil {
20801				return err
20802			}
20803			if val == nil {
20804				break
20805			}
20806			{
20807				xtv := string(val)
20808				sv.SubnetIdentifier = ptr.String(xtv)
20809			}
20810
20811		case strings.EqualFold("SubnetOutpost", t.Name.Local):
20812			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
20813			if err := awsAwsquery_deserializeDocumentSubnetOutpost(&sv.SubnetOutpost, nodeDecoder); err != nil {
20814				return err
20815			}
20816
20817		default:
20818			// Do nothing and ignore the unexpected tag element
20819			err = decoder.Decoder.Skip()
20820			if err != nil {
20821				return err
20822			}
20823
20824		}
20825		decoder = originalDecoder
20826	}
20827	*v = sv
20828	return nil
20829}
20830
20831func awsAwsquery_deserializeDocumentSubnetInUse(v **types.SubnetInUse, decoder smithyxml.NodeDecoder) error {
20832	if v == nil {
20833		return fmt.Errorf("unexpected nil of type %T", v)
20834	}
20835	var sv *types.SubnetInUse
20836	if *v == nil {
20837		sv = &types.SubnetInUse{}
20838	} else {
20839		sv = *v
20840	}
20841
20842	for {
20843		t, done, err := decoder.Token()
20844		if err != nil {
20845			return err
20846		}
20847		if done {
20848			break
20849		}
20850		originalDecoder := decoder
20851		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
20852		switch {
20853		case strings.EqualFold("message", t.Name.Local):
20854			val, err := decoder.Value()
20855			if err != nil {
20856				return err
20857			}
20858			if val == nil {
20859				break
20860			}
20861			{
20862				xtv := string(val)
20863				sv.Message = ptr.String(xtv)
20864			}
20865
20866		default:
20867			// Do nothing and ignore the unexpected tag element
20868			err = decoder.Decoder.Skip()
20869			if err != nil {
20870				return err
20871			}
20872
20873		}
20874		decoder = originalDecoder
20875	}
20876	*v = sv
20877	return nil
20878}
20879
20880func awsAwsquery_deserializeDocumentSubnetList(v *[]types.Subnet, decoder smithyxml.NodeDecoder) error {
20881	if v == nil {
20882		return fmt.Errorf("unexpected nil of type %T", v)
20883	}
20884	var sv []types.Subnet
20885	if *v == nil {
20886		sv = make([]types.Subnet, 0)
20887	} else {
20888		sv = *v
20889	}
20890
20891	originalDecoder := decoder
20892	for {
20893		t, done, err := decoder.Token()
20894		if err != nil {
20895			return err
20896		}
20897		if done {
20898			break
20899		}
20900		switch {
20901		case strings.EqualFold("Subnet", t.Name.Local):
20902			var col types.Subnet
20903			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
20904			destAddr := &col
20905			if err := awsAwsquery_deserializeDocumentSubnet(&destAddr, nodeDecoder); err != nil {
20906				return err
20907			}
20908			col = *destAddr
20909			sv = append(sv, col)
20910
20911		default:
20912			err = decoder.Decoder.Skip()
20913			if err != nil {
20914				return err
20915			}
20916
20917		}
20918		decoder = originalDecoder
20919	}
20920	*v = sv
20921	return nil
20922}
20923
20924func awsAwsquery_deserializeDocumentSubnetListUnwrapped(v *[]types.Subnet, decoder smithyxml.NodeDecoder) error {
20925	var sv []types.Subnet
20926	if *v == nil {
20927		sv = make([]types.Subnet, 0)
20928	} else {
20929		sv = *v
20930	}
20931
20932	switch {
20933	default:
20934		var mv types.Subnet
20935		t := decoder.StartEl
20936		_ = t
20937		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
20938		destAddr := &mv
20939		if err := awsAwsquery_deserializeDocumentSubnet(&destAddr, nodeDecoder); err != nil {
20940			return err
20941		}
20942		mv = *destAddr
20943		sv = append(sv, mv)
20944	}
20945	*v = sv
20946	return nil
20947}
20948func awsAwsquery_deserializeDocumentSubnetNotAllowedFault(v **types.SubnetNotAllowedFault, decoder smithyxml.NodeDecoder) error {
20949	if v == nil {
20950		return fmt.Errorf("unexpected nil of type %T", v)
20951	}
20952	var sv *types.SubnetNotAllowedFault
20953	if *v == nil {
20954		sv = &types.SubnetNotAllowedFault{}
20955	} else {
20956		sv = *v
20957	}
20958
20959	for {
20960		t, done, err := decoder.Token()
20961		if err != nil {
20962			return err
20963		}
20964		if done {
20965			break
20966		}
20967		originalDecoder := decoder
20968		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
20969		switch {
20970		case strings.EqualFold("message", t.Name.Local):
20971			val, err := decoder.Value()
20972			if err != nil {
20973				return err
20974			}
20975			if val == nil {
20976				break
20977			}
20978			{
20979				xtv := string(val)
20980				sv.Message = ptr.String(xtv)
20981			}
20982
20983		default:
20984			// Do nothing and ignore the unexpected tag element
20985			err = decoder.Decoder.Skip()
20986			if err != nil {
20987				return err
20988			}
20989
20990		}
20991		decoder = originalDecoder
20992	}
20993	*v = sv
20994	return nil
20995}
20996
20997func awsAwsquery_deserializeDocumentSubnetOutpost(v **types.SubnetOutpost, decoder smithyxml.NodeDecoder) error {
20998	if v == nil {
20999		return fmt.Errorf("unexpected nil of type %T", v)
21000	}
21001	var sv *types.SubnetOutpost
21002	if *v == nil {
21003		sv = &types.SubnetOutpost{}
21004	} else {
21005		sv = *v
21006	}
21007
21008	for {
21009		t, done, err := decoder.Token()
21010		if err != nil {
21011			return err
21012		}
21013		if done {
21014			break
21015		}
21016		originalDecoder := decoder
21017		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
21018		switch {
21019		case strings.EqualFold("SubnetOutpostArn", t.Name.Local):
21020			val, err := decoder.Value()
21021			if err != nil {
21022				return err
21023			}
21024			if val == nil {
21025				break
21026			}
21027			{
21028				xtv := string(val)
21029				sv.SubnetOutpostArn = ptr.String(xtv)
21030			}
21031
21032		default:
21033			// Do nothing and ignore the unexpected tag element
21034			err = decoder.Decoder.Skip()
21035			if err != nil {
21036				return err
21037			}
21038
21039		}
21040		decoder = originalDecoder
21041	}
21042	*v = sv
21043	return nil
21044}
21045
21046func awsAwsquery_deserializeDocumentTag(v **types.Tag, decoder smithyxml.NodeDecoder) error {
21047	if v == nil {
21048		return fmt.Errorf("unexpected nil of type %T", v)
21049	}
21050	var sv *types.Tag
21051	if *v == nil {
21052		sv = &types.Tag{}
21053	} else {
21054		sv = *v
21055	}
21056
21057	for {
21058		t, done, err := decoder.Token()
21059		if err != nil {
21060			return err
21061		}
21062		if done {
21063			break
21064		}
21065		originalDecoder := decoder
21066		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
21067		switch {
21068		case strings.EqualFold("Key", t.Name.Local):
21069			val, err := decoder.Value()
21070			if err != nil {
21071				return err
21072			}
21073			if val == nil {
21074				break
21075			}
21076			{
21077				xtv := string(val)
21078				sv.Key = ptr.String(xtv)
21079			}
21080
21081		case strings.EqualFold("Value", t.Name.Local):
21082			val, err := decoder.Value()
21083			if err != nil {
21084				return err
21085			}
21086			if val == nil {
21087				break
21088			}
21089			{
21090				xtv := string(val)
21091				sv.Value = ptr.String(xtv)
21092			}
21093
21094		default:
21095			// Do nothing and ignore the unexpected tag element
21096			err = decoder.Decoder.Skip()
21097			if err != nil {
21098				return err
21099			}
21100
21101		}
21102		decoder = originalDecoder
21103	}
21104	*v = sv
21105	return nil
21106}
21107
21108func awsAwsquery_deserializeDocumentTagList(v *[]types.Tag, decoder smithyxml.NodeDecoder) error {
21109	if v == nil {
21110		return fmt.Errorf("unexpected nil of type %T", v)
21111	}
21112	var sv []types.Tag
21113	if *v == nil {
21114		sv = make([]types.Tag, 0)
21115	} else {
21116		sv = *v
21117	}
21118
21119	originalDecoder := decoder
21120	for {
21121		t, done, err := decoder.Token()
21122		if err != nil {
21123			return err
21124		}
21125		if done {
21126			break
21127		}
21128		switch {
21129		case strings.EqualFold("Tag", t.Name.Local):
21130			var col types.Tag
21131			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
21132			destAddr := &col
21133			if err := awsAwsquery_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil {
21134				return err
21135			}
21136			col = *destAddr
21137			sv = append(sv, col)
21138
21139		default:
21140			err = decoder.Decoder.Skip()
21141			if err != nil {
21142				return err
21143			}
21144
21145		}
21146		decoder = originalDecoder
21147	}
21148	*v = sv
21149	return nil
21150}
21151
21152func awsAwsquery_deserializeDocumentTagListUnwrapped(v *[]types.Tag, decoder smithyxml.NodeDecoder) error {
21153	var sv []types.Tag
21154	if *v == nil {
21155		sv = make([]types.Tag, 0)
21156	} else {
21157		sv = *v
21158	}
21159
21160	switch {
21161	default:
21162		var mv types.Tag
21163		t := decoder.StartEl
21164		_ = t
21165		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
21166		destAddr := &mv
21167		if err := awsAwsquery_deserializeDocumentTag(&destAddr, nodeDecoder); err != nil {
21168			return err
21169		}
21170		mv = *destAddr
21171		sv = append(sv, mv)
21172	}
21173	*v = sv
21174	return nil
21175}
21176func awsAwsquery_deserializeDocumentTagNotFoundFault(v **types.TagNotFoundFault, decoder smithyxml.NodeDecoder) error {
21177	if v == nil {
21178		return fmt.Errorf("unexpected nil of type %T", v)
21179	}
21180	var sv *types.TagNotFoundFault
21181	if *v == nil {
21182		sv = &types.TagNotFoundFault{}
21183	} else {
21184		sv = *v
21185	}
21186
21187	for {
21188		t, done, err := decoder.Token()
21189		if err != nil {
21190			return err
21191		}
21192		if done {
21193			break
21194		}
21195		originalDecoder := decoder
21196		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
21197		switch {
21198		case strings.EqualFold("message", t.Name.Local):
21199			val, err := decoder.Value()
21200			if err != nil {
21201				return err
21202			}
21203			if val == nil {
21204				break
21205			}
21206			{
21207				xtv := string(val)
21208				sv.Message = ptr.String(xtv)
21209			}
21210
21211		default:
21212			// Do nothing and ignore the unexpected tag element
21213			err = decoder.Decoder.Skip()
21214			if err != nil {
21215				return err
21216			}
21217
21218		}
21219		decoder = originalDecoder
21220	}
21221	*v = sv
21222	return nil
21223}
21224
21225func awsAwsquery_deserializeDocumentTagQuotaPerResourceExceeded(v **types.TagQuotaPerResourceExceeded, decoder smithyxml.NodeDecoder) error {
21226	if v == nil {
21227		return fmt.Errorf("unexpected nil of type %T", v)
21228	}
21229	var sv *types.TagQuotaPerResourceExceeded
21230	if *v == nil {
21231		sv = &types.TagQuotaPerResourceExceeded{}
21232	} else {
21233		sv = *v
21234	}
21235
21236	for {
21237		t, done, err := decoder.Token()
21238		if err != nil {
21239			return err
21240		}
21241		if done {
21242			break
21243		}
21244		originalDecoder := decoder
21245		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
21246		switch {
21247		case strings.EqualFold("message", t.Name.Local):
21248			val, err := decoder.Value()
21249			if err != nil {
21250				return err
21251			}
21252			if val == nil {
21253				break
21254			}
21255			{
21256				xtv := string(val)
21257				sv.Message = ptr.String(xtv)
21258			}
21259
21260		default:
21261			// Do nothing and ignore the unexpected tag element
21262			err = decoder.Decoder.Skip()
21263			if err != nil {
21264				return err
21265			}
21266
21267		}
21268		decoder = originalDecoder
21269	}
21270	*v = sv
21271	return nil
21272}
21273
21274func awsAwsquery_deserializeDocumentTestFailoverNotAvailableFault(v **types.TestFailoverNotAvailableFault, decoder smithyxml.NodeDecoder) error {
21275	if v == nil {
21276		return fmt.Errorf("unexpected nil of type %T", v)
21277	}
21278	var sv *types.TestFailoverNotAvailableFault
21279	if *v == nil {
21280		sv = &types.TestFailoverNotAvailableFault{}
21281	} else {
21282		sv = *v
21283	}
21284
21285	for {
21286		t, done, err := decoder.Token()
21287		if err != nil {
21288			return err
21289		}
21290		if done {
21291			break
21292		}
21293		originalDecoder := decoder
21294		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
21295		switch {
21296		case strings.EqualFold("message", t.Name.Local):
21297			val, err := decoder.Value()
21298			if err != nil {
21299				return err
21300			}
21301			if val == nil {
21302				break
21303			}
21304			{
21305				xtv := string(val)
21306				sv.Message = ptr.String(xtv)
21307			}
21308
21309		default:
21310			// Do nothing and ignore the unexpected tag element
21311			err = decoder.Decoder.Skip()
21312			if err != nil {
21313				return err
21314			}
21315
21316		}
21317		decoder = originalDecoder
21318	}
21319	*v = sv
21320	return nil
21321}
21322
21323func awsAwsquery_deserializeDocumentUGReplicationGroupIdList(v *[]string, decoder smithyxml.NodeDecoder) error {
21324	if v == nil {
21325		return fmt.Errorf("unexpected nil of type %T", v)
21326	}
21327	var sv []string
21328	if *v == nil {
21329		sv = make([]string, 0)
21330	} else {
21331		sv = *v
21332	}
21333
21334	originalDecoder := decoder
21335	for {
21336		t, done, err := decoder.Token()
21337		if err != nil {
21338			return err
21339		}
21340		if done {
21341			break
21342		}
21343		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
21344		decoder = memberDecoder
21345		switch {
21346		case strings.EqualFold("member", t.Name.Local):
21347			var col string
21348			val, err := decoder.Value()
21349			if err != nil {
21350				return err
21351			}
21352			if val == nil {
21353				break
21354			}
21355			{
21356				xtv := string(val)
21357				col = xtv
21358			}
21359			sv = append(sv, col)
21360
21361		default:
21362			err = decoder.Decoder.Skip()
21363			if err != nil {
21364				return err
21365			}
21366
21367		}
21368		decoder = originalDecoder
21369	}
21370	*v = sv
21371	return nil
21372}
21373
21374func awsAwsquery_deserializeDocumentUGReplicationGroupIdListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
21375	var sv []string
21376	if *v == nil {
21377		sv = make([]string, 0)
21378	} else {
21379		sv = *v
21380	}
21381
21382	switch {
21383	default:
21384		var mv string
21385		t := decoder.StartEl
21386		_ = t
21387		val, err := decoder.Value()
21388		if err != nil {
21389			return err
21390		}
21391		if val == nil {
21392			break
21393		}
21394		{
21395			xtv := string(val)
21396			mv = xtv
21397		}
21398		sv = append(sv, mv)
21399	}
21400	*v = sv
21401	return nil
21402}
21403func awsAwsquery_deserializeDocumentUnprocessedUpdateAction(v **types.UnprocessedUpdateAction, decoder smithyxml.NodeDecoder) error {
21404	if v == nil {
21405		return fmt.Errorf("unexpected nil of type %T", v)
21406	}
21407	var sv *types.UnprocessedUpdateAction
21408	if *v == nil {
21409		sv = &types.UnprocessedUpdateAction{}
21410	} else {
21411		sv = *v
21412	}
21413
21414	for {
21415		t, done, err := decoder.Token()
21416		if err != nil {
21417			return err
21418		}
21419		if done {
21420			break
21421		}
21422		originalDecoder := decoder
21423		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
21424		switch {
21425		case strings.EqualFold("CacheClusterId", t.Name.Local):
21426			val, err := decoder.Value()
21427			if err != nil {
21428				return err
21429			}
21430			if val == nil {
21431				break
21432			}
21433			{
21434				xtv := string(val)
21435				sv.CacheClusterId = ptr.String(xtv)
21436			}
21437
21438		case strings.EqualFold("ErrorMessage", t.Name.Local):
21439			val, err := decoder.Value()
21440			if err != nil {
21441				return err
21442			}
21443			if val == nil {
21444				break
21445			}
21446			{
21447				xtv := string(val)
21448				sv.ErrorMessage = ptr.String(xtv)
21449			}
21450
21451		case strings.EqualFold("ErrorType", t.Name.Local):
21452			val, err := decoder.Value()
21453			if err != nil {
21454				return err
21455			}
21456			if val == nil {
21457				break
21458			}
21459			{
21460				xtv := string(val)
21461				sv.ErrorType = ptr.String(xtv)
21462			}
21463
21464		case strings.EqualFold("ReplicationGroupId", t.Name.Local):
21465			val, err := decoder.Value()
21466			if err != nil {
21467				return err
21468			}
21469			if val == nil {
21470				break
21471			}
21472			{
21473				xtv := string(val)
21474				sv.ReplicationGroupId = ptr.String(xtv)
21475			}
21476
21477		case strings.EqualFold("ServiceUpdateName", t.Name.Local):
21478			val, err := decoder.Value()
21479			if err != nil {
21480				return err
21481			}
21482			if val == nil {
21483				break
21484			}
21485			{
21486				xtv := string(val)
21487				sv.ServiceUpdateName = ptr.String(xtv)
21488			}
21489
21490		default:
21491			// Do nothing and ignore the unexpected tag element
21492			err = decoder.Decoder.Skip()
21493			if err != nil {
21494				return err
21495			}
21496
21497		}
21498		decoder = originalDecoder
21499	}
21500	*v = sv
21501	return nil
21502}
21503
21504func awsAwsquery_deserializeDocumentUnprocessedUpdateActionList(v *[]types.UnprocessedUpdateAction, decoder smithyxml.NodeDecoder) error {
21505	if v == nil {
21506		return fmt.Errorf("unexpected nil of type %T", v)
21507	}
21508	var sv []types.UnprocessedUpdateAction
21509	if *v == nil {
21510		sv = make([]types.UnprocessedUpdateAction, 0)
21511	} else {
21512		sv = *v
21513	}
21514
21515	originalDecoder := decoder
21516	for {
21517		t, done, err := decoder.Token()
21518		if err != nil {
21519			return err
21520		}
21521		if done {
21522			break
21523		}
21524		switch {
21525		case strings.EqualFold("UnprocessedUpdateAction", t.Name.Local):
21526			var col types.UnprocessedUpdateAction
21527			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
21528			destAddr := &col
21529			if err := awsAwsquery_deserializeDocumentUnprocessedUpdateAction(&destAddr, nodeDecoder); err != nil {
21530				return err
21531			}
21532			col = *destAddr
21533			sv = append(sv, col)
21534
21535		default:
21536			err = decoder.Decoder.Skip()
21537			if err != nil {
21538				return err
21539			}
21540
21541		}
21542		decoder = originalDecoder
21543	}
21544	*v = sv
21545	return nil
21546}
21547
21548func awsAwsquery_deserializeDocumentUnprocessedUpdateActionListUnwrapped(v *[]types.UnprocessedUpdateAction, decoder smithyxml.NodeDecoder) error {
21549	var sv []types.UnprocessedUpdateAction
21550	if *v == nil {
21551		sv = make([]types.UnprocessedUpdateAction, 0)
21552	} else {
21553		sv = *v
21554	}
21555
21556	switch {
21557	default:
21558		var mv types.UnprocessedUpdateAction
21559		t := decoder.StartEl
21560		_ = t
21561		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
21562		destAddr := &mv
21563		if err := awsAwsquery_deserializeDocumentUnprocessedUpdateAction(&destAddr, nodeDecoder); err != nil {
21564			return err
21565		}
21566		mv = *destAddr
21567		sv = append(sv, mv)
21568	}
21569	*v = sv
21570	return nil
21571}
21572func awsAwsquery_deserializeDocumentUpdateAction(v **types.UpdateAction, decoder smithyxml.NodeDecoder) error {
21573	if v == nil {
21574		return fmt.Errorf("unexpected nil of type %T", v)
21575	}
21576	var sv *types.UpdateAction
21577	if *v == nil {
21578		sv = &types.UpdateAction{}
21579	} else {
21580		sv = *v
21581	}
21582
21583	for {
21584		t, done, err := decoder.Token()
21585		if err != nil {
21586			return err
21587		}
21588		if done {
21589			break
21590		}
21591		originalDecoder := decoder
21592		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
21593		switch {
21594		case strings.EqualFold("CacheClusterId", t.Name.Local):
21595			val, err := decoder.Value()
21596			if err != nil {
21597				return err
21598			}
21599			if val == nil {
21600				break
21601			}
21602			{
21603				xtv := string(val)
21604				sv.CacheClusterId = ptr.String(xtv)
21605			}
21606
21607		case strings.EqualFold("CacheNodeUpdateStatus", t.Name.Local):
21608			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
21609			if err := awsAwsquery_deserializeDocumentCacheNodeUpdateStatusList(&sv.CacheNodeUpdateStatus, nodeDecoder); err != nil {
21610				return err
21611			}
21612
21613		case strings.EqualFold("Engine", t.Name.Local):
21614			val, err := decoder.Value()
21615			if err != nil {
21616				return err
21617			}
21618			if val == nil {
21619				break
21620			}
21621			{
21622				xtv := string(val)
21623				sv.Engine = ptr.String(xtv)
21624			}
21625
21626		case strings.EqualFold("EstimatedUpdateTime", t.Name.Local):
21627			val, err := decoder.Value()
21628			if err != nil {
21629				return err
21630			}
21631			if val == nil {
21632				break
21633			}
21634			{
21635				xtv := string(val)
21636				sv.EstimatedUpdateTime = ptr.String(xtv)
21637			}
21638
21639		case strings.EqualFold("NodeGroupUpdateStatus", t.Name.Local):
21640			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
21641			if err := awsAwsquery_deserializeDocumentNodeGroupUpdateStatusList(&sv.NodeGroupUpdateStatus, nodeDecoder); err != nil {
21642				return err
21643			}
21644
21645		case strings.EqualFold("NodesUpdated", t.Name.Local):
21646			val, err := decoder.Value()
21647			if err != nil {
21648				return err
21649			}
21650			if val == nil {
21651				break
21652			}
21653			{
21654				xtv := string(val)
21655				sv.NodesUpdated = ptr.String(xtv)
21656			}
21657
21658		case strings.EqualFold("ReplicationGroupId", t.Name.Local):
21659			val, err := decoder.Value()
21660			if err != nil {
21661				return err
21662			}
21663			if val == nil {
21664				break
21665			}
21666			{
21667				xtv := string(val)
21668				sv.ReplicationGroupId = ptr.String(xtv)
21669			}
21670
21671		case strings.EqualFold("ServiceUpdateName", t.Name.Local):
21672			val, err := decoder.Value()
21673			if err != nil {
21674				return err
21675			}
21676			if val == nil {
21677				break
21678			}
21679			{
21680				xtv := string(val)
21681				sv.ServiceUpdateName = ptr.String(xtv)
21682			}
21683
21684		case strings.EqualFold("ServiceUpdateRecommendedApplyByDate", t.Name.Local):
21685			val, err := decoder.Value()
21686			if err != nil {
21687				return err
21688			}
21689			if val == nil {
21690				break
21691			}
21692			{
21693				xtv := string(val)
21694				t, err := smithytime.ParseDateTime(xtv)
21695				if err != nil {
21696					return err
21697				}
21698				sv.ServiceUpdateRecommendedApplyByDate = ptr.Time(t)
21699			}
21700
21701		case strings.EqualFold("ServiceUpdateReleaseDate", t.Name.Local):
21702			val, err := decoder.Value()
21703			if err != nil {
21704				return err
21705			}
21706			if val == nil {
21707				break
21708			}
21709			{
21710				xtv := string(val)
21711				t, err := smithytime.ParseDateTime(xtv)
21712				if err != nil {
21713					return err
21714				}
21715				sv.ServiceUpdateReleaseDate = ptr.Time(t)
21716			}
21717
21718		case strings.EqualFold("ServiceUpdateSeverity", t.Name.Local):
21719			val, err := decoder.Value()
21720			if err != nil {
21721				return err
21722			}
21723			if val == nil {
21724				break
21725			}
21726			{
21727				xtv := string(val)
21728				sv.ServiceUpdateSeverity = types.ServiceUpdateSeverity(xtv)
21729			}
21730
21731		case strings.EqualFold("ServiceUpdateStatus", t.Name.Local):
21732			val, err := decoder.Value()
21733			if err != nil {
21734				return err
21735			}
21736			if val == nil {
21737				break
21738			}
21739			{
21740				xtv := string(val)
21741				sv.ServiceUpdateStatus = types.ServiceUpdateStatus(xtv)
21742			}
21743
21744		case strings.EqualFold("ServiceUpdateType", t.Name.Local):
21745			val, err := decoder.Value()
21746			if err != nil {
21747				return err
21748			}
21749			if val == nil {
21750				break
21751			}
21752			{
21753				xtv := string(val)
21754				sv.ServiceUpdateType = types.ServiceUpdateType(xtv)
21755			}
21756
21757		case strings.EqualFold("SlaMet", t.Name.Local):
21758			val, err := decoder.Value()
21759			if err != nil {
21760				return err
21761			}
21762			if val == nil {
21763				break
21764			}
21765			{
21766				xtv := string(val)
21767				sv.SlaMet = types.SlaMet(xtv)
21768			}
21769
21770		case strings.EqualFold("UpdateActionAvailableDate", t.Name.Local):
21771			val, err := decoder.Value()
21772			if err != nil {
21773				return err
21774			}
21775			if val == nil {
21776				break
21777			}
21778			{
21779				xtv := string(val)
21780				t, err := smithytime.ParseDateTime(xtv)
21781				if err != nil {
21782					return err
21783				}
21784				sv.UpdateActionAvailableDate = ptr.Time(t)
21785			}
21786
21787		case strings.EqualFold("UpdateActionStatus", t.Name.Local):
21788			val, err := decoder.Value()
21789			if err != nil {
21790				return err
21791			}
21792			if val == nil {
21793				break
21794			}
21795			{
21796				xtv := string(val)
21797				sv.UpdateActionStatus = types.UpdateActionStatus(xtv)
21798			}
21799
21800		case strings.EqualFold("UpdateActionStatusModifiedDate", t.Name.Local):
21801			val, err := decoder.Value()
21802			if err != nil {
21803				return err
21804			}
21805			if val == nil {
21806				break
21807			}
21808			{
21809				xtv := string(val)
21810				t, err := smithytime.ParseDateTime(xtv)
21811				if err != nil {
21812					return err
21813				}
21814				sv.UpdateActionStatusModifiedDate = ptr.Time(t)
21815			}
21816
21817		default:
21818			// Do nothing and ignore the unexpected tag element
21819			err = decoder.Decoder.Skip()
21820			if err != nil {
21821				return err
21822			}
21823
21824		}
21825		decoder = originalDecoder
21826	}
21827	*v = sv
21828	return nil
21829}
21830
21831func awsAwsquery_deserializeDocumentUpdateActionList(v *[]types.UpdateAction, decoder smithyxml.NodeDecoder) error {
21832	if v == nil {
21833		return fmt.Errorf("unexpected nil of type %T", v)
21834	}
21835	var sv []types.UpdateAction
21836	if *v == nil {
21837		sv = make([]types.UpdateAction, 0)
21838	} else {
21839		sv = *v
21840	}
21841
21842	originalDecoder := decoder
21843	for {
21844		t, done, err := decoder.Token()
21845		if err != nil {
21846			return err
21847		}
21848		if done {
21849			break
21850		}
21851		switch {
21852		case strings.EqualFold("UpdateAction", t.Name.Local):
21853			var col types.UpdateAction
21854			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
21855			destAddr := &col
21856			if err := awsAwsquery_deserializeDocumentUpdateAction(&destAddr, nodeDecoder); err != nil {
21857				return err
21858			}
21859			col = *destAddr
21860			sv = append(sv, col)
21861
21862		default:
21863			err = decoder.Decoder.Skip()
21864			if err != nil {
21865				return err
21866			}
21867
21868		}
21869		decoder = originalDecoder
21870	}
21871	*v = sv
21872	return nil
21873}
21874
21875func awsAwsquery_deserializeDocumentUpdateActionListUnwrapped(v *[]types.UpdateAction, decoder smithyxml.NodeDecoder) error {
21876	var sv []types.UpdateAction
21877	if *v == nil {
21878		sv = make([]types.UpdateAction, 0)
21879	} else {
21880		sv = *v
21881	}
21882
21883	switch {
21884	default:
21885		var mv types.UpdateAction
21886		t := decoder.StartEl
21887		_ = t
21888		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
21889		destAddr := &mv
21890		if err := awsAwsquery_deserializeDocumentUpdateAction(&destAddr, nodeDecoder); err != nil {
21891			return err
21892		}
21893		mv = *destAddr
21894		sv = append(sv, mv)
21895	}
21896	*v = sv
21897	return nil
21898}
21899func awsAwsquery_deserializeDocumentUser(v **types.User, decoder smithyxml.NodeDecoder) error {
21900	if v == nil {
21901		return fmt.Errorf("unexpected nil of type %T", v)
21902	}
21903	var sv *types.User
21904	if *v == nil {
21905		sv = &types.User{}
21906	} else {
21907		sv = *v
21908	}
21909
21910	for {
21911		t, done, err := decoder.Token()
21912		if err != nil {
21913			return err
21914		}
21915		if done {
21916			break
21917		}
21918		originalDecoder := decoder
21919		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
21920		switch {
21921		case strings.EqualFold("AccessString", t.Name.Local):
21922			val, err := decoder.Value()
21923			if err != nil {
21924				return err
21925			}
21926			if val == nil {
21927				break
21928			}
21929			{
21930				xtv := string(val)
21931				sv.AccessString = ptr.String(xtv)
21932			}
21933
21934		case strings.EqualFold("ARN", t.Name.Local):
21935			val, err := decoder.Value()
21936			if err != nil {
21937				return err
21938			}
21939			if val == nil {
21940				break
21941			}
21942			{
21943				xtv := string(val)
21944				sv.ARN = ptr.String(xtv)
21945			}
21946
21947		case strings.EqualFold("Authentication", t.Name.Local):
21948			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
21949			if err := awsAwsquery_deserializeDocumentAuthentication(&sv.Authentication, nodeDecoder); err != nil {
21950				return err
21951			}
21952
21953		case strings.EqualFold("Engine", t.Name.Local):
21954			val, err := decoder.Value()
21955			if err != nil {
21956				return err
21957			}
21958			if val == nil {
21959				break
21960			}
21961			{
21962				xtv := string(val)
21963				sv.Engine = ptr.String(xtv)
21964			}
21965
21966		case strings.EqualFold("Status", t.Name.Local):
21967			val, err := decoder.Value()
21968			if err != nil {
21969				return err
21970			}
21971			if val == nil {
21972				break
21973			}
21974			{
21975				xtv := string(val)
21976				sv.Status = ptr.String(xtv)
21977			}
21978
21979		case strings.EqualFold("UserGroupIds", t.Name.Local):
21980			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
21981			if err := awsAwsquery_deserializeDocumentUserGroupIdList(&sv.UserGroupIds, nodeDecoder); err != nil {
21982				return err
21983			}
21984
21985		case strings.EqualFold("UserId", t.Name.Local):
21986			val, err := decoder.Value()
21987			if err != nil {
21988				return err
21989			}
21990			if val == nil {
21991				break
21992			}
21993			{
21994				xtv := string(val)
21995				sv.UserId = ptr.String(xtv)
21996			}
21997
21998		case strings.EqualFold("UserName", t.Name.Local):
21999			val, err := decoder.Value()
22000			if err != nil {
22001				return err
22002			}
22003			if val == nil {
22004				break
22005			}
22006			{
22007				xtv := string(val)
22008				sv.UserName = ptr.String(xtv)
22009			}
22010
22011		default:
22012			// Do nothing and ignore the unexpected tag element
22013			err = decoder.Decoder.Skip()
22014			if err != nil {
22015				return err
22016			}
22017
22018		}
22019		decoder = originalDecoder
22020	}
22021	*v = sv
22022	return nil
22023}
22024
22025func awsAwsquery_deserializeDocumentUserAlreadyExistsFault(v **types.UserAlreadyExistsFault, decoder smithyxml.NodeDecoder) error {
22026	if v == nil {
22027		return fmt.Errorf("unexpected nil of type %T", v)
22028	}
22029	var sv *types.UserAlreadyExistsFault
22030	if *v == nil {
22031		sv = &types.UserAlreadyExistsFault{}
22032	} else {
22033		sv = *v
22034	}
22035
22036	for {
22037		t, done, err := decoder.Token()
22038		if err != nil {
22039			return err
22040		}
22041		if done {
22042			break
22043		}
22044		originalDecoder := decoder
22045		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
22046		switch {
22047		case strings.EqualFold("message", t.Name.Local):
22048			val, err := decoder.Value()
22049			if err != nil {
22050				return err
22051			}
22052			if val == nil {
22053				break
22054			}
22055			{
22056				xtv := string(val)
22057				sv.Message = ptr.String(xtv)
22058			}
22059
22060		default:
22061			// Do nothing and ignore the unexpected tag element
22062			err = decoder.Decoder.Skip()
22063			if err != nil {
22064				return err
22065			}
22066
22067		}
22068		decoder = originalDecoder
22069	}
22070	*v = sv
22071	return nil
22072}
22073
22074func awsAwsquery_deserializeDocumentUserGroup(v **types.UserGroup, decoder smithyxml.NodeDecoder) error {
22075	if v == nil {
22076		return fmt.Errorf("unexpected nil of type %T", v)
22077	}
22078	var sv *types.UserGroup
22079	if *v == nil {
22080		sv = &types.UserGroup{}
22081	} else {
22082		sv = *v
22083	}
22084
22085	for {
22086		t, done, err := decoder.Token()
22087		if err != nil {
22088			return err
22089		}
22090		if done {
22091			break
22092		}
22093		originalDecoder := decoder
22094		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
22095		switch {
22096		case strings.EqualFold("ARN", t.Name.Local):
22097			val, err := decoder.Value()
22098			if err != nil {
22099				return err
22100			}
22101			if val == nil {
22102				break
22103			}
22104			{
22105				xtv := string(val)
22106				sv.ARN = ptr.String(xtv)
22107			}
22108
22109		case strings.EqualFold("Engine", t.Name.Local):
22110			val, err := decoder.Value()
22111			if err != nil {
22112				return err
22113			}
22114			if val == nil {
22115				break
22116			}
22117			{
22118				xtv := string(val)
22119				sv.Engine = ptr.String(xtv)
22120			}
22121
22122		case strings.EqualFold("PendingChanges", t.Name.Local):
22123			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
22124			if err := awsAwsquery_deserializeDocumentUserGroupPendingChanges(&sv.PendingChanges, nodeDecoder); err != nil {
22125				return err
22126			}
22127
22128		case strings.EqualFold("ReplicationGroups", t.Name.Local):
22129			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
22130			if err := awsAwsquery_deserializeDocumentUGReplicationGroupIdList(&sv.ReplicationGroups, nodeDecoder); err != nil {
22131				return err
22132			}
22133
22134		case strings.EqualFold("Status", t.Name.Local):
22135			val, err := decoder.Value()
22136			if err != nil {
22137				return err
22138			}
22139			if val == nil {
22140				break
22141			}
22142			{
22143				xtv := string(val)
22144				sv.Status = ptr.String(xtv)
22145			}
22146
22147		case strings.EqualFold("UserGroupId", t.Name.Local):
22148			val, err := decoder.Value()
22149			if err != nil {
22150				return err
22151			}
22152			if val == nil {
22153				break
22154			}
22155			{
22156				xtv := string(val)
22157				sv.UserGroupId = ptr.String(xtv)
22158			}
22159
22160		case strings.EqualFold("UserIds", t.Name.Local):
22161			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
22162			if err := awsAwsquery_deserializeDocumentUserIdList(&sv.UserIds, nodeDecoder); err != nil {
22163				return err
22164			}
22165
22166		default:
22167			// Do nothing and ignore the unexpected tag element
22168			err = decoder.Decoder.Skip()
22169			if err != nil {
22170				return err
22171			}
22172
22173		}
22174		decoder = originalDecoder
22175	}
22176	*v = sv
22177	return nil
22178}
22179
22180func awsAwsquery_deserializeDocumentUserGroupAlreadyExistsFault(v **types.UserGroupAlreadyExistsFault, decoder smithyxml.NodeDecoder) error {
22181	if v == nil {
22182		return fmt.Errorf("unexpected nil of type %T", v)
22183	}
22184	var sv *types.UserGroupAlreadyExistsFault
22185	if *v == nil {
22186		sv = &types.UserGroupAlreadyExistsFault{}
22187	} else {
22188		sv = *v
22189	}
22190
22191	for {
22192		t, done, err := decoder.Token()
22193		if err != nil {
22194			return err
22195		}
22196		if done {
22197			break
22198		}
22199		originalDecoder := decoder
22200		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
22201		switch {
22202		case strings.EqualFold("message", t.Name.Local):
22203			val, err := decoder.Value()
22204			if err != nil {
22205				return err
22206			}
22207			if val == nil {
22208				break
22209			}
22210			{
22211				xtv := string(val)
22212				sv.Message = ptr.String(xtv)
22213			}
22214
22215		default:
22216			// Do nothing and ignore the unexpected tag element
22217			err = decoder.Decoder.Skip()
22218			if err != nil {
22219				return err
22220			}
22221
22222		}
22223		decoder = originalDecoder
22224	}
22225	*v = sv
22226	return nil
22227}
22228
22229func awsAwsquery_deserializeDocumentUserGroupIdList(v *[]string, decoder smithyxml.NodeDecoder) error {
22230	if v == nil {
22231		return fmt.Errorf("unexpected nil of type %T", v)
22232	}
22233	var sv []string
22234	if *v == nil {
22235		sv = make([]string, 0)
22236	} else {
22237		sv = *v
22238	}
22239
22240	originalDecoder := decoder
22241	for {
22242		t, done, err := decoder.Token()
22243		if err != nil {
22244			return err
22245		}
22246		if done {
22247			break
22248		}
22249		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
22250		decoder = memberDecoder
22251		switch {
22252		case strings.EqualFold("member", t.Name.Local):
22253			var col string
22254			val, err := decoder.Value()
22255			if err != nil {
22256				return err
22257			}
22258			if val == nil {
22259				break
22260			}
22261			{
22262				xtv := string(val)
22263				col = xtv
22264			}
22265			sv = append(sv, col)
22266
22267		default:
22268			err = decoder.Decoder.Skip()
22269			if err != nil {
22270				return err
22271			}
22272
22273		}
22274		decoder = originalDecoder
22275	}
22276	*v = sv
22277	return nil
22278}
22279
22280func awsAwsquery_deserializeDocumentUserGroupIdListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
22281	var sv []string
22282	if *v == nil {
22283		sv = make([]string, 0)
22284	} else {
22285		sv = *v
22286	}
22287
22288	switch {
22289	default:
22290		var mv string
22291		t := decoder.StartEl
22292		_ = t
22293		val, err := decoder.Value()
22294		if err != nil {
22295			return err
22296		}
22297		if val == nil {
22298			break
22299		}
22300		{
22301			xtv := string(val)
22302			mv = xtv
22303		}
22304		sv = append(sv, mv)
22305	}
22306	*v = sv
22307	return nil
22308}
22309func awsAwsquery_deserializeDocumentUserGroupList(v *[]types.UserGroup, decoder smithyxml.NodeDecoder) error {
22310	if v == nil {
22311		return fmt.Errorf("unexpected nil of type %T", v)
22312	}
22313	var sv []types.UserGroup
22314	if *v == nil {
22315		sv = make([]types.UserGroup, 0)
22316	} else {
22317		sv = *v
22318	}
22319
22320	originalDecoder := decoder
22321	for {
22322		t, done, err := decoder.Token()
22323		if err != nil {
22324			return err
22325		}
22326		if done {
22327			break
22328		}
22329		switch {
22330		case strings.EqualFold("member", t.Name.Local):
22331			var col types.UserGroup
22332			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
22333			destAddr := &col
22334			if err := awsAwsquery_deserializeDocumentUserGroup(&destAddr, nodeDecoder); err != nil {
22335				return err
22336			}
22337			col = *destAddr
22338			sv = append(sv, col)
22339
22340		default:
22341			err = decoder.Decoder.Skip()
22342			if err != nil {
22343				return err
22344			}
22345
22346		}
22347		decoder = originalDecoder
22348	}
22349	*v = sv
22350	return nil
22351}
22352
22353func awsAwsquery_deserializeDocumentUserGroupListUnwrapped(v *[]types.UserGroup, decoder smithyxml.NodeDecoder) error {
22354	var sv []types.UserGroup
22355	if *v == nil {
22356		sv = make([]types.UserGroup, 0)
22357	} else {
22358		sv = *v
22359	}
22360
22361	switch {
22362	default:
22363		var mv types.UserGroup
22364		t := decoder.StartEl
22365		_ = t
22366		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
22367		destAddr := &mv
22368		if err := awsAwsquery_deserializeDocumentUserGroup(&destAddr, nodeDecoder); err != nil {
22369			return err
22370		}
22371		mv = *destAddr
22372		sv = append(sv, mv)
22373	}
22374	*v = sv
22375	return nil
22376}
22377func awsAwsquery_deserializeDocumentUserGroupNotFoundFault(v **types.UserGroupNotFoundFault, decoder smithyxml.NodeDecoder) error {
22378	if v == nil {
22379		return fmt.Errorf("unexpected nil of type %T", v)
22380	}
22381	var sv *types.UserGroupNotFoundFault
22382	if *v == nil {
22383		sv = &types.UserGroupNotFoundFault{}
22384	} else {
22385		sv = *v
22386	}
22387
22388	for {
22389		t, done, err := decoder.Token()
22390		if err != nil {
22391			return err
22392		}
22393		if done {
22394			break
22395		}
22396		originalDecoder := decoder
22397		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
22398		switch {
22399		case strings.EqualFold("message", t.Name.Local):
22400			val, err := decoder.Value()
22401			if err != nil {
22402				return err
22403			}
22404			if val == nil {
22405				break
22406			}
22407			{
22408				xtv := string(val)
22409				sv.Message = ptr.String(xtv)
22410			}
22411
22412		default:
22413			// Do nothing and ignore the unexpected tag element
22414			err = decoder.Decoder.Skip()
22415			if err != nil {
22416				return err
22417			}
22418
22419		}
22420		decoder = originalDecoder
22421	}
22422	*v = sv
22423	return nil
22424}
22425
22426func awsAwsquery_deserializeDocumentUserGroupPendingChanges(v **types.UserGroupPendingChanges, decoder smithyxml.NodeDecoder) error {
22427	if v == nil {
22428		return fmt.Errorf("unexpected nil of type %T", v)
22429	}
22430	var sv *types.UserGroupPendingChanges
22431	if *v == nil {
22432		sv = &types.UserGroupPendingChanges{}
22433	} else {
22434		sv = *v
22435	}
22436
22437	for {
22438		t, done, err := decoder.Token()
22439		if err != nil {
22440			return err
22441		}
22442		if done {
22443			break
22444		}
22445		originalDecoder := decoder
22446		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
22447		switch {
22448		case strings.EqualFold("UserIdsToAdd", t.Name.Local):
22449			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
22450			if err := awsAwsquery_deserializeDocumentUserIdList(&sv.UserIdsToAdd, nodeDecoder); err != nil {
22451				return err
22452			}
22453
22454		case strings.EqualFold("UserIdsToRemove", t.Name.Local):
22455			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
22456			if err := awsAwsquery_deserializeDocumentUserIdList(&sv.UserIdsToRemove, nodeDecoder); err != nil {
22457				return err
22458			}
22459
22460		default:
22461			// Do nothing and ignore the unexpected tag element
22462			err = decoder.Decoder.Skip()
22463			if err != nil {
22464				return err
22465			}
22466
22467		}
22468		decoder = originalDecoder
22469	}
22470	*v = sv
22471	return nil
22472}
22473
22474func awsAwsquery_deserializeDocumentUserGroupQuotaExceededFault(v **types.UserGroupQuotaExceededFault, decoder smithyxml.NodeDecoder) error {
22475	if v == nil {
22476		return fmt.Errorf("unexpected nil of type %T", v)
22477	}
22478	var sv *types.UserGroupQuotaExceededFault
22479	if *v == nil {
22480		sv = &types.UserGroupQuotaExceededFault{}
22481	} else {
22482		sv = *v
22483	}
22484
22485	for {
22486		t, done, err := decoder.Token()
22487		if err != nil {
22488			return err
22489		}
22490		if done {
22491			break
22492		}
22493		originalDecoder := decoder
22494		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
22495		switch {
22496		case strings.EqualFold("message", t.Name.Local):
22497			val, err := decoder.Value()
22498			if err != nil {
22499				return err
22500			}
22501			if val == nil {
22502				break
22503			}
22504			{
22505				xtv := string(val)
22506				sv.Message = ptr.String(xtv)
22507			}
22508
22509		default:
22510			// Do nothing and ignore the unexpected tag element
22511			err = decoder.Decoder.Skip()
22512			if err != nil {
22513				return err
22514			}
22515
22516		}
22517		decoder = originalDecoder
22518	}
22519	*v = sv
22520	return nil
22521}
22522
22523func awsAwsquery_deserializeDocumentUserGroupsUpdateStatus(v **types.UserGroupsUpdateStatus, decoder smithyxml.NodeDecoder) error {
22524	if v == nil {
22525		return fmt.Errorf("unexpected nil of type %T", v)
22526	}
22527	var sv *types.UserGroupsUpdateStatus
22528	if *v == nil {
22529		sv = &types.UserGroupsUpdateStatus{}
22530	} else {
22531		sv = *v
22532	}
22533
22534	for {
22535		t, done, err := decoder.Token()
22536		if err != nil {
22537			return err
22538		}
22539		if done {
22540			break
22541		}
22542		originalDecoder := decoder
22543		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
22544		switch {
22545		case strings.EqualFold("UserGroupIdsToAdd", t.Name.Local):
22546			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
22547			if err := awsAwsquery_deserializeDocumentUserGroupIdList(&sv.UserGroupIdsToAdd, nodeDecoder); err != nil {
22548				return err
22549			}
22550
22551		case strings.EqualFold("UserGroupIdsToRemove", t.Name.Local):
22552			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
22553			if err := awsAwsquery_deserializeDocumentUserGroupIdList(&sv.UserGroupIdsToRemove, nodeDecoder); err != nil {
22554				return err
22555			}
22556
22557		default:
22558			// Do nothing and ignore the unexpected tag element
22559			err = decoder.Decoder.Skip()
22560			if err != nil {
22561				return err
22562			}
22563
22564		}
22565		decoder = originalDecoder
22566	}
22567	*v = sv
22568	return nil
22569}
22570
22571func awsAwsquery_deserializeDocumentUserIdList(v *[]string, decoder smithyxml.NodeDecoder) error {
22572	if v == nil {
22573		return fmt.Errorf("unexpected nil of type %T", v)
22574	}
22575	var sv []string
22576	if *v == nil {
22577		sv = make([]string, 0)
22578	} else {
22579		sv = *v
22580	}
22581
22582	originalDecoder := decoder
22583	for {
22584		t, done, err := decoder.Token()
22585		if err != nil {
22586			return err
22587		}
22588		if done {
22589			break
22590		}
22591		memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
22592		decoder = memberDecoder
22593		switch {
22594		case strings.EqualFold("member", t.Name.Local):
22595			var col string
22596			val, err := decoder.Value()
22597			if err != nil {
22598				return err
22599			}
22600			if val == nil {
22601				break
22602			}
22603			{
22604				xtv := string(val)
22605				col = xtv
22606			}
22607			sv = append(sv, col)
22608
22609		default:
22610			err = decoder.Decoder.Skip()
22611			if err != nil {
22612				return err
22613			}
22614
22615		}
22616		decoder = originalDecoder
22617	}
22618	*v = sv
22619	return nil
22620}
22621
22622func awsAwsquery_deserializeDocumentUserIdListUnwrapped(v *[]string, decoder smithyxml.NodeDecoder) error {
22623	var sv []string
22624	if *v == nil {
22625		sv = make([]string, 0)
22626	} else {
22627		sv = *v
22628	}
22629
22630	switch {
22631	default:
22632		var mv string
22633		t := decoder.StartEl
22634		_ = t
22635		val, err := decoder.Value()
22636		if err != nil {
22637			return err
22638		}
22639		if val == nil {
22640			break
22641		}
22642		{
22643			xtv := string(val)
22644			mv = xtv
22645		}
22646		sv = append(sv, mv)
22647	}
22648	*v = sv
22649	return nil
22650}
22651func awsAwsquery_deserializeDocumentUserList(v *[]types.User, decoder smithyxml.NodeDecoder) error {
22652	if v == nil {
22653		return fmt.Errorf("unexpected nil of type %T", v)
22654	}
22655	var sv []types.User
22656	if *v == nil {
22657		sv = make([]types.User, 0)
22658	} else {
22659		sv = *v
22660	}
22661
22662	originalDecoder := decoder
22663	for {
22664		t, done, err := decoder.Token()
22665		if err != nil {
22666			return err
22667		}
22668		if done {
22669			break
22670		}
22671		switch {
22672		case strings.EqualFold("member", t.Name.Local):
22673			var col types.User
22674			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
22675			destAddr := &col
22676			if err := awsAwsquery_deserializeDocumentUser(&destAddr, nodeDecoder); err != nil {
22677				return err
22678			}
22679			col = *destAddr
22680			sv = append(sv, col)
22681
22682		default:
22683			err = decoder.Decoder.Skip()
22684			if err != nil {
22685				return err
22686			}
22687
22688		}
22689		decoder = originalDecoder
22690	}
22691	*v = sv
22692	return nil
22693}
22694
22695func awsAwsquery_deserializeDocumentUserListUnwrapped(v *[]types.User, decoder smithyxml.NodeDecoder) error {
22696	var sv []types.User
22697	if *v == nil {
22698		sv = make([]types.User, 0)
22699	} else {
22700		sv = *v
22701	}
22702
22703	switch {
22704	default:
22705		var mv types.User
22706		t := decoder.StartEl
22707		_ = t
22708		nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
22709		destAddr := &mv
22710		if err := awsAwsquery_deserializeDocumentUser(&destAddr, nodeDecoder); err != nil {
22711			return err
22712		}
22713		mv = *destAddr
22714		sv = append(sv, mv)
22715	}
22716	*v = sv
22717	return nil
22718}
22719func awsAwsquery_deserializeDocumentUserNotFoundFault(v **types.UserNotFoundFault, decoder smithyxml.NodeDecoder) error {
22720	if v == nil {
22721		return fmt.Errorf("unexpected nil of type %T", v)
22722	}
22723	var sv *types.UserNotFoundFault
22724	if *v == nil {
22725		sv = &types.UserNotFoundFault{}
22726	} else {
22727		sv = *v
22728	}
22729
22730	for {
22731		t, done, err := decoder.Token()
22732		if err != nil {
22733			return err
22734		}
22735		if done {
22736			break
22737		}
22738		originalDecoder := decoder
22739		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
22740		switch {
22741		case strings.EqualFold("message", t.Name.Local):
22742			val, err := decoder.Value()
22743			if err != nil {
22744				return err
22745			}
22746			if val == nil {
22747				break
22748			}
22749			{
22750				xtv := string(val)
22751				sv.Message = ptr.String(xtv)
22752			}
22753
22754		default:
22755			// Do nothing and ignore the unexpected tag element
22756			err = decoder.Decoder.Skip()
22757			if err != nil {
22758				return err
22759			}
22760
22761		}
22762		decoder = originalDecoder
22763	}
22764	*v = sv
22765	return nil
22766}
22767
22768func awsAwsquery_deserializeDocumentUserQuotaExceededFault(v **types.UserQuotaExceededFault, decoder smithyxml.NodeDecoder) error {
22769	if v == nil {
22770		return fmt.Errorf("unexpected nil of type %T", v)
22771	}
22772	var sv *types.UserQuotaExceededFault
22773	if *v == nil {
22774		sv = &types.UserQuotaExceededFault{}
22775	} else {
22776		sv = *v
22777	}
22778
22779	for {
22780		t, done, err := decoder.Token()
22781		if err != nil {
22782			return err
22783		}
22784		if done {
22785			break
22786		}
22787		originalDecoder := decoder
22788		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
22789		switch {
22790		case strings.EqualFold("message", t.Name.Local):
22791			val, err := decoder.Value()
22792			if err != nil {
22793				return err
22794			}
22795			if val == nil {
22796				break
22797			}
22798			{
22799				xtv := string(val)
22800				sv.Message = ptr.String(xtv)
22801			}
22802
22803		default:
22804			// Do nothing and ignore the unexpected tag element
22805			err = decoder.Decoder.Skip()
22806			if err != nil {
22807				return err
22808			}
22809
22810		}
22811		decoder = originalDecoder
22812	}
22813	*v = sv
22814	return nil
22815}
22816
22817func awsAwsquery_deserializeOpDocumentAddTagsToResourceOutput(v **AddTagsToResourceOutput, decoder smithyxml.NodeDecoder) error {
22818	if v == nil {
22819		return fmt.Errorf("unexpected nil of type %T", v)
22820	}
22821	var sv *AddTagsToResourceOutput
22822	if *v == nil {
22823		sv = &AddTagsToResourceOutput{}
22824	} else {
22825		sv = *v
22826	}
22827
22828	for {
22829		t, done, err := decoder.Token()
22830		if err != nil {
22831			return err
22832		}
22833		if done {
22834			break
22835		}
22836		originalDecoder := decoder
22837		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
22838		switch {
22839		case strings.EqualFold("TagList", t.Name.Local):
22840			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
22841			if err := awsAwsquery_deserializeDocumentTagList(&sv.TagList, nodeDecoder); err != nil {
22842				return err
22843			}
22844
22845		default:
22846			// Do nothing and ignore the unexpected tag element
22847			err = decoder.Decoder.Skip()
22848			if err != nil {
22849				return err
22850			}
22851
22852		}
22853		decoder = originalDecoder
22854	}
22855	*v = sv
22856	return nil
22857}
22858
22859func awsAwsquery_deserializeOpDocumentAuthorizeCacheSecurityGroupIngressOutput(v **AuthorizeCacheSecurityGroupIngressOutput, decoder smithyxml.NodeDecoder) error {
22860	if v == nil {
22861		return fmt.Errorf("unexpected nil of type %T", v)
22862	}
22863	var sv *AuthorizeCacheSecurityGroupIngressOutput
22864	if *v == nil {
22865		sv = &AuthorizeCacheSecurityGroupIngressOutput{}
22866	} else {
22867		sv = *v
22868	}
22869
22870	for {
22871		t, done, err := decoder.Token()
22872		if err != nil {
22873			return err
22874		}
22875		if done {
22876			break
22877		}
22878		originalDecoder := decoder
22879		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
22880		switch {
22881		case strings.EqualFold("CacheSecurityGroup", t.Name.Local):
22882			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
22883			if err := awsAwsquery_deserializeDocumentCacheSecurityGroup(&sv.CacheSecurityGroup, nodeDecoder); err != nil {
22884				return err
22885			}
22886
22887		default:
22888			// Do nothing and ignore the unexpected tag element
22889			err = decoder.Decoder.Skip()
22890			if err != nil {
22891				return err
22892			}
22893
22894		}
22895		decoder = originalDecoder
22896	}
22897	*v = sv
22898	return nil
22899}
22900
22901func awsAwsquery_deserializeOpDocumentBatchApplyUpdateActionOutput(v **BatchApplyUpdateActionOutput, decoder smithyxml.NodeDecoder) error {
22902	if v == nil {
22903		return fmt.Errorf("unexpected nil of type %T", v)
22904	}
22905	var sv *BatchApplyUpdateActionOutput
22906	if *v == nil {
22907		sv = &BatchApplyUpdateActionOutput{}
22908	} else {
22909		sv = *v
22910	}
22911
22912	for {
22913		t, done, err := decoder.Token()
22914		if err != nil {
22915			return err
22916		}
22917		if done {
22918			break
22919		}
22920		originalDecoder := decoder
22921		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
22922		switch {
22923		case strings.EqualFold("ProcessedUpdateActions", t.Name.Local):
22924			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
22925			if err := awsAwsquery_deserializeDocumentProcessedUpdateActionList(&sv.ProcessedUpdateActions, nodeDecoder); err != nil {
22926				return err
22927			}
22928
22929		case strings.EqualFold("UnprocessedUpdateActions", t.Name.Local):
22930			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
22931			if err := awsAwsquery_deserializeDocumentUnprocessedUpdateActionList(&sv.UnprocessedUpdateActions, nodeDecoder); err != nil {
22932				return err
22933			}
22934
22935		default:
22936			// Do nothing and ignore the unexpected tag element
22937			err = decoder.Decoder.Skip()
22938			if err != nil {
22939				return err
22940			}
22941
22942		}
22943		decoder = originalDecoder
22944	}
22945	*v = sv
22946	return nil
22947}
22948
22949func awsAwsquery_deserializeOpDocumentBatchStopUpdateActionOutput(v **BatchStopUpdateActionOutput, decoder smithyxml.NodeDecoder) error {
22950	if v == nil {
22951		return fmt.Errorf("unexpected nil of type %T", v)
22952	}
22953	var sv *BatchStopUpdateActionOutput
22954	if *v == nil {
22955		sv = &BatchStopUpdateActionOutput{}
22956	} else {
22957		sv = *v
22958	}
22959
22960	for {
22961		t, done, err := decoder.Token()
22962		if err != nil {
22963			return err
22964		}
22965		if done {
22966			break
22967		}
22968		originalDecoder := decoder
22969		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
22970		switch {
22971		case strings.EqualFold("ProcessedUpdateActions", t.Name.Local):
22972			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
22973			if err := awsAwsquery_deserializeDocumentProcessedUpdateActionList(&sv.ProcessedUpdateActions, nodeDecoder); err != nil {
22974				return err
22975			}
22976
22977		case strings.EqualFold("UnprocessedUpdateActions", t.Name.Local):
22978			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
22979			if err := awsAwsquery_deserializeDocumentUnprocessedUpdateActionList(&sv.UnprocessedUpdateActions, nodeDecoder); err != nil {
22980				return err
22981			}
22982
22983		default:
22984			// Do nothing and ignore the unexpected tag element
22985			err = decoder.Decoder.Skip()
22986			if err != nil {
22987				return err
22988			}
22989
22990		}
22991		decoder = originalDecoder
22992	}
22993	*v = sv
22994	return nil
22995}
22996
22997func awsAwsquery_deserializeOpDocumentCompleteMigrationOutput(v **CompleteMigrationOutput, decoder smithyxml.NodeDecoder) error {
22998	if v == nil {
22999		return fmt.Errorf("unexpected nil of type %T", v)
23000	}
23001	var sv *CompleteMigrationOutput
23002	if *v == nil {
23003		sv = &CompleteMigrationOutput{}
23004	} else {
23005		sv = *v
23006	}
23007
23008	for {
23009		t, done, err := decoder.Token()
23010		if err != nil {
23011			return err
23012		}
23013		if done {
23014			break
23015		}
23016		originalDecoder := decoder
23017		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
23018		switch {
23019		case strings.EqualFold("ReplicationGroup", t.Name.Local):
23020			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
23021			if err := awsAwsquery_deserializeDocumentReplicationGroup(&sv.ReplicationGroup, nodeDecoder); err != nil {
23022				return err
23023			}
23024
23025		default:
23026			// Do nothing and ignore the unexpected tag element
23027			err = decoder.Decoder.Skip()
23028			if err != nil {
23029				return err
23030			}
23031
23032		}
23033		decoder = originalDecoder
23034	}
23035	*v = sv
23036	return nil
23037}
23038
23039func awsAwsquery_deserializeOpDocumentCopySnapshotOutput(v **CopySnapshotOutput, decoder smithyxml.NodeDecoder) error {
23040	if v == nil {
23041		return fmt.Errorf("unexpected nil of type %T", v)
23042	}
23043	var sv *CopySnapshotOutput
23044	if *v == nil {
23045		sv = &CopySnapshotOutput{}
23046	} else {
23047		sv = *v
23048	}
23049
23050	for {
23051		t, done, err := decoder.Token()
23052		if err != nil {
23053			return err
23054		}
23055		if done {
23056			break
23057		}
23058		originalDecoder := decoder
23059		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
23060		switch {
23061		case strings.EqualFold("Snapshot", t.Name.Local):
23062			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
23063			if err := awsAwsquery_deserializeDocumentSnapshot(&sv.Snapshot, nodeDecoder); err != nil {
23064				return err
23065			}
23066
23067		default:
23068			// Do nothing and ignore the unexpected tag element
23069			err = decoder.Decoder.Skip()
23070			if err != nil {
23071				return err
23072			}
23073
23074		}
23075		decoder = originalDecoder
23076	}
23077	*v = sv
23078	return nil
23079}
23080
23081func awsAwsquery_deserializeOpDocumentCreateCacheClusterOutput(v **CreateCacheClusterOutput, decoder smithyxml.NodeDecoder) error {
23082	if v == nil {
23083		return fmt.Errorf("unexpected nil of type %T", v)
23084	}
23085	var sv *CreateCacheClusterOutput
23086	if *v == nil {
23087		sv = &CreateCacheClusterOutput{}
23088	} else {
23089		sv = *v
23090	}
23091
23092	for {
23093		t, done, err := decoder.Token()
23094		if err != nil {
23095			return err
23096		}
23097		if done {
23098			break
23099		}
23100		originalDecoder := decoder
23101		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
23102		switch {
23103		case strings.EqualFold("CacheCluster", t.Name.Local):
23104			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
23105			if err := awsAwsquery_deserializeDocumentCacheCluster(&sv.CacheCluster, nodeDecoder); err != nil {
23106				return err
23107			}
23108
23109		default:
23110			// Do nothing and ignore the unexpected tag element
23111			err = decoder.Decoder.Skip()
23112			if err != nil {
23113				return err
23114			}
23115
23116		}
23117		decoder = originalDecoder
23118	}
23119	*v = sv
23120	return nil
23121}
23122
23123func awsAwsquery_deserializeOpDocumentCreateCacheParameterGroupOutput(v **CreateCacheParameterGroupOutput, decoder smithyxml.NodeDecoder) error {
23124	if v == nil {
23125		return fmt.Errorf("unexpected nil of type %T", v)
23126	}
23127	var sv *CreateCacheParameterGroupOutput
23128	if *v == nil {
23129		sv = &CreateCacheParameterGroupOutput{}
23130	} else {
23131		sv = *v
23132	}
23133
23134	for {
23135		t, done, err := decoder.Token()
23136		if err != nil {
23137			return err
23138		}
23139		if done {
23140			break
23141		}
23142		originalDecoder := decoder
23143		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
23144		switch {
23145		case strings.EqualFold("CacheParameterGroup", t.Name.Local):
23146			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
23147			if err := awsAwsquery_deserializeDocumentCacheParameterGroup(&sv.CacheParameterGroup, nodeDecoder); err != nil {
23148				return err
23149			}
23150
23151		default:
23152			// Do nothing and ignore the unexpected tag element
23153			err = decoder.Decoder.Skip()
23154			if err != nil {
23155				return err
23156			}
23157
23158		}
23159		decoder = originalDecoder
23160	}
23161	*v = sv
23162	return nil
23163}
23164
23165func awsAwsquery_deserializeOpDocumentCreateCacheSecurityGroupOutput(v **CreateCacheSecurityGroupOutput, decoder smithyxml.NodeDecoder) error {
23166	if v == nil {
23167		return fmt.Errorf("unexpected nil of type %T", v)
23168	}
23169	var sv *CreateCacheSecurityGroupOutput
23170	if *v == nil {
23171		sv = &CreateCacheSecurityGroupOutput{}
23172	} else {
23173		sv = *v
23174	}
23175
23176	for {
23177		t, done, err := decoder.Token()
23178		if err != nil {
23179			return err
23180		}
23181		if done {
23182			break
23183		}
23184		originalDecoder := decoder
23185		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
23186		switch {
23187		case strings.EqualFold("CacheSecurityGroup", t.Name.Local):
23188			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
23189			if err := awsAwsquery_deserializeDocumentCacheSecurityGroup(&sv.CacheSecurityGroup, nodeDecoder); err != nil {
23190				return err
23191			}
23192
23193		default:
23194			// Do nothing and ignore the unexpected tag element
23195			err = decoder.Decoder.Skip()
23196			if err != nil {
23197				return err
23198			}
23199
23200		}
23201		decoder = originalDecoder
23202	}
23203	*v = sv
23204	return nil
23205}
23206
23207func awsAwsquery_deserializeOpDocumentCreateCacheSubnetGroupOutput(v **CreateCacheSubnetGroupOutput, decoder smithyxml.NodeDecoder) error {
23208	if v == nil {
23209		return fmt.Errorf("unexpected nil of type %T", v)
23210	}
23211	var sv *CreateCacheSubnetGroupOutput
23212	if *v == nil {
23213		sv = &CreateCacheSubnetGroupOutput{}
23214	} else {
23215		sv = *v
23216	}
23217
23218	for {
23219		t, done, err := decoder.Token()
23220		if err != nil {
23221			return err
23222		}
23223		if done {
23224			break
23225		}
23226		originalDecoder := decoder
23227		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
23228		switch {
23229		case strings.EqualFold("CacheSubnetGroup", t.Name.Local):
23230			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
23231			if err := awsAwsquery_deserializeDocumentCacheSubnetGroup(&sv.CacheSubnetGroup, nodeDecoder); err != nil {
23232				return err
23233			}
23234
23235		default:
23236			// Do nothing and ignore the unexpected tag element
23237			err = decoder.Decoder.Skip()
23238			if err != nil {
23239				return err
23240			}
23241
23242		}
23243		decoder = originalDecoder
23244	}
23245	*v = sv
23246	return nil
23247}
23248
23249func awsAwsquery_deserializeOpDocumentCreateGlobalReplicationGroupOutput(v **CreateGlobalReplicationGroupOutput, decoder smithyxml.NodeDecoder) error {
23250	if v == nil {
23251		return fmt.Errorf("unexpected nil of type %T", v)
23252	}
23253	var sv *CreateGlobalReplicationGroupOutput
23254	if *v == nil {
23255		sv = &CreateGlobalReplicationGroupOutput{}
23256	} else {
23257		sv = *v
23258	}
23259
23260	for {
23261		t, done, err := decoder.Token()
23262		if err != nil {
23263			return err
23264		}
23265		if done {
23266			break
23267		}
23268		originalDecoder := decoder
23269		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
23270		switch {
23271		case strings.EqualFold("GlobalReplicationGroup", t.Name.Local):
23272			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
23273			if err := awsAwsquery_deserializeDocumentGlobalReplicationGroup(&sv.GlobalReplicationGroup, nodeDecoder); err != nil {
23274				return err
23275			}
23276
23277		default:
23278			// Do nothing and ignore the unexpected tag element
23279			err = decoder.Decoder.Skip()
23280			if err != nil {
23281				return err
23282			}
23283
23284		}
23285		decoder = originalDecoder
23286	}
23287	*v = sv
23288	return nil
23289}
23290
23291func awsAwsquery_deserializeOpDocumentCreateReplicationGroupOutput(v **CreateReplicationGroupOutput, decoder smithyxml.NodeDecoder) error {
23292	if v == nil {
23293		return fmt.Errorf("unexpected nil of type %T", v)
23294	}
23295	var sv *CreateReplicationGroupOutput
23296	if *v == nil {
23297		sv = &CreateReplicationGroupOutput{}
23298	} else {
23299		sv = *v
23300	}
23301
23302	for {
23303		t, done, err := decoder.Token()
23304		if err != nil {
23305			return err
23306		}
23307		if done {
23308			break
23309		}
23310		originalDecoder := decoder
23311		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
23312		switch {
23313		case strings.EqualFold("ReplicationGroup", t.Name.Local):
23314			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
23315			if err := awsAwsquery_deserializeDocumentReplicationGroup(&sv.ReplicationGroup, nodeDecoder); err != nil {
23316				return err
23317			}
23318
23319		default:
23320			// Do nothing and ignore the unexpected tag element
23321			err = decoder.Decoder.Skip()
23322			if err != nil {
23323				return err
23324			}
23325
23326		}
23327		decoder = originalDecoder
23328	}
23329	*v = sv
23330	return nil
23331}
23332
23333func awsAwsquery_deserializeOpDocumentCreateSnapshotOutput(v **CreateSnapshotOutput, decoder smithyxml.NodeDecoder) error {
23334	if v == nil {
23335		return fmt.Errorf("unexpected nil of type %T", v)
23336	}
23337	var sv *CreateSnapshotOutput
23338	if *v == nil {
23339		sv = &CreateSnapshotOutput{}
23340	} else {
23341		sv = *v
23342	}
23343
23344	for {
23345		t, done, err := decoder.Token()
23346		if err != nil {
23347			return err
23348		}
23349		if done {
23350			break
23351		}
23352		originalDecoder := decoder
23353		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
23354		switch {
23355		case strings.EqualFold("Snapshot", t.Name.Local):
23356			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
23357			if err := awsAwsquery_deserializeDocumentSnapshot(&sv.Snapshot, nodeDecoder); err != nil {
23358				return err
23359			}
23360
23361		default:
23362			// Do nothing and ignore the unexpected tag element
23363			err = decoder.Decoder.Skip()
23364			if err != nil {
23365				return err
23366			}
23367
23368		}
23369		decoder = originalDecoder
23370	}
23371	*v = sv
23372	return nil
23373}
23374
23375func awsAwsquery_deserializeOpDocumentCreateUserGroupOutput(v **CreateUserGroupOutput, decoder smithyxml.NodeDecoder) error {
23376	if v == nil {
23377		return fmt.Errorf("unexpected nil of type %T", v)
23378	}
23379	var sv *CreateUserGroupOutput
23380	if *v == nil {
23381		sv = &CreateUserGroupOutput{}
23382	} else {
23383		sv = *v
23384	}
23385
23386	for {
23387		t, done, err := decoder.Token()
23388		if err != nil {
23389			return err
23390		}
23391		if done {
23392			break
23393		}
23394		originalDecoder := decoder
23395		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
23396		switch {
23397		case strings.EqualFold("ARN", t.Name.Local):
23398			val, err := decoder.Value()
23399			if err != nil {
23400				return err
23401			}
23402			if val == nil {
23403				break
23404			}
23405			{
23406				xtv := string(val)
23407				sv.ARN = ptr.String(xtv)
23408			}
23409
23410		case strings.EqualFold("Engine", t.Name.Local):
23411			val, err := decoder.Value()
23412			if err != nil {
23413				return err
23414			}
23415			if val == nil {
23416				break
23417			}
23418			{
23419				xtv := string(val)
23420				sv.Engine = ptr.String(xtv)
23421			}
23422
23423		case strings.EqualFold("PendingChanges", t.Name.Local):
23424			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
23425			if err := awsAwsquery_deserializeDocumentUserGroupPendingChanges(&sv.PendingChanges, nodeDecoder); err != nil {
23426				return err
23427			}
23428
23429		case strings.EqualFold("ReplicationGroups", t.Name.Local):
23430			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
23431			if err := awsAwsquery_deserializeDocumentUGReplicationGroupIdList(&sv.ReplicationGroups, nodeDecoder); err != nil {
23432				return err
23433			}
23434
23435		case strings.EqualFold("Status", t.Name.Local):
23436			val, err := decoder.Value()
23437			if err != nil {
23438				return err
23439			}
23440			if val == nil {
23441				break
23442			}
23443			{
23444				xtv := string(val)
23445				sv.Status = ptr.String(xtv)
23446			}
23447
23448		case strings.EqualFold("UserGroupId", t.Name.Local):
23449			val, err := decoder.Value()
23450			if err != nil {
23451				return err
23452			}
23453			if val == nil {
23454				break
23455			}
23456			{
23457				xtv := string(val)
23458				sv.UserGroupId = ptr.String(xtv)
23459			}
23460
23461		case strings.EqualFold("UserIds", t.Name.Local):
23462			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
23463			if err := awsAwsquery_deserializeDocumentUserIdList(&sv.UserIds, nodeDecoder); err != nil {
23464				return err
23465			}
23466
23467		default:
23468			// Do nothing and ignore the unexpected tag element
23469			err = decoder.Decoder.Skip()
23470			if err != nil {
23471				return err
23472			}
23473
23474		}
23475		decoder = originalDecoder
23476	}
23477	*v = sv
23478	return nil
23479}
23480
23481func awsAwsquery_deserializeOpDocumentCreateUserOutput(v **CreateUserOutput, decoder smithyxml.NodeDecoder) error {
23482	if v == nil {
23483		return fmt.Errorf("unexpected nil of type %T", v)
23484	}
23485	var sv *CreateUserOutput
23486	if *v == nil {
23487		sv = &CreateUserOutput{}
23488	} else {
23489		sv = *v
23490	}
23491
23492	for {
23493		t, done, err := decoder.Token()
23494		if err != nil {
23495			return err
23496		}
23497		if done {
23498			break
23499		}
23500		originalDecoder := decoder
23501		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
23502		switch {
23503		case strings.EqualFold("AccessString", t.Name.Local):
23504			val, err := decoder.Value()
23505			if err != nil {
23506				return err
23507			}
23508			if val == nil {
23509				break
23510			}
23511			{
23512				xtv := string(val)
23513				sv.AccessString = ptr.String(xtv)
23514			}
23515
23516		case strings.EqualFold("ARN", t.Name.Local):
23517			val, err := decoder.Value()
23518			if err != nil {
23519				return err
23520			}
23521			if val == nil {
23522				break
23523			}
23524			{
23525				xtv := string(val)
23526				sv.ARN = ptr.String(xtv)
23527			}
23528
23529		case strings.EqualFold("Authentication", t.Name.Local):
23530			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
23531			if err := awsAwsquery_deserializeDocumentAuthentication(&sv.Authentication, nodeDecoder); err != nil {
23532				return err
23533			}
23534
23535		case strings.EqualFold("Engine", t.Name.Local):
23536			val, err := decoder.Value()
23537			if err != nil {
23538				return err
23539			}
23540			if val == nil {
23541				break
23542			}
23543			{
23544				xtv := string(val)
23545				sv.Engine = ptr.String(xtv)
23546			}
23547
23548		case strings.EqualFold("Status", t.Name.Local):
23549			val, err := decoder.Value()
23550			if err != nil {
23551				return err
23552			}
23553			if val == nil {
23554				break
23555			}
23556			{
23557				xtv := string(val)
23558				sv.Status = ptr.String(xtv)
23559			}
23560
23561		case strings.EqualFold("UserGroupIds", t.Name.Local):
23562			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
23563			if err := awsAwsquery_deserializeDocumentUserGroupIdList(&sv.UserGroupIds, nodeDecoder); err != nil {
23564				return err
23565			}
23566
23567		case strings.EqualFold("UserId", t.Name.Local):
23568			val, err := decoder.Value()
23569			if err != nil {
23570				return err
23571			}
23572			if val == nil {
23573				break
23574			}
23575			{
23576				xtv := string(val)
23577				sv.UserId = ptr.String(xtv)
23578			}
23579
23580		case strings.EqualFold("UserName", t.Name.Local):
23581			val, err := decoder.Value()
23582			if err != nil {
23583				return err
23584			}
23585			if val == nil {
23586				break
23587			}
23588			{
23589				xtv := string(val)
23590				sv.UserName = ptr.String(xtv)
23591			}
23592
23593		default:
23594			// Do nothing and ignore the unexpected tag element
23595			err = decoder.Decoder.Skip()
23596			if err != nil {
23597				return err
23598			}
23599
23600		}
23601		decoder = originalDecoder
23602	}
23603	*v = sv
23604	return nil
23605}
23606
23607func awsAwsquery_deserializeOpDocumentDecreaseNodeGroupsInGlobalReplicationGroupOutput(v **DecreaseNodeGroupsInGlobalReplicationGroupOutput, decoder smithyxml.NodeDecoder) error {
23608	if v == nil {
23609		return fmt.Errorf("unexpected nil of type %T", v)
23610	}
23611	var sv *DecreaseNodeGroupsInGlobalReplicationGroupOutput
23612	if *v == nil {
23613		sv = &DecreaseNodeGroupsInGlobalReplicationGroupOutput{}
23614	} else {
23615		sv = *v
23616	}
23617
23618	for {
23619		t, done, err := decoder.Token()
23620		if err != nil {
23621			return err
23622		}
23623		if done {
23624			break
23625		}
23626		originalDecoder := decoder
23627		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
23628		switch {
23629		case strings.EqualFold("GlobalReplicationGroup", t.Name.Local):
23630			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
23631			if err := awsAwsquery_deserializeDocumentGlobalReplicationGroup(&sv.GlobalReplicationGroup, nodeDecoder); err != nil {
23632				return err
23633			}
23634
23635		default:
23636			// Do nothing and ignore the unexpected tag element
23637			err = decoder.Decoder.Skip()
23638			if err != nil {
23639				return err
23640			}
23641
23642		}
23643		decoder = originalDecoder
23644	}
23645	*v = sv
23646	return nil
23647}
23648
23649func awsAwsquery_deserializeOpDocumentDecreaseReplicaCountOutput(v **DecreaseReplicaCountOutput, decoder smithyxml.NodeDecoder) error {
23650	if v == nil {
23651		return fmt.Errorf("unexpected nil of type %T", v)
23652	}
23653	var sv *DecreaseReplicaCountOutput
23654	if *v == nil {
23655		sv = &DecreaseReplicaCountOutput{}
23656	} else {
23657		sv = *v
23658	}
23659
23660	for {
23661		t, done, err := decoder.Token()
23662		if err != nil {
23663			return err
23664		}
23665		if done {
23666			break
23667		}
23668		originalDecoder := decoder
23669		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
23670		switch {
23671		case strings.EqualFold("ReplicationGroup", t.Name.Local):
23672			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
23673			if err := awsAwsquery_deserializeDocumentReplicationGroup(&sv.ReplicationGroup, nodeDecoder); err != nil {
23674				return err
23675			}
23676
23677		default:
23678			// Do nothing and ignore the unexpected tag element
23679			err = decoder.Decoder.Skip()
23680			if err != nil {
23681				return err
23682			}
23683
23684		}
23685		decoder = originalDecoder
23686	}
23687	*v = sv
23688	return nil
23689}
23690
23691func awsAwsquery_deserializeOpDocumentDeleteCacheClusterOutput(v **DeleteCacheClusterOutput, decoder smithyxml.NodeDecoder) error {
23692	if v == nil {
23693		return fmt.Errorf("unexpected nil of type %T", v)
23694	}
23695	var sv *DeleteCacheClusterOutput
23696	if *v == nil {
23697		sv = &DeleteCacheClusterOutput{}
23698	} else {
23699		sv = *v
23700	}
23701
23702	for {
23703		t, done, err := decoder.Token()
23704		if err != nil {
23705			return err
23706		}
23707		if done {
23708			break
23709		}
23710		originalDecoder := decoder
23711		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
23712		switch {
23713		case strings.EqualFold("CacheCluster", t.Name.Local):
23714			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
23715			if err := awsAwsquery_deserializeDocumentCacheCluster(&sv.CacheCluster, nodeDecoder); err != nil {
23716				return err
23717			}
23718
23719		default:
23720			// Do nothing and ignore the unexpected tag element
23721			err = decoder.Decoder.Skip()
23722			if err != nil {
23723				return err
23724			}
23725
23726		}
23727		decoder = originalDecoder
23728	}
23729	*v = sv
23730	return nil
23731}
23732
23733func awsAwsquery_deserializeOpDocumentDeleteGlobalReplicationGroupOutput(v **DeleteGlobalReplicationGroupOutput, decoder smithyxml.NodeDecoder) error {
23734	if v == nil {
23735		return fmt.Errorf("unexpected nil of type %T", v)
23736	}
23737	var sv *DeleteGlobalReplicationGroupOutput
23738	if *v == nil {
23739		sv = &DeleteGlobalReplicationGroupOutput{}
23740	} else {
23741		sv = *v
23742	}
23743
23744	for {
23745		t, done, err := decoder.Token()
23746		if err != nil {
23747			return err
23748		}
23749		if done {
23750			break
23751		}
23752		originalDecoder := decoder
23753		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
23754		switch {
23755		case strings.EqualFold("GlobalReplicationGroup", t.Name.Local):
23756			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
23757			if err := awsAwsquery_deserializeDocumentGlobalReplicationGroup(&sv.GlobalReplicationGroup, nodeDecoder); err != nil {
23758				return err
23759			}
23760
23761		default:
23762			// Do nothing and ignore the unexpected tag element
23763			err = decoder.Decoder.Skip()
23764			if err != nil {
23765				return err
23766			}
23767
23768		}
23769		decoder = originalDecoder
23770	}
23771	*v = sv
23772	return nil
23773}
23774
23775func awsAwsquery_deserializeOpDocumentDeleteReplicationGroupOutput(v **DeleteReplicationGroupOutput, decoder smithyxml.NodeDecoder) error {
23776	if v == nil {
23777		return fmt.Errorf("unexpected nil of type %T", v)
23778	}
23779	var sv *DeleteReplicationGroupOutput
23780	if *v == nil {
23781		sv = &DeleteReplicationGroupOutput{}
23782	} else {
23783		sv = *v
23784	}
23785
23786	for {
23787		t, done, err := decoder.Token()
23788		if err != nil {
23789			return err
23790		}
23791		if done {
23792			break
23793		}
23794		originalDecoder := decoder
23795		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
23796		switch {
23797		case strings.EqualFold("ReplicationGroup", t.Name.Local):
23798			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
23799			if err := awsAwsquery_deserializeDocumentReplicationGroup(&sv.ReplicationGroup, nodeDecoder); err != nil {
23800				return err
23801			}
23802
23803		default:
23804			// Do nothing and ignore the unexpected tag element
23805			err = decoder.Decoder.Skip()
23806			if err != nil {
23807				return err
23808			}
23809
23810		}
23811		decoder = originalDecoder
23812	}
23813	*v = sv
23814	return nil
23815}
23816
23817func awsAwsquery_deserializeOpDocumentDeleteSnapshotOutput(v **DeleteSnapshotOutput, decoder smithyxml.NodeDecoder) error {
23818	if v == nil {
23819		return fmt.Errorf("unexpected nil of type %T", v)
23820	}
23821	var sv *DeleteSnapshotOutput
23822	if *v == nil {
23823		sv = &DeleteSnapshotOutput{}
23824	} else {
23825		sv = *v
23826	}
23827
23828	for {
23829		t, done, err := decoder.Token()
23830		if err != nil {
23831			return err
23832		}
23833		if done {
23834			break
23835		}
23836		originalDecoder := decoder
23837		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
23838		switch {
23839		case strings.EqualFold("Snapshot", t.Name.Local):
23840			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
23841			if err := awsAwsquery_deserializeDocumentSnapshot(&sv.Snapshot, nodeDecoder); err != nil {
23842				return err
23843			}
23844
23845		default:
23846			// Do nothing and ignore the unexpected tag element
23847			err = decoder.Decoder.Skip()
23848			if err != nil {
23849				return err
23850			}
23851
23852		}
23853		decoder = originalDecoder
23854	}
23855	*v = sv
23856	return nil
23857}
23858
23859func awsAwsquery_deserializeOpDocumentDeleteUserGroupOutput(v **DeleteUserGroupOutput, decoder smithyxml.NodeDecoder) error {
23860	if v == nil {
23861		return fmt.Errorf("unexpected nil of type %T", v)
23862	}
23863	var sv *DeleteUserGroupOutput
23864	if *v == nil {
23865		sv = &DeleteUserGroupOutput{}
23866	} else {
23867		sv = *v
23868	}
23869
23870	for {
23871		t, done, err := decoder.Token()
23872		if err != nil {
23873			return err
23874		}
23875		if done {
23876			break
23877		}
23878		originalDecoder := decoder
23879		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
23880		switch {
23881		case strings.EqualFold("ARN", t.Name.Local):
23882			val, err := decoder.Value()
23883			if err != nil {
23884				return err
23885			}
23886			if val == nil {
23887				break
23888			}
23889			{
23890				xtv := string(val)
23891				sv.ARN = ptr.String(xtv)
23892			}
23893
23894		case strings.EqualFold("Engine", t.Name.Local):
23895			val, err := decoder.Value()
23896			if err != nil {
23897				return err
23898			}
23899			if val == nil {
23900				break
23901			}
23902			{
23903				xtv := string(val)
23904				sv.Engine = ptr.String(xtv)
23905			}
23906
23907		case strings.EqualFold("PendingChanges", t.Name.Local):
23908			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
23909			if err := awsAwsquery_deserializeDocumentUserGroupPendingChanges(&sv.PendingChanges, nodeDecoder); err != nil {
23910				return err
23911			}
23912
23913		case strings.EqualFold("ReplicationGroups", t.Name.Local):
23914			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
23915			if err := awsAwsquery_deserializeDocumentUGReplicationGroupIdList(&sv.ReplicationGroups, nodeDecoder); err != nil {
23916				return err
23917			}
23918
23919		case strings.EqualFold("Status", t.Name.Local):
23920			val, err := decoder.Value()
23921			if err != nil {
23922				return err
23923			}
23924			if val == nil {
23925				break
23926			}
23927			{
23928				xtv := string(val)
23929				sv.Status = ptr.String(xtv)
23930			}
23931
23932		case strings.EqualFold("UserGroupId", t.Name.Local):
23933			val, err := decoder.Value()
23934			if err != nil {
23935				return err
23936			}
23937			if val == nil {
23938				break
23939			}
23940			{
23941				xtv := string(val)
23942				sv.UserGroupId = ptr.String(xtv)
23943			}
23944
23945		case strings.EqualFold("UserIds", t.Name.Local):
23946			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
23947			if err := awsAwsquery_deserializeDocumentUserIdList(&sv.UserIds, nodeDecoder); err != nil {
23948				return err
23949			}
23950
23951		default:
23952			// Do nothing and ignore the unexpected tag element
23953			err = decoder.Decoder.Skip()
23954			if err != nil {
23955				return err
23956			}
23957
23958		}
23959		decoder = originalDecoder
23960	}
23961	*v = sv
23962	return nil
23963}
23964
23965func awsAwsquery_deserializeOpDocumentDeleteUserOutput(v **DeleteUserOutput, decoder smithyxml.NodeDecoder) error {
23966	if v == nil {
23967		return fmt.Errorf("unexpected nil of type %T", v)
23968	}
23969	var sv *DeleteUserOutput
23970	if *v == nil {
23971		sv = &DeleteUserOutput{}
23972	} else {
23973		sv = *v
23974	}
23975
23976	for {
23977		t, done, err := decoder.Token()
23978		if err != nil {
23979			return err
23980		}
23981		if done {
23982			break
23983		}
23984		originalDecoder := decoder
23985		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
23986		switch {
23987		case strings.EqualFold("AccessString", t.Name.Local):
23988			val, err := decoder.Value()
23989			if err != nil {
23990				return err
23991			}
23992			if val == nil {
23993				break
23994			}
23995			{
23996				xtv := string(val)
23997				sv.AccessString = ptr.String(xtv)
23998			}
23999
24000		case strings.EqualFold("ARN", t.Name.Local):
24001			val, err := decoder.Value()
24002			if err != nil {
24003				return err
24004			}
24005			if val == nil {
24006				break
24007			}
24008			{
24009				xtv := string(val)
24010				sv.ARN = ptr.String(xtv)
24011			}
24012
24013		case strings.EqualFold("Authentication", t.Name.Local):
24014			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
24015			if err := awsAwsquery_deserializeDocumentAuthentication(&sv.Authentication, nodeDecoder); err != nil {
24016				return err
24017			}
24018
24019		case strings.EqualFold("Engine", t.Name.Local):
24020			val, err := decoder.Value()
24021			if err != nil {
24022				return err
24023			}
24024			if val == nil {
24025				break
24026			}
24027			{
24028				xtv := string(val)
24029				sv.Engine = ptr.String(xtv)
24030			}
24031
24032		case strings.EqualFold("Status", t.Name.Local):
24033			val, err := decoder.Value()
24034			if err != nil {
24035				return err
24036			}
24037			if val == nil {
24038				break
24039			}
24040			{
24041				xtv := string(val)
24042				sv.Status = ptr.String(xtv)
24043			}
24044
24045		case strings.EqualFold("UserGroupIds", t.Name.Local):
24046			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
24047			if err := awsAwsquery_deserializeDocumentUserGroupIdList(&sv.UserGroupIds, nodeDecoder); err != nil {
24048				return err
24049			}
24050
24051		case strings.EqualFold("UserId", t.Name.Local):
24052			val, err := decoder.Value()
24053			if err != nil {
24054				return err
24055			}
24056			if val == nil {
24057				break
24058			}
24059			{
24060				xtv := string(val)
24061				sv.UserId = ptr.String(xtv)
24062			}
24063
24064		case strings.EqualFold("UserName", t.Name.Local):
24065			val, err := decoder.Value()
24066			if err != nil {
24067				return err
24068			}
24069			if val == nil {
24070				break
24071			}
24072			{
24073				xtv := string(val)
24074				sv.UserName = ptr.String(xtv)
24075			}
24076
24077		default:
24078			// Do nothing and ignore the unexpected tag element
24079			err = decoder.Decoder.Skip()
24080			if err != nil {
24081				return err
24082			}
24083
24084		}
24085		decoder = originalDecoder
24086	}
24087	*v = sv
24088	return nil
24089}
24090
24091func awsAwsquery_deserializeOpDocumentDescribeCacheClustersOutput(v **DescribeCacheClustersOutput, decoder smithyxml.NodeDecoder) error {
24092	if v == nil {
24093		return fmt.Errorf("unexpected nil of type %T", v)
24094	}
24095	var sv *DescribeCacheClustersOutput
24096	if *v == nil {
24097		sv = &DescribeCacheClustersOutput{}
24098	} else {
24099		sv = *v
24100	}
24101
24102	for {
24103		t, done, err := decoder.Token()
24104		if err != nil {
24105			return err
24106		}
24107		if done {
24108			break
24109		}
24110		originalDecoder := decoder
24111		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
24112		switch {
24113		case strings.EqualFold("CacheClusters", t.Name.Local):
24114			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
24115			if err := awsAwsquery_deserializeDocumentCacheClusterList(&sv.CacheClusters, nodeDecoder); err != nil {
24116				return err
24117			}
24118
24119		case strings.EqualFold("Marker", t.Name.Local):
24120			val, err := decoder.Value()
24121			if err != nil {
24122				return err
24123			}
24124			if val == nil {
24125				break
24126			}
24127			{
24128				xtv := string(val)
24129				sv.Marker = ptr.String(xtv)
24130			}
24131
24132		default:
24133			// Do nothing and ignore the unexpected tag element
24134			err = decoder.Decoder.Skip()
24135			if err != nil {
24136				return err
24137			}
24138
24139		}
24140		decoder = originalDecoder
24141	}
24142	*v = sv
24143	return nil
24144}
24145
24146func awsAwsquery_deserializeOpDocumentDescribeCacheEngineVersionsOutput(v **DescribeCacheEngineVersionsOutput, decoder smithyxml.NodeDecoder) error {
24147	if v == nil {
24148		return fmt.Errorf("unexpected nil of type %T", v)
24149	}
24150	var sv *DescribeCacheEngineVersionsOutput
24151	if *v == nil {
24152		sv = &DescribeCacheEngineVersionsOutput{}
24153	} else {
24154		sv = *v
24155	}
24156
24157	for {
24158		t, done, err := decoder.Token()
24159		if err != nil {
24160			return err
24161		}
24162		if done {
24163			break
24164		}
24165		originalDecoder := decoder
24166		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
24167		switch {
24168		case strings.EqualFold("CacheEngineVersions", t.Name.Local):
24169			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
24170			if err := awsAwsquery_deserializeDocumentCacheEngineVersionList(&sv.CacheEngineVersions, nodeDecoder); err != nil {
24171				return err
24172			}
24173
24174		case strings.EqualFold("Marker", t.Name.Local):
24175			val, err := decoder.Value()
24176			if err != nil {
24177				return err
24178			}
24179			if val == nil {
24180				break
24181			}
24182			{
24183				xtv := string(val)
24184				sv.Marker = ptr.String(xtv)
24185			}
24186
24187		default:
24188			// Do nothing and ignore the unexpected tag element
24189			err = decoder.Decoder.Skip()
24190			if err != nil {
24191				return err
24192			}
24193
24194		}
24195		decoder = originalDecoder
24196	}
24197	*v = sv
24198	return nil
24199}
24200
24201func awsAwsquery_deserializeOpDocumentDescribeCacheParameterGroupsOutput(v **DescribeCacheParameterGroupsOutput, decoder smithyxml.NodeDecoder) error {
24202	if v == nil {
24203		return fmt.Errorf("unexpected nil of type %T", v)
24204	}
24205	var sv *DescribeCacheParameterGroupsOutput
24206	if *v == nil {
24207		sv = &DescribeCacheParameterGroupsOutput{}
24208	} else {
24209		sv = *v
24210	}
24211
24212	for {
24213		t, done, err := decoder.Token()
24214		if err != nil {
24215			return err
24216		}
24217		if done {
24218			break
24219		}
24220		originalDecoder := decoder
24221		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
24222		switch {
24223		case strings.EqualFold("CacheParameterGroups", t.Name.Local):
24224			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
24225			if err := awsAwsquery_deserializeDocumentCacheParameterGroupList(&sv.CacheParameterGroups, nodeDecoder); err != nil {
24226				return err
24227			}
24228
24229		case strings.EqualFold("Marker", t.Name.Local):
24230			val, err := decoder.Value()
24231			if err != nil {
24232				return err
24233			}
24234			if val == nil {
24235				break
24236			}
24237			{
24238				xtv := string(val)
24239				sv.Marker = ptr.String(xtv)
24240			}
24241
24242		default:
24243			// Do nothing and ignore the unexpected tag element
24244			err = decoder.Decoder.Skip()
24245			if err != nil {
24246				return err
24247			}
24248
24249		}
24250		decoder = originalDecoder
24251	}
24252	*v = sv
24253	return nil
24254}
24255
24256func awsAwsquery_deserializeOpDocumentDescribeCacheParametersOutput(v **DescribeCacheParametersOutput, decoder smithyxml.NodeDecoder) error {
24257	if v == nil {
24258		return fmt.Errorf("unexpected nil of type %T", v)
24259	}
24260	var sv *DescribeCacheParametersOutput
24261	if *v == nil {
24262		sv = &DescribeCacheParametersOutput{}
24263	} else {
24264		sv = *v
24265	}
24266
24267	for {
24268		t, done, err := decoder.Token()
24269		if err != nil {
24270			return err
24271		}
24272		if done {
24273			break
24274		}
24275		originalDecoder := decoder
24276		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
24277		switch {
24278		case strings.EqualFold("CacheNodeTypeSpecificParameters", t.Name.Local):
24279			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
24280			if err := awsAwsquery_deserializeDocumentCacheNodeTypeSpecificParametersList(&sv.CacheNodeTypeSpecificParameters, nodeDecoder); err != nil {
24281				return err
24282			}
24283
24284		case strings.EqualFold("Marker", t.Name.Local):
24285			val, err := decoder.Value()
24286			if err != nil {
24287				return err
24288			}
24289			if val == nil {
24290				break
24291			}
24292			{
24293				xtv := string(val)
24294				sv.Marker = ptr.String(xtv)
24295			}
24296
24297		case strings.EqualFold("Parameters", t.Name.Local):
24298			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
24299			if err := awsAwsquery_deserializeDocumentParametersList(&sv.Parameters, nodeDecoder); err != nil {
24300				return err
24301			}
24302
24303		default:
24304			// Do nothing and ignore the unexpected tag element
24305			err = decoder.Decoder.Skip()
24306			if err != nil {
24307				return err
24308			}
24309
24310		}
24311		decoder = originalDecoder
24312	}
24313	*v = sv
24314	return nil
24315}
24316
24317func awsAwsquery_deserializeOpDocumentDescribeCacheSecurityGroupsOutput(v **DescribeCacheSecurityGroupsOutput, decoder smithyxml.NodeDecoder) error {
24318	if v == nil {
24319		return fmt.Errorf("unexpected nil of type %T", v)
24320	}
24321	var sv *DescribeCacheSecurityGroupsOutput
24322	if *v == nil {
24323		sv = &DescribeCacheSecurityGroupsOutput{}
24324	} else {
24325		sv = *v
24326	}
24327
24328	for {
24329		t, done, err := decoder.Token()
24330		if err != nil {
24331			return err
24332		}
24333		if done {
24334			break
24335		}
24336		originalDecoder := decoder
24337		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
24338		switch {
24339		case strings.EqualFold("CacheSecurityGroups", t.Name.Local):
24340			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
24341			if err := awsAwsquery_deserializeDocumentCacheSecurityGroups(&sv.CacheSecurityGroups, nodeDecoder); err != nil {
24342				return err
24343			}
24344
24345		case strings.EqualFold("Marker", t.Name.Local):
24346			val, err := decoder.Value()
24347			if err != nil {
24348				return err
24349			}
24350			if val == nil {
24351				break
24352			}
24353			{
24354				xtv := string(val)
24355				sv.Marker = ptr.String(xtv)
24356			}
24357
24358		default:
24359			// Do nothing and ignore the unexpected tag element
24360			err = decoder.Decoder.Skip()
24361			if err != nil {
24362				return err
24363			}
24364
24365		}
24366		decoder = originalDecoder
24367	}
24368	*v = sv
24369	return nil
24370}
24371
24372func awsAwsquery_deserializeOpDocumentDescribeCacheSubnetGroupsOutput(v **DescribeCacheSubnetGroupsOutput, decoder smithyxml.NodeDecoder) error {
24373	if v == nil {
24374		return fmt.Errorf("unexpected nil of type %T", v)
24375	}
24376	var sv *DescribeCacheSubnetGroupsOutput
24377	if *v == nil {
24378		sv = &DescribeCacheSubnetGroupsOutput{}
24379	} else {
24380		sv = *v
24381	}
24382
24383	for {
24384		t, done, err := decoder.Token()
24385		if err != nil {
24386			return err
24387		}
24388		if done {
24389			break
24390		}
24391		originalDecoder := decoder
24392		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
24393		switch {
24394		case strings.EqualFold("CacheSubnetGroups", t.Name.Local):
24395			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
24396			if err := awsAwsquery_deserializeDocumentCacheSubnetGroups(&sv.CacheSubnetGroups, nodeDecoder); err != nil {
24397				return err
24398			}
24399
24400		case strings.EqualFold("Marker", t.Name.Local):
24401			val, err := decoder.Value()
24402			if err != nil {
24403				return err
24404			}
24405			if val == nil {
24406				break
24407			}
24408			{
24409				xtv := string(val)
24410				sv.Marker = ptr.String(xtv)
24411			}
24412
24413		default:
24414			// Do nothing and ignore the unexpected tag element
24415			err = decoder.Decoder.Skip()
24416			if err != nil {
24417				return err
24418			}
24419
24420		}
24421		decoder = originalDecoder
24422	}
24423	*v = sv
24424	return nil
24425}
24426
24427func awsAwsquery_deserializeOpDocumentDescribeEngineDefaultParametersOutput(v **DescribeEngineDefaultParametersOutput, decoder smithyxml.NodeDecoder) error {
24428	if v == nil {
24429		return fmt.Errorf("unexpected nil of type %T", v)
24430	}
24431	var sv *DescribeEngineDefaultParametersOutput
24432	if *v == nil {
24433		sv = &DescribeEngineDefaultParametersOutput{}
24434	} else {
24435		sv = *v
24436	}
24437
24438	for {
24439		t, done, err := decoder.Token()
24440		if err != nil {
24441			return err
24442		}
24443		if done {
24444			break
24445		}
24446		originalDecoder := decoder
24447		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
24448		switch {
24449		case strings.EqualFold("EngineDefaults", t.Name.Local):
24450			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
24451			if err := awsAwsquery_deserializeDocumentEngineDefaults(&sv.EngineDefaults, nodeDecoder); err != nil {
24452				return err
24453			}
24454
24455		default:
24456			// Do nothing and ignore the unexpected tag element
24457			err = decoder.Decoder.Skip()
24458			if err != nil {
24459				return err
24460			}
24461
24462		}
24463		decoder = originalDecoder
24464	}
24465	*v = sv
24466	return nil
24467}
24468
24469func awsAwsquery_deserializeOpDocumentDescribeEventsOutput(v **DescribeEventsOutput, decoder smithyxml.NodeDecoder) error {
24470	if v == nil {
24471		return fmt.Errorf("unexpected nil of type %T", v)
24472	}
24473	var sv *DescribeEventsOutput
24474	if *v == nil {
24475		sv = &DescribeEventsOutput{}
24476	} else {
24477		sv = *v
24478	}
24479
24480	for {
24481		t, done, err := decoder.Token()
24482		if err != nil {
24483			return err
24484		}
24485		if done {
24486			break
24487		}
24488		originalDecoder := decoder
24489		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
24490		switch {
24491		case strings.EqualFold("Events", t.Name.Local):
24492			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
24493			if err := awsAwsquery_deserializeDocumentEventList(&sv.Events, nodeDecoder); err != nil {
24494				return err
24495			}
24496
24497		case strings.EqualFold("Marker", t.Name.Local):
24498			val, err := decoder.Value()
24499			if err != nil {
24500				return err
24501			}
24502			if val == nil {
24503				break
24504			}
24505			{
24506				xtv := string(val)
24507				sv.Marker = ptr.String(xtv)
24508			}
24509
24510		default:
24511			// Do nothing and ignore the unexpected tag element
24512			err = decoder.Decoder.Skip()
24513			if err != nil {
24514				return err
24515			}
24516
24517		}
24518		decoder = originalDecoder
24519	}
24520	*v = sv
24521	return nil
24522}
24523
24524func awsAwsquery_deserializeOpDocumentDescribeGlobalReplicationGroupsOutput(v **DescribeGlobalReplicationGroupsOutput, decoder smithyxml.NodeDecoder) error {
24525	if v == nil {
24526		return fmt.Errorf("unexpected nil of type %T", v)
24527	}
24528	var sv *DescribeGlobalReplicationGroupsOutput
24529	if *v == nil {
24530		sv = &DescribeGlobalReplicationGroupsOutput{}
24531	} else {
24532		sv = *v
24533	}
24534
24535	for {
24536		t, done, err := decoder.Token()
24537		if err != nil {
24538			return err
24539		}
24540		if done {
24541			break
24542		}
24543		originalDecoder := decoder
24544		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
24545		switch {
24546		case strings.EqualFold("GlobalReplicationGroups", t.Name.Local):
24547			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
24548			if err := awsAwsquery_deserializeDocumentGlobalReplicationGroupList(&sv.GlobalReplicationGroups, nodeDecoder); err != nil {
24549				return err
24550			}
24551
24552		case strings.EqualFold("Marker", t.Name.Local):
24553			val, err := decoder.Value()
24554			if err != nil {
24555				return err
24556			}
24557			if val == nil {
24558				break
24559			}
24560			{
24561				xtv := string(val)
24562				sv.Marker = ptr.String(xtv)
24563			}
24564
24565		default:
24566			// Do nothing and ignore the unexpected tag element
24567			err = decoder.Decoder.Skip()
24568			if err != nil {
24569				return err
24570			}
24571
24572		}
24573		decoder = originalDecoder
24574	}
24575	*v = sv
24576	return nil
24577}
24578
24579func awsAwsquery_deserializeOpDocumentDescribeReplicationGroupsOutput(v **DescribeReplicationGroupsOutput, decoder smithyxml.NodeDecoder) error {
24580	if v == nil {
24581		return fmt.Errorf("unexpected nil of type %T", v)
24582	}
24583	var sv *DescribeReplicationGroupsOutput
24584	if *v == nil {
24585		sv = &DescribeReplicationGroupsOutput{}
24586	} else {
24587		sv = *v
24588	}
24589
24590	for {
24591		t, done, err := decoder.Token()
24592		if err != nil {
24593			return err
24594		}
24595		if done {
24596			break
24597		}
24598		originalDecoder := decoder
24599		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
24600		switch {
24601		case strings.EqualFold("Marker", t.Name.Local):
24602			val, err := decoder.Value()
24603			if err != nil {
24604				return err
24605			}
24606			if val == nil {
24607				break
24608			}
24609			{
24610				xtv := string(val)
24611				sv.Marker = ptr.String(xtv)
24612			}
24613
24614		case strings.EqualFold("ReplicationGroups", t.Name.Local):
24615			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
24616			if err := awsAwsquery_deserializeDocumentReplicationGroupList(&sv.ReplicationGroups, nodeDecoder); err != nil {
24617				return err
24618			}
24619
24620		default:
24621			// Do nothing and ignore the unexpected tag element
24622			err = decoder.Decoder.Skip()
24623			if err != nil {
24624				return err
24625			}
24626
24627		}
24628		decoder = originalDecoder
24629	}
24630	*v = sv
24631	return nil
24632}
24633
24634func awsAwsquery_deserializeOpDocumentDescribeReservedCacheNodesOfferingsOutput(v **DescribeReservedCacheNodesOfferingsOutput, decoder smithyxml.NodeDecoder) error {
24635	if v == nil {
24636		return fmt.Errorf("unexpected nil of type %T", v)
24637	}
24638	var sv *DescribeReservedCacheNodesOfferingsOutput
24639	if *v == nil {
24640		sv = &DescribeReservedCacheNodesOfferingsOutput{}
24641	} else {
24642		sv = *v
24643	}
24644
24645	for {
24646		t, done, err := decoder.Token()
24647		if err != nil {
24648			return err
24649		}
24650		if done {
24651			break
24652		}
24653		originalDecoder := decoder
24654		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
24655		switch {
24656		case strings.EqualFold("Marker", t.Name.Local):
24657			val, err := decoder.Value()
24658			if err != nil {
24659				return err
24660			}
24661			if val == nil {
24662				break
24663			}
24664			{
24665				xtv := string(val)
24666				sv.Marker = ptr.String(xtv)
24667			}
24668
24669		case strings.EqualFold("ReservedCacheNodesOfferings", t.Name.Local):
24670			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
24671			if err := awsAwsquery_deserializeDocumentReservedCacheNodesOfferingList(&sv.ReservedCacheNodesOfferings, nodeDecoder); err != nil {
24672				return err
24673			}
24674
24675		default:
24676			// Do nothing and ignore the unexpected tag element
24677			err = decoder.Decoder.Skip()
24678			if err != nil {
24679				return err
24680			}
24681
24682		}
24683		decoder = originalDecoder
24684	}
24685	*v = sv
24686	return nil
24687}
24688
24689func awsAwsquery_deserializeOpDocumentDescribeReservedCacheNodesOutput(v **DescribeReservedCacheNodesOutput, decoder smithyxml.NodeDecoder) error {
24690	if v == nil {
24691		return fmt.Errorf("unexpected nil of type %T", v)
24692	}
24693	var sv *DescribeReservedCacheNodesOutput
24694	if *v == nil {
24695		sv = &DescribeReservedCacheNodesOutput{}
24696	} else {
24697		sv = *v
24698	}
24699
24700	for {
24701		t, done, err := decoder.Token()
24702		if err != nil {
24703			return err
24704		}
24705		if done {
24706			break
24707		}
24708		originalDecoder := decoder
24709		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
24710		switch {
24711		case strings.EqualFold("Marker", t.Name.Local):
24712			val, err := decoder.Value()
24713			if err != nil {
24714				return err
24715			}
24716			if val == nil {
24717				break
24718			}
24719			{
24720				xtv := string(val)
24721				sv.Marker = ptr.String(xtv)
24722			}
24723
24724		case strings.EqualFold("ReservedCacheNodes", t.Name.Local):
24725			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
24726			if err := awsAwsquery_deserializeDocumentReservedCacheNodeList(&sv.ReservedCacheNodes, nodeDecoder); err != nil {
24727				return err
24728			}
24729
24730		default:
24731			// Do nothing and ignore the unexpected tag element
24732			err = decoder.Decoder.Skip()
24733			if err != nil {
24734				return err
24735			}
24736
24737		}
24738		decoder = originalDecoder
24739	}
24740	*v = sv
24741	return nil
24742}
24743
24744func awsAwsquery_deserializeOpDocumentDescribeServiceUpdatesOutput(v **DescribeServiceUpdatesOutput, decoder smithyxml.NodeDecoder) error {
24745	if v == nil {
24746		return fmt.Errorf("unexpected nil of type %T", v)
24747	}
24748	var sv *DescribeServiceUpdatesOutput
24749	if *v == nil {
24750		sv = &DescribeServiceUpdatesOutput{}
24751	} else {
24752		sv = *v
24753	}
24754
24755	for {
24756		t, done, err := decoder.Token()
24757		if err != nil {
24758			return err
24759		}
24760		if done {
24761			break
24762		}
24763		originalDecoder := decoder
24764		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
24765		switch {
24766		case strings.EqualFold("Marker", t.Name.Local):
24767			val, err := decoder.Value()
24768			if err != nil {
24769				return err
24770			}
24771			if val == nil {
24772				break
24773			}
24774			{
24775				xtv := string(val)
24776				sv.Marker = ptr.String(xtv)
24777			}
24778
24779		case strings.EqualFold("ServiceUpdates", t.Name.Local):
24780			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
24781			if err := awsAwsquery_deserializeDocumentServiceUpdateList(&sv.ServiceUpdates, nodeDecoder); err != nil {
24782				return err
24783			}
24784
24785		default:
24786			// Do nothing and ignore the unexpected tag element
24787			err = decoder.Decoder.Skip()
24788			if err != nil {
24789				return err
24790			}
24791
24792		}
24793		decoder = originalDecoder
24794	}
24795	*v = sv
24796	return nil
24797}
24798
24799func awsAwsquery_deserializeOpDocumentDescribeSnapshotsOutput(v **DescribeSnapshotsOutput, decoder smithyxml.NodeDecoder) error {
24800	if v == nil {
24801		return fmt.Errorf("unexpected nil of type %T", v)
24802	}
24803	var sv *DescribeSnapshotsOutput
24804	if *v == nil {
24805		sv = &DescribeSnapshotsOutput{}
24806	} else {
24807		sv = *v
24808	}
24809
24810	for {
24811		t, done, err := decoder.Token()
24812		if err != nil {
24813			return err
24814		}
24815		if done {
24816			break
24817		}
24818		originalDecoder := decoder
24819		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
24820		switch {
24821		case strings.EqualFold("Marker", t.Name.Local):
24822			val, err := decoder.Value()
24823			if err != nil {
24824				return err
24825			}
24826			if val == nil {
24827				break
24828			}
24829			{
24830				xtv := string(val)
24831				sv.Marker = ptr.String(xtv)
24832			}
24833
24834		case strings.EqualFold("Snapshots", t.Name.Local):
24835			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
24836			if err := awsAwsquery_deserializeDocumentSnapshotList(&sv.Snapshots, nodeDecoder); err != nil {
24837				return err
24838			}
24839
24840		default:
24841			// Do nothing and ignore the unexpected tag element
24842			err = decoder.Decoder.Skip()
24843			if err != nil {
24844				return err
24845			}
24846
24847		}
24848		decoder = originalDecoder
24849	}
24850	*v = sv
24851	return nil
24852}
24853
24854func awsAwsquery_deserializeOpDocumentDescribeUpdateActionsOutput(v **DescribeUpdateActionsOutput, decoder smithyxml.NodeDecoder) error {
24855	if v == nil {
24856		return fmt.Errorf("unexpected nil of type %T", v)
24857	}
24858	var sv *DescribeUpdateActionsOutput
24859	if *v == nil {
24860		sv = &DescribeUpdateActionsOutput{}
24861	} else {
24862		sv = *v
24863	}
24864
24865	for {
24866		t, done, err := decoder.Token()
24867		if err != nil {
24868			return err
24869		}
24870		if done {
24871			break
24872		}
24873		originalDecoder := decoder
24874		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
24875		switch {
24876		case strings.EqualFold("Marker", t.Name.Local):
24877			val, err := decoder.Value()
24878			if err != nil {
24879				return err
24880			}
24881			if val == nil {
24882				break
24883			}
24884			{
24885				xtv := string(val)
24886				sv.Marker = ptr.String(xtv)
24887			}
24888
24889		case strings.EqualFold("UpdateActions", t.Name.Local):
24890			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
24891			if err := awsAwsquery_deserializeDocumentUpdateActionList(&sv.UpdateActions, nodeDecoder); err != nil {
24892				return err
24893			}
24894
24895		default:
24896			// Do nothing and ignore the unexpected tag element
24897			err = decoder.Decoder.Skip()
24898			if err != nil {
24899				return err
24900			}
24901
24902		}
24903		decoder = originalDecoder
24904	}
24905	*v = sv
24906	return nil
24907}
24908
24909func awsAwsquery_deserializeOpDocumentDescribeUserGroupsOutput(v **DescribeUserGroupsOutput, decoder smithyxml.NodeDecoder) error {
24910	if v == nil {
24911		return fmt.Errorf("unexpected nil of type %T", v)
24912	}
24913	var sv *DescribeUserGroupsOutput
24914	if *v == nil {
24915		sv = &DescribeUserGroupsOutput{}
24916	} else {
24917		sv = *v
24918	}
24919
24920	for {
24921		t, done, err := decoder.Token()
24922		if err != nil {
24923			return err
24924		}
24925		if done {
24926			break
24927		}
24928		originalDecoder := decoder
24929		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
24930		switch {
24931		case strings.EqualFold("Marker", t.Name.Local):
24932			val, err := decoder.Value()
24933			if err != nil {
24934				return err
24935			}
24936			if val == nil {
24937				break
24938			}
24939			{
24940				xtv := string(val)
24941				sv.Marker = ptr.String(xtv)
24942			}
24943
24944		case strings.EqualFold("UserGroups", t.Name.Local):
24945			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
24946			if err := awsAwsquery_deserializeDocumentUserGroupList(&sv.UserGroups, nodeDecoder); err != nil {
24947				return err
24948			}
24949
24950		default:
24951			// Do nothing and ignore the unexpected tag element
24952			err = decoder.Decoder.Skip()
24953			if err != nil {
24954				return err
24955			}
24956
24957		}
24958		decoder = originalDecoder
24959	}
24960	*v = sv
24961	return nil
24962}
24963
24964func awsAwsquery_deserializeOpDocumentDescribeUsersOutput(v **DescribeUsersOutput, decoder smithyxml.NodeDecoder) error {
24965	if v == nil {
24966		return fmt.Errorf("unexpected nil of type %T", v)
24967	}
24968	var sv *DescribeUsersOutput
24969	if *v == nil {
24970		sv = &DescribeUsersOutput{}
24971	} else {
24972		sv = *v
24973	}
24974
24975	for {
24976		t, done, err := decoder.Token()
24977		if err != nil {
24978			return err
24979		}
24980		if done {
24981			break
24982		}
24983		originalDecoder := decoder
24984		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
24985		switch {
24986		case strings.EqualFold("Marker", t.Name.Local):
24987			val, err := decoder.Value()
24988			if err != nil {
24989				return err
24990			}
24991			if val == nil {
24992				break
24993			}
24994			{
24995				xtv := string(val)
24996				sv.Marker = ptr.String(xtv)
24997			}
24998
24999		case strings.EqualFold("Users", t.Name.Local):
25000			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
25001			if err := awsAwsquery_deserializeDocumentUserList(&sv.Users, nodeDecoder); err != nil {
25002				return err
25003			}
25004
25005		default:
25006			// Do nothing and ignore the unexpected tag element
25007			err = decoder.Decoder.Skip()
25008			if err != nil {
25009				return err
25010			}
25011
25012		}
25013		decoder = originalDecoder
25014	}
25015	*v = sv
25016	return nil
25017}
25018
25019func awsAwsquery_deserializeOpDocumentDisassociateGlobalReplicationGroupOutput(v **DisassociateGlobalReplicationGroupOutput, decoder smithyxml.NodeDecoder) error {
25020	if v == nil {
25021		return fmt.Errorf("unexpected nil of type %T", v)
25022	}
25023	var sv *DisassociateGlobalReplicationGroupOutput
25024	if *v == nil {
25025		sv = &DisassociateGlobalReplicationGroupOutput{}
25026	} else {
25027		sv = *v
25028	}
25029
25030	for {
25031		t, done, err := decoder.Token()
25032		if err != nil {
25033			return err
25034		}
25035		if done {
25036			break
25037		}
25038		originalDecoder := decoder
25039		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
25040		switch {
25041		case strings.EqualFold("GlobalReplicationGroup", t.Name.Local):
25042			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
25043			if err := awsAwsquery_deserializeDocumentGlobalReplicationGroup(&sv.GlobalReplicationGroup, nodeDecoder); err != nil {
25044				return err
25045			}
25046
25047		default:
25048			// Do nothing and ignore the unexpected tag element
25049			err = decoder.Decoder.Skip()
25050			if err != nil {
25051				return err
25052			}
25053
25054		}
25055		decoder = originalDecoder
25056	}
25057	*v = sv
25058	return nil
25059}
25060
25061func awsAwsquery_deserializeOpDocumentFailoverGlobalReplicationGroupOutput(v **FailoverGlobalReplicationGroupOutput, decoder smithyxml.NodeDecoder) error {
25062	if v == nil {
25063		return fmt.Errorf("unexpected nil of type %T", v)
25064	}
25065	var sv *FailoverGlobalReplicationGroupOutput
25066	if *v == nil {
25067		sv = &FailoverGlobalReplicationGroupOutput{}
25068	} else {
25069		sv = *v
25070	}
25071
25072	for {
25073		t, done, err := decoder.Token()
25074		if err != nil {
25075			return err
25076		}
25077		if done {
25078			break
25079		}
25080		originalDecoder := decoder
25081		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
25082		switch {
25083		case strings.EqualFold("GlobalReplicationGroup", t.Name.Local):
25084			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
25085			if err := awsAwsquery_deserializeDocumentGlobalReplicationGroup(&sv.GlobalReplicationGroup, nodeDecoder); err != nil {
25086				return err
25087			}
25088
25089		default:
25090			// Do nothing and ignore the unexpected tag element
25091			err = decoder.Decoder.Skip()
25092			if err != nil {
25093				return err
25094			}
25095
25096		}
25097		decoder = originalDecoder
25098	}
25099	*v = sv
25100	return nil
25101}
25102
25103func awsAwsquery_deserializeOpDocumentIncreaseNodeGroupsInGlobalReplicationGroupOutput(v **IncreaseNodeGroupsInGlobalReplicationGroupOutput, decoder smithyxml.NodeDecoder) error {
25104	if v == nil {
25105		return fmt.Errorf("unexpected nil of type %T", v)
25106	}
25107	var sv *IncreaseNodeGroupsInGlobalReplicationGroupOutput
25108	if *v == nil {
25109		sv = &IncreaseNodeGroupsInGlobalReplicationGroupOutput{}
25110	} else {
25111		sv = *v
25112	}
25113
25114	for {
25115		t, done, err := decoder.Token()
25116		if err != nil {
25117			return err
25118		}
25119		if done {
25120			break
25121		}
25122		originalDecoder := decoder
25123		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
25124		switch {
25125		case strings.EqualFold("GlobalReplicationGroup", t.Name.Local):
25126			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
25127			if err := awsAwsquery_deserializeDocumentGlobalReplicationGroup(&sv.GlobalReplicationGroup, nodeDecoder); err != nil {
25128				return err
25129			}
25130
25131		default:
25132			// Do nothing and ignore the unexpected tag element
25133			err = decoder.Decoder.Skip()
25134			if err != nil {
25135				return err
25136			}
25137
25138		}
25139		decoder = originalDecoder
25140	}
25141	*v = sv
25142	return nil
25143}
25144
25145func awsAwsquery_deserializeOpDocumentIncreaseReplicaCountOutput(v **IncreaseReplicaCountOutput, decoder smithyxml.NodeDecoder) error {
25146	if v == nil {
25147		return fmt.Errorf("unexpected nil of type %T", v)
25148	}
25149	var sv *IncreaseReplicaCountOutput
25150	if *v == nil {
25151		sv = &IncreaseReplicaCountOutput{}
25152	} else {
25153		sv = *v
25154	}
25155
25156	for {
25157		t, done, err := decoder.Token()
25158		if err != nil {
25159			return err
25160		}
25161		if done {
25162			break
25163		}
25164		originalDecoder := decoder
25165		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
25166		switch {
25167		case strings.EqualFold("ReplicationGroup", t.Name.Local):
25168			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
25169			if err := awsAwsquery_deserializeDocumentReplicationGroup(&sv.ReplicationGroup, nodeDecoder); err != nil {
25170				return err
25171			}
25172
25173		default:
25174			// Do nothing and ignore the unexpected tag element
25175			err = decoder.Decoder.Skip()
25176			if err != nil {
25177				return err
25178			}
25179
25180		}
25181		decoder = originalDecoder
25182	}
25183	*v = sv
25184	return nil
25185}
25186
25187func awsAwsquery_deserializeOpDocumentListAllowedNodeTypeModificationsOutput(v **ListAllowedNodeTypeModificationsOutput, decoder smithyxml.NodeDecoder) error {
25188	if v == nil {
25189		return fmt.Errorf("unexpected nil of type %T", v)
25190	}
25191	var sv *ListAllowedNodeTypeModificationsOutput
25192	if *v == nil {
25193		sv = &ListAllowedNodeTypeModificationsOutput{}
25194	} else {
25195		sv = *v
25196	}
25197
25198	for {
25199		t, done, err := decoder.Token()
25200		if err != nil {
25201			return err
25202		}
25203		if done {
25204			break
25205		}
25206		originalDecoder := decoder
25207		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
25208		switch {
25209		case strings.EqualFold("ScaleDownModifications", t.Name.Local):
25210			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
25211			if err := awsAwsquery_deserializeDocumentNodeTypeList(&sv.ScaleDownModifications, nodeDecoder); err != nil {
25212				return err
25213			}
25214
25215		case strings.EqualFold("ScaleUpModifications", t.Name.Local):
25216			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
25217			if err := awsAwsquery_deserializeDocumentNodeTypeList(&sv.ScaleUpModifications, nodeDecoder); err != nil {
25218				return err
25219			}
25220
25221		default:
25222			// Do nothing and ignore the unexpected tag element
25223			err = decoder.Decoder.Skip()
25224			if err != nil {
25225				return err
25226			}
25227
25228		}
25229		decoder = originalDecoder
25230	}
25231	*v = sv
25232	return nil
25233}
25234
25235func awsAwsquery_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, decoder smithyxml.NodeDecoder) error {
25236	if v == nil {
25237		return fmt.Errorf("unexpected nil of type %T", v)
25238	}
25239	var sv *ListTagsForResourceOutput
25240	if *v == nil {
25241		sv = &ListTagsForResourceOutput{}
25242	} else {
25243		sv = *v
25244	}
25245
25246	for {
25247		t, done, err := decoder.Token()
25248		if err != nil {
25249			return err
25250		}
25251		if done {
25252			break
25253		}
25254		originalDecoder := decoder
25255		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
25256		switch {
25257		case strings.EqualFold("TagList", t.Name.Local):
25258			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
25259			if err := awsAwsquery_deserializeDocumentTagList(&sv.TagList, nodeDecoder); err != nil {
25260				return err
25261			}
25262
25263		default:
25264			// Do nothing and ignore the unexpected tag element
25265			err = decoder.Decoder.Skip()
25266			if err != nil {
25267				return err
25268			}
25269
25270		}
25271		decoder = originalDecoder
25272	}
25273	*v = sv
25274	return nil
25275}
25276
25277func awsAwsquery_deserializeOpDocumentModifyCacheClusterOutput(v **ModifyCacheClusterOutput, decoder smithyxml.NodeDecoder) error {
25278	if v == nil {
25279		return fmt.Errorf("unexpected nil of type %T", v)
25280	}
25281	var sv *ModifyCacheClusterOutput
25282	if *v == nil {
25283		sv = &ModifyCacheClusterOutput{}
25284	} else {
25285		sv = *v
25286	}
25287
25288	for {
25289		t, done, err := decoder.Token()
25290		if err != nil {
25291			return err
25292		}
25293		if done {
25294			break
25295		}
25296		originalDecoder := decoder
25297		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
25298		switch {
25299		case strings.EqualFold("CacheCluster", t.Name.Local):
25300			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
25301			if err := awsAwsquery_deserializeDocumentCacheCluster(&sv.CacheCluster, nodeDecoder); err != nil {
25302				return err
25303			}
25304
25305		default:
25306			// Do nothing and ignore the unexpected tag element
25307			err = decoder.Decoder.Skip()
25308			if err != nil {
25309				return err
25310			}
25311
25312		}
25313		decoder = originalDecoder
25314	}
25315	*v = sv
25316	return nil
25317}
25318
25319func awsAwsquery_deserializeOpDocumentModifyCacheParameterGroupOutput(v **ModifyCacheParameterGroupOutput, decoder smithyxml.NodeDecoder) error {
25320	if v == nil {
25321		return fmt.Errorf("unexpected nil of type %T", v)
25322	}
25323	var sv *ModifyCacheParameterGroupOutput
25324	if *v == nil {
25325		sv = &ModifyCacheParameterGroupOutput{}
25326	} else {
25327		sv = *v
25328	}
25329
25330	for {
25331		t, done, err := decoder.Token()
25332		if err != nil {
25333			return err
25334		}
25335		if done {
25336			break
25337		}
25338		originalDecoder := decoder
25339		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
25340		switch {
25341		case strings.EqualFold("CacheParameterGroupName", t.Name.Local):
25342			val, err := decoder.Value()
25343			if err != nil {
25344				return err
25345			}
25346			if val == nil {
25347				break
25348			}
25349			{
25350				xtv := string(val)
25351				sv.CacheParameterGroupName = ptr.String(xtv)
25352			}
25353
25354		default:
25355			// Do nothing and ignore the unexpected tag element
25356			err = decoder.Decoder.Skip()
25357			if err != nil {
25358				return err
25359			}
25360
25361		}
25362		decoder = originalDecoder
25363	}
25364	*v = sv
25365	return nil
25366}
25367
25368func awsAwsquery_deserializeOpDocumentModifyCacheSubnetGroupOutput(v **ModifyCacheSubnetGroupOutput, decoder smithyxml.NodeDecoder) error {
25369	if v == nil {
25370		return fmt.Errorf("unexpected nil of type %T", v)
25371	}
25372	var sv *ModifyCacheSubnetGroupOutput
25373	if *v == nil {
25374		sv = &ModifyCacheSubnetGroupOutput{}
25375	} else {
25376		sv = *v
25377	}
25378
25379	for {
25380		t, done, err := decoder.Token()
25381		if err != nil {
25382			return err
25383		}
25384		if done {
25385			break
25386		}
25387		originalDecoder := decoder
25388		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
25389		switch {
25390		case strings.EqualFold("CacheSubnetGroup", t.Name.Local):
25391			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
25392			if err := awsAwsquery_deserializeDocumentCacheSubnetGroup(&sv.CacheSubnetGroup, nodeDecoder); err != nil {
25393				return err
25394			}
25395
25396		default:
25397			// Do nothing and ignore the unexpected tag element
25398			err = decoder.Decoder.Skip()
25399			if err != nil {
25400				return err
25401			}
25402
25403		}
25404		decoder = originalDecoder
25405	}
25406	*v = sv
25407	return nil
25408}
25409
25410func awsAwsquery_deserializeOpDocumentModifyGlobalReplicationGroupOutput(v **ModifyGlobalReplicationGroupOutput, decoder smithyxml.NodeDecoder) error {
25411	if v == nil {
25412		return fmt.Errorf("unexpected nil of type %T", v)
25413	}
25414	var sv *ModifyGlobalReplicationGroupOutput
25415	if *v == nil {
25416		sv = &ModifyGlobalReplicationGroupOutput{}
25417	} else {
25418		sv = *v
25419	}
25420
25421	for {
25422		t, done, err := decoder.Token()
25423		if err != nil {
25424			return err
25425		}
25426		if done {
25427			break
25428		}
25429		originalDecoder := decoder
25430		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
25431		switch {
25432		case strings.EqualFold("GlobalReplicationGroup", t.Name.Local):
25433			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
25434			if err := awsAwsquery_deserializeDocumentGlobalReplicationGroup(&sv.GlobalReplicationGroup, nodeDecoder); err != nil {
25435				return err
25436			}
25437
25438		default:
25439			// Do nothing and ignore the unexpected tag element
25440			err = decoder.Decoder.Skip()
25441			if err != nil {
25442				return err
25443			}
25444
25445		}
25446		decoder = originalDecoder
25447	}
25448	*v = sv
25449	return nil
25450}
25451
25452func awsAwsquery_deserializeOpDocumentModifyReplicationGroupOutput(v **ModifyReplicationGroupOutput, decoder smithyxml.NodeDecoder) error {
25453	if v == nil {
25454		return fmt.Errorf("unexpected nil of type %T", v)
25455	}
25456	var sv *ModifyReplicationGroupOutput
25457	if *v == nil {
25458		sv = &ModifyReplicationGroupOutput{}
25459	} else {
25460		sv = *v
25461	}
25462
25463	for {
25464		t, done, err := decoder.Token()
25465		if err != nil {
25466			return err
25467		}
25468		if done {
25469			break
25470		}
25471		originalDecoder := decoder
25472		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
25473		switch {
25474		case strings.EqualFold("ReplicationGroup", t.Name.Local):
25475			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
25476			if err := awsAwsquery_deserializeDocumentReplicationGroup(&sv.ReplicationGroup, nodeDecoder); err != nil {
25477				return err
25478			}
25479
25480		default:
25481			// Do nothing and ignore the unexpected tag element
25482			err = decoder.Decoder.Skip()
25483			if err != nil {
25484				return err
25485			}
25486
25487		}
25488		decoder = originalDecoder
25489	}
25490	*v = sv
25491	return nil
25492}
25493
25494func awsAwsquery_deserializeOpDocumentModifyReplicationGroupShardConfigurationOutput(v **ModifyReplicationGroupShardConfigurationOutput, decoder smithyxml.NodeDecoder) error {
25495	if v == nil {
25496		return fmt.Errorf("unexpected nil of type %T", v)
25497	}
25498	var sv *ModifyReplicationGroupShardConfigurationOutput
25499	if *v == nil {
25500		sv = &ModifyReplicationGroupShardConfigurationOutput{}
25501	} else {
25502		sv = *v
25503	}
25504
25505	for {
25506		t, done, err := decoder.Token()
25507		if err != nil {
25508			return err
25509		}
25510		if done {
25511			break
25512		}
25513		originalDecoder := decoder
25514		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
25515		switch {
25516		case strings.EqualFold("ReplicationGroup", t.Name.Local):
25517			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
25518			if err := awsAwsquery_deserializeDocumentReplicationGroup(&sv.ReplicationGroup, nodeDecoder); err != nil {
25519				return err
25520			}
25521
25522		default:
25523			// Do nothing and ignore the unexpected tag element
25524			err = decoder.Decoder.Skip()
25525			if err != nil {
25526				return err
25527			}
25528
25529		}
25530		decoder = originalDecoder
25531	}
25532	*v = sv
25533	return nil
25534}
25535
25536func awsAwsquery_deserializeOpDocumentModifyUserGroupOutput(v **ModifyUserGroupOutput, decoder smithyxml.NodeDecoder) error {
25537	if v == nil {
25538		return fmt.Errorf("unexpected nil of type %T", v)
25539	}
25540	var sv *ModifyUserGroupOutput
25541	if *v == nil {
25542		sv = &ModifyUserGroupOutput{}
25543	} else {
25544		sv = *v
25545	}
25546
25547	for {
25548		t, done, err := decoder.Token()
25549		if err != nil {
25550			return err
25551		}
25552		if done {
25553			break
25554		}
25555		originalDecoder := decoder
25556		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
25557		switch {
25558		case strings.EqualFold("ARN", t.Name.Local):
25559			val, err := decoder.Value()
25560			if err != nil {
25561				return err
25562			}
25563			if val == nil {
25564				break
25565			}
25566			{
25567				xtv := string(val)
25568				sv.ARN = ptr.String(xtv)
25569			}
25570
25571		case strings.EqualFold("Engine", t.Name.Local):
25572			val, err := decoder.Value()
25573			if err != nil {
25574				return err
25575			}
25576			if val == nil {
25577				break
25578			}
25579			{
25580				xtv := string(val)
25581				sv.Engine = ptr.String(xtv)
25582			}
25583
25584		case strings.EqualFold("PendingChanges", t.Name.Local):
25585			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
25586			if err := awsAwsquery_deserializeDocumentUserGroupPendingChanges(&sv.PendingChanges, nodeDecoder); err != nil {
25587				return err
25588			}
25589
25590		case strings.EqualFold("ReplicationGroups", t.Name.Local):
25591			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
25592			if err := awsAwsquery_deserializeDocumentUGReplicationGroupIdList(&sv.ReplicationGroups, nodeDecoder); err != nil {
25593				return err
25594			}
25595
25596		case strings.EqualFold("Status", t.Name.Local):
25597			val, err := decoder.Value()
25598			if err != nil {
25599				return err
25600			}
25601			if val == nil {
25602				break
25603			}
25604			{
25605				xtv := string(val)
25606				sv.Status = ptr.String(xtv)
25607			}
25608
25609		case strings.EqualFold("UserGroupId", t.Name.Local):
25610			val, err := decoder.Value()
25611			if err != nil {
25612				return err
25613			}
25614			if val == nil {
25615				break
25616			}
25617			{
25618				xtv := string(val)
25619				sv.UserGroupId = ptr.String(xtv)
25620			}
25621
25622		case strings.EqualFold("UserIds", t.Name.Local):
25623			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
25624			if err := awsAwsquery_deserializeDocumentUserIdList(&sv.UserIds, nodeDecoder); err != nil {
25625				return err
25626			}
25627
25628		default:
25629			// Do nothing and ignore the unexpected tag element
25630			err = decoder.Decoder.Skip()
25631			if err != nil {
25632				return err
25633			}
25634
25635		}
25636		decoder = originalDecoder
25637	}
25638	*v = sv
25639	return nil
25640}
25641
25642func awsAwsquery_deserializeOpDocumentModifyUserOutput(v **ModifyUserOutput, decoder smithyxml.NodeDecoder) error {
25643	if v == nil {
25644		return fmt.Errorf("unexpected nil of type %T", v)
25645	}
25646	var sv *ModifyUserOutput
25647	if *v == nil {
25648		sv = &ModifyUserOutput{}
25649	} else {
25650		sv = *v
25651	}
25652
25653	for {
25654		t, done, err := decoder.Token()
25655		if err != nil {
25656			return err
25657		}
25658		if done {
25659			break
25660		}
25661		originalDecoder := decoder
25662		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
25663		switch {
25664		case strings.EqualFold("AccessString", t.Name.Local):
25665			val, err := decoder.Value()
25666			if err != nil {
25667				return err
25668			}
25669			if val == nil {
25670				break
25671			}
25672			{
25673				xtv := string(val)
25674				sv.AccessString = ptr.String(xtv)
25675			}
25676
25677		case strings.EqualFold("ARN", t.Name.Local):
25678			val, err := decoder.Value()
25679			if err != nil {
25680				return err
25681			}
25682			if val == nil {
25683				break
25684			}
25685			{
25686				xtv := string(val)
25687				sv.ARN = ptr.String(xtv)
25688			}
25689
25690		case strings.EqualFold("Authentication", t.Name.Local):
25691			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
25692			if err := awsAwsquery_deserializeDocumentAuthentication(&sv.Authentication, nodeDecoder); err != nil {
25693				return err
25694			}
25695
25696		case strings.EqualFold("Engine", t.Name.Local):
25697			val, err := decoder.Value()
25698			if err != nil {
25699				return err
25700			}
25701			if val == nil {
25702				break
25703			}
25704			{
25705				xtv := string(val)
25706				sv.Engine = ptr.String(xtv)
25707			}
25708
25709		case strings.EqualFold("Status", t.Name.Local):
25710			val, err := decoder.Value()
25711			if err != nil {
25712				return err
25713			}
25714			if val == nil {
25715				break
25716			}
25717			{
25718				xtv := string(val)
25719				sv.Status = ptr.String(xtv)
25720			}
25721
25722		case strings.EqualFold("UserGroupIds", t.Name.Local):
25723			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
25724			if err := awsAwsquery_deserializeDocumentUserGroupIdList(&sv.UserGroupIds, nodeDecoder); err != nil {
25725				return err
25726			}
25727
25728		case strings.EqualFold("UserId", t.Name.Local):
25729			val, err := decoder.Value()
25730			if err != nil {
25731				return err
25732			}
25733			if val == nil {
25734				break
25735			}
25736			{
25737				xtv := string(val)
25738				sv.UserId = ptr.String(xtv)
25739			}
25740
25741		case strings.EqualFold("UserName", t.Name.Local):
25742			val, err := decoder.Value()
25743			if err != nil {
25744				return err
25745			}
25746			if val == nil {
25747				break
25748			}
25749			{
25750				xtv := string(val)
25751				sv.UserName = ptr.String(xtv)
25752			}
25753
25754		default:
25755			// Do nothing and ignore the unexpected tag element
25756			err = decoder.Decoder.Skip()
25757			if err != nil {
25758				return err
25759			}
25760
25761		}
25762		decoder = originalDecoder
25763	}
25764	*v = sv
25765	return nil
25766}
25767
25768func awsAwsquery_deserializeOpDocumentPurchaseReservedCacheNodesOfferingOutput(v **PurchaseReservedCacheNodesOfferingOutput, decoder smithyxml.NodeDecoder) error {
25769	if v == nil {
25770		return fmt.Errorf("unexpected nil of type %T", v)
25771	}
25772	var sv *PurchaseReservedCacheNodesOfferingOutput
25773	if *v == nil {
25774		sv = &PurchaseReservedCacheNodesOfferingOutput{}
25775	} else {
25776		sv = *v
25777	}
25778
25779	for {
25780		t, done, err := decoder.Token()
25781		if err != nil {
25782			return err
25783		}
25784		if done {
25785			break
25786		}
25787		originalDecoder := decoder
25788		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
25789		switch {
25790		case strings.EqualFold("ReservedCacheNode", t.Name.Local):
25791			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
25792			if err := awsAwsquery_deserializeDocumentReservedCacheNode(&sv.ReservedCacheNode, nodeDecoder); err != nil {
25793				return err
25794			}
25795
25796		default:
25797			// Do nothing and ignore the unexpected tag element
25798			err = decoder.Decoder.Skip()
25799			if err != nil {
25800				return err
25801			}
25802
25803		}
25804		decoder = originalDecoder
25805	}
25806	*v = sv
25807	return nil
25808}
25809
25810func awsAwsquery_deserializeOpDocumentRebalanceSlotsInGlobalReplicationGroupOutput(v **RebalanceSlotsInGlobalReplicationGroupOutput, decoder smithyxml.NodeDecoder) error {
25811	if v == nil {
25812		return fmt.Errorf("unexpected nil of type %T", v)
25813	}
25814	var sv *RebalanceSlotsInGlobalReplicationGroupOutput
25815	if *v == nil {
25816		sv = &RebalanceSlotsInGlobalReplicationGroupOutput{}
25817	} else {
25818		sv = *v
25819	}
25820
25821	for {
25822		t, done, err := decoder.Token()
25823		if err != nil {
25824			return err
25825		}
25826		if done {
25827			break
25828		}
25829		originalDecoder := decoder
25830		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
25831		switch {
25832		case strings.EqualFold("GlobalReplicationGroup", t.Name.Local):
25833			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
25834			if err := awsAwsquery_deserializeDocumentGlobalReplicationGroup(&sv.GlobalReplicationGroup, nodeDecoder); err != nil {
25835				return err
25836			}
25837
25838		default:
25839			// Do nothing and ignore the unexpected tag element
25840			err = decoder.Decoder.Skip()
25841			if err != nil {
25842				return err
25843			}
25844
25845		}
25846		decoder = originalDecoder
25847	}
25848	*v = sv
25849	return nil
25850}
25851
25852func awsAwsquery_deserializeOpDocumentRebootCacheClusterOutput(v **RebootCacheClusterOutput, decoder smithyxml.NodeDecoder) error {
25853	if v == nil {
25854		return fmt.Errorf("unexpected nil of type %T", v)
25855	}
25856	var sv *RebootCacheClusterOutput
25857	if *v == nil {
25858		sv = &RebootCacheClusterOutput{}
25859	} else {
25860		sv = *v
25861	}
25862
25863	for {
25864		t, done, err := decoder.Token()
25865		if err != nil {
25866			return err
25867		}
25868		if done {
25869			break
25870		}
25871		originalDecoder := decoder
25872		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
25873		switch {
25874		case strings.EqualFold("CacheCluster", t.Name.Local):
25875			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
25876			if err := awsAwsquery_deserializeDocumentCacheCluster(&sv.CacheCluster, nodeDecoder); err != nil {
25877				return err
25878			}
25879
25880		default:
25881			// Do nothing and ignore the unexpected tag element
25882			err = decoder.Decoder.Skip()
25883			if err != nil {
25884				return err
25885			}
25886
25887		}
25888		decoder = originalDecoder
25889	}
25890	*v = sv
25891	return nil
25892}
25893
25894func awsAwsquery_deserializeOpDocumentRemoveTagsFromResourceOutput(v **RemoveTagsFromResourceOutput, decoder smithyxml.NodeDecoder) error {
25895	if v == nil {
25896		return fmt.Errorf("unexpected nil of type %T", v)
25897	}
25898	var sv *RemoveTagsFromResourceOutput
25899	if *v == nil {
25900		sv = &RemoveTagsFromResourceOutput{}
25901	} else {
25902		sv = *v
25903	}
25904
25905	for {
25906		t, done, err := decoder.Token()
25907		if err != nil {
25908			return err
25909		}
25910		if done {
25911			break
25912		}
25913		originalDecoder := decoder
25914		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
25915		switch {
25916		case strings.EqualFold("TagList", t.Name.Local):
25917			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
25918			if err := awsAwsquery_deserializeDocumentTagList(&sv.TagList, nodeDecoder); err != nil {
25919				return err
25920			}
25921
25922		default:
25923			// Do nothing and ignore the unexpected tag element
25924			err = decoder.Decoder.Skip()
25925			if err != nil {
25926				return err
25927			}
25928
25929		}
25930		decoder = originalDecoder
25931	}
25932	*v = sv
25933	return nil
25934}
25935
25936func awsAwsquery_deserializeOpDocumentResetCacheParameterGroupOutput(v **ResetCacheParameterGroupOutput, decoder smithyxml.NodeDecoder) error {
25937	if v == nil {
25938		return fmt.Errorf("unexpected nil of type %T", v)
25939	}
25940	var sv *ResetCacheParameterGroupOutput
25941	if *v == nil {
25942		sv = &ResetCacheParameterGroupOutput{}
25943	} else {
25944		sv = *v
25945	}
25946
25947	for {
25948		t, done, err := decoder.Token()
25949		if err != nil {
25950			return err
25951		}
25952		if done {
25953			break
25954		}
25955		originalDecoder := decoder
25956		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
25957		switch {
25958		case strings.EqualFold("CacheParameterGroupName", t.Name.Local):
25959			val, err := decoder.Value()
25960			if err != nil {
25961				return err
25962			}
25963			if val == nil {
25964				break
25965			}
25966			{
25967				xtv := string(val)
25968				sv.CacheParameterGroupName = ptr.String(xtv)
25969			}
25970
25971		default:
25972			// Do nothing and ignore the unexpected tag element
25973			err = decoder.Decoder.Skip()
25974			if err != nil {
25975				return err
25976			}
25977
25978		}
25979		decoder = originalDecoder
25980	}
25981	*v = sv
25982	return nil
25983}
25984
25985func awsAwsquery_deserializeOpDocumentRevokeCacheSecurityGroupIngressOutput(v **RevokeCacheSecurityGroupIngressOutput, decoder smithyxml.NodeDecoder) error {
25986	if v == nil {
25987		return fmt.Errorf("unexpected nil of type %T", v)
25988	}
25989	var sv *RevokeCacheSecurityGroupIngressOutput
25990	if *v == nil {
25991		sv = &RevokeCacheSecurityGroupIngressOutput{}
25992	} else {
25993		sv = *v
25994	}
25995
25996	for {
25997		t, done, err := decoder.Token()
25998		if err != nil {
25999			return err
26000		}
26001		if done {
26002			break
26003		}
26004		originalDecoder := decoder
26005		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
26006		switch {
26007		case strings.EqualFold("CacheSecurityGroup", t.Name.Local):
26008			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
26009			if err := awsAwsquery_deserializeDocumentCacheSecurityGroup(&sv.CacheSecurityGroup, nodeDecoder); err != nil {
26010				return err
26011			}
26012
26013		default:
26014			// Do nothing and ignore the unexpected tag element
26015			err = decoder.Decoder.Skip()
26016			if err != nil {
26017				return err
26018			}
26019
26020		}
26021		decoder = originalDecoder
26022	}
26023	*v = sv
26024	return nil
26025}
26026
26027func awsAwsquery_deserializeOpDocumentStartMigrationOutput(v **StartMigrationOutput, decoder smithyxml.NodeDecoder) error {
26028	if v == nil {
26029		return fmt.Errorf("unexpected nil of type %T", v)
26030	}
26031	var sv *StartMigrationOutput
26032	if *v == nil {
26033		sv = &StartMigrationOutput{}
26034	} else {
26035		sv = *v
26036	}
26037
26038	for {
26039		t, done, err := decoder.Token()
26040		if err != nil {
26041			return err
26042		}
26043		if done {
26044			break
26045		}
26046		originalDecoder := decoder
26047		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
26048		switch {
26049		case strings.EqualFold("ReplicationGroup", t.Name.Local):
26050			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
26051			if err := awsAwsquery_deserializeDocumentReplicationGroup(&sv.ReplicationGroup, nodeDecoder); err != nil {
26052				return err
26053			}
26054
26055		default:
26056			// Do nothing and ignore the unexpected tag element
26057			err = decoder.Decoder.Skip()
26058			if err != nil {
26059				return err
26060			}
26061
26062		}
26063		decoder = originalDecoder
26064	}
26065	*v = sv
26066	return nil
26067}
26068
26069func awsAwsquery_deserializeOpDocumentTestFailoverOutput(v **TestFailoverOutput, decoder smithyxml.NodeDecoder) error {
26070	if v == nil {
26071		return fmt.Errorf("unexpected nil of type %T", v)
26072	}
26073	var sv *TestFailoverOutput
26074	if *v == nil {
26075		sv = &TestFailoverOutput{}
26076	} else {
26077		sv = *v
26078	}
26079
26080	for {
26081		t, done, err := decoder.Token()
26082		if err != nil {
26083			return err
26084		}
26085		if done {
26086			break
26087		}
26088		originalDecoder := decoder
26089		decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
26090		switch {
26091		case strings.EqualFold("ReplicationGroup", t.Name.Local):
26092			nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
26093			if err := awsAwsquery_deserializeDocumentReplicationGroup(&sv.ReplicationGroup, nodeDecoder); err != nil {
26094				return err
26095			}
26096
26097		default:
26098			// Do nothing and ignore the unexpected tag element
26099			err = decoder.Decoder.Skip()
26100			if err != nil {
26101				return err
26102			}
26103
26104		}
26105		decoder = originalDecoder
26106	}
26107	*v = sv
26108	return nil
26109}
26110