deserializers.go raw
1 // Code generated by smithy-go-codegen DO NOT EDIT.
2
3 package lightsail
4
5 import (
6 "bytes"
7 "context"
8 "encoding/json"
9 "fmt"
10 "github.com/aws/aws-sdk-go-v2/aws/protocol/restjson"
11 "github.com/aws/aws-sdk-go-v2/service/lightsail/types"
12 smithy "github.com/aws/smithy-go"
13 smithyio "github.com/aws/smithy-go/io"
14 "github.com/aws/smithy-go/middleware"
15 "github.com/aws/smithy-go/ptr"
16 smithytime "github.com/aws/smithy-go/time"
17 "github.com/aws/smithy-go/tracing"
18 smithyhttp "github.com/aws/smithy-go/transport/http"
19 "io"
20 "math"
21 "strings"
22 )
23
24 type awsAwsjson11_deserializeOpAllocateStaticIp struct {
25 }
26
27 func (*awsAwsjson11_deserializeOpAllocateStaticIp) ID() string {
28 return "OperationDeserializer"
29 }
30
31 func (m *awsAwsjson11_deserializeOpAllocateStaticIp) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
32 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
33 ) {
34 out, metadata, err = next.HandleDeserialize(ctx, in)
35 if err != nil {
36 return out, metadata, err
37 }
38
39 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
40 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
41 defer endTimer()
42 defer span.End()
43 response, ok := out.RawResponse.(*smithyhttp.Response)
44 if !ok {
45 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
46 }
47
48 if response.StatusCode < 200 || response.StatusCode >= 300 {
49 return out, metadata, awsAwsjson11_deserializeOpErrorAllocateStaticIp(response, &metadata)
50 }
51 output := &AllocateStaticIpOutput{}
52 out.Result = output
53
54 var buff [1024]byte
55 ringBuffer := smithyio.NewRingBuffer(buff[:])
56
57 body := io.TeeReader(response.Body, ringBuffer)
58 decoder := json.NewDecoder(body)
59 decoder.UseNumber()
60 var shape interface{}
61 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
62 var snapshot bytes.Buffer
63 io.Copy(&snapshot, ringBuffer)
64 err = &smithy.DeserializationError{
65 Err: fmt.Errorf("failed to decode response body, %w", err),
66 Snapshot: snapshot.Bytes(),
67 }
68 return out, metadata, err
69 }
70
71 err = awsAwsjson11_deserializeOpDocumentAllocateStaticIpOutput(&output, shape)
72 if err != nil {
73 var snapshot bytes.Buffer
74 io.Copy(&snapshot, ringBuffer)
75 err = &smithy.DeserializationError{
76 Err: fmt.Errorf("failed to decode response body, %w", err),
77 Snapshot: snapshot.Bytes(),
78 }
79 return out, metadata, err
80 }
81
82 return out, metadata, err
83 }
84
85 func awsAwsjson11_deserializeOpErrorAllocateStaticIp(response *smithyhttp.Response, metadata *middleware.Metadata) error {
86 var errorBuffer bytes.Buffer
87 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
88 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
89 }
90 errorBody := bytes.NewReader(errorBuffer.Bytes())
91
92 errorCode := "UnknownError"
93 errorMessage := errorCode
94
95 headerCode := response.Header.Get("X-Amzn-ErrorType")
96
97 var buff [1024]byte
98 ringBuffer := smithyio.NewRingBuffer(buff[:])
99
100 body := io.TeeReader(errorBody, ringBuffer)
101 decoder := json.NewDecoder(body)
102 decoder.UseNumber()
103 bodyInfo, err := getProtocolErrorInfo(decoder)
104 if err != nil {
105 var snapshot bytes.Buffer
106 io.Copy(&snapshot, ringBuffer)
107 err = &smithy.DeserializationError{
108 Err: fmt.Errorf("failed to decode response body, %w", err),
109 Snapshot: snapshot.Bytes(),
110 }
111 return err
112 }
113
114 errorBody.Seek(0, io.SeekStart)
115 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
116 errorCode = restjson.SanitizeErrorCode(typ)
117 }
118 if len(bodyInfo.Message) != 0 {
119 errorMessage = bodyInfo.Message
120 }
121 switch {
122 case strings.EqualFold("AccessDeniedException", errorCode):
123 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
124
125 case strings.EqualFold("AccountSetupInProgressException", errorCode):
126 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
127
128 case strings.EqualFold("InvalidInputException", errorCode):
129 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
130
131 case strings.EqualFold("NotFoundException", errorCode):
132 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
133
134 case strings.EqualFold("OperationFailureException", errorCode):
135 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
136
137 case strings.EqualFold("RegionSetupInProgressException", errorCode):
138 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
139
140 case strings.EqualFold("ServiceException", errorCode):
141 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
142
143 case strings.EqualFold("UnauthenticatedException", errorCode):
144 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
145
146 default:
147 genericError := &smithy.GenericAPIError{
148 Code: errorCode,
149 Message: errorMessage,
150 }
151 return genericError
152
153 }
154 }
155
156 type awsAwsjson11_deserializeOpAttachCertificateToDistribution struct {
157 }
158
159 func (*awsAwsjson11_deserializeOpAttachCertificateToDistribution) ID() string {
160 return "OperationDeserializer"
161 }
162
163 func (m *awsAwsjson11_deserializeOpAttachCertificateToDistribution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
164 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
165 ) {
166 out, metadata, err = next.HandleDeserialize(ctx, in)
167 if err != nil {
168 return out, metadata, err
169 }
170
171 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
172 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
173 defer endTimer()
174 defer span.End()
175 response, ok := out.RawResponse.(*smithyhttp.Response)
176 if !ok {
177 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
178 }
179
180 if response.StatusCode < 200 || response.StatusCode >= 300 {
181 return out, metadata, awsAwsjson11_deserializeOpErrorAttachCertificateToDistribution(response, &metadata)
182 }
183 output := &AttachCertificateToDistributionOutput{}
184 out.Result = output
185
186 var buff [1024]byte
187 ringBuffer := smithyio.NewRingBuffer(buff[:])
188
189 body := io.TeeReader(response.Body, ringBuffer)
190 decoder := json.NewDecoder(body)
191 decoder.UseNumber()
192 var shape interface{}
193 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
194 var snapshot bytes.Buffer
195 io.Copy(&snapshot, ringBuffer)
196 err = &smithy.DeserializationError{
197 Err: fmt.Errorf("failed to decode response body, %w", err),
198 Snapshot: snapshot.Bytes(),
199 }
200 return out, metadata, err
201 }
202
203 err = awsAwsjson11_deserializeOpDocumentAttachCertificateToDistributionOutput(&output, shape)
204 if err != nil {
205 var snapshot bytes.Buffer
206 io.Copy(&snapshot, ringBuffer)
207 err = &smithy.DeserializationError{
208 Err: fmt.Errorf("failed to decode response body, %w", err),
209 Snapshot: snapshot.Bytes(),
210 }
211 return out, metadata, err
212 }
213
214 return out, metadata, err
215 }
216
217 func awsAwsjson11_deserializeOpErrorAttachCertificateToDistribution(response *smithyhttp.Response, metadata *middleware.Metadata) error {
218 var errorBuffer bytes.Buffer
219 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
220 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
221 }
222 errorBody := bytes.NewReader(errorBuffer.Bytes())
223
224 errorCode := "UnknownError"
225 errorMessage := errorCode
226
227 headerCode := response.Header.Get("X-Amzn-ErrorType")
228
229 var buff [1024]byte
230 ringBuffer := smithyio.NewRingBuffer(buff[:])
231
232 body := io.TeeReader(errorBody, ringBuffer)
233 decoder := json.NewDecoder(body)
234 decoder.UseNumber()
235 bodyInfo, err := getProtocolErrorInfo(decoder)
236 if err != nil {
237 var snapshot bytes.Buffer
238 io.Copy(&snapshot, ringBuffer)
239 err = &smithy.DeserializationError{
240 Err: fmt.Errorf("failed to decode response body, %w", err),
241 Snapshot: snapshot.Bytes(),
242 }
243 return err
244 }
245
246 errorBody.Seek(0, io.SeekStart)
247 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
248 errorCode = restjson.SanitizeErrorCode(typ)
249 }
250 if len(bodyInfo.Message) != 0 {
251 errorMessage = bodyInfo.Message
252 }
253 switch {
254 case strings.EqualFold("AccessDeniedException", errorCode):
255 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
256
257 case strings.EqualFold("InvalidInputException", errorCode):
258 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
259
260 case strings.EqualFold("NotFoundException", errorCode):
261 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
262
263 case strings.EqualFold("OperationFailureException", errorCode):
264 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
265
266 case strings.EqualFold("ServiceException", errorCode):
267 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
268
269 case strings.EqualFold("UnauthenticatedException", errorCode):
270 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
271
272 default:
273 genericError := &smithy.GenericAPIError{
274 Code: errorCode,
275 Message: errorMessage,
276 }
277 return genericError
278
279 }
280 }
281
282 type awsAwsjson11_deserializeOpAttachDisk struct {
283 }
284
285 func (*awsAwsjson11_deserializeOpAttachDisk) ID() string {
286 return "OperationDeserializer"
287 }
288
289 func (m *awsAwsjson11_deserializeOpAttachDisk) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
290 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
291 ) {
292 out, metadata, err = next.HandleDeserialize(ctx, in)
293 if err != nil {
294 return out, metadata, err
295 }
296
297 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
298 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
299 defer endTimer()
300 defer span.End()
301 response, ok := out.RawResponse.(*smithyhttp.Response)
302 if !ok {
303 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
304 }
305
306 if response.StatusCode < 200 || response.StatusCode >= 300 {
307 return out, metadata, awsAwsjson11_deserializeOpErrorAttachDisk(response, &metadata)
308 }
309 output := &AttachDiskOutput{}
310 out.Result = output
311
312 var buff [1024]byte
313 ringBuffer := smithyio.NewRingBuffer(buff[:])
314
315 body := io.TeeReader(response.Body, ringBuffer)
316 decoder := json.NewDecoder(body)
317 decoder.UseNumber()
318 var shape interface{}
319 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
320 var snapshot bytes.Buffer
321 io.Copy(&snapshot, ringBuffer)
322 err = &smithy.DeserializationError{
323 Err: fmt.Errorf("failed to decode response body, %w", err),
324 Snapshot: snapshot.Bytes(),
325 }
326 return out, metadata, err
327 }
328
329 err = awsAwsjson11_deserializeOpDocumentAttachDiskOutput(&output, shape)
330 if err != nil {
331 var snapshot bytes.Buffer
332 io.Copy(&snapshot, ringBuffer)
333 err = &smithy.DeserializationError{
334 Err: fmt.Errorf("failed to decode response body, %w", err),
335 Snapshot: snapshot.Bytes(),
336 }
337 return out, metadata, err
338 }
339
340 return out, metadata, err
341 }
342
343 func awsAwsjson11_deserializeOpErrorAttachDisk(response *smithyhttp.Response, metadata *middleware.Metadata) error {
344 var errorBuffer bytes.Buffer
345 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
346 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
347 }
348 errorBody := bytes.NewReader(errorBuffer.Bytes())
349
350 errorCode := "UnknownError"
351 errorMessage := errorCode
352
353 headerCode := response.Header.Get("X-Amzn-ErrorType")
354
355 var buff [1024]byte
356 ringBuffer := smithyio.NewRingBuffer(buff[:])
357
358 body := io.TeeReader(errorBody, ringBuffer)
359 decoder := json.NewDecoder(body)
360 decoder.UseNumber()
361 bodyInfo, err := getProtocolErrorInfo(decoder)
362 if err != nil {
363 var snapshot bytes.Buffer
364 io.Copy(&snapshot, ringBuffer)
365 err = &smithy.DeserializationError{
366 Err: fmt.Errorf("failed to decode response body, %w", err),
367 Snapshot: snapshot.Bytes(),
368 }
369 return err
370 }
371
372 errorBody.Seek(0, io.SeekStart)
373 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
374 errorCode = restjson.SanitizeErrorCode(typ)
375 }
376 if len(bodyInfo.Message) != 0 {
377 errorMessage = bodyInfo.Message
378 }
379 switch {
380 case strings.EqualFold("AccessDeniedException", errorCode):
381 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
382
383 case strings.EqualFold("AccountSetupInProgressException", errorCode):
384 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
385
386 case strings.EqualFold("InvalidInputException", errorCode):
387 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
388
389 case strings.EqualFold("NotFoundException", errorCode):
390 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
391
392 case strings.EqualFold("OperationFailureException", errorCode):
393 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
394
395 case strings.EqualFold("RegionSetupInProgressException", errorCode):
396 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
397
398 case strings.EqualFold("ServiceException", errorCode):
399 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
400
401 case strings.EqualFold("UnauthenticatedException", errorCode):
402 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
403
404 default:
405 genericError := &smithy.GenericAPIError{
406 Code: errorCode,
407 Message: errorMessage,
408 }
409 return genericError
410
411 }
412 }
413
414 type awsAwsjson11_deserializeOpAttachInstancesToLoadBalancer struct {
415 }
416
417 func (*awsAwsjson11_deserializeOpAttachInstancesToLoadBalancer) ID() string {
418 return "OperationDeserializer"
419 }
420
421 func (m *awsAwsjson11_deserializeOpAttachInstancesToLoadBalancer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
422 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
423 ) {
424 out, metadata, err = next.HandleDeserialize(ctx, in)
425 if err != nil {
426 return out, metadata, err
427 }
428
429 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
430 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
431 defer endTimer()
432 defer span.End()
433 response, ok := out.RawResponse.(*smithyhttp.Response)
434 if !ok {
435 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
436 }
437
438 if response.StatusCode < 200 || response.StatusCode >= 300 {
439 return out, metadata, awsAwsjson11_deserializeOpErrorAttachInstancesToLoadBalancer(response, &metadata)
440 }
441 output := &AttachInstancesToLoadBalancerOutput{}
442 out.Result = output
443
444 var buff [1024]byte
445 ringBuffer := smithyio.NewRingBuffer(buff[:])
446
447 body := io.TeeReader(response.Body, ringBuffer)
448 decoder := json.NewDecoder(body)
449 decoder.UseNumber()
450 var shape interface{}
451 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
452 var snapshot bytes.Buffer
453 io.Copy(&snapshot, ringBuffer)
454 err = &smithy.DeserializationError{
455 Err: fmt.Errorf("failed to decode response body, %w", err),
456 Snapshot: snapshot.Bytes(),
457 }
458 return out, metadata, err
459 }
460
461 err = awsAwsjson11_deserializeOpDocumentAttachInstancesToLoadBalancerOutput(&output, shape)
462 if err != nil {
463 var snapshot bytes.Buffer
464 io.Copy(&snapshot, ringBuffer)
465 err = &smithy.DeserializationError{
466 Err: fmt.Errorf("failed to decode response body, %w", err),
467 Snapshot: snapshot.Bytes(),
468 }
469 return out, metadata, err
470 }
471
472 return out, metadata, err
473 }
474
475 func awsAwsjson11_deserializeOpErrorAttachInstancesToLoadBalancer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
476 var errorBuffer bytes.Buffer
477 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
478 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
479 }
480 errorBody := bytes.NewReader(errorBuffer.Bytes())
481
482 errorCode := "UnknownError"
483 errorMessage := errorCode
484
485 headerCode := response.Header.Get("X-Amzn-ErrorType")
486
487 var buff [1024]byte
488 ringBuffer := smithyio.NewRingBuffer(buff[:])
489
490 body := io.TeeReader(errorBody, ringBuffer)
491 decoder := json.NewDecoder(body)
492 decoder.UseNumber()
493 bodyInfo, err := getProtocolErrorInfo(decoder)
494 if err != nil {
495 var snapshot bytes.Buffer
496 io.Copy(&snapshot, ringBuffer)
497 err = &smithy.DeserializationError{
498 Err: fmt.Errorf("failed to decode response body, %w", err),
499 Snapshot: snapshot.Bytes(),
500 }
501 return err
502 }
503
504 errorBody.Seek(0, io.SeekStart)
505 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
506 errorCode = restjson.SanitizeErrorCode(typ)
507 }
508 if len(bodyInfo.Message) != 0 {
509 errorMessage = bodyInfo.Message
510 }
511 switch {
512 case strings.EqualFold("AccessDeniedException", errorCode):
513 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
514
515 case strings.EqualFold("AccountSetupInProgressException", errorCode):
516 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
517
518 case strings.EqualFold("InvalidInputException", errorCode):
519 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
520
521 case strings.EqualFold("NotFoundException", errorCode):
522 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
523
524 case strings.EqualFold("OperationFailureException", errorCode):
525 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
526
527 case strings.EqualFold("RegionSetupInProgressException", errorCode):
528 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
529
530 case strings.EqualFold("ServiceException", errorCode):
531 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
532
533 case strings.EqualFold("UnauthenticatedException", errorCode):
534 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
535
536 default:
537 genericError := &smithy.GenericAPIError{
538 Code: errorCode,
539 Message: errorMessage,
540 }
541 return genericError
542
543 }
544 }
545
546 type awsAwsjson11_deserializeOpAttachLoadBalancerTlsCertificate struct {
547 }
548
549 func (*awsAwsjson11_deserializeOpAttachLoadBalancerTlsCertificate) ID() string {
550 return "OperationDeserializer"
551 }
552
553 func (m *awsAwsjson11_deserializeOpAttachLoadBalancerTlsCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
554 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
555 ) {
556 out, metadata, err = next.HandleDeserialize(ctx, in)
557 if err != nil {
558 return out, metadata, err
559 }
560
561 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
562 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
563 defer endTimer()
564 defer span.End()
565 response, ok := out.RawResponse.(*smithyhttp.Response)
566 if !ok {
567 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
568 }
569
570 if response.StatusCode < 200 || response.StatusCode >= 300 {
571 return out, metadata, awsAwsjson11_deserializeOpErrorAttachLoadBalancerTlsCertificate(response, &metadata)
572 }
573 output := &AttachLoadBalancerTlsCertificateOutput{}
574 out.Result = output
575
576 var buff [1024]byte
577 ringBuffer := smithyio.NewRingBuffer(buff[:])
578
579 body := io.TeeReader(response.Body, ringBuffer)
580 decoder := json.NewDecoder(body)
581 decoder.UseNumber()
582 var shape interface{}
583 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
584 var snapshot bytes.Buffer
585 io.Copy(&snapshot, ringBuffer)
586 err = &smithy.DeserializationError{
587 Err: fmt.Errorf("failed to decode response body, %w", err),
588 Snapshot: snapshot.Bytes(),
589 }
590 return out, metadata, err
591 }
592
593 err = awsAwsjson11_deserializeOpDocumentAttachLoadBalancerTlsCertificateOutput(&output, shape)
594 if err != nil {
595 var snapshot bytes.Buffer
596 io.Copy(&snapshot, ringBuffer)
597 err = &smithy.DeserializationError{
598 Err: fmt.Errorf("failed to decode response body, %w", err),
599 Snapshot: snapshot.Bytes(),
600 }
601 return out, metadata, err
602 }
603
604 return out, metadata, err
605 }
606
607 func awsAwsjson11_deserializeOpErrorAttachLoadBalancerTlsCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error {
608 var errorBuffer bytes.Buffer
609 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
610 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
611 }
612 errorBody := bytes.NewReader(errorBuffer.Bytes())
613
614 errorCode := "UnknownError"
615 errorMessage := errorCode
616
617 headerCode := response.Header.Get("X-Amzn-ErrorType")
618
619 var buff [1024]byte
620 ringBuffer := smithyio.NewRingBuffer(buff[:])
621
622 body := io.TeeReader(errorBody, ringBuffer)
623 decoder := json.NewDecoder(body)
624 decoder.UseNumber()
625 bodyInfo, err := getProtocolErrorInfo(decoder)
626 if err != nil {
627 var snapshot bytes.Buffer
628 io.Copy(&snapshot, ringBuffer)
629 err = &smithy.DeserializationError{
630 Err: fmt.Errorf("failed to decode response body, %w", err),
631 Snapshot: snapshot.Bytes(),
632 }
633 return err
634 }
635
636 errorBody.Seek(0, io.SeekStart)
637 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
638 errorCode = restjson.SanitizeErrorCode(typ)
639 }
640 if len(bodyInfo.Message) != 0 {
641 errorMessage = bodyInfo.Message
642 }
643 switch {
644 case strings.EqualFold("AccessDeniedException", errorCode):
645 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
646
647 case strings.EqualFold("AccountSetupInProgressException", errorCode):
648 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
649
650 case strings.EqualFold("InvalidInputException", errorCode):
651 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
652
653 case strings.EqualFold("NotFoundException", errorCode):
654 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
655
656 case strings.EqualFold("OperationFailureException", errorCode):
657 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
658
659 case strings.EqualFold("RegionSetupInProgressException", errorCode):
660 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
661
662 case strings.EqualFold("ServiceException", errorCode):
663 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
664
665 case strings.EqualFold("UnauthenticatedException", errorCode):
666 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
667
668 default:
669 genericError := &smithy.GenericAPIError{
670 Code: errorCode,
671 Message: errorMessage,
672 }
673 return genericError
674
675 }
676 }
677
678 type awsAwsjson11_deserializeOpAttachStaticIp struct {
679 }
680
681 func (*awsAwsjson11_deserializeOpAttachStaticIp) ID() string {
682 return "OperationDeserializer"
683 }
684
685 func (m *awsAwsjson11_deserializeOpAttachStaticIp) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
686 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
687 ) {
688 out, metadata, err = next.HandleDeserialize(ctx, in)
689 if err != nil {
690 return out, metadata, err
691 }
692
693 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
694 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
695 defer endTimer()
696 defer span.End()
697 response, ok := out.RawResponse.(*smithyhttp.Response)
698 if !ok {
699 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
700 }
701
702 if response.StatusCode < 200 || response.StatusCode >= 300 {
703 return out, metadata, awsAwsjson11_deserializeOpErrorAttachStaticIp(response, &metadata)
704 }
705 output := &AttachStaticIpOutput{}
706 out.Result = output
707
708 var buff [1024]byte
709 ringBuffer := smithyio.NewRingBuffer(buff[:])
710
711 body := io.TeeReader(response.Body, ringBuffer)
712 decoder := json.NewDecoder(body)
713 decoder.UseNumber()
714 var shape interface{}
715 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
716 var snapshot bytes.Buffer
717 io.Copy(&snapshot, ringBuffer)
718 err = &smithy.DeserializationError{
719 Err: fmt.Errorf("failed to decode response body, %w", err),
720 Snapshot: snapshot.Bytes(),
721 }
722 return out, metadata, err
723 }
724
725 err = awsAwsjson11_deserializeOpDocumentAttachStaticIpOutput(&output, shape)
726 if err != nil {
727 var snapshot bytes.Buffer
728 io.Copy(&snapshot, ringBuffer)
729 err = &smithy.DeserializationError{
730 Err: fmt.Errorf("failed to decode response body, %w", err),
731 Snapshot: snapshot.Bytes(),
732 }
733 return out, metadata, err
734 }
735
736 return out, metadata, err
737 }
738
739 func awsAwsjson11_deserializeOpErrorAttachStaticIp(response *smithyhttp.Response, metadata *middleware.Metadata) error {
740 var errorBuffer bytes.Buffer
741 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
742 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
743 }
744 errorBody := bytes.NewReader(errorBuffer.Bytes())
745
746 errorCode := "UnknownError"
747 errorMessage := errorCode
748
749 headerCode := response.Header.Get("X-Amzn-ErrorType")
750
751 var buff [1024]byte
752 ringBuffer := smithyio.NewRingBuffer(buff[:])
753
754 body := io.TeeReader(errorBody, ringBuffer)
755 decoder := json.NewDecoder(body)
756 decoder.UseNumber()
757 bodyInfo, err := getProtocolErrorInfo(decoder)
758 if err != nil {
759 var snapshot bytes.Buffer
760 io.Copy(&snapshot, ringBuffer)
761 err = &smithy.DeserializationError{
762 Err: fmt.Errorf("failed to decode response body, %w", err),
763 Snapshot: snapshot.Bytes(),
764 }
765 return err
766 }
767
768 errorBody.Seek(0, io.SeekStart)
769 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
770 errorCode = restjson.SanitizeErrorCode(typ)
771 }
772 if len(bodyInfo.Message) != 0 {
773 errorMessage = bodyInfo.Message
774 }
775 switch {
776 case strings.EqualFold("AccessDeniedException", errorCode):
777 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
778
779 case strings.EqualFold("AccountSetupInProgressException", errorCode):
780 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
781
782 case strings.EqualFold("InvalidInputException", errorCode):
783 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
784
785 case strings.EqualFold("NotFoundException", errorCode):
786 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
787
788 case strings.EqualFold("OperationFailureException", errorCode):
789 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
790
791 case strings.EqualFold("RegionSetupInProgressException", errorCode):
792 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
793
794 case strings.EqualFold("ServiceException", errorCode):
795 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
796
797 case strings.EqualFold("UnauthenticatedException", errorCode):
798 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
799
800 default:
801 genericError := &smithy.GenericAPIError{
802 Code: errorCode,
803 Message: errorMessage,
804 }
805 return genericError
806
807 }
808 }
809
810 type awsAwsjson11_deserializeOpCloseInstancePublicPorts struct {
811 }
812
813 func (*awsAwsjson11_deserializeOpCloseInstancePublicPorts) ID() string {
814 return "OperationDeserializer"
815 }
816
817 func (m *awsAwsjson11_deserializeOpCloseInstancePublicPorts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
818 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
819 ) {
820 out, metadata, err = next.HandleDeserialize(ctx, in)
821 if err != nil {
822 return out, metadata, err
823 }
824
825 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
826 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
827 defer endTimer()
828 defer span.End()
829 response, ok := out.RawResponse.(*smithyhttp.Response)
830 if !ok {
831 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
832 }
833
834 if response.StatusCode < 200 || response.StatusCode >= 300 {
835 return out, metadata, awsAwsjson11_deserializeOpErrorCloseInstancePublicPorts(response, &metadata)
836 }
837 output := &CloseInstancePublicPortsOutput{}
838 out.Result = output
839
840 var buff [1024]byte
841 ringBuffer := smithyio.NewRingBuffer(buff[:])
842
843 body := io.TeeReader(response.Body, ringBuffer)
844 decoder := json.NewDecoder(body)
845 decoder.UseNumber()
846 var shape interface{}
847 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
848 var snapshot bytes.Buffer
849 io.Copy(&snapshot, ringBuffer)
850 err = &smithy.DeserializationError{
851 Err: fmt.Errorf("failed to decode response body, %w", err),
852 Snapshot: snapshot.Bytes(),
853 }
854 return out, metadata, err
855 }
856
857 err = awsAwsjson11_deserializeOpDocumentCloseInstancePublicPortsOutput(&output, shape)
858 if err != nil {
859 var snapshot bytes.Buffer
860 io.Copy(&snapshot, ringBuffer)
861 err = &smithy.DeserializationError{
862 Err: fmt.Errorf("failed to decode response body, %w", err),
863 Snapshot: snapshot.Bytes(),
864 }
865 return out, metadata, err
866 }
867
868 return out, metadata, err
869 }
870
871 func awsAwsjson11_deserializeOpErrorCloseInstancePublicPorts(response *smithyhttp.Response, metadata *middleware.Metadata) error {
872 var errorBuffer bytes.Buffer
873 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
874 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
875 }
876 errorBody := bytes.NewReader(errorBuffer.Bytes())
877
878 errorCode := "UnknownError"
879 errorMessage := errorCode
880
881 headerCode := response.Header.Get("X-Amzn-ErrorType")
882
883 var buff [1024]byte
884 ringBuffer := smithyio.NewRingBuffer(buff[:])
885
886 body := io.TeeReader(errorBody, ringBuffer)
887 decoder := json.NewDecoder(body)
888 decoder.UseNumber()
889 bodyInfo, err := getProtocolErrorInfo(decoder)
890 if err != nil {
891 var snapshot bytes.Buffer
892 io.Copy(&snapshot, ringBuffer)
893 err = &smithy.DeserializationError{
894 Err: fmt.Errorf("failed to decode response body, %w", err),
895 Snapshot: snapshot.Bytes(),
896 }
897 return err
898 }
899
900 errorBody.Seek(0, io.SeekStart)
901 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
902 errorCode = restjson.SanitizeErrorCode(typ)
903 }
904 if len(bodyInfo.Message) != 0 {
905 errorMessage = bodyInfo.Message
906 }
907 switch {
908 case strings.EqualFold("AccessDeniedException", errorCode):
909 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
910
911 case strings.EqualFold("AccountSetupInProgressException", errorCode):
912 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
913
914 case strings.EqualFold("InvalidInputException", errorCode):
915 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
916
917 case strings.EqualFold("NotFoundException", errorCode):
918 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
919
920 case strings.EqualFold("OperationFailureException", errorCode):
921 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
922
923 case strings.EqualFold("RegionSetupInProgressException", errorCode):
924 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
925
926 case strings.EqualFold("ServiceException", errorCode):
927 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
928
929 case strings.EqualFold("UnauthenticatedException", errorCode):
930 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
931
932 default:
933 genericError := &smithy.GenericAPIError{
934 Code: errorCode,
935 Message: errorMessage,
936 }
937 return genericError
938
939 }
940 }
941
942 type awsAwsjson11_deserializeOpCopySnapshot struct {
943 }
944
945 func (*awsAwsjson11_deserializeOpCopySnapshot) ID() string {
946 return "OperationDeserializer"
947 }
948
949 func (m *awsAwsjson11_deserializeOpCopySnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
950 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
951 ) {
952 out, metadata, err = next.HandleDeserialize(ctx, in)
953 if err != nil {
954 return out, metadata, err
955 }
956
957 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
958 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
959 defer endTimer()
960 defer span.End()
961 response, ok := out.RawResponse.(*smithyhttp.Response)
962 if !ok {
963 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
964 }
965
966 if response.StatusCode < 200 || response.StatusCode >= 300 {
967 return out, metadata, awsAwsjson11_deserializeOpErrorCopySnapshot(response, &metadata)
968 }
969 output := &CopySnapshotOutput{}
970 out.Result = output
971
972 var buff [1024]byte
973 ringBuffer := smithyio.NewRingBuffer(buff[:])
974
975 body := io.TeeReader(response.Body, ringBuffer)
976 decoder := json.NewDecoder(body)
977 decoder.UseNumber()
978 var shape interface{}
979 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
980 var snapshot bytes.Buffer
981 io.Copy(&snapshot, ringBuffer)
982 err = &smithy.DeserializationError{
983 Err: fmt.Errorf("failed to decode response body, %w", err),
984 Snapshot: snapshot.Bytes(),
985 }
986 return out, metadata, err
987 }
988
989 err = awsAwsjson11_deserializeOpDocumentCopySnapshotOutput(&output, shape)
990 if err != nil {
991 var snapshot bytes.Buffer
992 io.Copy(&snapshot, ringBuffer)
993 err = &smithy.DeserializationError{
994 Err: fmt.Errorf("failed to decode response body, %w", err),
995 Snapshot: snapshot.Bytes(),
996 }
997 return out, metadata, err
998 }
999
1000 return out, metadata, err
1001 }
1002
1003 func awsAwsjson11_deserializeOpErrorCopySnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1004 var errorBuffer bytes.Buffer
1005 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1006 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1007 }
1008 errorBody := bytes.NewReader(errorBuffer.Bytes())
1009
1010 errorCode := "UnknownError"
1011 errorMessage := errorCode
1012
1013 headerCode := response.Header.Get("X-Amzn-ErrorType")
1014
1015 var buff [1024]byte
1016 ringBuffer := smithyio.NewRingBuffer(buff[:])
1017
1018 body := io.TeeReader(errorBody, ringBuffer)
1019 decoder := json.NewDecoder(body)
1020 decoder.UseNumber()
1021 bodyInfo, err := getProtocolErrorInfo(decoder)
1022 if err != nil {
1023 var snapshot bytes.Buffer
1024 io.Copy(&snapshot, ringBuffer)
1025 err = &smithy.DeserializationError{
1026 Err: fmt.Errorf("failed to decode response body, %w", err),
1027 Snapshot: snapshot.Bytes(),
1028 }
1029 return err
1030 }
1031
1032 errorBody.Seek(0, io.SeekStart)
1033 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
1034 errorCode = restjson.SanitizeErrorCode(typ)
1035 }
1036 if len(bodyInfo.Message) != 0 {
1037 errorMessage = bodyInfo.Message
1038 }
1039 switch {
1040 case strings.EqualFold("AccessDeniedException", errorCode):
1041 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1042
1043 case strings.EqualFold("AccountSetupInProgressException", errorCode):
1044 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
1045
1046 case strings.EqualFold("InvalidInputException", errorCode):
1047 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1048
1049 case strings.EqualFold("NotFoundException", errorCode):
1050 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
1051
1052 case strings.EqualFold("OperationFailureException", errorCode):
1053 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
1054
1055 case strings.EqualFold("RegionSetupInProgressException", errorCode):
1056 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
1057
1058 case strings.EqualFold("ServiceException", errorCode):
1059 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1060
1061 case strings.EqualFold("UnauthenticatedException", errorCode):
1062 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
1063
1064 default:
1065 genericError := &smithy.GenericAPIError{
1066 Code: errorCode,
1067 Message: errorMessage,
1068 }
1069 return genericError
1070
1071 }
1072 }
1073
1074 type awsAwsjson11_deserializeOpCreateBucket struct {
1075 }
1076
1077 func (*awsAwsjson11_deserializeOpCreateBucket) ID() string {
1078 return "OperationDeserializer"
1079 }
1080
1081 func (m *awsAwsjson11_deserializeOpCreateBucket) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1082 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1083 ) {
1084 out, metadata, err = next.HandleDeserialize(ctx, in)
1085 if err != nil {
1086 return out, metadata, err
1087 }
1088
1089 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
1090 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
1091 defer endTimer()
1092 defer span.End()
1093 response, ok := out.RawResponse.(*smithyhttp.Response)
1094 if !ok {
1095 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1096 }
1097
1098 if response.StatusCode < 200 || response.StatusCode >= 300 {
1099 return out, metadata, awsAwsjson11_deserializeOpErrorCreateBucket(response, &metadata)
1100 }
1101 output := &CreateBucketOutput{}
1102 out.Result = output
1103
1104 var buff [1024]byte
1105 ringBuffer := smithyio.NewRingBuffer(buff[:])
1106
1107 body := io.TeeReader(response.Body, ringBuffer)
1108 decoder := json.NewDecoder(body)
1109 decoder.UseNumber()
1110 var shape interface{}
1111 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1112 var snapshot bytes.Buffer
1113 io.Copy(&snapshot, ringBuffer)
1114 err = &smithy.DeserializationError{
1115 Err: fmt.Errorf("failed to decode response body, %w", err),
1116 Snapshot: snapshot.Bytes(),
1117 }
1118 return out, metadata, err
1119 }
1120
1121 err = awsAwsjson11_deserializeOpDocumentCreateBucketOutput(&output, shape)
1122 if err != nil {
1123 var snapshot bytes.Buffer
1124 io.Copy(&snapshot, ringBuffer)
1125 err = &smithy.DeserializationError{
1126 Err: fmt.Errorf("failed to decode response body, %w", err),
1127 Snapshot: snapshot.Bytes(),
1128 }
1129 return out, metadata, err
1130 }
1131
1132 return out, metadata, err
1133 }
1134
1135 func awsAwsjson11_deserializeOpErrorCreateBucket(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1136 var errorBuffer bytes.Buffer
1137 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1138 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1139 }
1140 errorBody := bytes.NewReader(errorBuffer.Bytes())
1141
1142 errorCode := "UnknownError"
1143 errorMessage := errorCode
1144
1145 headerCode := response.Header.Get("X-Amzn-ErrorType")
1146
1147 var buff [1024]byte
1148 ringBuffer := smithyio.NewRingBuffer(buff[:])
1149
1150 body := io.TeeReader(errorBody, ringBuffer)
1151 decoder := json.NewDecoder(body)
1152 decoder.UseNumber()
1153 bodyInfo, err := getProtocolErrorInfo(decoder)
1154 if err != nil {
1155 var snapshot bytes.Buffer
1156 io.Copy(&snapshot, ringBuffer)
1157 err = &smithy.DeserializationError{
1158 Err: fmt.Errorf("failed to decode response body, %w", err),
1159 Snapshot: snapshot.Bytes(),
1160 }
1161 return err
1162 }
1163
1164 errorBody.Seek(0, io.SeekStart)
1165 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
1166 errorCode = restjson.SanitizeErrorCode(typ)
1167 }
1168 if len(bodyInfo.Message) != 0 {
1169 errorMessage = bodyInfo.Message
1170 }
1171 switch {
1172 case strings.EqualFold("AccessDeniedException", errorCode):
1173 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1174
1175 case strings.EqualFold("InvalidInputException", errorCode):
1176 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1177
1178 case strings.EqualFold("RegionSetupInProgressException", errorCode):
1179 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
1180
1181 case strings.EqualFold("ServiceException", errorCode):
1182 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1183
1184 case strings.EqualFold("UnauthenticatedException", errorCode):
1185 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
1186
1187 default:
1188 genericError := &smithy.GenericAPIError{
1189 Code: errorCode,
1190 Message: errorMessage,
1191 }
1192 return genericError
1193
1194 }
1195 }
1196
1197 type awsAwsjson11_deserializeOpCreateBucketAccessKey struct {
1198 }
1199
1200 func (*awsAwsjson11_deserializeOpCreateBucketAccessKey) ID() string {
1201 return "OperationDeserializer"
1202 }
1203
1204 func (m *awsAwsjson11_deserializeOpCreateBucketAccessKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1205 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1206 ) {
1207 out, metadata, err = next.HandleDeserialize(ctx, in)
1208 if err != nil {
1209 return out, metadata, err
1210 }
1211
1212 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
1213 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
1214 defer endTimer()
1215 defer span.End()
1216 response, ok := out.RawResponse.(*smithyhttp.Response)
1217 if !ok {
1218 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1219 }
1220
1221 if response.StatusCode < 200 || response.StatusCode >= 300 {
1222 return out, metadata, awsAwsjson11_deserializeOpErrorCreateBucketAccessKey(response, &metadata)
1223 }
1224 output := &CreateBucketAccessKeyOutput{}
1225 out.Result = output
1226
1227 var buff [1024]byte
1228 ringBuffer := smithyio.NewRingBuffer(buff[:])
1229
1230 body := io.TeeReader(response.Body, ringBuffer)
1231 decoder := json.NewDecoder(body)
1232 decoder.UseNumber()
1233 var shape interface{}
1234 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1235 var snapshot bytes.Buffer
1236 io.Copy(&snapshot, ringBuffer)
1237 err = &smithy.DeserializationError{
1238 Err: fmt.Errorf("failed to decode response body, %w", err),
1239 Snapshot: snapshot.Bytes(),
1240 }
1241 return out, metadata, err
1242 }
1243
1244 err = awsAwsjson11_deserializeOpDocumentCreateBucketAccessKeyOutput(&output, shape)
1245 if err != nil {
1246 var snapshot bytes.Buffer
1247 io.Copy(&snapshot, ringBuffer)
1248 err = &smithy.DeserializationError{
1249 Err: fmt.Errorf("failed to decode response body, %w", err),
1250 Snapshot: snapshot.Bytes(),
1251 }
1252 return out, metadata, err
1253 }
1254
1255 return out, metadata, err
1256 }
1257
1258 func awsAwsjson11_deserializeOpErrorCreateBucketAccessKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1259 var errorBuffer bytes.Buffer
1260 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1261 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1262 }
1263 errorBody := bytes.NewReader(errorBuffer.Bytes())
1264
1265 errorCode := "UnknownError"
1266 errorMessage := errorCode
1267
1268 headerCode := response.Header.Get("X-Amzn-ErrorType")
1269
1270 var buff [1024]byte
1271 ringBuffer := smithyio.NewRingBuffer(buff[:])
1272
1273 body := io.TeeReader(errorBody, ringBuffer)
1274 decoder := json.NewDecoder(body)
1275 decoder.UseNumber()
1276 bodyInfo, err := getProtocolErrorInfo(decoder)
1277 if err != nil {
1278 var snapshot bytes.Buffer
1279 io.Copy(&snapshot, ringBuffer)
1280 err = &smithy.DeserializationError{
1281 Err: fmt.Errorf("failed to decode response body, %w", err),
1282 Snapshot: snapshot.Bytes(),
1283 }
1284 return err
1285 }
1286
1287 errorBody.Seek(0, io.SeekStart)
1288 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
1289 errorCode = restjson.SanitizeErrorCode(typ)
1290 }
1291 if len(bodyInfo.Message) != 0 {
1292 errorMessage = bodyInfo.Message
1293 }
1294 switch {
1295 case strings.EqualFold("AccessDeniedException", errorCode):
1296 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1297
1298 case strings.EqualFold("InvalidInputException", errorCode):
1299 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1300
1301 case strings.EqualFold("NotFoundException", errorCode):
1302 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
1303
1304 case strings.EqualFold("RegionSetupInProgressException", errorCode):
1305 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
1306
1307 case strings.EqualFold("ServiceException", errorCode):
1308 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1309
1310 case strings.EqualFold("UnauthenticatedException", errorCode):
1311 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
1312
1313 default:
1314 genericError := &smithy.GenericAPIError{
1315 Code: errorCode,
1316 Message: errorMessage,
1317 }
1318 return genericError
1319
1320 }
1321 }
1322
1323 type awsAwsjson11_deserializeOpCreateCertificate struct {
1324 }
1325
1326 func (*awsAwsjson11_deserializeOpCreateCertificate) ID() string {
1327 return "OperationDeserializer"
1328 }
1329
1330 func (m *awsAwsjson11_deserializeOpCreateCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1331 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1332 ) {
1333 out, metadata, err = next.HandleDeserialize(ctx, in)
1334 if err != nil {
1335 return out, metadata, err
1336 }
1337
1338 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
1339 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
1340 defer endTimer()
1341 defer span.End()
1342 response, ok := out.RawResponse.(*smithyhttp.Response)
1343 if !ok {
1344 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1345 }
1346
1347 if response.StatusCode < 200 || response.StatusCode >= 300 {
1348 return out, metadata, awsAwsjson11_deserializeOpErrorCreateCertificate(response, &metadata)
1349 }
1350 output := &CreateCertificateOutput{}
1351 out.Result = output
1352
1353 var buff [1024]byte
1354 ringBuffer := smithyio.NewRingBuffer(buff[:])
1355
1356 body := io.TeeReader(response.Body, ringBuffer)
1357 decoder := json.NewDecoder(body)
1358 decoder.UseNumber()
1359 var shape interface{}
1360 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1361 var snapshot bytes.Buffer
1362 io.Copy(&snapshot, ringBuffer)
1363 err = &smithy.DeserializationError{
1364 Err: fmt.Errorf("failed to decode response body, %w", err),
1365 Snapshot: snapshot.Bytes(),
1366 }
1367 return out, metadata, err
1368 }
1369
1370 err = awsAwsjson11_deserializeOpDocumentCreateCertificateOutput(&output, shape)
1371 if err != nil {
1372 var snapshot bytes.Buffer
1373 io.Copy(&snapshot, ringBuffer)
1374 err = &smithy.DeserializationError{
1375 Err: fmt.Errorf("failed to decode response body, %w", err),
1376 Snapshot: snapshot.Bytes(),
1377 }
1378 return out, metadata, err
1379 }
1380
1381 return out, metadata, err
1382 }
1383
1384 func awsAwsjson11_deserializeOpErrorCreateCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1385 var errorBuffer bytes.Buffer
1386 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1387 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1388 }
1389 errorBody := bytes.NewReader(errorBuffer.Bytes())
1390
1391 errorCode := "UnknownError"
1392 errorMessage := errorCode
1393
1394 headerCode := response.Header.Get("X-Amzn-ErrorType")
1395
1396 var buff [1024]byte
1397 ringBuffer := smithyio.NewRingBuffer(buff[:])
1398
1399 body := io.TeeReader(errorBody, ringBuffer)
1400 decoder := json.NewDecoder(body)
1401 decoder.UseNumber()
1402 bodyInfo, err := getProtocolErrorInfo(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 err
1411 }
1412
1413 errorBody.Seek(0, io.SeekStart)
1414 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
1415 errorCode = restjson.SanitizeErrorCode(typ)
1416 }
1417 if len(bodyInfo.Message) != 0 {
1418 errorMessage = bodyInfo.Message
1419 }
1420 switch {
1421 case strings.EqualFold("AccessDeniedException", errorCode):
1422 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1423
1424 case strings.EqualFold("InvalidInputException", errorCode):
1425 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1426
1427 case strings.EqualFold("NotFoundException", errorCode):
1428 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
1429
1430 case strings.EqualFold("RegionSetupInProgressException", errorCode):
1431 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
1432
1433 case strings.EqualFold("ServiceException", errorCode):
1434 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1435
1436 case strings.EqualFold("UnauthenticatedException", errorCode):
1437 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
1438
1439 default:
1440 genericError := &smithy.GenericAPIError{
1441 Code: errorCode,
1442 Message: errorMessage,
1443 }
1444 return genericError
1445
1446 }
1447 }
1448
1449 type awsAwsjson11_deserializeOpCreateCloudFormationStack struct {
1450 }
1451
1452 func (*awsAwsjson11_deserializeOpCreateCloudFormationStack) ID() string {
1453 return "OperationDeserializer"
1454 }
1455
1456 func (m *awsAwsjson11_deserializeOpCreateCloudFormationStack) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1457 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1458 ) {
1459 out, metadata, err = next.HandleDeserialize(ctx, in)
1460 if err != nil {
1461 return out, metadata, err
1462 }
1463
1464 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
1465 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
1466 defer endTimer()
1467 defer span.End()
1468 response, ok := out.RawResponse.(*smithyhttp.Response)
1469 if !ok {
1470 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1471 }
1472
1473 if response.StatusCode < 200 || response.StatusCode >= 300 {
1474 return out, metadata, awsAwsjson11_deserializeOpErrorCreateCloudFormationStack(response, &metadata)
1475 }
1476 output := &CreateCloudFormationStackOutput{}
1477 out.Result = output
1478
1479 var buff [1024]byte
1480 ringBuffer := smithyio.NewRingBuffer(buff[:])
1481
1482 body := io.TeeReader(response.Body, ringBuffer)
1483 decoder := json.NewDecoder(body)
1484 decoder.UseNumber()
1485 var shape interface{}
1486 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1487 var snapshot bytes.Buffer
1488 io.Copy(&snapshot, ringBuffer)
1489 err = &smithy.DeserializationError{
1490 Err: fmt.Errorf("failed to decode response body, %w", err),
1491 Snapshot: snapshot.Bytes(),
1492 }
1493 return out, metadata, err
1494 }
1495
1496 err = awsAwsjson11_deserializeOpDocumentCreateCloudFormationStackOutput(&output, shape)
1497 if err != nil {
1498 var snapshot bytes.Buffer
1499 io.Copy(&snapshot, ringBuffer)
1500 err = &smithy.DeserializationError{
1501 Err: fmt.Errorf("failed to decode response body, %w", err),
1502 Snapshot: snapshot.Bytes(),
1503 }
1504 return out, metadata, err
1505 }
1506
1507 return out, metadata, err
1508 }
1509
1510 func awsAwsjson11_deserializeOpErrorCreateCloudFormationStack(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1511 var errorBuffer bytes.Buffer
1512 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1513 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1514 }
1515 errorBody := bytes.NewReader(errorBuffer.Bytes())
1516
1517 errorCode := "UnknownError"
1518 errorMessage := errorCode
1519
1520 headerCode := response.Header.Get("X-Amzn-ErrorType")
1521
1522 var buff [1024]byte
1523 ringBuffer := smithyio.NewRingBuffer(buff[:])
1524
1525 body := io.TeeReader(errorBody, ringBuffer)
1526 decoder := json.NewDecoder(body)
1527 decoder.UseNumber()
1528 bodyInfo, err := getProtocolErrorInfo(decoder)
1529 if err != nil {
1530 var snapshot bytes.Buffer
1531 io.Copy(&snapshot, ringBuffer)
1532 err = &smithy.DeserializationError{
1533 Err: fmt.Errorf("failed to decode response body, %w", err),
1534 Snapshot: snapshot.Bytes(),
1535 }
1536 return err
1537 }
1538
1539 errorBody.Seek(0, io.SeekStart)
1540 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
1541 errorCode = restjson.SanitizeErrorCode(typ)
1542 }
1543 if len(bodyInfo.Message) != 0 {
1544 errorMessage = bodyInfo.Message
1545 }
1546 switch {
1547 case strings.EqualFold("AccessDeniedException", errorCode):
1548 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1549
1550 case strings.EqualFold("AccountSetupInProgressException", errorCode):
1551 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
1552
1553 case strings.EqualFold("InvalidInputException", errorCode):
1554 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1555
1556 case strings.EqualFold("NotFoundException", errorCode):
1557 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
1558
1559 case strings.EqualFold("OperationFailureException", errorCode):
1560 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
1561
1562 case strings.EqualFold("RegionSetupInProgressException", errorCode):
1563 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
1564
1565 case strings.EqualFold("ServiceException", errorCode):
1566 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1567
1568 case strings.EqualFold("UnauthenticatedException", errorCode):
1569 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
1570
1571 default:
1572 genericError := &smithy.GenericAPIError{
1573 Code: errorCode,
1574 Message: errorMessage,
1575 }
1576 return genericError
1577
1578 }
1579 }
1580
1581 type awsAwsjson11_deserializeOpCreateContactMethod struct {
1582 }
1583
1584 func (*awsAwsjson11_deserializeOpCreateContactMethod) ID() string {
1585 return "OperationDeserializer"
1586 }
1587
1588 func (m *awsAwsjson11_deserializeOpCreateContactMethod) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1589 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1590 ) {
1591 out, metadata, err = next.HandleDeserialize(ctx, in)
1592 if err != nil {
1593 return out, metadata, err
1594 }
1595
1596 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
1597 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
1598 defer endTimer()
1599 defer span.End()
1600 response, ok := out.RawResponse.(*smithyhttp.Response)
1601 if !ok {
1602 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1603 }
1604
1605 if response.StatusCode < 200 || response.StatusCode >= 300 {
1606 return out, metadata, awsAwsjson11_deserializeOpErrorCreateContactMethod(response, &metadata)
1607 }
1608 output := &CreateContactMethodOutput{}
1609 out.Result = output
1610
1611 var buff [1024]byte
1612 ringBuffer := smithyio.NewRingBuffer(buff[:])
1613
1614 body := io.TeeReader(response.Body, ringBuffer)
1615 decoder := json.NewDecoder(body)
1616 decoder.UseNumber()
1617 var shape interface{}
1618 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1619 var snapshot bytes.Buffer
1620 io.Copy(&snapshot, ringBuffer)
1621 err = &smithy.DeserializationError{
1622 Err: fmt.Errorf("failed to decode response body, %w", err),
1623 Snapshot: snapshot.Bytes(),
1624 }
1625 return out, metadata, err
1626 }
1627
1628 err = awsAwsjson11_deserializeOpDocumentCreateContactMethodOutput(&output, shape)
1629 if err != nil {
1630 var snapshot bytes.Buffer
1631 io.Copy(&snapshot, ringBuffer)
1632 err = &smithy.DeserializationError{
1633 Err: fmt.Errorf("failed to decode response body, %w", err),
1634 Snapshot: snapshot.Bytes(),
1635 }
1636 return out, metadata, err
1637 }
1638
1639 return out, metadata, err
1640 }
1641
1642 func awsAwsjson11_deserializeOpErrorCreateContactMethod(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1643 var errorBuffer bytes.Buffer
1644 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1645 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1646 }
1647 errorBody := bytes.NewReader(errorBuffer.Bytes())
1648
1649 errorCode := "UnknownError"
1650 errorMessage := errorCode
1651
1652 headerCode := response.Header.Get("X-Amzn-ErrorType")
1653
1654 var buff [1024]byte
1655 ringBuffer := smithyio.NewRingBuffer(buff[:])
1656
1657 body := io.TeeReader(errorBody, ringBuffer)
1658 decoder := json.NewDecoder(body)
1659 decoder.UseNumber()
1660 bodyInfo, err := getProtocolErrorInfo(decoder)
1661 if err != nil {
1662 var snapshot bytes.Buffer
1663 io.Copy(&snapshot, ringBuffer)
1664 err = &smithy.DeserializationError{
1665 Err: fmt.Errorf("failed to decode response body, %w", err),
1666 Snapshot: snapshot.Bytes(),
1667 }
1668 return err
1669 }
1670
1671 errorBody.Seek(0, io.SeekStart)
1672 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
1673 errorCode = restjson.SanitizeErrorCode(typ)
1674 }
1675 if len(bodyInfo.Message) != 0 {
1676 errorMessage = bodyInfo.Message
1677 }
1678 switch {
1679 case strings.EqualFold("AccessDeniedException", errorCode):
1680 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1681
1682 case strings.EqualFold("InvalidInputException", errorCode):
1683 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1684
1685 case strings.EqualFold("NotFoundException", errorCode):
1686 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
1687
1688 case strings.EqualFold("OperationFailureException", errorCode):
1689 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
1690
1691 case strings.EqualFold("RegionSetupInProgressException", errorCode):
1692 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
1693
1694 case strings.EqualFold("ServiceException", errorCode):
1695 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1696
1697 case strings.EqualFold("UnauthenticatedException", errorCode):
1698 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
1699
1700 default:
1701 genericError := &smithy.GenericAPIError{
1702 Code: errorCode,
1703 Message: errorMessage,
1704 }
1705 return genericError
1706
1707 }
1708 }
1709
1710 type awsAwsjson11_deserializeOpCreateContainerService struct {
1711 }
1712
1713 func (*awsAwsjson11_deserializeOpCreateContainerService) ID() string {
1714 return "OperationDeserializer"
1715 }
1716
1717 func (m *awsAwsjson11_deserializeOpCreateContainerService) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1718 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1719 ) {
1720 out, metadata, err = next.HandleDeserialize(ctx, in)
1721 if err != nil {
1722 return out, metadata, err
1723 }
1724
1725 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
1726 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
1727 defer endTimer()
1728 defer span.End()
1729 response, ok := out.RawResponse.(*smithyhttp.Response)
1730 if !ok {
1731 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1732 }
1733
1734 if response.StatusCode < 200 || response.StatusCode >= 300 {
1735 return out, metadata, awsAwsjson11_deserializeOpErrorCreateContainerService(response, &metadata)
1736 }
1737 output := &CreateContainerServiceOutput{}
1738 out.Result = output
1739
1740 var buff [1024]byte
1741 ringBuffer := smithyio.NewRingBuffer(buff[:])
1742
1743 body := io.TeeReader(response.Body, ringBuffer)
1744 decoder := json.NewDecoder(body)
1745 decoder.UseNumber()
1746 var shape interface{}
1747 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1748 var snapshot bytes.Buffer
1749 io.Copy(&snapshot, ringBuffer)
1750 err = &smithy.DeserializationError{
1751 Err: fmt.Errorf("failed to decode response body, %w", err),
1752 Snapshot: snapshot.Bytes(),
1753 }
1754 return out, metadata, err
1755 }
1756
1757 err = awsAwsjson11_deserializeOpDocumentCreateContainerServiceOutput(&output, shape)
1758 if err != nil {
1759 var snapshot bytes.Buffer
1760 io.Copy(&snapshot, ringBuffer)
1761 err = &smithy.DeserializationError{
1762 Err: fmt.Errorf("failed to decode response body, %w", err),
1763 Snapshot: snapshot.Bytes(),
1764 }
1765 return out, metadata, err
1766 }
1767
1768 return out, metadata, err
1769 }
1770
1771 func awsAwsjson11_deserializeOpErrorCreateContainerService(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1772 var errorBuffer bytes.Buffer
1773 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1774 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1775 }
1776 errorBody := bytes.NewReader(errorBuffer.Bytes())
1777
1778 errorCode := "UnknownError"
1779 errorMessage := errorCode
1780
1781 headerCode := response.Header.Get("X-Amzn-ErrorType")
1782
1783 var buff [1024]byte
1784 ringBuffer := smithyio.NewRingBuffer(buff[:])
1785
1786 body := io.TeeReader(errorBody, ringBuffer)
1787 decoder := json.NewDecoder(body)
1788 decoder.UseNumber()
1789 bodyInfo, err := getProtocolErrorInfo(decoder)
1790 if err != nil {
1791 var snapshot bytes.Buffer
1792 io.Copy(&snapshot, ringBuffer)
1793 err = &smithy.DeserializationError{
1794 Err: fmt.Errorf("failed to decode response body, %w", err),
1795 Snapshot: snapshot.Bytes(),
1796 }
1797 return err
1798 }
1799
1800 errorBody.Seek(0, io.SeekStart)
1801 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
1802 errorCode = restjson.SanitizeErrorCode(typ)
1803 }
1804 if len(bodyInfo.Message) != 0 {
1805 errorMessage = bodyInfo.Message
1806 }
1807 switch {
1808 case strings.EqualFold("AccessDeniedException", errorCode):
1809 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1810
1811 case strings.EqualFold("InvalidInputException", errorCode):
1812 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1813
1814 case strings.EqualFold("NotFoundException", errorCode):
1815 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
1816
1817 case strings.EqualFold("RegionSetupInProgressException", errorCode):
1818 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
1819
1820 case strings.EqualFold("ServiceException", errorCode):
1821 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1822
1823 case strings.EqualFold("UnauthenticatedException", errorCode):
1824 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
1825
1826 default:
1827 genericError := &smithy.GenericAPIError{
1828 Code: errorCode,
1829 Message: errorMessage,
1830 }
1831 return genericError
1832
1833 }
1834 }
1835
1836 type awsAwsjson11_deserializeOpCreateContainerServiceDeployment struct {
1837 }
1838
1839 func (*awsAwsjson11_deserializeOpCreateContainerServiceDeployment) ID() string {
1840 return "OperationDeserializer"
1841 }
1842
1843 func (m *awsAwsjson11_deserializeOpCreateContainerServiceDeployment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1844 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1845 ) {
1846 out, metadata, err = next.HandleDeserialize(ctx, in)
1847 if err != nil {
1848 return out, metadata, err
1849 }
1850
1851 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
1852 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
1853 defer endTimer()
1854 defer span.End()
1855 response, ok := out.RawResponse.(*smithyhttp.Response)
1856 if !ok {
1857 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1858 }
1859
1860 if response.StatusCode < 200 || response.StatusCode >= 300 {
1861 return out, metadata, awsAwsjson11_deserializeOpErrorCreateContainerServiceDeployment(response, &metadata)
1862 }
1863 output := &CreateContainerServiceDeploymentOutput{}
1864 out.Result = output
1865
1866 var buff [1024]byte
1867 ringBuffer := smithyio.NewRingBuffer(buff[:])
1868
1869 body := io.TeeReader(response.Body, ringBuffer)
1870 decoder := json.NewDecoder(body)
1871 decoder.UseNumber()
1872 var shape interface{}
1873 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1874 var snapshot bytes.Buffer
1875 io.Copy(&snapshot, ringBuffer)
1876 err = &smithy.DeserializationError{
1877 Err: fmt.Errorf("failed to decode response body, %w", err),
1878 Snapshot: snapshot.Bytes(),
1879 }
1880 return out, metadata, err
1881 }
1882
1883 err = awsAwsjson11_deserializeOpDocumentCreateContainerServiceDeploymentOutput(&output, shape)
1884 if err != nil {
1885 var snapshot bytes.Buffer
1886 io.Copy(&snapshot, ringBuffer)
1887 err = &smithy.DeserializationError{
1888 Err: fmt.Errorf("failed to decode response body, %w", err),
1889 Snapshot: snapshot.Bytes(),
1890 }
1891 return out, metadata, err
1892 }
1893
1894 return out, metadata, err
1895 }
1896
1897 func awsAwsjson11_deserializeOpErrorCreateContainerServiceDeployment(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1898 var errorBuffer bytes.Buffer
1899 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1900 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1901 }
1902 errorBody := bytes.NewReader(errorBuffer.Bytes())
1903
1904 errorCode := "UnknownError"
1905 errorMessage := errorCode
1906
1907 headerCode := response.Header.Get("X-Amzn-ErrorType")
1908
1909 var buff [1024]byte
1910 ringBuffer := smithyio.NewRingBuffer(buff[:])
1911
1912 body := io.TeeReader(errorBody, ringBuffer)
1913 decoder := json.NewDecoder(body)
1914 decoder.UseNumber()
1915 bodyInfo, err := getProtocolErrorInfo(decoder)
1916 if err != nil {
1917 var snapshot bytes.Buffer
1918 io.Copy(&snapshot, ringBuffer)
1919 err = &smithy.DeserializationError{
1920 Err: fmt.Errorf("failed to decode response body, %w", err),
1921 Snapshot: snapshot.Bytes(),
1922 }
1923 return err
1924 }
1925
1926 errorBody.Seek(0, io.SeekStart)
1927 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
1928 errorCode = restjson.SanitizeErrorCode(typ)
1929 }
1930 if len(bodyInfo.Message) != 0 {
1931 errorMessage = bodyInfo.Message
1932 }
1933 switch {
1934 case strings.EqualFold("AccessDeniedException", errorCode):
1935 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1936
1937 case strings.EqualFold("InvalidInputException", errorCode):
1938 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1939
1940 case strings.EqualFold("NotFoundException", errorCode):
1941 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
1942
1943 case strings.EqualFold("RegionSetupInProgressException", errorCode):
1944 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
1945
1946 case strings.EqualFold("ServiceException", errorCode):
1947 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1948
1949 case strings.EqualFold("UnauthenticatedException", errorCode):
1950 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
1951
1952 default:
1953 genericError := &smithy.GenericAPIError{
1954 Code: errorCode,
1955 Message: errorMessage,
1956 }
1957 return genericError
1958
1959 }
1960 }
1961
1962 type awsAwsjson11_deserializeOpCreateContainerServiceRegistryLogin struct {
1963 }
1964
1965 func (*awsAwsjson11_deserializeOpCreateContainerServiceRegistryLogin) ID() string {
1966 return "OperationDeserializer"
1967 }
1968
1969 func (m *awsAwsjson11_deserializeOpCreateContainerServiceRegistryLogin) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1970 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1971 ) {
1972 out, metadata, err = next.HandleDeserialize(ctx, in)
1973 if err != nil {
1974 return out, metadata, err
1975 }
1976
1977 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
1978 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
1979 defer endTimer()
1980 defer span.End()
1981 response, ok := out.RawResponse.(*smithyhttp.Response)
1982 if !ok {
1983 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1984 }
1985
1986 if response.StatusCode < 200 || response.StatusCode >= 300 {
1987 return out, metadata, awsAwsjson11_deserializeOpErrorCreateContainerServiceRegistryLogin(response, &metadata)
1988 }
1989 output := &CreateContainerServiceRegistryLoginOutput{}
1990 out.Result = output
1991
1992 var buff [1024]byte
1993 ringBuffer := smithyio.NewRingBuffer(buff[:])
1994
1995 body := io.TeeReader(response.Body, ringBuffer)
1996 decoder := json.NewDecoder(body)
1997 decoder.UseNumber()
1998 var shape interface{}
1999 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2000 var snapshot bytes.Buffer
2001 io.Copy(&snapshot, ringBuffer)
2002 err = &smithy.DeserializationError{
2003 Err: fmt.Errorf("failed to decode response body, %w", err),
2004 Snapshot: snapshot.Bytes(),
2005 }
2006 return out, metadata, err
2007 }
2008
2009 err = awsAwsjson11_deserializeOpDocumentCreateContainerServiceRegistryLoginOutput(&output, shape)
2010 if err != nil {
2011 var snapshot bytes.Buffer
2012 io.Copy(&snapshot, ringBuffer)
2013 err = &smithy.DeserializationError{
2014 Err: fmt.Errorf("failed to decode response body, %w", err),
2015 Snapshot: snapshot.Bytes(),
2016 }
2017 return out, metadata, err
2018 }
2019
2020 return out, metadata, err
2021 }
2022
2023 func awsAwsjson11_deserializeOpErrorCreateContainerServiceRegistryLogin(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2024 var errorBuffer bytes.Buffer
2025 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2026 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2027 }
2028 errorBody := bytes.NewReader(errorBuffer.Bytes())
2029
2030 errorCode := "UnknownError"
2031 errorMessage := errorCode
2032
2033 headerCode := response.Header.Get("X-Amzn-ErrorType")
2034
2035 var buff [1024]byte
2036 ringBuffer := smithyio.NewRingBuffer(buff[:])
2037
2038 body := io.TeeReader(errorBody, ringBuffer)
2039 decoder := json.NewDecoder(body)
2040 decoder.UseNumber()
2041 bodyInfo, err := getProtocolErrorInfo(decoder)
2042 if err != nil {
2043 var snapshot bytes.Buffer
2044 io.Copy(&snapshot, ringBuffer)
2045 err = &smithy.DeserializationError{
2046 Err: fmt.Errorf("failed to decode response body, %w", err),
2047 Snapshot: snapshot.Bytes(),
2048 }
2049 return err
2050 }
2051
2052 errorBody.Seek(0, io.SeekStart)
2053 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
2054 errorCode = restjson.SanitizeErrorCode(typ)
2055 }
2056 if len(bodyInfo.Message) != 0 {
2057 errorMessage = bodyInfo.Message
2058 }
2059 switch {
2060 case strings.EqualFold("AccessDeniedException", errorCode):
2061 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2062
2063 case strings.EqualFold("InvalidInputException", errorCode):
2064 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2065
2066 case strings.EqualFold("NotFoundException", errorCode):
2067 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
2068
2069 case strings.EqualFold("RegionSetupInProgressException", errorCode):
2070 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
2071
2072 case strings.EqualFold("ServiceException", errorCode):
2073 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2074
2075 case strings.EqualFold("UnauthenticatedException", errorCode):
2076 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
2077
2078 default:
2079 genericError := &smithy.GenericAPIError{
2080 Code: errorCode,
2081 Message: errorMessage,
2082 }
2083 return genericError
2084
2085 }
2086 }
2087
2088 type awsAwsjson11_deserializeOpCreateDisk struct {
2089 }
2090
2091 func (*awsAwsjson11_deserializeOpCreateDisk) ID() string {
2092 return "OperationDeserializer"
2093 }
2094
2095 func (m *awsAwsjson11_deserializeOpCreateDisk) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2096 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2097 ) {
2098 out, metadata, err = next.HandleDeserialize(ctx, in)
2099 if err != nil {
2100 return out, metadata, err
2101 }
2102
2103 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
2104 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
2105 defer endTimer()
2106 defer span.End()
2107 response, ok := out.RawResponse.(*smithyhttp.Response)
2108 if !ok {
2109 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2110 }
2111
2112 if response.StatusCode < 200 || response.StatusCode >= 300 {
2113 return out, metadata, awsAwsjson11_deserializeOpErrorCreateDisk(response, &metadata)
2114 }
2115 output := &CreateDiskOutput{}
2116 out.Result = output
2117
2118 var buff [1024]byte
2119 ringBuffer := smithyio.NewRingBuffer(buff[:])
2120
2121 body := io.TeeReader(response.Body, ringBuffer)
2122 decoder := json.NewDecoder(body)
2123 decoder.UseNumber()
2124 var shape interface{}
2125 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2126 var snapshot bytes.Buffer
2127 io.Copy(&snapshot, ringBuffer)
2128 err = &smithy.DeserializationError{
2129 Err: fmt.Errorf("failed to decode response body, %w", err),
2130 Snapshot: snapshot.Bytes(),
2131 }
2132 return out, metadata, err
2133 }
2134
2135 err = awsAwsjson11_deserializeOpDocumentCreateDiskOutput(&output, shape)
2136 if err != nil {
2137 var snapshot bytes.Buffer
2138 io.Copy(&snapshot, ringBuffer)
2139 err = &smithy.DeserializationError{
2140 Err: fmt.Errorf("failed to decode response body, %w", err),
2141 Snapshot: snapshot.Bytes(),
2142 }
2143 return out, metadata, err
2144 }
2145
2146 return out, metadata, err
2147 }
2148
2149 func awsAwsjson11_deserializeOpErrorCreateDisk(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2150 var errorBuffer bytes.Buffer
2151 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2152 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2153 }
2154 errorBody := bytes.NewReader(errorBuffer.Bytes())
2155
2156 errorCode := "UnknownError"
2157 errorMessage := errorCode
2158
2159 headerCode := response.Header.Get("X-Amzn-ErrorType")
2160
2161 var buff [1024]byte
2162 ringBuffer := smithyio.NewRingBuffer(buff[:])
2163
2164 body := io.TeeReader(errorBody, ringBuffer)
2165 decoder := json.NewDecoder(body)
2166 decoder.UseNumber()
2167 bodyInfo, err := getProtocolErrorInfo(decoder)
2168 if err != nil {
2169 var snapshot bytes.Buffer
2170 io.Copy(&snapshot, ringBuffer)
2171 err = &smithy.DeserializationError{
2172 Err: fmt.Errorf("failed to decode response body, %w", err),
2173 Snapshot: snapshot.Bytes(),
2174 }
2175 return err
2176 }
2177
2178 errorBody.Seek(0, io.SeekStart)
2179 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
2180 errorCode = restjson.SanitizeErrorCode(typ)
2181 }
2182 if len(bodyInfo.Message) != 0 {
2183 errorMessage = bodyInfo.Message
2184 }
2185 switch {
2186 case strings.EqualFold("AccessDeniedException", errorCode):
2187 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2188
2189 case strings.EqualFold("AccountSetupInProgressException", errorCode):
2190 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
2191
2192 case strings.EqualFold("InvalidInputException", errorCode):
2193 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2194
2195 case strings.EqualFold("NotFoundException", errorCode):
2196 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
2197
2198 case strings.EqualFold("OperationFailureException", errorCode):
2199 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
2200
2201 case strings.EqualFold("RegionSetupInProgressException", errorCode):
2202 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
2203
2204 case strings.EqualFold("ServiceException", errorCode):
2205 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2206
2207 case strings.EqualFold("UnauthenticatedException", errorCode):
2208 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
2209
2210 default:
2211 genericError := &smithy.GenericAPIError{
2212 Code: errorCode,
2213 Message: errorMessage,
2214 }
2215 return genericError
2216
2217 }
2218 }
2219
2220 type awsAwsjson11_deserializeOpCreateDiskFromSnapshot struct {
2221 }
2222
2223 func (*awsAwsjson11_deserializeOpCreateDiskFromSnapshot) ID() string {
2224 return "OperationDeserializer"
2225 }
2226
2227 func (m *awsAwsjson11_deserializeOpCreateDiskFromSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2228 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2229 ) {
2230 out, metadata, err = next.HandleDeserialize(ctx, in)
2231 if err != nil {
2232 return out, metadata, err
2233 }
2234
2235 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
2236 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
2237 defer endTimer()
2238 defer span.End()
2239 response, ok := out.RawResponse.(*smithyhttp.Response)
2240 if !ok {
2241 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2242 }
2243
2244 if response.StatusCode < 200 || response.StatusCode >= 300 {
2245 return out, metadata, awsAwsjson11_deserializeOpErrorCreateDiskFromSnapshot(response, &metadata)
2246 }
2247 output := &CreateDiskFromSnapshotOutput{}
2248 out.Result = output
2249
2250 var buff [1024]byte
2251 ringBuffer := smithyio.NewRingBuffer(buff[:])
2252
2253 body := io.TeeReader(response.Body, ringBuffer)
2254 decoder := json.NewDecoder(body)
2255 decoder.UseNumber()
2256 var shape interface{}
2257 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2258 var snapshot bytes.Buffer
2259 io.Copy(&snapshot, ringBuffer)
2260 err = &smithy.DeserializationError{
2261 Err: fmt.Errorf("failed to decode response body, %w", err),
2262 Snapshot: snapshot.Bytes(),
2263 }
2264 return out, metadata, err
2265 }
2266
2267 err = awsAwsjson11_deserializeOpDocumentCreateDiskFromSnapshotOutput(&output, shape)
2268 if err != nil {
2269 var snapshot bytes.Buffer
2270 io.Copy(&snapshot, ringBuffer)
2271 err = &smithy.DeserializationError{
2272 Err: fmt.Errorf("failed to decode response body, %w", err),
2273 Snapshot: snapshot.Bytes(),
2274 }
2275 return out, metadata, err
2276 }
2277
2278 return out, metadata, err
2279 }
2280
2281 func awsAwsjson11_deserializeOpErrorCreateDiskFromSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2282 var errorBuffer bytes.Buffer
2283 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2284 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2285 }
2286 errorBody := bytes.NewReader(errorBuffer.Bytes())
2287
2288 errorCode := "UnknownError"
2289 errorMessage := errorCode
2290
2291 headerCode := response.Header.Get("X-Amzn-ErrorType")
2292
2293 var buff [1024]byte
2294 ringBuffer := smithyio.NewRingBuffer(buff[:])
2295
2296 body := io.TeeReader(errorBody, ringBuffer)
2297 decoder := json.NewDecoder(body)
2298 decoder.UseNumber()
2299 bodyInfo, err := getProtocolErrorInfo(decoder)
2300 if err != nil {
2301 var snapshot bytes.Buffer
2302 io.Copy(&snapshot, ringBuffer)
2303 err = &smithy.DeserializationError{
2304 Err: fmt.Errorf("failed to decode response body, %w", err),
2305 Snapshot: snapshot.Bytes(),
2306 }
2307 return err
2308 }
2309
2310 errorBody.Seek(0, io.SeekStart)
2311 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
2312 errorCode = restjson.SanitizeErrorCode(typ)
2313 }
2314 if len(bodyInfo.Message) != 0 {
2315 errorMessage = bodyInfo.Message
2316 }
2317 switch {
2318 case strings.EqualFold("AccessDeniedException", errorCode):
2319 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2320
2321 case strings.EqualFold("AccountSetupInProgressException", errorCode):
2322 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
2323
2324 case strings.EqualFold("InvalidInputException", errorCode):
2325 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2326
2327 case strings.EqualFold("NotFoundException", errorCode):
2328 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
2329
2330 case strings.EqualFold("OperationFailureException", errorCode):
2331 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
2332
2333 case strings.EqualFold("RegionSetupInProgressException", errorCode):
2334 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
2335
2336 case strings.EqualFold("ServiceException", errorCode):
2337 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2338
2339 case strings.EqualFold("UnauthenticatedException", errorCode):
2340 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
2341
2342 default:
2343 genericError := &smithy.GenericAPIError{
2344 Code: errorCode,
2345 Message: errorMessage,
2346 }
2347 return genericError
2348
2349 }
2350 }
2351
2352 type awsAwsjson11_deserializeOpCreateDiskSnapshot struct {
2353 }
2354
2355 func (*awsAwsjson11_deserializeOpCreateDiskSnapshot) ID() string {
2356 return "OperationDeserializer"
2357 }
2358
2359 func (m *awsAwsjson11_deserializeOpCreateDiskSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2360 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2361 ) {
2362 out, metadata, err = next.HandleDeserialize(ctx, in)
2363 if err != nil {
2364 return out, metadata, err
2365 }
2366
2367 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
2368 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
2369 defer endTimer()
2370 defer span.End()
2371 response, ok := out.RawResponse.(*smithyhttp.Response)
2372 if !ok {
2373 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2374 }
2375
2376 if response.StatusCode < 200 || response.StatusCode >= 300 {
2377 return out, metadata, awsAwsjson11_deserializeOpErrorCreateDiskSnapshot(response, &metadata)
2378 }
2379 output := &CreateDiskSnapshotOutput{}
2380 out.Result = output
2381
2382 var buff [1024]byte
2383 ringBuffer := smithyio.NewRingBuffer(buff[:])
2384
2385 body := io.TeeReader(response.Body, ringBuffer)
2386 decoder := json.NewDecoder(body)
2387 decoder.UseNumber()
2388 var shape interface{}
2389 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2390 var snapshot bytes.Buffer
2391 io.Copy(&snapshot, ringBuffer)
2392 err = &smithy.DeserializationError{
2393 Err: fmt.Errorf("failed to decode response body, %w", err),
2394 Snapshot: snapshot.Bytes(),
2395 }
2396 return out, metadata, err
2397 }
2398
2399 err = awsAwsjson11_deserializeOpDocumentCreateDiskSnapshotOutput(&output, shape)
2400 if err != nil {
2401 var snapshot bytes.Buffer
2402 io.Copy(&snapshot, ringBuffer)
2403 err = &smithy.DeserializationError{
2404 Err: fmt.Errorf("failed to decode response body, %w", err),
2405 Snapshot: snapshot.Bytes(),
2406 }
2407 return out, metadata, err
2408 }
2409
2410 return out, metadata, err
2411 }
2412
2413 func awsAwsjson11_deserializeOpErrorCreateDiskSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2414 var errorBuffer bytes.Buffer
2415 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2416 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2417 }
2418 errorBody := bytes.NewReader(errorBuffer.Bytes())
2419
2420 errorCode := "UnknownError"
2421 errorMessage := errorCode
2422
2423 headerCode := response.Header.Get("X-Amzn-ErrorType")
2424
2425 var buff [1024]byte
2426 ringBuffer := smithyio.NewRingBuffer(buff[:])
2427
2428 body := io.TeeReader(errorBody, ringBuffer)
2429 decoder := json.NewDecoder(body)
2430 decoder.UseNumber()
2431 bodyInfo, err := getProtocolErrorInfo(decoder)
2432 if err != nil {
2433 var snapshot bytes.Buffer
2434 io.Copy(&snapshot, ringBuffer)
2435 err = &smithy.DeserializationError{
2436 Err: fmt.Errorf("failed to decode response body, %w", err),
2437 Snapshot: snapshot.Bytes(),
2438 }
2439 return err
2440 }
2441
2442 errorBody.Seek(0, io.SeekStart)
2443 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
2444 errorCode = restjson.SanitizeErrorCode(typ)
2445 }
2446 if len(bodyInfo.Message) != 0 {
2447 errorMessage = bodyInfo.Message
2448 }
2449 switch {
2450 case strings.EqualFold("AccessDeniedException", errorCode):
2451 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2452
2453 case strings.EqualFold("AccountSetupInProgressException", errorCode):
2454 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
2455
2456 case strings.EqualFold("InvalidInputException", errorCode):
2457 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2458
2459 case strings.EqualFold("NotFoundException", errorCode):
2460 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
2461
2462 case strings.EqualFold("OperationFailureException", errorCode):
2463 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
2464
2465 case strings.EqualFold("RegionSetupInProgressException", errorCode):
2466 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
2467
2468 case strings.EqualFold("ServiceException", errorCode):
2469 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2470
2471 case strings.EqualFold("UnauthenticatedException", errorCode):
2472 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
2473
2474 default:
2475 genericError := &smithy.GenericAPIError{
2476 Code: errorCode,
2477 Message: errorMessage,
2478 }
2479 return genericError
2480
2481 }
2482 }
2483
2484 type awsAwsjson11_deserializeOpCreateDistribution struct {
2485 }
2486
2487 func (*awsAwsjson11_deserializeOpCreateDistribution) ID() string {
2488 return "OperationDeserializer"
2489 }
2490
2491 func (m *awsAwsjson11_deserializeOpCreateDistribution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2492 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2493 ) {
2494 out, metadata, err = next.HandleDeserialize(ctx, in)
2495 if err != nil {
2496 return out, metadata, err
2497 }
2498
2499 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
2500 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
2501 defer endTimer()
2502 defer span.End()
2503 response, ok := out.RawResponse.(*smithyhttp.Response)
2504 if !ok {
2505 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2506 }
2507
2508 if response.StatusCode < 200 || response.StatusCode >= 300 {
2509 return out, metadata, awsAwsjson11_deserializeOpErrorCreateDistribution(response, &metadata)
2510 }
2511 output := &CreateDistributionOutput{}
2512 out.Result = output
2513
2514 var buff [1024]byte
2515 ringBuffer := smithyio.NewRingBuffer(buff[:])
2516
2517 body := io.TeeReader(response.Body, ringBuffer)
2518 decoder := json.NewDecoder(body)
2519 decoder.UseNumber()
2520 var shape interface{}
2521 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2522 var snapshot bytes.Buffer
2523 io.Copy(&snapshot, ringBuffer)
2524 err = &smithy.DeserializationError{
2525 Err: fmt.Errorf("failed to decode response body, %w", err),
2526 Snapshot: snapshot.Bytes(),
2527 }
2528 return out, metadata, err
2529 }
2530
2531 err = awsAwsjson11_deserializeOpDocumentCreateDistributionOutput(&output, shape)
2532 if err != nil {
2533 var snapshot bytes.Buffer
2534 io.Copy(&snapshot, ringBuffer)
2535 err = &smithy.DeserializationError{
2536 Err: fmt.Errorf("failed to decode response body, %w", err),
2537 Snapshot: snapshot.Bytes(),
2538 }
2539 return out, metadata, err
2540 }
2541
2542 return out, metadata, err
2543 }
2544
2545 func awsAwsjson11_deserializeOpErrorCreateDistribution(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2546 var errorBuffer bytes.Buffer
2547 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2548 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2549 }
2550 errorBody := bytes.NewReader(errorBuffer.Bytes())
2551
2552 errorCode := "UnknownError"
2553 errorMessage := errorCode
2554
2555 headerCode := response.Header.Get("X-Amzn-ErrorType")
2556
2557 var buff [1024]byte
2558 ringBuffer := smithyio.NewRingBuffer(buff[:])
2559
2560 body := io.TeeReader(errorBody, ringBuffer)
2561 decoder := json.NewDecoder(body)
2562 decoder.UseNumber()
2563 bodyInfo, err := getProtocolErrorInfo(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 err
2572 }
2573
2574 errorBody.Seek(0, io.SeekStart)
2575 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
2576 errorCode = restjson.SanitizeErrorCode(typ)
2577 }
2578 if len(bodyInfo.Message) != 0 {
2579 errorMessage = bodyInfo.Message
2580 }
2581 switch {
2582 case strings.EqualFold("AccessDeniedException", errorCode):
2583 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2584
2585 case strings.EqualFold("InvalidInputException", errorCode):
2586 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2587
2588 case strings.EqualFold("NotFoundException", errorCode):
2589 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
2590
2591 case strings.EqualFold("OperationFailureException", errorCode):
2592 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
2593
2594 case strings.EqualFold("ServiceException", errorCode):
2595 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2596
2597 case strings.EqualFold("UnauthenticatedException", errorCode):
2598 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
2599
2600 default:
2601 genericError := &smithy.GenericAPIError{
2602 Code: errorCode,
2603 Message: errorMessage,
2604 }
2605 return genericError
2606
2607 }
2608 }
2609
2610 type awsAwsjson11_deserializeOpCreateDomain struct {
2611 }
2612
2613 func (*awsAwsjson11_deserializeOpCreateDomain) ID() string {
2614 return "OperationDeserializer"
2615 }
2616
2617 func (m *awsAwsjson11_deserializeOpCreateDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2618 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2619 ) {
2620 out, metadata, err = next.HandleDeserialize(ctx, in)
2621 if err != nil {
2622 return out, metadata, err
2623 }
2624
2625 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
2626 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
2627 defer endTimer()
2628 defer span.End()
2629 response, ok := out.RawResponse.(*smithyhttp.Response)
2630 if !ok {
2631 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2632 }
2633
2634 if response.StatusCode < 200 || response.StatusCode >= 300 {
2635 return out, metadata, awsAwsjson11_deserializeOpErrorCreateDomain(response, &metadata)
2636 }
2637 output := &CreateDomainOutput{}
2638 out.Result = output
2639
2640 var buff [1024]byte
2641 ringBuffer := smithyio.NewRingBuffer(buff[:])
2642
2643 body := io.TeeReader(response.Body, ringBuffer)
2644 decoder := json.NewDecoder(body)
2645 decoder.UseNumber()
2646 var shape interface{}
2647 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2648 var snapshot bytes.Buffer
2649 io.Copy(&snapshot, ringBuffer)
2650 err = &smithy.DeserializationError{
2651 Err: fmt.Errorf("failed to decode response body, %w", err),
2652 Snapshot: snapshot.Bytes(),
2653 }
2654 return out, metadata, err
2655 }
2656
2657 err = awsAwsjson11_deserializeOpDocumentCreateDomainOutput(&output, shape)
2658 if err != nil {
2659 var snapshot bytes.Buffer
2660 io.Copy(&snapshot, ringBuffer)
2661 err = &smithy.DeserializationError{
2662 Err: fmt.Errorf("failed to decode response body, %w", err),
2663 Snapshot: snapshot.Bytes(),
2664 }
2665 return out, metadata, err
2666 }
2667
2668 return out, metadata, err
2669 }
2670
2671 func awsAwsjson11_deserializeOpErrorCreateDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2672 var errorBuffer bytes.Buffer
2673 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2674 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2675 }
2676 errorBody := bytes.NewReader(errorBuffer.Bytes())
2677
2678 errorCode := "UnknownError"
2679 errorMessage := errorCode
2680
2681 headerCode := response.Header.Get("X-Amzn-ErrorType")
2682
2683 var buff [1024]byte
2684 ringBuffer := smithyio.NewRingBuffer(buff[:])
2685
2686 body := io.TeeReader(errorBody, ringBuffer)
2687 decoder := json.NewDecoder(body)
2688 decoder.UseNumber()
2689 bodyInfo, err := getProtocolErrorInfo(decoder)
2690 if err != nil {
2691 var snapshot bytes.Buffer
2692 io.Copy(&snapshot, ringBuffer)
2693 err = &smithy.DeserializationError{
2694 Err: fmt.Errorf("failed to decode response body, %w", err),
2695 Snapshot: snapshot.Bytes(),
2696 }
2697 return err
2698 }
2699
2700 errorBody.Seek(0, io.SeekStart)
2701 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
2702 errorCode = restjson.SanitizeErrorCode(typ)
2703 }
2704 if len(bodyInfo.Message) != 0 {
2705 errorMessage = bodyInfo.Message
2706 }
2707 switch {
2708 case strings.EqualFold("AccessDeniedException", errorCode):
2709 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2710
2711 case strings.EqualFold("AccountSetupInProgressException", errorCode):
2712 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
2713
2714 case strings.EqualFold("InvalidInputException", errorCode):
2715 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2716
2717 case strings.EqualFold("NotFoundException", errorCode):
2718 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
2719
2720 case strings.EqualFold("OperationFailureException", errorCode):
2721 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
2722
2723 case strings.EqualFold("RegionSetupInProgressException", errorCode):
2724 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
2725
2726 case strings.EqualFold("ServiceException", errorCode):
2727 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2728
2729 case strings.EqualFold("UnauthenticatedException", errorCode):
2730 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
2731
2732 default:
2733 genericError := &smithy.GenericAPIError{
2734 Code: errorCode,
2735 Message: errorMessage,
2736 }
2737 return genericError
2738
2739 }
2740 }
2741
2742 type awsAwsjson11_deserializeOpCreateDomainEntry struct {
2743 }
2744
2745 func (*awsAwsjson11_deserializeOpCreateDomainEntry) ID() string {
2746 return "OperationDeserializer"
2747 }
2748
2749 func (m *awsAwsjson11_deserializeOpCreateDomainEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2750 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2751 ) {
2752 out, metadata, err = next.HandleDeserialize(ctx, in)
2753 if err != nil {
2754 return out, metadata, err
2755 }
2756
2757 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
2758 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
2759 defer endTimer()
2760 defer span.End()
2761 response, ok := out.RawResponse.(*smithyhttp.Response)
2762 if !ok {
2763 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2764 }
2765
2766 if response.StatusCode < 200 || response.StatusCode >= 300 {
2767 return out, metadata, awsAwsjson11_deserializeOpErrorCreateDomainEntry(response, &metadata)
2768 }
2769 output := &CreateDomainEntryOutput{}
2770 out.Result = output
2771
2772 var buff [1024]byte
2773 ringBuffer := smithyio.NewRingBuffer(buff[:])
2774
2775 body := io.TeeReader(response.Body, ringBuffer)
2776 decoder := json.NewDecoder(body)
2777 decoder.UseNumber()
2778 var shape interface{}
2779 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2780 var snapshot bytes.Buffer
2781 io.Copy(&snapshot, ringBuffer)
2782 err = &smithy.DeserializationError{
2783 Err: fmt.Errorf("failed to decode response body, %w", err),
2784 Snapshot: snapshot.Bytes(),
2785 }
2786 return out, metadata, err
2787 }
2788
2789 err = awsAwsjson11_deserializeOpDocumentCreateDomainEntryOutput(&output, shape)
2790 if err != nil {
2791 var snapshot bytes.Buffer
2792 io.Copy(&snapshot, ringBuffer)
2793 err = &smithy.DeserializationError{
2794 Err: fmt.Errorf("failed to decode response body, %w", err),
2795 Snapshot: snapshot.Bytes(),
2796 }
2797 return out, metadata, err
2798 }
2799
2800 return out, metadata, err
2801 }
2802
2803 func awsAwsjson11_deserializeOpErrorCreateDomainEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2804 var errorBuffer bytes.Buffer
2805 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2806 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2807 }
2808 errorBody := bytes.NewReader(errorBuffer.Bytes())
2809
2810 errorCode := "UnknownError"
2811 errorMessage := errorCode
2812
2813 headerCode := response.Header.Get("X-Amzn-ErrorType")
2814
2815 var buff [1024]byte
2816 ringBuffer := smithyio.NewRingBuffer(buff[:])
2817
2818 body := io.TeeReader(errorBody, ringBuffer)
2819 decoder := json.NewDecoder(body)
2820 decoder.UseNumber()
2821 bodyInfo, err := getProtocolErrorInfo(decoder)
2822 if err != nil {
2823 var snapshot bytes.Buffer
2824 io.Copy(&snapshot, ringBuffer)
2825 err = &smithy.DeserializationError{
2826 Err: fmt.Errorf("failed to decode response body, %w", err),
2827 Snapshot: snapshot.Bytes(),
2828 }
2829 return err
2830 }
2831
2832 errorBody.Seek(0, io.SeekStart)
2833 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
2834 errorCode = restjson.SanitizeErrorCode(typ)
2835 }
2836 if len(bodyInfo.Message) != 0 {
2837 errorMessage = bodyInfo.Message
2838 }
2839 switch {
2840 case strings.EqualFold("AccessDeniedException", errorCode):
2841 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2842
2843 case strings.EqualFold("AccountSetupInProgressException", errorCode):
2844 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
2845
2846 case strings.EqualFold("InvalidInputException", errorCode):
2847 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2848
2849 case strings.EqualFold("NotFoundException", errorCode):
2850 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
2851
2852 case strings.EqualFold("OperationFailureException", errorCode):
2853 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
2854
2855 case strings.EqualFold("RegionSetupInProgressException", errorCode):
2856 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
2857
2858 case strings.EqualFold("ServiceException", errorCode):
2859 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2860
2861 case strings.EqualFold("UnauthenticatedException", errorCode):
2862 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
2863
2864 default:
2865 genericError := &smithy.GenericAPIError{
2866 Code: errorCode,
2867 Message: errorMessage,
2868 }
2869 return genericError
2870
2871 }
2872 }
2873
2874 type awsAwsjson11_deserializeOpCreateGUISessionAccessDetails struct {
2875 }
2876
2877 func (*awsAwsjson11_deserializeOpCreateGUISessionAccessDetails) ID() string {
2878 return "OperationDeserializer"
2879 }
2880
2881 func (m *awsAwsjson11_deserializeOpCreateGUISessionAccessDetails) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2882 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2883 ) {
2884 out, metadata, err = next.HandleDeserialize(ctx, in)
2885 if err != nil {
2886 return out, metadata, err
2887 }
2888
2889 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
2890 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
2891 defer endTimer()
2892 defer span.End()
2893 response, ok := out.RawResponse.(*smithyhttp.Response)
2894 if !ok {
2895 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2896 }
2897
2898 if response.StatusCode < 200 || response.StatusCode >= 300 {
2899 return out, metadata, awsAwsjson11_deserializeOpErrorCreateGUISessionAccessDetails(response, &metadata)
2900 }
2901 output := &CreateGUISessionAccessDetailsOutput{}
2902 out.Result = output
2903
2904 var buff [1024]byte
2905 ringBuffer := smithyio.NewRingBuffer(buff[:])
2906
2907 body := io.TeeReader(response.Body, ringBuffer)
2908 decoder := json.NewDecoder(body)
2909 decoder.UseNumber()
2910 var shape interface{}
2911 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2912 var snapshot bytes.Buffer
2913 io.Copy(&snapshot, ringBuffer)
2914 err = &smithy.DeserializationError{
2915 Err: fmt.Errorf("failed to decode response body, %w", err),
2916 Snapshot: snapshot.Bytes(),
2917 }
2918 return out, metadata, err
2919 }
2920
2921 err = awsAwsjson11_deserializeOpDocumentCreateGUISessionAccessDetailsOutput(&output, shape)
2922 if err != nil {
2923 var snapshot bytes.Buffer
2924 io.Copy(&snapshot, ringBuffer)
2925 err = &smithy.DeserializationError{
2926 Err: fmt.Errorf("failed to decode response body, %w", err),
2927 Snapshot: snapshot.Bytes(),
2928 }
2929 return out, metadata, err
2930 }
2931
2932 return out, metadata, err
2933 }
2934
2935 func awsAwsjson11_deserializeOpErrorCreateGUISessionAccessDetails(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2936 var errorBuffer bytes.Buffer
2937 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2938 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2939 }
2940 errorBody := bytes.NewReader(errorBuffer.Bytes())
2941
2942 errorCode := "UnknownError"
2943 errorMessage := errorCode
2944
2945 headerCode := response.Header.Get("X-Amzn-ErrorType")
2946
2947 var buff [1024]byte
2948 ringBuffer := smithyio.NewRingBuffer(buff[:])
2949
2950 body := io.TeeReader(errorBody, ringBuffer)
2951 decoder := json.NewDecoder(body)
2952 decoder.UseNumber()
2953 bodyInfo, err := getProtocolErrorInfo(decoder)
2954 if err != nil {
2955 var snapshot bytes.Buffer
2956 io.Copy(&snapshot, ringBuffer)
2957 err = &smithy.DeserializationError{
2958 Err: fmt.Errorf("failed to decode response body, %w", err),
2959 Snapshot: snapshot.Bytes(),
2960 }
2961 return err
2962 }
2963
2964 errorBody.Seek(0, io.SeekStart)
2965 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
2966 errorCode = restjson.SanitizeErrorCode(typ)
2967 }
2968 if len(bodyInfo.Message) != 0 {
2969 errorMessage = bodyInfo.Message
2970 }
2971 switch {
2972 case strings.EqualFold("AccessDeniedException", errorCode):
2973 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2974
2975 case strings.EqualFold("InvalidInputException", errorCode):
2976 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2977
2978 case strings.EqualFold("NotFoundException", errorCode):
2979 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
2980
2981 case strings.EqualFold("RegionSetupInProgressException", errorCode):
2982 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
2983
2984 case strings.EqualFold("ServiceException", errorCode):
2985 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2986
2987 case strings.EqualFold("UnauthenticatedException", errorCode):
2988 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
2989
2990 default:
2991 genericError := &smithy.GenericAPIError{
2992 Code: errorCode,
2993 Message: errorMessage,
2994 }
2995 return genericError
2996
2997 }
2998 }
2999
3000 type awsAwsjson11_deserializeOpCreateInstances struct {
3001 }
3002
3003 func (*awsAwsjson11_deserializeOpCreateInstances) ID() string {
3004 return "OperationDeserializer"
3005 }
3006
3007 func (m *awsAwsjson11_deserializeOpCreateInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3008 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3009 ) {
3010 out, metadata, err = next.HandleDeserialize(ctx, in)
3011 if err != nil {
3012 return out, metadata, err
3013 }
3014
3015 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
3016 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
3017 defer endTimer()
3018 defer span.End()
3019 response, ok := out.RawResponse.(*smithyhttp.Response)
3020 if !ok {
3021 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3022 }
3023
3024 if response.StatusCode < 200 || response.StatusCode >= 300 {
3025 return out, metadata, awsAwsjson11_deserializeOpErrorCreateInstances(response, &metadata)
3026 }
3027 output := &CreateInstancesOutput{}
3028 out.Result = output
3029
3030 var buff [1024]byte
3031 ringBuffer := smithyio.NewRingBuffer(buff[:])
3032
3033 body := io.TeeReader(response.Body, ringBuffer)
3034 decoder := json.NewDecoder(body)
3035 decoder.UseNumber()
3036 var shape interface{}
3037 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3038 var snapshot bytes.Buffer
3039 io.Copy(&snapshot, ringBuffer)
3040 err = &smithy.DeserializationError{
3041 Err: fmt.Errorf("failed to decode response body, %w", err),
3042 Snapshot: snapshot.Bytes(),
3043 }
3044 return out, metadata, err
3045 }
3046
3047 err = awsAwsjson11_deserializeOpDocumentCreateInstancesOutput(&output, shape)
3048 if err != nil {
3049 var snapshot bytes.Buffer
3050 io.Copy(&snapshot, ringBuffer)
3051 err = &smithy.DeserializationError{
3052 Err: fmt.Errorf("failed to decode response body, %w", err),
3053 Snapshot: snapshot.Bytes(),
3054 }
3055 return out, metadata, err
3056 }
3057
3058 return out, metadata, err
3059 }
3060
3061 func awsAwsjson11_deserializeOpErrorCreateInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3062 var errorBuffer bytes.Buffer
3063 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3064 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3065 }
3066 errorBody := bytes.NewReader(errorBuffer.Bytes())
3067
3068 errorCode := "UnknownError"
3069 errorMessage := errorCode
3070
3071 headerCode := response.Header.Get("X-Amzn-ErrorType")
3072
3073 var buff [1024]byte
3074 ringBuffer := smithyio.NewRingBuffer(buff[:])
3075
3076 body := io.TeeReader(errorBody, ringBuffer)
3077 decoder := json.NewDecoder(body)
3078 decoder.UseNumber()
3079 bodyInfo, err := getProtocolErrorInfo(decoder)
3080 if err != nil {
3081 var snapshot bytes.Buffer
3082 io.Copy(&snapshot, ringBuffer)
3083 err = &smithy.DeserializationError{
3084 Err: fmt.Errorf("failed to decode response body, %w", err),
3085 Snapshot: snapshot.Bytes(),
3086 }
3087 return err
3088 }
3089
3090 errorBody.Seek(0, io.SeekStart)
3091 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
3092 errorCode = restjson.SanitizeErrorCode(typ)
3093 }
3094 if len(bodyInfo.Message) != 0 {
3095 errorMessage = bodyInfo.Message
3096 }
3097 switch {
3098 case strings.EqualFold("AccessDeniedException", errorCode):
3099 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3100
3101 case strings.EqualFold("AccountSetupInProgressException", errorCode):
3102 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
3103
3104 case strings.EqualFold("InvalidInputException", errorCode):
3105 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3106
3107 case strings.EqualFold("NotFoundException", errorCode):
3108 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
3109
3110 case strings.EqualFold("OperationFailureException", errorCode):
3111 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
3112
3113 case strings.EqualFold("RegionSetupInProgressException", errorCode):
3114 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
3115
3116 case strings.EqualFold("ServiceException", errorCode):
3117 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3118
3119 case strings.EqualFold("UnauthenticatedException", errorCode):
3120 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
3121
3122 default:
3123 genericError := &smithy.GenericAPIError{
3124 Code: errorCode,
3125 Message: errorMessage,
3126 }
3127 return genericError
3128
3129 }
3130 }
3131
3132 type awsAwsjson11_deserializeOpCreateInstancesFromSnapshot struct {
3133 }
3134
3135 func (*awsAwsjson11_deserializeOpCreateInstancesFromSnapshot) ID() string {
3136 return "OperationDeserializer"
3137 }
3138
3139 func (m *awsAwsjson11_deserializeOpCreateInstancesFromSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3140 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3141 ) {
3142 out, metadata, err = next.HandleDeserialize(ctx, in)
3143 if err != nil {
3144 return out, metadata, err
3145 }
3146
3147 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
3148 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
3149 defer endTimer()
3150 defer span.End()
3151 response, ok := out.RawResponse.(*smithyhttp.Response)
3152 if !ok {
3153 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3154 }
3155
3156 if response.StatusCode < 200 || response.StatusCode >= 300 {
3157 return out, metadata, awsAwsjson11_deserializeOpErrorCreateInstancesFromSnapshot(response, &metadata)
3158 }
3159 output := &CreateInstancesFromSnapshotOutput{}
3160 out.Result = output
3161
3162 var buff [1024]byte
3163 ringBuffer := smithyio.NewRingBuffer(buff[:])
3164
3165 body := io.TeeReader(response.Body, ringBuffer)
3166 decoder := json.NewDecoder(body)
3167 decoder.UseNumber()
3168 var shape interface{}
3169 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3170 var snapshot bytes.Buffer
3171 io.Copy(&snapshot, ringBuffer)
3172 err = &smithy.DeserializationError{
3173 Err: fmt.Errorf("failed to decode response body, %w", err),
3174 Snapshot: snapshot.Bytes(),
3175 }
3176 return out, metadata, err
3177 }
3178
3179 err = awsAwsjson11_deserializeOpDocumentCreateInstancesFromSnapshotOutput(&output, shape)
3180 if err != nil {
3181 var snapshot bytes.Buffer
3182 io.Copy(&snapshot, ringBuffer)
3183 err = &smithy.DeserializationError{
3184 Err: fmt.Errorf("failed to decode response body, %w", err),
3185 Snapshot: snapshot.Bytes(),
3186 }
3187 return out, metadata, err
3188 }
3189
3190 return out, metadata, err
3191 }
3192
3193 func awsAwsjson11_deserializeOpErrorCreateInstancesFromSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3194 var errorBuffer bytes.Buffer
3195 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3196 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3197 }
3198 errorBody := bytes.NewReader(errorBuffer.Bytes())
3199
3200 errorCode := "UnknownError"
3201 errorMessage := errorCode
3202
3203 headerCode := response.Header.Get("X-Amzn-ErrorType")
3204
3205 var buff [1024]byte
3206 ringBuffer := smithyio.NewRingBuffer(buff[:])
3207
3208 body := io.TeeReader(errorBody, ringBuffer)
3209 decoder := json.NewDecoder(body)
3210 decoder.UseNumber()
3211 bodyInfo, err := getProtocolErrorInfo(decoder)
3212 if err != nil {
3213 var snapshot bytes.Buffer
3214 io.Copy(&snapshot, ringBuffer)
3215 err = &smithy.DeserializationError{
3216 Err: fmt.Errorf("failed to decode response body, %w", err),
3217 Snapshot: snapshot.Bytes(),
3218 }
3219 return err
3220 }
3221
3222 errorBody.Seek(0, io.SeekStart)
3223 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
3224 errorCode = restjson.SanitizeErrorCode(typ)
3225 }
3226 if len(bodyInfo.Message) != 0 {
3227 errorMessage = bodyInfo.Message
3228 }
3229 switch {
3230 case strings.EqualFold("AccessDeniedException", errorCode):
3231 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3232
3233 case strings.EqualFold("AccountSetupInProgressException", errorCode):
3234 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
3235
3236 case strings.EqualFold("InvalidInputException", errorCode):
3237 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3238
3239 case strings.EqualFold("NotFoundException", errorCode):
3240 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
3241
3242 case strings.EqualFold("OperationFailureException", errorCode):
3243 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
3244
3245 case strings.EqualFold("RegionSetupInProgressException", errorCode):
3246 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
3247
3248 case strings.EqualFold("ServiceException", errorCode):
3249 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3250
3251 case strings.EqualFold("UnauthenticatedException", errorCode):
3252 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
3253
3254 default:
3255 genericError := &smithy.GenericAPIError{
3256 Code: errorCode,
3257 Message: errorMessage,
3258 }
3259 return genericError
3260
3261 }
3262 }
3263
3264 type awsAwsjson11_deserializeOpCreateInstanceSnapshot struct {
3265 }
3266
3267 func (*awsAwsjson11_deserializeOpCreateInstanceSnapshot) ID() string {
3268 return "OperationDeserializer"
3269 }
3270
3271 func (m *awsAwsjson11_deserializeOpCreateInstanceSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3272 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3273 ) {
3274 out, metadata, err = next.HandleDeserialize(ctx, in)
3275 if err != nil {
3276 return out, metadata, err
3277 }
3278
3279 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
3280 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
3281 defer endTimer()
3282 defer span.End()
3283 response, ok := out.RawResponse.(*smithyhttp.Response)
3284 if !ok {
3285 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3286 }
3287
3288 if response.StatusCode < 200 || response.StatusCode >= 300 {
3289 return out, metadata, awsAwsjson11_deserializeOpErrorCreateInstanceSnapshot(response, &metadata)
3290 }
3291 output := &CreateInstanceSnapshotOutput{}
3292 out.Result = output
3293
3294 var buff [1024]byte
3295 ringBuffer := smithyio.NewRingBuffer(buff[:])
3296
3297 body := io.TeeReader(response.Body, ringBuffer)
3298 decoder := json.NewDecoder(body)
3299 decoder.UseNumber()
3300 var shape interface{}
3301 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3302 var snapshot bytes.Buffer
3303 io.Copy(&snapshot, ringBuffer)
3304 err = &smithy.DeserializationError{
3305 Err: fmt.Errorf("failed to decode response body, %w", err),
3306 Snapshot: snapshot.Bytes(),
3307 }
3308 return out, metadata, err
3309 }
3310
3311 err = awsAwsjson11_deserializeOpDocumentCreateInstanceSnapshotOutput(&output, shape)
3312 if err != nil {
3313 var snapshot bytes.Buffer
3314 io.Copy(&snapshot, ringBuffer)
3315 err = &smithy.DeserializationError{
3316 Err: fmt.Errorf("failed to decode response body, %w", err),
3317 Snapshot: snapshot.Bytes(),
3318 }
3319 return out, metadata, err
3320 }
3321
3322 return out, metadata, err
3323 }
3324
3325 func awsAwsjson11_deserializeOpErrorCreateInstanceSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3326 var errorBuffer bytes.Buffer
3327 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3328 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3329 }
3330 errorBody := bytes.NewReader(errorBuffer.Bytes())
3331
3332 errorCode := "UnknownError"
3333 errorMessage := errorCode
3334
3335 headerCode := response.Header.Get("X-Amzn-ErrorType")
3336
3337 var buff [1024]byte
3338 ringBuffer := smithyio.NewRingBuffer(buff[:])
3339
3340 body := io.TeeReader(errorBody, ringBuffer)
3341 decoder := json.NewDecoder(body)
3342 decoder.UseNumber()
3343 bodyInfo, err := getProtocolErrorInfo(decoder)
3344 if err != nil {
3345 var snapshot bytes.Buffer
3346 io.Copy(&snapshot, ringBuffer)
3347 err = &smithy.DeserializationError{
3348 Err: fmt.Errorf("failed to decode response body, %w", err),
3349 Snapshot: snapshot.Bytes(),
3350 }
3351 return err
3352 }
3353
3354 errorBody.Seek(0, io.SeekStart)
3355 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
3356 errorCode = restjson.SanitizeErrorCode(typ)
3357 }
3358 if len(bodyInfo.Message) != 0 {
3359 errorMessage = bodyInfo.Message
3360 }
3361 switch {
3362 case strings.EqualFold("AccessDeniedException", errorCode):
3363 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3364
3365 case strings.EqualFold("AccountSetupInProgressException", errorCode):
3366 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
3367
3368 case strings.EqualFold("InvalidInputException", errorCode):
3369 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3370
3371 case strings.EqualFold("NotFoundException", errorCode):
3372 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
3373
3374 case strings.EqualFold("OperationFailureException", errorCode):
3375 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
3376
3377 case strings.EqualFold("RegionSetupInProgressException", errorCode):
3378 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
3379
3380 case strings.EqualFold("ServiceException", errorCode):
3381 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3382
3383 case strings.EqualFold("UnauthenticatedException", errorCode):
3384 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
3385
3386 default:
3387 genericError := &smithy.GenericAPIError{
3388 Code: errorCode,
3389 Message: errorMessage,
3390 }
3391 return genericError
3392
3393 }
3394 }
3395
3396 type awsAwsjson11_deserializeOpCreateKeyPair struct {
3397 }
3398
3399 func (*awsAwsjson11_deserializeOpCreateKeyPair) ID() string {
3400 return "OperationDeserializer"
3401 }
3402
3403 func (m *awsAwsjson11_deserializeOpCreateKeyPair) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3404 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3405 ) {
3406 out, metadata, err = next.HandleDeserialize(ctx, in)
3407 if err != nil {
3408 return out, metadata, err
3409 }
3410
3411 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
3412 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
3413 defer endTimer()
3414 defer span.End()
3415 response, ok := out.RawResponse.(*smithyhttp.Response)
3416 if !ok {
3417 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3418 }
3419
3420 if response.StatusCode < 200 || response.StatusCode >= 300 {
3421 return out, metadata, awsAwsjson11_deserializeOpErrorCreateKeyPair(response, &metadata)
3422 }
3423 output := &CreateKeyPairOutput{}
3424 out.Result = output
3425
3426 var buff [1024]byte
3427 ringBuffer := smithyio.NewRingBuffer(buff[:])
3428
3429 body := io.TeeReader(response.Body, ringBuffer)
3430 decoder := json.NewDecoder(body)
3431 decoder.UseNumber()
3432 var shape interface{}
3433 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3434 var snapshot bytes.Buffer
3435 io.Copy(&snapshot, ringBuffer)
3436 err = &smithy.DeserializationError{
3437 Err: fmt.Errorf("failed to decode response body, %w", err),
3438 Snapshot: snapshot.Bytes(),
3439 }
3440 return out, metadata, err
3441 }
3442
3443 err = awsAwsjson11_deserializeOpDocumentCreateKeyPairOutput(&output, shape)
3444 if err != nil {
3445 var snapshot bytes.Buffer
3446 io.Copy(&snapshot, ringBuffer)
3447 err = &smithy.DeserializationError{
3448 Err: fmt.Errorf("failed to decode response body, %w", err),
3449 Snapshot: snapshot.Bytes(),
3450 }
3451 return out, metadata, err
3452 }
3453
3454 return out, metadata, err
3455 }
3456
3457 func awsAwsjson11_deserializeOpErrorCreateKeyPair(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3458 var errorBuffer bytes.Buffer
3459 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3460 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3461 }
3462 errorBody := bytes.NewReader(errorBuffer.Bytes())
3463
3464 errorCode := "UnknownError"
3465 errorMessage := errorCode
3466
3467 headerCode := response.Header.Get("X-Amzn-ErrorType")
3468
3469 var buff [1024]byte
3470 ringBuffer := smithyio.NewRingBuffer(buff[:])
3471
3472 body := io.TeeReader(errorBody, ringBuffer)
3473 decoder := json.NewDecoder(body)
3474 decoder.UseNumber()
3475 bodyInfo, err := getProtocolErrorInfo(decoder)
3476 if err != nil {
3477 var snapshot bytes.Buffer
3478 io.Copy(&snapshot, ringBuffer)
3479 err = &smithy.DeserializationError{
3480 Err: fmt.Errorf("failed to decode response body, %w", err),
3481 Snapshot: snapshot.Bytes(),
3482 }
3483 return err
3484 }
3485
3486 errorBody.Seek(0, io.SeekStart)
3487 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
3488 errorCode = restjson.SanitizeErrorCode(typ)
3489 }
3490 if len(bodyInfo.Message) != 0 {
3491 errorMessage = bodyInfo.Message
3492 }
3493 switch {
3494 case strings.EqualFold("AccessDeniedException", errorCode):
3495 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3496
3497 case strings.EqualFold("AccountSetupInProgressException", errorCode):
3498 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
3499
3500 case strings.EqualFold("InvalidInputException", errorCode):
3501 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3502
3503 case strings.EqualFold("NotFoundException", errorCode):
3504 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
3505
3506 case strings.EqualFold("OperationFailureException", errorCode):
3507 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
3508
3509 case strings.EqualFold("RegionSetupInProgressException", errorCode):
3510 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
3511
3512 case strings.EqualFold("ServiceException", errorCode):
3513 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3514
3515 case strings.EqualFold("UnauthenticatedException", errorCode):
3516 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
3517
3518 default:
3519 genericError := &smithy.GenericAPIError{
3520 Code: errorCode,
3521 Message: errorMessage,
3522 }
3523 return genericError
3524
3525 }
3526 }
3527
3528 type awsAwsjson11_deserializeOpCreateLoadBalancer struct {
3529 }
3530
3531 func (*awsAwsjson11_deserializeOpCreateLoadBalancer) ID() string {
3532 return "OperationDeserializer"
3533 }
3534
3535 func (m *awsAwsjson11_deserializeOpCreateLoadBalancer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3536 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3537 ) {
3538 out, metadata, err = next.HandleDeserialize(ctx, in)
3539 if err != nil {
3540 return out, metadata, err
3541 }
3542
3543 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
3544 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
3545 defer endTimer()
3546 defer span.End()
3547 response, ok := out.RawResponse.(*smithyhttp.Response)
3548 if !ok {
3549 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3550 }
3551
3552 if response.StatusCode < 200 || response.StatusCode >= 300 {
3553 return out, metadata, awsAwsjson11_deserializeOpErrorCreateLoadBalancer(response, &metadata)
3554 }
3555 output := &CreateLoadBalancerOutput{}
3556 out.Result = output
3557
3558 var buff [1024]byte
3559 ringBuffer := smithyio.NewRingBuffer(buff[:])
3560
3561 body := io.TeeReader(response.Body, ringBuffer)
3562 decoder := json.NewDecoder(body)
3563 decoder.UseNumber()
3564 var shape interface{}
3565 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3566 var snapshot bytes.Buffer
3567 io.Copy(&snapshot, ringBuffer)
3568 err = &smithy.DeserializationError{
3569 Err: fmt.Errorf("failed to decode response body, %w", err),
3570 Snapshot: snapshot.Bytes(),
3571 }
3572 return out, metadata, err
3573 }
3574
3575 err = awsAwsjson11_deserializeOpDocumentCreateLoadBalancerOutput(&output, shape)
3576 if err != nil {
3577 var snapshot bytes.Buffer
3578 io.Copy(&snapshot, ringBuffer)
3579 err = &smithy.DeserializationError{
3580 Err: fmt.Errorf("failed to decode response body, %w", err),
3581 Snapshot: snapshot.Bytes(),
3582 }
3583 return out, metadata, err
3584 }
3585
3586 return out, metadata, err
3587 }
3588
3589 func awsAwsjson11_deserializeOpErrorCreateLoadBalancer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3590 var errorBuffer bytes.Buffer
3591 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3592 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3593 }
3594 errorBody := bytes.NewReader(errorBuffer.Bytes())
3595
3596 errorCode := "UnknownError"
3597 errorMessage := errorCode
3598
3599 headerCode := response.Header.Get("X-Amzn-ErrorType")
3600
3601 var buff [1024]byte
3602 ringBuffer := smithyio.NewRingBuffer(buff[:])
3603
3604 body := io.TeeReader(errorBody, ringBuffer)
3605 decoder := json.NewDecoder(body)
3606 decoder.UseNumber()
3607 bodyInfo, err := getProtocolErrorInfo(decoder)
3608 if err != nil {
3609 var snapshot bytes.Buffer
3610 io.Copy(&snapshot, ringBuffer)
3611 err = &smithy.DeserializationError{
3612 Err: fmt.Errorf("failed to decode response body, %w", err),
3613 Snapshot: snapshot.Bytes(),
3614 }
3615 return err
3616 }
3617
3618 errorBody.Seek(0, io.SeekStart)
3619 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
3620 errorCode = restjson.SanitizeErrorCode(typ)
3621 }
3622 if len(bodyInfo.Message) != 0 {
3623 errorMessage = bodyInfo.Message
3624 }
3625 switch {
3626 case strings.EqualFold("AccessDeniedException", errorCode):
3627 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3628
3629 case strings.EqualFold("AccountSetupInProgressException", errorCode):
3630 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
3631
3632 case strings.EqualFold("InvalidInputException", errorCode):
3633 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3634
3635 case strings.EqualFold("NotFoundException", errorCode):
3636 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
3637
3638 case strings.EqualFold("OperationFailureException", errorCode):
3639 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
3640
3641 case strings.EqualFold("RegionSetupInProgressException", errorCode):
3642 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
3643
3644 case strings.EqualFold("ServiceException", errorCode):
3645 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3646
3647 case strings.EqualFold("UnauthenticatedException", errorCode):
3648 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
3649
3650 default:
3651 genericError := &smithy.GenericAPIError{
3652 Code: errorCode,
3653 Message: errorMessage,
3654 }
3655 return genericError
3656
3657 }
3658 }
3659
3660 type awsAwsjson11_deserializeOpCreateLoadBalancerTlsCertificate struct {
3661 }
3662
3663 func (*awsAwsjson11_deserializeOpCreateLoadBalancerTlsCertificate) ID() string {
3664 return "OperationDeserializer"
3665 }
3666
3667 func (m *awsAwsjson11_deserializeOpCreateLoadBalancerTlsCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3668 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3669 ) {
3670 out, metadata, err = next.HandleDeserialize(ctx, in)
3671 if err != nil {
3672 return out, metadata, err
3673 }
3674
3675 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
3676 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
3677 defer endTimer()
3678 defer span.End()
3679 response, ok := out.RawResponse.(*smithyhttp.Response)
3680 if !ok {
3681 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3682 }
3683
3684 if response.StatusCode < 200 || response.StatusCode >= 300 {
3685 return out, metadata, awsAwsjson11_deserializeOpErrorCreateLoadBalancerTlsCertificate(response, &metadata)
3686 }
3687 output := &CreateLoadBalancerTlsCertificateOutput{}
3688 out.Result = output
3689
3690 var buff [1024]byte
3691 ringBuffer := smithyio.NewRingBuffer(buff[:])
3692
3693 body := io.TeeReader(response.Body, ringBuffer)
3694 decoder := json.NewDecoder(body)
3695 decoder.UseNumber()
3696 var shape interface{}
3697 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3698 var snapshot bytes.Buffer
3699 io.Copy(&snapshot, ringBuffer)
3700 err = &smithy.DeserializationError{
3701 Err: fmt.Errorf("failed to decode response body, %w", err),
3702 Snapshot: snapshot.Bytes(),
3703 }
3704 return out, metadata, err
3705 }
3706
3707 err = awsAwsjson11_deserializeOpDocumentCreateLoadBalancerTlsCertificateOutput(&output, shape)
3708 if err != nil {
3709 var snapshot bytes.Buffer
3710 io.Copy(&snapshot, ringBuffer)
3711 err = &smithy.DeserializationError{
3712 Err: fmt.Errorf("failed to decode response body, %w", err),
3713 Snapshot: snapshot.Bytes(),
3714 }
3715 return out, metadata, err
3716 }
3717
3718 return out, metadata, err
3719 }
3720
3721 func awsAwsjson11_deserializeOpErrorCreateLoadBalancerTlsCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3722 var errorBuffer bytes.Buffer
3723 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3724 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3725 }
3726 errorBody := bytes.NewReader(errorBuffer.Bytes())
3727
3728 errorCode := "UnknownError"
3729 errorMessage := errorCode
3730
3731 headerCode := response.Header.Get("X-Amzn-ErrorType")
3732
3733 var buff [1024]byte
3734 ringBuffer := smithyio.NewRingBuffer(buff[:])
3735
3736 body := io.TeeReader(errorBody, ringBuffer)
3737 decoder := json.NewDecoder(body)
3738 decoder.UseNumber()
3739 bodyInfo, err := getProtocolErrorInfo(decoder)
3740 if err != nil {
3741 var snapshot bytes.Buffer
3742 io.Copy(&snapshot, ringBuffer)
3743 err = &smithy.DeserializationError{
3744 Err: fmt.Errorf("failed to decode response body, %w", err),
3745 Snapshot: snapshot.Bytes(),
3746 }
3747 return err
3748 }
3749
3750 errorBody.Seek(0, io.SeekStart)
3751 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
3752 errorCode = restjson.SanitizeErrorCode(typ)
3753 }
3754 if len(bodyInfo.Message) != 0 {
3755 errorMessage = bodyInfo.Message
3756 }
3757 switch {
3758 case strings.EqualFold("AccessDeniedException", errorCode):
3759 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3760
3761 case strings.EqualFold("AccountSetupInProgressException", errorCode):
3762 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
3763
3764 case strings.EqualFold("InvalidInputException", errorCode):
3765 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3766
3767 case strings.EqualFold("NotFoundException", errorCode):
3768 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
3769
3770 case strings.EqualFold("OperationFailureException", errorCode):
3771 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
3772
3773 case strings.EqualFold("RegionSetupInProgressException", errorCode):
3774 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
3775
3776 case strings.EqualFold("ServiceException", errorCode):
3777 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3778
3779 case strings.EqualFold("UnauthenticatedException", errorCode):
3780 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
3781
3782 default:
3783 genericError := &smithy.GenericAPIError{
3784 Code: errorCode,
3785 Message: errorMessage,
3786 }
3787 return genericError
3788
3789 }
3790 }
3791
3792 type awsAwsjson11_deserializeOpCreateRelationalDatabase struct {
3793 }
3794
3795 func (*awsAwsjson11_deserializeOpCreateRelationalDatabase) ID() string {
3796 return "OperationDeserializer"
3797 }
3798
3799 func (m *awsAwsjson11_deserializeOpCreateRelationalDatabase) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3800 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3801 ) {
3802 out, metadata, err = next.HandleDeserialize(ctx, in)
3803 if err != nil {
3804 return out, metadata, err
3805 }
3806
3807 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
3808 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
3809 defer endTimer()
3810 defer span.End()
3811 response, ok := out.RawResponse.(*smithyhttp.Response)
3812 if !ok {
3813 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3814 }
3815
3816 if response.StatusCode < 200 || response.StatusCode >= 300 {
3817 return out, metadata, awsAwsjson11_deserializeOpErrorCreateRelationalDatabase(response, &metadata)
3818 }
3819 output := &CreateRelationalDatabaseOutput{}
3820 out.Result = output
3821
3822 var buff [1024]byte
3823 ringBuffer := smithyio.NewRingBuffer(buff[:])
3824
3825 body := io.TeeReader(response.Body, ringBuffer)
3826 decoder := json.NewDecoder(body)
3827 decoder.UseNumber()
3828 var shape interface{}
3829 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3830 var snapshot bytes.Buffer
3831 io.Copy(&snapshot, ringBuffer)
3832 err = &smithy.DeserializationError{
3833 Err: fmt.Errorf("failed to decode response body, %w", err),
3834 Snapshot: snapshot.Bytes(),
3835 }
3836 return out, metadata, err
3837 }
3838
3839 err = awsAwsjson11_deserializeOpDocumentCreateRelationalDatabaseOutput(&output, shape)
3840 if err != nil {
3841 var snapshot bytes.Buffer
3842 io.Copy(&snapshot, ringBuffer)
3843 err = &smithy.DeserializationError{
3844 Err: fmt.Errorf("failed to decode response body, %w", err),
3845 Snapshot: snapshot.Bytes(),
3846 }
3847 return out, metadata, err
3848 }
3849
3850 return out, metadata, err
3851 }
3852
3853 func awsAwsjson11_deserializeOpErrorCreateRelationalDatabase(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3854 var errorBuffer bytes.Buffer
3855 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3856 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3857 }
3858 errorBody := bytes.NewReader(errorBuffer.Bytes())
3859
3860 errorCode := "UnknownError"
3861 errorMessage := errorCode
3862
3863 headerCode := response.Header.Get("X-Amzn-ErrorType")
3864
3865 var buff [1024]byte
3866 ringBuffer := smithyio.NewRingBuffer(buff[:])
3867
3868 body := io.TeeReader(errorBody, ringBuffer)
3869 decoder := json.NewDecoder(body)
3870 decoder.UseNumber()
3871 bodyInfo, err := getProtocolErrorInfo(decoder)
3872 if err != nil {
3873 var snapshot bytes.Buffer
3874 io.Copy(&snapshot, ringBuffer)
3875 err = &smithy.DeserializationError{
3876 Err: fmt.Errorf("failed to decode response body, %w", err),
3877 Snapshot: snapshot.Bytes(),
3878 }
3879 return err
3880 }
3881
3882 errorBody.Seek(0, io.SeekStart)
3883 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
3884 errorCode = restjson.SanitizeErrorCode(typ)
3885 }
3886 if len(bodyInfo.Message) != 0 {
3887 errorMessage = bodyInfo.Message
3888 }
3889 switch {
3890 case strings.EqualFold("AccessDeniedException", errorCode):
3891 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3892
3893 case strings.EqualFold("AccountSetupInProgressException", errorCode):
3894 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
3895
3896 case strings.EqualFold("InvalidInputException", errorCode):
3897 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3898
3899 case strings.EqualFold("NotFoundException", errorCode):
3900 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
3901
3902 case strings.EqualFold("OperationFailureException", errorCode):
3903 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
3904
3905 case strings.EqualFold("RegionSetupInProgressException", errorCode):
3906 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
3907
3908 case strings.EqualFold("ServiceException", errorCode):
3909 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3910
3911 case strings.EqualFold("UnauthenticatedException", errorCode):
3912 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
3913
3914 default:
3915 genericError := &smithy.GenericAPIError{
3916 Code: errorCode,
3917 Message: errorMessage,
3918 }
3919 return genericError
3920
3921 }
3922 }
3923
3924 type awsAwsjson11_deserializeOpCreateRelationalDatabaseFromSnapshot struct {
3925 }
3926
3927 func (*awsAwsjson11_deserializeOpCreateRelationalDatabaseFromSnapshot) ID() string {
3928 return "OperationDeserializer"
3929 }
3930
3931 func (m *awsAwsjson11_deserializeOpCreateRelationalDatabaseFromSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3932 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3933 ) {
3934 out, metadata, err = next.HandleDeserialize(ctx, in)
3935 if err != nil {
3936 return out, metadata, err
3937 }
3938
3939 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
3940 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
3941 defer endTimer()
3942 defer span.End()
3943 response, ok := out.RawResponse.(*smithyhttp.Response)
3944 if !ok {
3945 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3946 }
3947
3948 if response.StatusCode < 200 || response.StatusCode >= 300 {
3949 return out, metadata, awsAwsjson11_deserializeOpErrorCreateRelationalDatabaseFromSnapshot(response, &metadata)
3950 }
3951 output := &CreateRelationalDatabaseFromSnapshotOutput{}
3952 out.Result = output
3953
3954 var buff [1024]byte
3955 ringBuffer := smithyio.NewRingBuffer(buff[:])
3956
3957 body := io.TeeReader(response.Body, ringBuffer)
3958 decoder := json.NewDecoder(body)
3959 decoder.UseNumber()
3960 var shape interface{}
3961 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3962 var snapshot bytes.Buffer
3963 io.Copy(&snapshot, ringBuffer)
3964 err = &smithy.DeserializationError{
3965 Err: fmt.Errorf("failed to decode response body, %w", err),
3966 Snapshot: snapshot.Bytes(),
3967 }
3968 return out, metadata, err
3969 }
3970
3971 err = awsAwsjson11_deserializeOpDocumentCreateRelationalDatabaseFromSnapshotOutput(&output, shape)
3972 if err != nil {
3973 var snapshot bytes.Buffer
3974 io.Copy(&snapshot, ringBuffer)
3975 err = &smithy.DeserializationError{
3976 Err: fmt.Errorf("failed to decode response body, %w", err),
3977 Snapshot: snapshot.Bytes(),
3978 }
3979 return out, metadata, err
3980 }
3981
3982 return out, metadata, err
3983 }
3984
3985 func awsAwsjson11_deserializeOpErrorCreateRelationalDatabaseFromSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3986 var errorBuffer bytes.Buffer
3987 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3988 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3989 }
3990 errorBody := bytes.NewReader(errorBuffer.Bytes())
3991
3992 errorCode := "UnknownError"
3993 errorMessage := errorCode
3994
3995 headerCode := response.Header.Get("X-Amzn-ErrorType")
3996
3997 var buff [1024]byte
3998 ringBuffer := smithyio.NewRingBuffer(buff[:])
3999
4000 body := io.TeeReader(errorBody, ringBuffer)
4001 decoder := json.NewDecoder(body)
4002 decoder.UseNumber()
4003 bodyInfo, err := getProtocolErrorInfo(decoder)
4004 if err != nil {
4005 var snapshot bytes.Buffer
4006 io.Copy(&snapshot, ringBuffer)
4007 err = &smithy.DeserializationError{
4008 Err: fmt.Errorf("failed to decode response body, %w", err),
4009 Snapshot: snapshot.Bytes(),
4010 }
4011 return err
4012 }
4013
4014 errorBody.Seek(0, io.SeekStart)
4015 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
4016 errorCode = restjson.SanitizeErrorCode(typ)
4017 }
4018 if len(bodyInfo.Message) != 0 {
4019 errorMessage = bodyInfo.Message
4020 }
4021 switch {
4022 case strings.EqualFold("AccessDeniedException", errorCode):
4023 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4024
4025 case strings.EqualFold("AccountSetupInProgressException", errorCode):
4026 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
4027
4028 case strings.EqualFold("InvalidInputException", errorCode):
4029 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4030
4031 case strings.EqualFold("NotFoundException", errorCode):
4032 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
4033
4034 case strings.EqualFold("OperationFailureException", errorCode):
4035 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
4036
4037 case strings.EqualFold("RegionSetupInProgressException", errorCode):
4038 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
4039
4040 case strings.EqualFold("ServiceException", errorCode):
4041 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4042
4043 case strings.EqualFold("UnauthenticatedException", errorCode):
4044 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
4045
4046 default:
4047 genericError := &smithy.GenericAPIError{
4048 Code: errorCode,
4049 Message: errorMessage,
4050 }
4051 return genericError
4052
4053 }
4054 }
4055
4056 type awsAwsjson11_deserializeOpCreateRelationalDatabaseSnapshot struct {
4057 }
4058
4059 func (*awsAwsjson11_deserializeOpCreateRelationalDatabaseSnapshot) ID() string {
4060 return "OperationDeserializer"
4061 }
4062
4063 func (m *awsAwsjson11_deserializeOpCreateRelationalDatabaseSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4064 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4065 ) {
4066 out, metadata, err = next.HandleDeserialize(ctx, in)
4067 if err != nil {
4068 return out, metadata, err
4069 }
4070
4071 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
4072 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
4073 defer endTimer()
4074 defer span.End()
4075 response, ok := out.RawResponse.(*smithyhttp.Response)
4076 if !ok {
4077 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4078 }
4079
4080 if response.StatusCode < 200 || response.StatusCode >= 300 {
4081 return out, metadata, awsAwsjson11_deserializeOpErrorCreateRelationalDatabaseSnapshot(response, &metadata)
4082 }
4083 output := &CreateRelationalDatabaseSnapshotOutput{}
4084 out.Result = output
4085
4086 var buff [1024]byte
4087 ringBuffer := smithyio.NewRingBuffer(buff[:])
4088
4089 body := io.TeeReader(response.Body, ringBuffer)
4090 decoder := json.NewDecoder(body)
4091 decoder.UseNumber()
4092 var shape interface{}
4093 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4094 var snapshot bytes.Buffer
4095 io.Copy(&snapshot, ringBuffer)
4096 err = &smithy.DeserializationError{
4097 Err: fmt.Errorf("failed to decode response body, %w", err),
4098 Snapshot: snapshot.Bytes(),
4099 }
4100 return out, metadata, err
4101 }
4102
4103 err = awsAwsjson11_deserializeOpDocumentCreateRelationalDatabaseSnapshotOutput(&output, shape)
4104 if err != nil {
4105 var snapshot bytes.Buffer
4106 io.Copy(&snapshot, ringBuffer)
4107 err = &smithy.DeserializationError{
4108 Err: fmt.Errorf("failed to decode response body, %w", err),
4109 Snapshot: snapshot.Bytes(),
4110 }
4111 return out, metadata, err
4112 }
4113
4114 return out, metadata, err
4115 }
4116
4117 func awsAwsjson11_deserializeOpErrorCreateRelationalDatabaseSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4118 var errorBuffer bytes.Buffer
4119 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4120 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4121 }
4122 errorBody := bytes.NewReader(errorBuffer.Bytes())
4123
4124 errorCode := "UnknownError"
4125 errorMessage := errorCode
4126
4127 headerCode := response.Header.Get("X-Amzn-ErrorType")
4128
4129 var buff [1024]byte
4130 ringBuffer := smithyio.NewRingBuffer(buff[:])
4131
4132 body := io.TeeReader(errorBody, ringBuffer)
4133 decoder := json.NewDecoder(body)
4134 decoder.UseNumber()
4135 bodyInfo, err := getProtocolErrorInfo(decoder)
4136 if err != nil {
4137 var snapshot bytes.Buffer
4138 io.Copy(&snapshot, ringBuffer)
4139 err = &smithy.DeserializationError{
4140 Err: fmt.Errorf("failed to decode response body, %w", err),
4141 Snapshot: snapshot.Bytes(),
4142 }
4143 return err
4144 }
4145
4146 errorBody.Seek(0, io.SeekStart)
4147 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
4148 errorCode = restjson.SanitizeErrorCode(typ)
4149 }
4150 if len(bodyInfo.Message) != 0 {
4151 errorMessage = bodyInfo.Message
4152 }
4153 switch {
4154 case strings.EqualFold("AccessDeniedException", errorCode):
4155 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4156
4157 case strings.EqualFold("AccountSetupInProgressException", errorCode):
4158 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
4159
4160 case strings.EqualFold("InvalidInputException", errorCode):
4161 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4162
4163 case strings.EqualFold("NotFoundException", errorCode):
4164 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
4165
4166 case strings.EqualFold("OperationFailureException", errorCode):
4167 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
4168
4169 case strings.EqualFold("RegionSetupInProgressException", errorCode):
4170 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
4171
4172 case strings.EqualFold("ServiceException", errorCode):
4173 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4174
4175 case strings.EqualFold("UnauthenticatedException", errorCode):
4176 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
4177
4178 default:
4179 genericError := &smithy.GenericAPIError{
4180 Code: errorCode,
4181 Message: errorMessage,
4182 }
4183 return genericError
4184
4185 }
4186 }
4187
4188 type awsAwsjson11_deserializeOpDeleteAlarm struct {
4189 }
4190
4191 func (*awsAwsjson11_deserializeOpDeleteAlarm) ID() string {
4192 return "OperationDeserializer"
4193 }
4194
4195 func (m *awsAwsjson11_deserializeOpDeleteAlarm) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4196 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4197 ) {
4198 out, metadata, err = next.HandleDeserialize(ctx, in)
4199 if err != nil {
4200 return out, metadata, err
4201 }
4202
4203 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
4204 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
4205 defer endTimer()
4206 defer span.End()
4207 response, ok := out.RawResponse.(*smithyhttp.Response)
4208 if !ok {
4209 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4210 }
4211
4212 if response.StatusCode < 200 || response.StatusCode >= 300 {
4213 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteAlarm(response, &metadata)
4214 }
4215 output := &DeleteAlarmOutput{}
4216 out.Result = output
4217
4218 var buff [1024]byte
4219 ringBuffer := smithyio.NewRingBuffer(buff[:])
4220
4221 body := io.TeeReader(response.Body, ringBuffer)
4222 decoder := json.NewDecoder(body)
4223 decoder.UseNumber()
4224 var shape interface{}
4225 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4226 var snapshot bytes.Buffer
4227 io.Copy(&snapshot, ringBuffer)
4228 err = &smithy.DeserializationError{
4229 Err: fmt.Errorf("failed to decode response body, %w", err),
4230 Snapshot: snapshot.Bytes(),
4231 }
4232 return out, metadata, err
4233 }
4234
4235 err = awsAwsjson11_deserializeOpDocumentDeleteAlarmOutput(&output, shape)
4236 if err != nil {
4237 var snapshot bytes.Buffer
4238 io.Copy(&snapshot, ringBuffer)
4239 err = &smithy.DeserializationError{
4240 Err: fmt.Errorf("failed to decode response body, %w", err),
4241 Snapshot: snapshot.Bytes(),
4242 }
4243 return out, metadata, err
4244 }
4245
4246 return out, metadata, err
4247 }
4248
4249 func awsAwsjson11_deserializeOpErrorDeleteAlarm(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4250 var errorBuffer bytes.Buffer
4251 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4252 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4253 }
4254 errorBody := bytes.NewReader(errorBuffer.Bytes())
4255
4256 errorCode := "UnknownError"
4257 errorMessage := errorCode
4258
4259 headerCode := response.Header.Get("X-Amzn-ErrorType")
4260
4261 var buff [1024]byte
4262 ringBuffer := smithyio.NewRingBuffer(buff[:])
4263
4264 body := io.TeeReader(errorBody, ringBuffer)
4265 decoder := json.NewDecoder(body)
4266 decoder.UseNumber()
4267 bodyInfo, err := getProtocolErrorInfo(decoder)
4268 if err != nil {
4269 var snapshot bytes.Buffer
4270 io.Copy(&snapshot, ringBuffer)
4271 err = &smithy.DeserializationError{
4272 Err: fmt.Errorf("failed to decode response body, %w", err),
4273 Snapshot: snapshot.Bytes(),
4274 }
4275 return err
4276 }
4277
4278 errorBody.Seek(0, io.SeekStart)
4279 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
4280 errorCode = restjson.SanitizeErrorCode(typ)
4281 }
4282 if len(bodyInfo.Message) != 0 {
4283 errorMessage = bodyInfo.Message
4284 }
4285 switch {
4286 case strings.EqualFold("AccessDeniedException", errorCode):
4287 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4288
4289 case strings.EqualFold("InvalidInputException", errorCode):
4290 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4291
4292 case strings.EqualFold("NotFoundException", errorCode):
4293 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
4294
4295 case strings.EqualFold("OperationFailureException", errorCode):
4296 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
4297
4298 case strings.EqualFold("RegionSetupInProgressException", errorCode):
4299 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
4300
4301 case strings.EqualFold("ServiceException", errorCode):
4302 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4303
4304 case strings.EqualFold("UnauthenticatedException", errorCode):
4305 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
4306
4307 default:
4308 genericError := &smithy.GenericAPIError{
4309 Code: errorCode,
4310 Message: errorMessage,
4311 }
4312 return genericError
4313
4314 }
4315 }
4316
4317 type awsAwsjson11_deserializeOpDeleteAutoSnapshot struct {
4318 }
4319
4320 func (*awsAwsjson11_deserializeOpDeleteAutoSnapshot) ID() string {
4321 return "OperationDeserializer"
4322 }
4323
4324 func (m *awsAwsjson11_deserializeOpDeleteAutoSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4325 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4326 ) {
4327 out, metadata, err = next.HandleDeserialize(ctx, in)
4328 if err != nil {
4329 return out, metadata, err
4330 }
4331
4332 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
4333 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
4334 defer endTimer()
4335 defer span.End()
4336 response, ok := out.RawResponse.(*smithyhttp.Response)
4337 if !ok {
4338 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4339 }
4340
4341 if response.StatusCode < 200 || response.StatusCode >= 300 {
4342 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteAutoSnapshot(response, &metadata)
4343 }
4344 output := &DeleteAutoSnapshotOutput{}
4345 out.Result = output
4346
4347 var buff [1024]byte
4348 ringBuffer := smithyio.NewRingBuffer(buff[:])
4349
4350 body := io.TeeReader(response.Body, ringBuffer)
4351 decoder := json.NewDecoder(body)
4352 decoder.UseNumber()
4353 var shape interface{}
4354 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4355 var snapshot bytes.Buffer
4356 io.Copy(&snapshot, ringBuffer)
4357 err = &smithy.DeserializationError{
4358 Err: fmt.Errorf("failed to decode response body, %w", err),
4359 Snapshot: snapshot.Bytes(),
4360 }
4361 return out, metadata, err
4362 }
4363
4364 err = awsAwsjson11_deserializeOpDocumentDeleteAutoSnapshotOutput(&output, shape)
4365 if err != nil {
4366 var snapshot bytes.Buffer
4367 io.Copy(&snapshot, ringBuffer)
4368 err = &smithy.DeserializationError{
4369 Err: fmt.Errorf("failed to decode response body, %w", err),
4370 Snapshot: snapshot.Bytes(),
4371 }
4372 return out, metadata, err
4373 }
4374
4375 return out, metadata, err
4376 }
4377
4378 func awsAwsjson11_deserializeOpErrorDeleteAutoSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4379 var errorBuffer bytes.Buffer
4380 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4381 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4382 }
4383 errorBody := bytes.NewReader(errorBuffer.Bytes())
4384
4385 errorCode := "UnknownError"
4386 errorMessage := errorCode
4387
4388 headerCode := response.Header.Get("X-Amzn-ErrorType")
4389
4390 var buff [1024]byte
4391 ringBuffer := smithyio.NewRingBuffer(buff[:])
4392
4393 body := io.TeeReader(errorBody, ringBuffer)
4394 decoder := json.NewDecoder(body)
4395 decoder.UseNumber()
4396 bodyInfo, err := getProtocolErrorInfo(decoder)
4397 if err != nil {
4398 var snapshot bytes.Buffer
4399 io.Copy(&snapshot, ringBuffer)
4400 err = &smithy.DeserializationError{
4401 Err: fmt.Errorf("failed to decode response body, %w", err),
4402 Snapshot: snapshot.Bytes(),
4403 }
4404 return err
4405 }
4406
4407 errorBody.Seek(0, io.SeekStart)
4408 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
4409 errorCode = restjson.SanitizeErrorCode(typ)
4410 }
4411 if len(bodyInfo.Message) != 0 {
4412 errorMessage = bodyInfo.Message
4413 }
4414 switch {
4415 case strings.EqualFold("AccessDeniedException", errorCode):
4416 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4417
4418 case strings.EqualFold("InvalidInputException", errorCode):
4419 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4420
4421 case strings.EqualFold("NotFoundException", errorCode):
4422 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
4423
4424 case strings.EqualFold("OperationFailureException", errorCode):
4425 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
4426
4427 case strings.EqualFold("RegionSetupInProgressException", errorCode):
4428 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
4429
4430 case strings.EqualFold("ServiceException", errorCode):
4431 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4432
4433 case strings.EqualFold("UnauthenticatedException", errorCode):
4434 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
4435
4436 default:
4437 genericError := &smithy.GenericAPIError{
4438 Code: errorCode,
4439 Message: errorMessage,
4440 }
4441 return genericError
4442
4443 }
4444 }
4445
4446 type awsAwsjson11_deserializeOpDeleteBucket struct {
4447 }
4448
4449 func (*awsAwsjson11_deserializeOpDeleteBucket) ID() string {
4450 return "OperationDeserializer"
4451 }
4452
4453 func (m *awsAwsjson11_deserializeOpDeleteBucket) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4454 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4455 ) {
4456 out, metadata, err = next.HandleDeserialize(ctx, in)
4457 if err != nil {
4458 return out, metadata, err
4459 }
4460
4461 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
4462 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
4463 defer endTimer()
4464 defer span.End()
4465 response, ok := out.RawResponse.(*smithyhttp.Response)
4466 if !ok {
4467 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4468 }
4469
4470 if response.StatusCode < 200 || response.StatusCode >= 300 {
4471 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteBucket(response, &metadata)
4472 }
4473 output := &DeleteBucketOutput{}
4474 out.Result = output
4475
4476 var buff [1024]byte
4477 ringBuffer := smithyio.NewRingBuffer(buff[:])
4478
4479 body := io.TeeReader(response.Body, ringBuffer)
4480 decoder := json.NewDecoder(body)
4481 decoder.UseNumber()
4482 var shape interface{}
4483 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4484 var snapshot bytes.Buffer
4485 io.Copy(&snapshot, ringBuffer)
4486 err = &smithy.DeserializationError{
4487 Err: fmt.Errorf("failed to decode response body, %w", err),
4488 Snapshot: snapshot.Bytes(),
4489 }
4490 return out, metadata, err
4491 }
4492
4493 err = awsAwsjson11_deserializeOpDocumentDeleteBucketOutput(&output, shape)
4494 if err != nil {
4495 var snapshot bytes.Buffer
4496 io.Copy(&snapshot, ringBuffer)
4497 err = &smithy.DeserializationError{
4498 Err: fmt.Errorf("failed to decode response body, %w", err),
4499 Snapshot: snapshot.Bytes(),
4500 }
4501 return out, metadata, err
4502 }
4503
4504 return out, metadata, err
4505 }
4506
4507 func awsAwsjson11_deserializeOpErrorDeleteBucket(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4508 var errorBuffer bytes.Buffer
4509 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4510 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4511 }
4512 errorBody := bytes.NewReader(errorBuffer.Bytes())
4513
4514 errorCode := "UnknownError"
4515 errorMessage := errorCode
4516
4517 headerCode := response.Header.Get("X-Amzn-ErrorType")
4518
4519 var buff [1024]byte
4520 ringBuffer := smithyio.NewRingBuffer(buff[:])
4521
4522 body := io.TeeReader(errorBody, ringBuffer)
4523 decoder := json.NewDecoder(body)
4524 decoder.UseNumber()
4525 bodyInfo, err := getProtocolErrorInfo(decoder)
4526 if err != nil {
4527 var snapshot bytes.Buffer
4528 io.Copy(&snapshot, ringBuffer)
4529 err = &smithy.DeserializationError{
4530 Err: fmt.Errorf("failed to decode response body, %w", err),
4531 Snapshot: snapshot.Bytes(),
4532 }
4533 return err
4534 }
4535
4536 errorBody.Seek(0, io.SeekStart)
4537 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
4538 errorCode = restjson.SanitizeErrorCode(typ)
4539 }
4540 if len(bodyInfo.Message) != 0 {
4541 errorMessage = bodyInfo.Message
4542 }
4543 switch {
4544 case strings.EqualFold("AccessDeniedException", errorCode):
4545 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4546
4547 case strings.EqualFold("InvalidInputException", errorCode):
4548 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4549
4550 case strings.EqualFold("NotFoundException", errorCode):
4551 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
4552
4553 case strings.EqualFold("RegionSetupInProgressException", errorCode):
4554 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
4555
4556 case strings.EqualFold("ServiceException", errorCode):
4557 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4558
4559 case strings.EqualFold("UnauthenticatedException", errorCode):
4560 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
4561
4562 default:
4563 genericError := &smithy.GenericAPIError{
4564 Code: errorCode,
4565 Message: errorMessage,
4566 }
4567 return genericError
4568
4569 }
4570 }
4571
4572 type awsAwsjson11_deserializeOpDeleteBucketAccessKey struct {
4573 }
4574
4575 func (*awsAwsjson11_deserializeOpDeleteBucketAccessKey) ID() string {
4576 return "OperationDeserializer"
4577 }
4578
4579 func (m *awsAwsjson11_deserializeOpDeleteBucketAccessKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4580 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4581 ) {
4582 out, metadata, err = next.HandleDeserialize(ctx, in)
4583 if err != nil {
4584 return out, metadata, err
4585 }
4586
4587 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
4588 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
4589 defer endTimer()
4590 defer span.End()
4591 response, ok := out.RawResponse.(*smithyhttp.Response)
4592 if !ok {
4593 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4594 }
4595
4596 if response.StatusCode < 200 || response.StatusCode >= 300 {
4597 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteBucketAccessKey(response, &metadata)
4598 }
4599 output := &DeleteBucketAccessKeyOutput{}
4600 out.Result = output
4601
4602 var buff [1024]byte
4603 ringBuffer := smithyio.NewRingBuffer(buff[:])
4604
4605 body := io.TeeReader(response.Body, ringBuffer)
4606 decoder := json.NewDecoder(body)
4607 decoder.UseNumber()
4608 var shape interface{}
4609 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4610 var snapshot bytes.Buffer
4611 io.Copy(&snapshot, ringBuffer)
4612 err = &smithy.DeserializationError{
4613 Err: fmt.Errorf("failed to decode response body, %w", err),
4614 Snapshot: snapshot.Bytes(),
4615 }
4616 return out, metadata, err
4617 }
4618
4619 err = awsAwsjson11_deserializeOpDocumentDeleteBucketAccessKeyOutput(&output, shape)
4620 if err != nil {
4621 var snapshot bytes.Buffer
4622 io.Copy(&snapshot, ringBuffer)
4623 err = &smithy.DeserializationError{
4624 Err: fmt.Errorf("failed to decode response body, %w", err),
4625 Snapshot: snapshot.Bytes(),
4626 }
4627 return out, metadata, err
4628 }
4629
4630 return out, metadata, err
4631 }
4632
4633 func awsAwsjson11_deserializeOpErrorDeleteBucketAccessKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4634 var errorBuffer bytes.Buffer
4635 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4636 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4637 }
4638 errorBody := bytes.NewReader(errorBuffer.Bytes())
4639
4640 errorCode := "UnknownError"
4641 errorMessage := errorCode
4642
4643 headerCode := response.Header.Get("X-Amzn-ErrorType")
4644
4645 var buff [1024]byte
4646 ringBuffer := smithyio.NewRingBuffer(buff[:])
4647
4648 body := io.TeeReader(errorBody, ringBuffer)
4649 decoder := json.NewDecoder(body)
4650 decoder.UseNumber()
4651 bodyInfo, err := getProtocolErrorInfo(decoder)
4652 if err != nil {
4653 var snapshot bytes.Buffer
4654 io.Copy(&snapshot, ringBuffer)
4655 err = &smithy.DeserializationError{
4656 Err: fmt.Errorf("failed to decode response body, %w", err),
4657 Snapshot: snapshot.Bytes(),
4658 }
4659 return err
4660 }
4661
4662 errorBody.Seek(0, io.SeekStart)
4663 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
4664 errorCode = restjson.SanitizeErrorCode(typ)
4665 }
4666 if len(bodyInfo.Message) != 0 {
4667 errorMessage = bodyInfo.Message
4668 }
4669 switch {
4670 case strings.EqualFold("AccessDeniedException", errorCode):
4671 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4672
4673 case strings.EqualFold("InvalidInputException", errorCode):
4674 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4675
4676 case strings.EqualFold("NotFoundException", errorCode):
4677 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
4678
4679 case strings.EqualFold("RegionSetupInProgressException", errorCode):
4680 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
4681
4682 case strings.EqualFold("ServiceException", errorCode):
4683 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4684
4685 case strings.EqualFold("UnauthenticatedException", errorCode):
4686 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
4687
4688 default:
4689 genericError := &smithy.GenericAPIError{
4690 Code: errorCode,
4691 Message: errorMessage,
4692 }
4693 return genericError
4694
4695 }
4696 }
4697
4698 type awsAwsjson11_deserializeOpDeleteCertificate struct {
4699 }
4700
4701 func (*awsAwsjson11_deserializeOpDeleteCertificate) ID() string {
4702 return "OperationDeserializer"
4703 }
4704
4705 func (m *awsAwsjson11_deserializeOpDeleteCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4706 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4707 ) {
4708 out, metadata, err = next.HandleDeserialize(ctx, in)
4709 if err != nil {
4710 return out, metadata, err
4711 }
4712
4713 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
4714 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
4715 defer endTimer()
4716 defer span.End()
4717 response, ok := out.RawResponse.(*smithyhttp.Response)
4718 if !ok {
4719 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4720 }
4721
4722 if response.StatusCode < 200 || response.StatusCode >= 300 {
4723 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteCertificate(response, &metadata)
4724 }
4725 output := &DeleteCertificateOutput{}
4726 out.Result = output
4727
4728 var buff [1024]byte
4729 ringBuffer := smithyio.NewRingBuffer(buff[:])
4730
4731 body := io.TeeReader(response.Body, ringBuffer)
4732 decoder := json.NewDecoder(body)
4733 decoder.UseNumber()
4734 var shape interface{}
4735 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4736 var snapshot bytes.Buffer
4737 io.Copy(&snapshot, ringBuffer)
4738 err = &smithy.DeserializationError{
4739 Err: fmt.Errorf("failed to decode response body, %w", err),
4740 Snapshot: snapshot.Bytes(),
4741 }
4742 return out, metadata, err
4743 }
4744
4745 err = awsAwsjson11_deserializeOpDocumentDeleteCertificateOutput(&output, shape)
4746 if err != nil {
4747 var snapshot bytes.Buffer
4748 io.Copy(&snapshot, ringBuffer)
4749 err = &smithy.DeserializationError{
4750 Err: fmt.Errorf("failed to decode response body, %w", err),
4751 Snapshot: snapshot.Bytes(),
4752 }
4753 return out, metadata, err
4754 }
4755
4756 return out, metadata, err
4757 }
4758
4759 func awsAwsjson11_deserializeOpErrorDeleteCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4760 var errorBuffer bytes.Buffer
4761 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4762 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4763 }
4764 errorBody := bytes.NewReader(errorBuffer.Bytes())
4765
4766 errorCode := "UnknownError"
4767 errorMessage := errorCode
4768
4769 headerCode := response.Header.Get("X-Amzn-ErrorType")
4770
4771 var buff [1024]byte
4772 ringBuffer := smithyio.NewRingBuffer(buff[:])
4773
4774 body := io.TeeReader(errorBody, ringBuffer)
4775 decoder := json.NewDecoder(body)
4776 decoder.UseNumber()
4777 bodyInfo, err := getProtocolErrorInfo(decoder)
4778 if err != nil {
4779 var snapshot bytes.Buffer
4780 io.Copy(&snapshot, ringBuffer)
4781 err = &smithy.DeserializationError{
4782 Err: fmt.Errorf("failed to decode response body, %w", err),
4783 Snapshot: snapshot.Bytes(),
4784 }
4785 return err
4786 }
4787
4788 errorBody.Seek(0, io.SeekStart)
4789 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
4790 errorCode = restjson.SanitizeErrorCode(typ)
4791 }
4792 if len(bodyInfo.Message) != 0 {
4793 errorMessage = bodyInfo.Message
4794 }
4795 switch {
4796 case strings.EqualFold("AccessDeniedException", errorCode):
4797 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4798
4799 case strings.EqualFold("InvalidInputException", errorCode):
4800 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4801
4802 case strings.EqualFold("NotFoundException", errorCode):
4803 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
4804
4805 case strings.EqualFold("RegionSetupInProgressException", errorCode):
4806 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
4807
4808 case strings.EqualFold("ServiceException", errorCode):
4809 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4810
4811 case strings.EqualFold("UnauthenticatedException", errorCode):
4812 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
4813
4814 default:
4815 genericError := &smithy.GenericAPIError{
4816 Code: errorCode,
4817 Message: errorMessage,
4818 }
4819 return genericError
4820
4821 }
4822 }
4823
4824 type awsAwsjson11_deserializeOpDeleteContactMethod struct {
4825 }
4826
4827 func (*awsAwsjson11_deserializeOpDeleteContactMethod) ID() string {
4828 return "OperationDeserializer"
4829 }
4830
4831 func (m *awsAwsjson11_deserializeOpDeleteContactMethod) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4832 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4833 ) {
4834 out, metadata, err = next.HandleDeserialize(ctx, in)
4835 if err != nil {
4836 return out, metadata, err
4837 }
4838
4839 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
4840 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
4841 defer endTimer()
4842 defer span.End()
4843 response, ok := out.RawResponse.(*smithyhttp.Response)
4844 if !ok {
4845 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4846 }
4847
4848 if response.StatusCode < 200 || response.StatusCode >= 300 {
4849 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteContactMethod(response, &metadata)
4850 }
4851 output := &DeleteContactMethodOutput{}
4852 out.Result = output
4853
4854 var buff [1024]byte
4855 ringBuffer := smithyio.NewRingBuffer(buff[:])
4856
4857 body := io.TeeReader(response.Body, ringBuffer)
4858 decoder := json.NewDecoder(body)
4859 decoder.UseNumber()
4860 var shape interface{}
4861 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4862 var snapshot bytes.Buffer
4863 io.Copy(&snapshot, ringBuffer)
4864 err = &smithy.DeserializationError{
4865 Err: fmt.Errorf("failed to decode response body, %w", err),
4866 Snapshot: snapshot.Bytes(),
4867 }
4868 return out, metadata, err
4869 }
4870
4871 err = awsAwsjson11_deserializeOpDocumentDeleteContactMethodOutput(&output, shape)
4872 if err != nil {
4873 var snapshot bytes.Buffer
4874 io.Copy(&snapshot, ringBuffer)
4875 err = &smithy.DeserializationError{
4876 Err: fmt.Errorf("failed to decode response body, %w", err),
4877 Snapshot: snapshot.Bytes(),
4878 }
4879 return out, metadata, err
4880 }
4881
4882 return out, metadata, err
4883 }
4884
4885 func awsAwsjson11_deserializeOpErrorDeleteContactMethod(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4886 var errorBuffer bytes.Buffer
4887 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4888 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4889 }
4890 errorBody := bytes.NewReader(errorBuffer.Bytes())
4891
4892 errorCode := "UnknownError"
4893 errorMessage := errorCode
4894
4895 headerCode := response.Header.Get("X-Amzn-ErrorType")
4896
4897 var buff [1024]byte
4898 ringBuffer := smithyio.NewRingBuffer(buff[:])
4899
4900 body := io.TeeReader(errorBody, ringBuffer)
4901 decoder := json.NewDecoder(body)
4902 decoder.UseNumber()
4903 bodyInfo, err := getProtocolErrorInfo(decoder)
4904 if err != nil {
4905 var snapshot bytes.Buffer
4906 io.Copy(&snapshot, ringBuffer)
4907 err = &smithy.DeserializationError{
4908 Err: fmt.Errorf("failed to decode response body, %w", err),
4909 Snapshot: snapshot.Bytes(),
4910 }
4911 return err
4912 }
4913
4914 errorBody.Seek(0, io.SeekStart)
4915 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
4916 errorCode = restjson.SanitizeErrorCode(typ)
4917 }
4918 if len(bodyInfo.Message) != 0 {
4919 errorMessage = bodyInfo.Message
4920 }
4921 switch {
4922 case strings.EqualFold("AccessDeniedException", errorCode):
4923 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4924
4925 case strings.EqualFold("InvalidInputException", errorCode):
4926 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4927
4928 case strings.EqualFold("NotFoundException", errorCode):
4929 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
4930
4931 case strings.EqualFold("OperationFailureException", errorCode):
4932 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
4933
4934 case strings.EqualFold("RegionSetupInProgressException", errorCode):
4935 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
4936
4937 case strings.EqualFold("ServiceException", errorCode):
4938 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4939
4940 case strings.EqualFold("UnauthenticatedException", errorCode):
4941 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
4942
4943 default:
4944 genericError := &smithy.GenericAPIError{
4945 Code: errorCode,
4946 Message: errorMessage,
4947 }
4948 return genericError
4949
4950 }
4951 }
4952
4953 type awsAwsjson11_deserializeOpDeleteContainerImage struct {
4954 }
4955
4956 func (*awsAwsjson11_deserializeOpDeleteContainerImage) ID() string {
4957 return "OperationDeserializer"
4958 }
4959
4960 func (m *awsAwsjson11_deserializeOpDeleteContainerImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4961 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4962 ) {
4963 out, metadata, err = next.HandleDeserialize(ctx, in)
4964 if err != nil {
4965 return out, metadata, err
4966 }
4967
4968 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
4969 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
4970 defer endTimer()
4971 defer span.End()
4972 response, ok := out.RawResponse.(*smithyhttp.Response)
4973 if !ok {
4974 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4975 }
4976
4977 if response.StatusCode < 200 || response.StatusCode >= 300 {
4978 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteContainerImage(response, &metadata)
4979 }
4980 output := &DeleteContainerImageOutput{}
4981 out.Result = output
4982
4983 var buff [1024]byte
4984 ringBuffer := smithyio.NewRingBuffer(buff[:])
4985
4986 body := io.TeeReader(response.Body, ringBuffer)
4987 decoder := json.NewDecoder(body)
4988 decoder.UseNumber()
4989 var shape interface{}
4990 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4991 var snapshot bytes.Buffer
4992 io.Copy(&snapshot, ringBuffer)
4993 err = &smithy.DeserializationError{
4994 Err: fmt.Errorf("failed to decode response body, %w", err),
4995 Snapshot: snapshot.Bytes(),
4996 }
4997 return out, metadata, err
4998 }
4999
5000 err = awsAwsjson11_deserializeOpDocumentDeleteContainerImageOutput(&output, shape)
5001 if err != nil {
5002 var snapshot bytes.Buffer
5003 io.Copy(&snapshot, ringBuffer)
5004 err = &smithy.DeserializationError{
5005 Err: fmt.Errorf("failed to decode response body, %w", err),
5006 Snapshot: snapshot.Bytes(),
5007 }
5008 return out, metadata, err
5009 }
5010
5011 return out, metadata, err
5012 }
5013
5014 func awsAwsjson11_deserializeOpErrorDeleteContainerImage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5015 var errorBuffer bytes.Buffer
5016 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5017 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5018 }
5019 errorBody := bytes.NewReader(errorBuffer.Bytes())
5020
5021 errorCode := "UnknownError"
5022 errorMessage := errorCode
5023
5024 headerCode := response.Header.Get("X-Amzn-ErrorType")
5025
5026 var buff [1024]byte
5027 ringBuffer := smithyio.NewRingBuffer(buff[:])
5028
5029 body := io.TeeReader(errorBody, ringBuffer)
5030 decoder := json.NewDecoder(body)
5031 decoder.UseNumber()
5032 bodyInfo, err := getProtocolErrorInfo(decoder)
5033 if err != nil {
5034 var snapshot bytes.Buffer
5035 io.Copy(&snapshot, ringBuffer)
5036 err = &smithy.DeserializationError{
5037 Err: fmt.Errorf("failed to decode response body, %w", err),
5038 Snapshot: snapshot.Bytes(),
5039 }
5040 return err
5041 }
5042
5043 errorBody.Seek(0, io.SeekStart)
5044 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
5045 errorCode = restjson.SanitizeErrorCode(typ)
5046 }
5047 if len(bodyInfo.Message) != 0 {
5048 errorMessage = bodyInfo.Message
5049 }
5050 switch {
5051 case strings.EqualFold("AccessDeniedException", errorCode):
5052 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5053
5054 case strings.EqualFold("InvalidInputException", errorCode):
5055 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5056
5057 case strings.EqualFold("NotFoundException", errorCode):
5058 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
5059
5060 case strings.EqualFold("RegionSetupInProgressException", errorCode):
5061 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
5062
5063 case strings.EqualFold("ServiceException", errorCode):
5064 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5065
5066 case strings.EqualFold("UnauthenticatedException", errorCode):
5067 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
5068
5069 default:
5070 genericError := &smithy.GenericAPIError{
5071 Code: errorCode,
5072 Message: errorMessage,
5073 }
5074 return genericError
5075
5076 }
5077 }
5078
5079 type awsAwsjson11_deserializeOpDeleteContainerService struct {
5080 }
5081
5082 func (*awsAwsjson11_deserializeOpDeleteContainerService) ID() string {
5083 return "OperationDeserializer"
5084 }
5085
5086 func (m *awsAwsjson11_deserializeOpDeleteContainerService) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5087 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5088 ) {
5089 out, metadata, err = next.HandleDeserialize(ctx, in)
5090 if err != nil {
5091 return out, metadata, err
5092 }
5093
5094 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
5095 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
5096 defer endTimer()
5097 defer span.End()
5098 response, ok := out.RawResponse.(*smithyhttp.Response)
5099 if !ok {
5100 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5101 }
5102
5103 if response.StatusCode < 200 || response.StatusCode >= 300 {
5104 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteContainerService(response, &metadata)
5105 }
5106 output := &DeleteContainerServiceOutput{}
5107 out.Result = output
5108
5109 var buff [1024]byte
5110 ringBuffer := smithyio.NewRingBuffer(buff[:])
5111
5112 body := io.TeeReader(response.Body, ringBuffer)
5113 decoder := json.NewDecoder(body)
5114 decoder.UseNumber()
5115 var shape interface{}
5116 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5117 var snapshot bytes.Buffer
5118 io.Copy(&snapshot, ringBuffer)
5119 err = &smithy.DeserializationError{
5120 Err: fmt.Errorf("failed to decode response body, %w", err),
5121 Snapshot: snapshot.Bytes(),
5122 }
5123 return out, metadata, err
5124 }
5125
5126 err = awsAwsjson11_deserializeOpDocumentDeleteContainerServiceOutput(&output, shape)
5127 if err != nil {
5128 var snapshot bytes.Buffer
5129 io.Copy(&snapshot, ringBuffer)
5130 err = &smithy.DeserializationError{
5131 Err: fmt.Errorf("failed to decode response body, %w", err),
5132 Snapshot: snapshot.Bytes(),
5133 }
5134 return out, metadata, err
5135 }
5136
5137 return out, metadata, err
5138 }
5139
5140 func awsAwsjson11_deserializeOpErrorDeleteContainerService(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5141 var errorBuffer bytes.Buffer
5142 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5143 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5144 }
5145 errorBody := bytes.NewReader(errorBuffer.Bytes())
5146
5147 errorCode := "UnknownError"
5148 errorMessage := errorCode
5149
5150 headerCode := response.Header.Get("X-Amzn-ErrorType")
5151
5152 var buff [1024]byte
5153 ringBuffer := smithyio.NewRingBuffer(buff[:])
5154
5155 body := io.TeeReader(errorBody, ringBuffer)
5156 decoder := json.NewDecoder(body)
5157 decoder.UseNumber()
5158 bodyInfo, err := getProtocolErrorInfo(decoder)
5159 if err != nil {
5160 var snapshot bytes.Buffer
5161 io.Copy(&snapshot, ringBuffer)
5162 err = &smithy.DeserializationError{
5163 Err: fmt.Errorf("failed to decode response body, %w", err),
5164 Snapshot: snapshot.Bytes(),
5165 }
5166 return err
5167 }
5168
5169 errorBody.Seek(0, io.SeekStart)
5170 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
5171 errorCode = restjson.SanitizeErrorCode(typ)
5172 }
5173 if len(bodyInfo.Message) != 0 {
5174 errorMessage = bodyInfo.Message
5175 }
5176 switch {
5177 case strings.EqualFold("AccessDeniedException", errorCode):
5178 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5179
5180 case strings.EqualFold("InvalidInputException", errorCode):
5181 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5182
5183 case strings.EqualFold("NotFoundException", errorCode):
5184 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
5185
5186 case strings.EqualFold("RegionSetupInProgressException", errorCode):
5187 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
5188
5189 case strings.EqualFold("ServiceException", errorCode):
5190 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5191
5192 case strings.EqualFold("UnauthenticatedException", errorCode):
5193 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
5194
5195 default:
5196 genericError := &smithy.GenericAPIError{
5197 Code: errorCode,
5198 Message: errorMessage,
5199 }
5200 return genericError
5201
5202 }
5203 }
5204
5205 type awsAwsjson11_deserializeOpDeleteDisk struct {
5206 }
5207
5208 func (*awsAwsjson11_deserializeOpDeleteDisk) ID() string {
5209 return "OperationDeserializer"
5210 }
5211
5212 func (m *awsAwsjson11_deserializeOpDeleteDisk) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5213 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5214 ) {
5215 out, metadata, err = next.HandleDeserialize(ctx, in)
5216 if err != nil {
5217 return out, metadata, err
5218 }
5219
5220 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
5221 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
5222 defer endTimer()
5223 defer span.End()
5224 response, ok := out.RawResponse.(*smithyhttp.Response)
5225 if !ok {
5226 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5227 }
5228
5229 if response.StatusCode < 200 || response.StatusCode >= 300 {
5230 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDisk(response, &metadata)
5231 }
5232 output := &DeleteDiskOutput{}
5233 out.Result = output
5234
5235 var buff [1024]byte
5236 ringBuffer := smithyio.NewRingBuffer(buff[:])
5237
5238 body := io.TeeReader(response.Body, ringBuffer)
5239 decoder := json.NewDecoder(body)
5240 decoder.UseNumber()
5241 var shape interface{}
5242 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5243 var snapshot bytes.Buffer
5244 io.Copy(&snapshot, ringBuffer)
5245 err = &smithy.DeserializationError{
5246 Err: fmt.Errorf("failed to decode response body, %w", err),
5247 Snapshot: snapshot.Bytes(),
5248 }
5249 return out, metadata, err
5250 }
5251
5252 err = awsAwsjson11_deserializeOpDocumentDeleteDiskOutput(&output, shape)
5253 if err != nil {
5254 var snapshot bytes.Buffer
5255 io.Copy(&snapshot, ringBuffer)
5256 err = &smithy.DeserializationError{
5257 Err: fmt.Errorf("failed to decode response body, %w", err),
5258 Snapshot: snapshot.Bytes(),
5259 }
5260 return out, metadata, err
5261 }
5262
5263 return out, metadata, err
5264 }
5265
5266 func awsAwsjson11_deserializeOpErrorDeleteDisk(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5267 var errorBuffer bytes.Buffer
5268 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5269 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5270 }
5271 errorBody := bytes.NewReader(errorBuffer.Bytes())
5272
5273 errorCode := "UnknownError"
5274 errorMessage := errorCode
5275
5276 headerCode := response.Header.Get("X-Amzn-ErrorType")
5277
5278 var buff [1024]byte
5279 ringBuffer := smithyio.NewRingBuffer(buff[:])
5280
5281 body := io.TeeReader(errorBody, ringBuffer)
5282 decoder := json.NewDecoder(body)
5283 decoder.UseNumber()
5284 bodyInfo, err := getProtocolErrorInfo(decoder)
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 err
5293 }
5294
5295 errorBody.Seek(0, io.SeekStart)
5296 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
5297 errorCode = restjson.SanitizeErrorCode(typ)
5298 }
5299 if len(bodyInfo.Message) != 0 {
5300 errorMessage = bodyInfo.Message
5301 }
5302 switch {
5303 case strings.EqualFold("AccessDeniedException", errorCode):
5304 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5305
5306 case strings.EqualFold("AccountSetupInProgressException", errorCode):
5307 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
5308
5309 case strings.EqualFold("InvalidInputException", errorCode):
5310 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5311
5312 case strings.EqualFold("NotFoundException", errorCode):
5313 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
5314
5315 case strings.EqualFold("OperationFailureException", errorCode):
5316 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
5317
5318 case strings.EqualFold("RegionSetupInProgressException", errorCode):
5319 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
5320
5321 case strings.EqualFold("ServiceException", errorCode):
5322 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5323
5324 case strings.EqualFold("UnauthenticatedException", errorCode):
5325 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
5326
5327 default:
5328 genericError := &smithy.GenericAPIError{
5329 Code: errorCode,
5330 Message: errorMessage,
5331 }
5332 return genericError
5333
5334 }
5335 }
5336
5337 type awsAwsjson11_deserializeOpDeleteDiskSnapshot struct {
5338 }
5339
5340 func (*awsAwsjson11_deserializeOpDeleteDiskSnapshot) ID() string {
5341 return "OperationDeserializer"
5342 }
5343
5344 func (m *awsAwsjson11_deserializeOpDeleteDiskSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5345 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5346 ) {
5347 out, metadata, err = next.HandleDeserialize(ctx, in)
5348 if err != nil {
5349 return out, metadata, err
5350 }
5351
5352 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
5353 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
5354 defer endTimer()
5355 defer span.End()
5356 response, ok := out.RawResponse.(*smithyhttp.Response)
5357 if !ok {
5358 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5359 }
5360
5361 if response.StatusCode < 200 || response.StatusCode >= 300 {
5362 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDiskSnapshot(response, &metadata)
5363 }
5364 output := &DeleteDiskSnapshotOutput{}
5365 out.Result = output
5366
5367 var buff [1024]byte
5368 ringBuffer := smithyio.NewRingBuffer(buff[:])
5369
5370 body := io.TeeReader(response.Body, ringBuffer)
5371 decoder := json.NewDecoder(body)
5372 decoder.UseNumber()
5373 var shape interface{}
5374 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5375 var snapshot bytes.Buffer
5376 io.Copy(&snapshot, ringBuffer)
5377 err = &smithy.DeserializationError{
5378 Err: fmt.Errorf("failed to decode response body, %w", err),
5379 Snapshot: snapshot.Bytes(),
5380 }
5381 return out, metadata, err
5382 }
5383
5384 err = awsAwsjson11_deserializeOpDocumentDeleteDiskSnapshotOutput(&output, shape)
5385 if err != nil {
5386 var snapshot bytes.Buffer
5387 io.Copy(&snapshot, ringBuffer)
5388 err = &smithy.DeserializationError{
5389 Err: fmt.Errorf("failed to decode response body, %w", err),
5390 Snapshot: snapshot.Bytes(),
5391 }
5392 return out, metadata, err
5393 }
5394
5395 return out, metadata, err
5396 }
5397
5398 func awsAwsjson11_deserializeOpErrorDeleteDiskSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5399 var errorBuffer bytes.Buffer
5400 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5401 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5402 }
5403 errorBody := bytes.NewReader(errorBuffer.Bytes())
5404
5405 errorCode := "UnknownError"
5406 errorMessage := errorCode
5407
5408 headerCode := response.Header.Get("X-Amzn-ErrorType")
5409
5410 var buff [1024]byte
5411 ringBuffer := smithyio.NewRingBuffer(buff[:])
5412
5413 body := io.TeeReader(errorBody, ringBuffer)
5414 decoder := json.NewDecoder(body)
5415 decoder.UseNumber()
5416 bodyInfo, err := getProtocolErrorInfo(decoder)
5417 if err != nil {
5418 var snapshot bytes.Buffer
5419 io.Copy(&snapshot, ringBuffer)
5420 err = &smithy.DeserializationError{
5421 Err: fmt.Errorf("failed to decode response body, %w", err),
5422 Snapshot: snapshot.Bytes(),
5423 }
5424 return err
5425 }
5426
5427 errorBody.Seek(0, io.SeekStart)
5428 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
5429 errorCode = restjson.SanitizeErrorCode(typ)
5430 }
5431 if len(bodyInfo.Message) != 0 {
5432 errorMessage = bodyInfo.Message
5433 }
5434 switch {
5435 case strings.EqualFold("AccessDeniedException", errorCode):
5436 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5437
5438 case strings.EqualFold("AccountSetupInProgressException", errorCode):
5439 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
5440
5441 case strings.EqualFold("InvalidInputException", errorCode):
5442 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5443
5444 case strings.EqualFold("NotFoundException", errorCode):
5445 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
5446
5447 case strings.EqualFold("OperationFailureException", errorCode):
5448 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
5449
5450 case strings.EqualFold("RegionSetupInProgressException", errorCode):
5451 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
5452
5453 case strings.EqualFold("ServiceException", errorCode):
5454 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5455
5456 case strings.EqualFold("UnauthenticatedException", errorCode):
5457 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
5458
5459 default:
5460 genericError := &smithy.GenericAPIError{
5461 Code: errorCode,
5462 Message: errorMessage,
5463 }
5464 return genericError
5465
5466 }
5467 }
5468
5469 type awsAwsjson11_deserializeOpDeleteDistribution struct {
5470 }
5471
5472 func (*awsAwsjson11_deserializeOpDeleteDistribution) ID() string {
5473 return "OperationDeserializer"
5474 }
5475
5476 func (m *awsAwsjson11_deserializeOpDeleteDistribution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5477 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5478 ) {
5479 out, metadata, err = next.HandleDeserialize(ctx, in)
5480 if err != nil {
5481 return out, metadata, err
5482 }
5483
5484 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
5485 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
5486 defer endTimer()
5487 defer span.End()
5488 response, ok := out.RawResponse.(*smithyhttp.Response)
5489 if !ok {
5490 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5491 }
5492
5493 if response.StatusCode < 200 || response.StatusCode >= 300 {
5494 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDistribution(response, &metadata)
5495 }
5496 output := &DeleteDistributionOutput{}
5497 out.Result = output
5498
5499 var buff [1024]byte
5500 ringBuffer := smithyio.NewRingBuffer(buff[:])
5501
5502 body := io.TeeReader(response.Body, ringBuffer)
5503 decoder := json.NewDecoder(body)
5504 decoder.UseNumber()
5505 var shape interface{}
5506 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5507 var snapshot bytes.Buffer
5508 io.Copy(&snapshot, ringBuffer)
5509 err = &smithy.DeserializationError{
5510 Err: fmt.Errorf("failed to decode response body, %w", err),
5511 Snapshot: snapshot.Bytes(),
5512 }
5513 return out, metadata, err
5514 }
5515
5516 err = awsAwsjson11_deserializeOpDocumentDeleteDistributionOutput(&output, shape)
5517 if err != nil {
5518 var snapshot bytes.Buffer
5519 io.Copy(&snapshot, ringBuffer)
5520 err = &smithy.DeserializationError{
5521 Err: fmt.Errorf("failed to decode response body, %w", err),
5522 Snapshot: snapshot.Bytes(),
5523 }
5524 return out, metadata, err
5525 }
5526
5527 return out, metadata, err
5528 }
5529
5530 func awsAwsjson11_deserializeOpErrorDeleteDistribution(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5531 var errorBuffer bytes.Buffer
5532 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5533 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5534 }
5535 errorBody := bytes.NewReader(errorBuffer.Bytes())
5536
5537 errorCode := "UnknownError"
5538 errorMessage := errorCode
5539
5540 headerCode := response.Header.Get("X-Amzn-ErrorType")
5541
5542 var buff [1024]byte
5543 ringBuffer := smithyio.NewRingBuffer(buff[:])
5544
5545 body := io.TeeReader(errorBody, ringBuffer)
5546 decoder := json.NewDecoder(body)
5547 decoder.UseNumber()
5548 bodyInfo, err := getProtocolErrorInfo(decoder)
5549 if err != nil {
5550 var snapshot bytes.Buffer
5551 io.Copy(&snapshot, ringBuffer)
5552 err = &smithy.DeserializationError{
5553 Err: fmt.Errorf("failed to decode response body, %w", err),
5554 Snapshot: snapshot.Bytes(),
5555 }
5556 return err
5557 }
5558
5559 errorBody.Seek(0, io.SeekStart)
5560 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
5561 errorCode = restjson.SanitizeErrorCode(typ)
5562 }
5563 if len(bodyInfo.Message) != 0 {
5564 errorMessage = bodyInfo.Message
5565 }
5566 switch {
5567 case strings.EqualFold("AccessDeniedException", errorCode):
5568 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5569
5570 case strings.EqualFold("InvalidInputException", errorCode):
5571 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5572
5573 case strings.EqualFold("NotFoundException", errorCode):
5574 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
5575
5576 case strings.EqualFold("OperationFailureException", errorCode):
5577 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
5578
5579 case strings.EqualFold("ServiceException", errorCode):
5580 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5581
5582 case strings.EqualFold("UnauthenticatedException", errorCode):
5583 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
5584
5585 default:
5586 genericError := &smithy.GenericAPIError{
5587 Code: errorCode,
5588 Message: errorMessage,
5589 }
5590 return genericError
5591
5592 }
5593 }
5594
5595 type awsAwsjson11_deserializeOpDeleteDomain struct {
5596 }
5597
5598 func (*awsAwsjson11_deserializeOpDeleteDomain) ID() string {
5599 return "OperationDeserializer"
5600 }
5601
5602 func (m *awsAwsjson11_deserializeOpDeleteDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5603 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5604 ) {
5605 out, metadata, err = next.HandleDeserialize(ctx, in)
5606 if err != nil {
5607 return out, metadata, err
5608 }
5609
5610 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
5611 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
5612 defer endTimer()
5613 defer span.End()
5614 response, ok := out.RawResponse.(*smithyhttp.Response)
5615 if !ok {
5616 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5617 }
5618
5619 if response.StatusCode < 200 || response.StatusCode >= 300 {
5620 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDomain(response, &metadata)
5621 }
5622 output := &DeleteDomainOutput{}
5623 out.Result = output
5624
5625 var buff [1024]byte
5626 ringBuffer := smithyio.NewRingBuffer(buff[:])
5627
5628 body := io.TeeReader(response.Body, ringBuffer)
5629 decoder := json.NewDecoder(body)
5630 decoder.UseNumber()
5631 var shape interface{}
5632 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5633 var snapshot bytes.Buffer
5634 io.Copy(&snapshot, ringBuffer)
5635 err = &smithy.DeserializationError{
5636 Err: fmt.Errorf("failed to decode response body, %w", err),
5637 Snapshot: snapshot.Bytes(),
5638 }
5639 return out, metadata, err
5640 }
5641
5642 err = awsAwsjson11_deserializeOpDocumentDeleteDomainOutput(&output, shape)
5643 if err != nil {
5644 var snapshot bytes.Buffer
5645 io.Copy(&snapshot, ringBuffer)
5646 err = &smithy.DeserializationError{
5647 Err: fmt.Errorf("failed to decode response body, %w", err),
5648 Snapshot: snapshot.Bytes(),
5649 }
5650 return out, metadata, err
5651 }
5652
5653 return out, metadata, err
5654 }
5655
5656 func awsAwsjson11_deserializeOpErrorDeleteDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5657 var errorBuffer bytes.Buffer
5658 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5659 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5660 }
5661 errorBody := bytes.NewReader(errorBuffer.Bytes())
5662
5663 errorCode := "UnknownError"
5664 errorMessage := errorCode
5665
5666 headerCode := response.Header.Get("X-Amzn-ErrorType")
5667
5668 var buff [1024]byte
5669 ringBuffer := smithyio.NewRingBuffer(buff[:])
5670
5671 body := io.TeeReader(errorBody, ringBuffer)
5672 decoder := json.NewDecoder(body)
5673 decoder.UseNumber()
5674 bodyInfo, err := getProtocolErrorInfo(decoder)
5675 if err != nil {
5676 var snapshot bytes.Buffer
5677 io.Copy(&snapshot, ringBuffer)
5678 err = &smithy.DeserializationError{
5679 Err: fmt.Errorf("failed to decode response body, %w", err),
5680 Snapshot: snapshot.Bytes(),
5681 }
5682 return err
5683 }
5684
5685 errorBody.Seek(0, io.SeekStart)
5686 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
5687 errorCode = restjson.SanitizeErrorCode(typ)
5688 }
5689 if len(bodyInfo.Message) != 0 {
5690 errorMessage = bodyInfo.Message
5691 }
5692 switch {
5693 case strings.EqualFold("AccessDeniedException", errorCode):
5694 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5695
5696 case strings.EqualFold("AccountSetupInProgressException", errorCode):
5697 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
5698
5699 case strings.EqualFold("InvalidInputException", errorCode):
5700 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5701
5702 case strings.EqualFold("NotFoundException", errorCode):
5703 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
5704
5705 case strings.EqualFold("OperationFailureException", errorCode):
5706 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
5707
5708 case strings.EqualFold("RegionSetupInProgressException", errorCode):
5709 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
5710
5711 case strings.EqualFold("ServiceException", errorCode):
5712 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5713
5714 case strings.EqualFold("UnauthenticatedException", errorCode):
5715 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
5716
5717 default:
5718 genericError := &smithy.GenericAPIError{
5719 Code: errorCode,
5720 Message: errorMessage,
5721 }
5722 return genericError
5723
5724 }
5725 }
5726
5727 type awsAwsjson11_deserializeOpDeleteDomainEntry struct {
5728 }
5729
5730 func (*awsAwsjson11_deserializeOpDeleteDomainEntry) ID() string {
5731 return "OperationDeserializer"
5732 }
5733
5734 func (m *awsAwsjson11_deserializeOpDeleteDomainEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5735 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5736 ) {
5737 out, metadata, err = next.HandleDeserialize(ctx, in)
5738 if err != nil {
5739 return out, metadata, err
5740 }
5741
5742 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
5743 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
5744 defer endTimer()
5745 defer span.End()
5746 response, ok := out.RawResponse.(*smithyhttp.Response)
5747 if !ok {
5748 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5749 }
5750
5751 if response.StatusCode < 200 || response.StatusCode >= 300 {
5752 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDomainEntry(response, &metadata)
5753 }
5754 output := &DeleteDomainEntryOutput{}
5755 out.Result = output
5756
5757 var buff [1024]byte
5758 ringBuffer := smithyio.NewRingBuffer(buff[:])
5759
5760 body := io.TeeReader(response.Body, ringBuffer)
5761 decoder := json.NewDecoder(body)
5762 decoder.UseNumber()
5763 var shape interface{}
5764 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5765 var snapshot bytes.Buffer
5766 io.Copy(&snapshot, ringBuffer)
5767 err = &smithy.DeserializationError{
5768 Err: fmt.Errorf("failed to decode response body, %w", err),
5769 Snapshot: snapshot.Bytes(),
5770 }
5771 return out, metadata, err
5772 }
5773
5774 err = awsAwsjson11_deserializeOpDocumentDeleteDomainEntryOutput(&output, shape)
5775 if err != nil {
5776 var snapshot bytes.Buffer
5777 io.Copy(&snapshot, ringBuffer)
5778 err = &smithy.DeserializationError{
5779 Err: fmt.Errorf("failed to decode response body, %w", err),
5780 Snapshot: snapshot.Bytes(),
5781 }
5782 return out, metadata, err
5783 }
5784
5785 return out, metadata, err
5786 }
5787
5788 func awsAwsjson11_deserializeOpErrorDeleteDomainEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5789 var errorBuffer bytes.Buffer
5790 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5791 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5792 }
5793 errorBody := bytes.NewReader(errorBuffer.Bytes())
5794
5795 errorCode := "UnknownError"
5796 errorMessage := errorCode
5797
5798 headerCode := response.Header.Get("X-Amzn-ErrorType")
5799
5800 var buff [1024]byte
5801 ringBuffer := smithyio.NewRingBuffer(buff[:])
5802
5803 body := io.TeeReader(errorBody, ringBuffer)
5804 decoder := json.NewDecoder(body)
5805 decoder.UseNumber()
5806 bodyInfo, err := getProtocolErrorInfo(decoder)
5807 if err != nil {
5808 var snapshot bytes.Buffer
5809 io.Copy(&snapshot, ringBuffer)
5810 err = &smithy.DeserializationError{
5811 Err: fmt.Errorf("failed to decode response body, %w", err),
5812 Snapshot: snapshot.Bytes(),
5813 }
5814 return err
5815 }
5816
5817 errorBody.Seek(0, io.SeekStart)
5818 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
5819 errorCode = restjson.SanitizeErrorCode(typ)
5820 }
5821 if len(bodyInfo.Message) != 0 {
5822 errorMessage = bodyInfo.Message
5823 }
5824 switch {
5825 case strings.EqualFold("AccessDeniedException", errorCode):
5826 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5827
5828 case strings.EqualFold("AccountSetupInProgressException", errorCode):
5829 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
5830
5831 case strings.EqualFold("InvalidInputException", errorCode):
5832 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5833
5834 case strings.EqualFold("NotFoundException", errorCode):
5835 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
5836
5837 case strings.EqualFold("OperationFailureException", errorCode):
5838 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
5839
5840 case strings.EqualFold("RegionSetupInProgressException", errorCode):
5841 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
5842
5843 case strings.EqualFold("ServiceException", errorCode):
5844 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5845
5846 case strings.EqualFold("UnauthenticatedException", errorCode):
5847 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
5848
5849 default:
5850 genericError := &smithy.GenericAPIError{
5851 Code: errorCode,
5852 Message: errorMessage,
5853 }
5854 return genericError
5855
5856 }
5857 }
5858
5859 type awsAwsjson11_deserializeOpDeleteInstance struct {
5860 }
5861
5862 func (*awsAwsjson11_deserializeOpDeleteInstance) ID() string {
5863 return "OperationDeserializer"
5864 }
5865
5866 func (m *awsAwsjson11_deserializeOpDeleteInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5867 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5868 ) {
5869 out, metadata, err = next.HandleDeserialize(ctx, in)
5870 if err != nil {
5871 return out, metadata, err
5872 }
5873
5874 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
5875 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
5876 defer endTimer()
5877 defer span.End()
5878 response, ok := out.RawResponse.(*smithyhttp.Response)
5879 if !ok {
5880 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5881 }
5882
5883 if response.StatusCode < 200 || response.StatusCode >= 300 {
5884 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteInstance(response, &metadata)
5885 }
5886 output := &DeleteInstanceOutput{}
5887 out.Result = output
5888
5889 var buff [1024]byte
5890 ringBuffer := smithyio.NewRingBuffer(buff[:])
5891
5892 body := io.TeeReader(response.Body, ringBuffer)
5893 decoder := json.NewDecoder(body)
5894 decoder.UseNumber()
5895 var shape interface{}
5896 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5897 var snapshot bytes.Buffer
5898 io.Copy(&snapshot, ringBuffer)
5899 err = &smithy.DeserializationError{
5900 Err: fmt.Errorf("failed to decode response body, %w", err),
5901 Snapshot: snapshot.Bytes(),
5902 }
5903 return out, metadata, err
5904 }
5905
5906 err = awsAwsjson11_deserializeOpDocumentDeleteInstanceOutput(&output, shape)
5907 if err != nil {
5908 var snapshot bytes.Buffer
5909 io.Copy(&snapshot, ringBuffer)
5910 err = &smithy.DeserializationError{
5911 Err: fmt.Errorf("failed to decode response body, %w", err),
5912 Snapshot: snapshot.Bytes(),
5913 }
5914 return out, metadata, err
5915 }
5916
5917 return out, metadata, err
5918 }
5919
5920 func awsAwsjson11_deserializeOpErrorDeleteInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5921 var errorBuffer bytes.Buffer
5922 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5923 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5924 }
5925 errorBody := bytes.NewReader(errorBuffer.Bytes())
5926
5927 errorCode := "UnknownError"
5928 errorMessage := errorCode
5929
5930 headerCode := response.Header.Get("X-Amzn-ErrorType")
5931
5932 var buff [1024]byte
5933 ringBuffer := smithyio.NewRingBuffer(buff[:])
5934
5935 body := io.TeeReader(errorBody, ringBuffer)
5936 decoder := json.NewDecoder(body)
5937 decoder.UseNumber()
5938 bodyInfo, err := getProtocolErrorInfo(decoder)
5939 if err != nil {
5940 var snapshot bytes.Buffer
5941 io.Copy(&snapshot, ringBuffer)
5942 err = &smithy.DeserializationError{
5943 Err: fmt.Errorf("failed to decode response body, %w", err),
5944 Snapshot: snapshot.Bytes(),
5945 }
5946 return err
5947 }
5948
5949 errorBody.Seek(0, io.SeekStart)
5950 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
5951 errorCode = restjson.SanitizeErrorCode(typ)
5952 }
5953 if len(bodyInfo.Message) != 0 {
5954 errorMessage = bodyInfo.Message
5955 }
5956 switch {
5957 case strings.EqualFold("AccessDeniedException", errorCode):
5958 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5959
5960 case strings.EqualFold("AccountSetupInProgressException", errorCode):
5961 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
5962
5963 case strings.EqualFold("InvalidInputException", errorCode):
5964 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5965
5966 case strings.EqualFold("NotFoundException", errorCode):
5967 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
5968
5969 case strings.EqualFold("OperationFailureException", errorCode):
5970 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
5971
5972 case strings.EqualFold("RegionSetupInProgressException", errorCode):
5973 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
5974
5975 case strings.EqualFold("ServiceException", errorCode):
5976 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5977
5978 case strings.EqualFold("UnauthenticatedException", errorCode):
5979 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
5980
5981 default:
5982 genericError := &smithy.GenericAPIError{
5983 Code: errorCode,
5984 Message: errorMessage,
5985 }
5986 return genericError
5987
5988 }
5989 }
5990
5991 type awsAwsjson11_deserializeOpDeleteInstanceSnapshot struct {
5992 }
5993
5994 func (*awsAwsjson11_deserializeOpDeleteInstanceSnapshot) ID() string {
5995 return "OperationDeserializer"
5996 }
5997
5998 func (m *awsAwsjson11_deserializeOpDeleteInstanceSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5999 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6000 ) {
6001 out, metadata, err = next.HandleDeserialize(ctx, in)
6002 if err != nil {
6003 return out, metadata, err
6004 }
6005
6006 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
6007 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
6008 defer endTimer()
6009 defer span.End()
6010 response, ok := out.RawResponse.(*smithyhttp.Response)
6011 if !ok {
6012 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6013 }
6014
6015 if response.StatusCode < 200 || response.StatusCode >= 300 {
6016 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteInstanceSnapshot(response, &metadata)
6017 }
6018 output := &DeleteInstanceSnapshotOutput{}
6019 out.Result = output
6020
6021 var buff [1024]byte
6022 ringBuffer := smithyio.NewRingBuffer(buff[:])
6023
6024 body := io.TeeReader(response.Body, ringBuffer)
6025 decoder := json.NewDecoder(body)
6026 decoder.UseNumber()
6027 var shape interface{}
6028 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6029 var snapshot bytes.Buffer
6030 io.Copy(&snapshot, ringBuffer)
6031 err = &smithy.DeserializationError{
6032 Err: fmt.Errorf("failed to decode response body, %w", err),
6033 Snapshot: snapshot.Bytes(),
6034 }
6035 return out, metadata, err
6036 }
6037
6038 err = awsAwsjson11_deserializeOpDocumentDeleteInstanceSnapshotOutput(&output, shape)
6039 if err != nil {
6040 var snapshot bytes.Buffer
6041 io.Copy(&snapshot, ringBuffer)
6042 err = &smithy.DeserializationError{
6043 Err: fmt.Errorf("failed to decode response body, %w", err),
6044 Snapshot: snapshot.Bytes(),
6045 }
6046 return out, metadata, err
6047 }
6048
6049 return out, metadata, err
6050 }
6051
6052 func awsAwsjson11_deserializeOpErrorDeleteInstanceSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6053 var errorBuffer bytes.Buffer
6054 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6055 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6056 }
6057 errorBody := bytes.NewReader(errorBuffer.Bytes())
6058
6059 errorCode := "UnknownError"
6060 errorMessage := errorCode
6061
6062 headerCode := response.Header.Get("X-Amzn-ErrorType")
6063
6064 var buff [1024]byte
6065 ringBuffer := smithyio.NewRingBuffer(buff[:])
6066
6067 body := io.TeeReader(errorBody, ringBuffer)
6068 decoder := json.NewDecoder(body)
6069 decoder.UseNumber()
6070 bodyInfo, err := getProtocolErrorInfo(decoder)
6071 if err != nil {
6072 var snapshot bytes.Buffer
6073 io.Copy(&snapshot, ringBuffer)
6074 err = &smithy.DeserializationError{
6075 Err: fmt.Errorf("failed to decode response body, %w", err),
6076 Snapshot: snapshot.Bytes(),
6077 }
6078 return err
6079 }
6080
6081 errorBody.Seek(0, io.SeekStart)
6082 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
6083 errorCode = restjson.SanitizeErrorCode(typ)
6084 }
6085 if len(bodyInfo.Message) != 0 {
6086 errorMessage = bodyInfo.Message
6087 }
6088 switch {
6089 case strings.EqualFold("AccessDeniedException", errorCode):
6090 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6091
6092 case strings.EqualFold("AccountSetupInProgressException", errorCode):
6093 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
6094
6095 case strings.EqualFold("InvalidInputException", errorCode):
6096 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
6097
6098 case strings.EqualFold("NotFoundException", errorCode):
6099 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
6100
6101 case strings.EqualFold("OperationFailureException", errorCode):
6102 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
6103
6104 case strings.EqualFold("RegionSetupInProgressException", errorCode):
6105 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
6106
6107 case strings.EqualFold("ServiceException", errorCode):
6108 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
6109
6110 case strings.EqualFold("UnauthenticatedException", errorCode):
6111 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
6112
6113 default:
6114 genericError := &smithy.GenericAPIError{
6115 Code: errorCode,
6116 Message: errorMessage,
6117 }
6118 return genericError
6119
6120 }
6121 }
6122
6123 type awsAwsjson11_deserializeOpDeleteKeyPair struct {
6124 }
6125
6126 func (*awsAwsjson11_deserializeOpDeleteKeyPair) ID() string {
6127 return "OperationDeserializer"
6128 }
6129
6130 func (m *awsAwsjson11_deserializeOpDeleteKeyPair) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6131 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6132 ) {
6133 out, metadata, err = next.HandleDeserialize(ctx, in)
6134 if err != nil {
6135 return out, metadata, err
6136 }
6137
6138 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
6139 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
6140 defer endTimer()
6141 defer span.End()
6142 response, ok := out.RawResponse.(*smithyhttp.Response)
6143 if !ok {
6144 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6145 }
6146
6147 if response.StatusCode < 200 || response.StatusCode >= 300 {
6148 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteKeyPair(response, &metadata)
6149 }
6150 output := &DeleteKeyPairOutput{}
6151 out.Result = output
6152
6153 var buff [1024]byte
6154 ringBuffer := smithyio.NewRingBuffer(buff[:])
6155
6156 body := io.TeeReader(response.Body, ringBuffer)
6157 decoder := json.NewDecoder(body)
6158 decoder.UseNumber()
6159 var shape interface{}
6160 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6161 var snapshot bytes.Buffer
6162 io.Copy(&snapshot, ringBuffer)
6163 err = &smithy.DeserializationError{
6164 Err: fmt.Errorf("failed to decode response body, %w", err),
6165 Snapshot: snapshot.Bytes(),
6166 }
6167 return out, metadata, err
6168 }
6169
6170 err = awsAwsjson11_deserializeOpDocumentDeleteKeyPairOutput(&output, shape)
6171 if err != nil {
6172 var snapshot bytes.Buffer
6173 io.Copy(&snapshot, ringBuffer)
6174 err = &smithy.DeserializationError{
6175 Err: fmt.Errorf("failed to decode response body, %w", err),
6176 Snapshot: snapshot.Bytes(),
6177 }
6178 return out, metadata, err
6179 }
6180
6181 return out, metadata, err
6182 }
6183
6184 func awsAwsjson11_deserializeOpErrorDeleteKeyPair(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6185 var errorBuffer bytes.Buffer
6186 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6187 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6188 }
6189 errorBody := bytes.NewReader(errorBuffer.Bytes())
6190
6191 errorCode := "UnknownError"
6192 errorMessage := errorCode
6193
6194 headerCode := response.Header.Get("X-Amzn-ErrorType")
6195
6196 var buff [1024]byte
6197 ringBuffer := smithyio.NewRingBuffer(buff[:])
6198
6199 body := io.TeeReader(errorBody, ringBuffer)
6200 decoder := json.NewDecoder(body)
6201 decoder.UseNumber()
6202 bodyInfo, err := getProtocolErrorInfo(decoder)
6203 if err != nil {
6204 var snapshot bytes.Buffer
6205 io.Copy(&snapshot, ringBuffer)
6206 err = &smithy.DeserializationError{
6207 Err: fmt.Errorf("failed to decode response body, %w", err),
6208 Snapshot: snapshot.Bytes(),
6209 }
6210 return err
6211 }
6212
6213 errorBody.Seek(0, io.SeekStart)
6214 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
6215 errorCode = restjson.SanitizeErrorCode(typ)
6216 }
6217 if len(bodyInfo.Message) != 0 {
6218 errorMessage = bodyInfo.Message
6219 }
6220 switch {
6221 case strings.EqualFold("AccessDeniedException", errorCode):
6222 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6223
6224 case strings.EqualFold("AccountSetupInProgressException", errorCode):
6225 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
6226
6227 case strings.EqualFold("InvalidInputException", errorCode):
6228 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
6229
6230 case strings.EqualFold("NotFoundException", errorCode):
6231 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
6232
6233 case strings.EqualFold("OperationFailureException", errorCode):
6234 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
6235
6236 case strings.EqualFold("RegionSetupInProgressException", errorCode):
6237 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
6238
6239 case strings.EqualFold("ServiceException", errorCode):
6240 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
6241
6242 case strings.EqualFold("UnauthenticatedException", errorCode):
6243 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
6244
6245 default:
6246 genericError := &smithy.GenericAPIError{
6247 Code: errorCode,
6248 Message: errorMessage,
6249 }
6250 return genericError
6251
6252 }
6253 }
6254
6255 type awsAwsjson11_deserializeOpDeleteKnownHostKeys struct {
6256 }
6257
6258 func (*awsAwsjson11_deserializeOpDeleteKnownHostKeys) ID() string {
6259 return "OperationDeserializer"
6260 }
6261
6262 func (m *awsAwsjson11_deserializeOpDeleteKnownHostKeys) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6263 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6264 ) {
6265 out, metadata, err = next.HandleDeserialize(ctx, in)
6266 if err != nil {
6267 return out, metadata, err
6268 }
6269
6270 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
6271 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
6272 defer endTimer()
6273 defer span.End()
6274 response, ok := out.RawResponse.(*smithyhttp.Response)
6275 if !ok {
6276 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6277 }
6278
6279 if response.StatusCode < 200 || response.StatusCode >= 300 {
6280 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteKnownHostKeys(response, &metadata)
6281 }
6282 output := &DeleteKnownHostKeysOutput{}
6283 out.Result = output
6284
6285 var buff [1024]byte
6286 ringBuffer := smithyio.NewRingBuffer(buff[:])
6287
6288 body := io.TeeReader(response.Body, ringBuffer)
6289 decoder := json.NewDecoder(body)
6290 decoder.UseNumber()
6291 var shape interface{}
6292 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6293 var snapshot bytes.Buffer
6294 io.Copy(&snapshot, ringBuffer)
6295 err = &smithy.DeserializationError{
6296 Err: fmt.Errorf("failed to decode response body, %w", err),
6297 Snapshot: snapshot.Bytes(),
6298 }
6299 return out, metadata, err
6300 }
6301
6302 err = awsAwsjson11_deserializeOpDocumentDeleteKnownHostKeysOutput(&output, shape)
6303 if err != nil {
6304 var snapshot bytes.Buffer
6305 io.Copy(&snapshot, ringBuffer)
6306 err = &smithy.DeserializationError{
6307 Err: fmt.Errorf("failed to decode response body, %w", err),
6308 Snapshot: snapshot.Bytes(),
6309 }
6310 return out, metadata, err
6311 }
6312
6313 return out, metadata, err
6314 }
6315
6316 func awsAwsjson11_deserializeOpErrorDeleteKnownHostKeys(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6317 var errorBuffer bytes.Buffer
6318 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6319 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6320 }
6321 errorBody := bytes.NewReader(errorBuffer.Bytes())
6322
6323 errorCode := "UnknownError"
6324 errorMessage := errorCode
6325
6326 headerCode := response.Header.Get("X-Amzn-ErrorType")
6327
6328 var buff [1024]byte
6329 ringBuffer := smithyio.NewRingBuffer(buff[:])
6330
6331 body := io.TeeReader(errorBody, ringBuffer)
6332 decoder := json.NewDecoder(body)
6333 decoder.UseNumber()
6334 bodyInfo, err := getProtocolErrorInfo(decoder)
6335 if err != nil {
6336 var snapshot bytes.Buffer
6337 io.Copy(&snapshot, ringBuffer)
6338 err = &smithy.DeserializationError{
6339 Err: fmt.Errorf("failed to decode response body, %w", err),
6340 Snapshot: snapshot.Bytes(),
6341 }
6342 return err
6343 }
6344
6345 errorBody.Seek(0, io.SeekStart)
6346 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
6347 errorCode = restjson.SanitizeErrorCode(typ)
6348 }
6349 if len(bodyInfo.Message) != 0 {
6350 errorMessage = bodyInfo.Message
6351 }
6352 switch {
6353 case strings.EqualFold("AccessDeniedException", errorCode):
6354 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6355
6356 case strings.EqualFold("AccountSetupInProgressException", errorCode):
6357 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
6358
6359 case strings.EqualFold("InvalidInputException", errorCode):
6360 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
6361
6362 case strings.EqualFold("NotFoundException", errorCode):
6363 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
6364
6365 case strings.EqualFold("OperationFailureException", errorCode):
6366 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
6367
6368 case strings.EqualFold("RegionSetupInProgressException", errorCode):
6369 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
6370
6371 case strings.EqualFold("ServiceException", errorCode):
6372 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
6373
6374 case strings.EqualFold("UnauthenticatedException", errorCode):
6375 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
6376
6377 default:
6378 genericError := &smithy.GenericAPIError{
6379 Code: errorCode,
6380 Message: errorMessage,
6381 }
6382 return genericError
6383
6384 }
6385 }
6386
6387 type awsAwsjson11_deserializeOpDeleteLoadBalancer struct {
6388 }
6389
6390 func (*awsAwsjson11_deserializeOpDeleteLoadBalancer) ID() string {
6391 return "OperationDeserializer"
6392 }
6393
6394 func (m *awsAwsjson11_deserializeOpDeleteLoadBalancer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6395 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6396 ) {
6397 out, metadata, err = next.HandleDeserialize(ctx, in)
6398 if err != nil {
6399 return out, metadata, err
6400 }
6401
6402 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
6403 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
6404 defer endTimer()
6405 defer span.End()
6406 response, ok := out.RawResponse.(*smithyhttp.Response)
6407 if !ok {
6408 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6409 }
6410
6411 if response.StatusCode < 200 || response.StatusCode >= 300 {
6412 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteLoadBalancer(response, &metadata)
6413 }
6414 output := &DeleteLoadBalancerOutput{}
6415 out.Result = output
6416
6417 var buff [1024]byte
6418 ringBuffer := smithyio.NewRingBuffer(buff[:])
6419
6420 body := io.TeeReader(response.Body, ringBuffer)
6421 decoder := json.NewDecoder(body)
6422 decoder.UseNumber()
6423 var shape interface{}
6424 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6425 var snapshot bytes.Buffer
6426 io.Copy(&snapshot, ringBuffer)
6427 err = &smithy.DeserializationError{
6428 Err: fmt.Errorf("failed to decode response body, %w", err),
6429 Snapshot: snapshot.Bytes(),
6430 }
6431 return out, metadata, err
6432 }
6433
6434 err = awsAwsjson11_deserializeOpDocumentDeleteLoadBalancerOutput(&output, shape)
6435 if err != nil {
6436 var snapshot bytes.Buffer
6437 io.Copy(&snapshot, ringBuffer)
6438 err = &smithy.DeserializationError{
6439 Err: fmt.Errorf("failed to decode response body, %w", err),
6440 Snapshot: snapshot.Bytes(),
6441 }
6442 return out, metadata, err
6443 }
6444
6445 return out, metadata, err
6446 }
6447
6448 func awsAwsjson11_deserializeOpErrorDeleteLoadBalancer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6449 var errorBuffer bytes.Buffer
6450 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6451 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6452 }
6453 errorBody := bytes.NewReader(errorBuffer.Bytes())
6454
6455 errorCode := "UnknownError"
6456 errorMessage := errorCode
6457
6458 headerCode := response.Header.Get("X-Amzn-ErrorType")
6459
6460 var buff [1024]byte
6461 ringBuffer := smithyio.NewRingBuffer(buff[:])
6462
6463 body := io.TeeReader(errorBody, ringBuffer)
6464 decoder := json.NewDecoder(body)
6465 decoder.UseNumber()
6466 bodyInfo, err := getProtocolErrorInfo(decoder)
6467 if err != nil {
6468 var snapshot bytes.Buffer
6469 io.Copy(&snapshot, ringBuffer)
6470 err = &smithy.DeserializationError{
6471 Err: fmt.Errorf("failed to decode response body, %w", err),
6472 Snapshot: snapshot.Bytes(),
6473 }
6474 return err
6475 }
6476
6477 errorBody.Seek(0, io.SeekStart)
6478 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
6479 errorCode = restjson.SanitizeErrorCode(typ)
6480 }
6481 if len(bodyInfo.Message) != 0 {
6482 errorMessage = bodyInfo.Message
6483 }
6484 switch {
6485 case strings.EqualFold("AccessDeniedException", errorCode):
6486 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6487
6488 case strings.EqualFold("AccountSetupInProgressException", errorCode):
6489 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
6490
6491 case strings.EqualFold("InvalidInputException", errorCode):
6492 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
6493
6494 case strings.EqualFold("NotFoundException", errorCode):
6495 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
6496
6497 case strings.EqualFold("OperationFailureException", errorCode):
6498 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
6499
6500 case strings.EqualFold("RegionSetupInProgressException", errorCode):
6501 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
6502
6503 case strings.EqualFold("ServiceException", errorCode):
6504 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
6505
6506 case strings.EqualFold("UnauthenticatedException", errorCode):
6507 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
6508
6509 default:
6510 genericError := &smithy.GenericAPIError{
6511 Code: errorCode,
6512 Message: errorMessage,
6513 }
6514 return genericError
6515
6516 }
6517 }
6518
6519 type awsAwsjson11_deserializeOpDeleteLoadBalancerTlsCertificate struct {
6520 }
6521
6522 func (*awsAwsjson11_deserializeOpDeleteLoadBalancerTlsCertificate) ID() string {
6523 return "OperationDeserializer"
6524 }
6525
6526 func (m *awsAwsjson11_deserializeOpDeleteLoadBalancerTlsCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6527 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6528 ) {
6529 out, metadata, err = next.HandleDeserialize(ctx, in)
6530 if err != nil {
6531 return out, metadata, err
6532 }
6533
6534 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
6535 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
6536 defer endTimer()
6537 defer span.End()
6538 response, ok := out.RawResponse.(*smithyhttp.Response)
6539 if !ok {
6540 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6541 }
6542
6543 if response.StatusCode < 200 || response.StatusCode >= 300 {
6544 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteLoadBalancerTlsCertificate(response, &metadata)
6545 }
6546 output := &DeleteLoadBalancerTlsCertificateOutput{}
6547 out.Result = output
6548
6549 var buff [1024]byte
6550 ringBuffer := smithyio.NewRingBuffer(buff[:])
6551
6552 body := io.TeeReader(response.Body, ringBuffer)
6553 decoder := json.NewDecoder(body)
6554 decoder.UseNumber()
6555 var shape interface{}
6556 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6557 var snapshot bytes.Buffer
6558 io.Copy(&snapshot, ringBuffer)
6559 err = &smithy.DeserializationError{
6560 Err: fmt.Errorf("failed to decode response body, %w", err),
6561 Snapshot: snapshot.Bytes(),
6562 }
6563 return out, metadata, err
6564 }
6565
6566 err = awsAwsjson11_deserializeOpDocumentDeleteLoadBalancerTlsCertificateOutput(&output, shape)
6567 if err != nil {
6568 var snapshot bytes.Buffer
6569 io.Copy(&snapshot, ringBuffer)
6570 err = &smithy.DeserializationError{
6571 Err: fmt.Errorf("failed to decode response body, %w", err),
6572 Snapshot: snapshot.Bytes(),
6573 }
6574 return out, metadata, err
6575 }
6576
6577 return out, metadata, err
6578 }
6579
6580 func awsAwsjson11_deserializeOpErrorDeleteLoadBalancerTlsCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6581 var errorBuffer bytes.Buffer
6582 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6583 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6584 }
6585 errorBody := bytes.NewReader(errorBuffer.Bytes())
6586
6587 errorCode := "UnknownError"
6588 errorMessage := errorCode
6589
6590 headerCode := response.Header.Get("X-Amzn-ErrorType")
6591
6592 var buff [1024]byte
6593 ringBuffer := smithyio.NewRingBuffer(buff[:])
6594
6595 body := io.TeeReader(errorBody, ringBuffer)
6596 decoder := json.NewDecoder(body)
6597 decoder.UseNumber()
6598 bodyInfo, err := getProtocolErrorInfo(decoder)
6599 if err != nil {
6600 var snapshot bytes.Buffer
6601 io.Copy(&snapshot, ringBuffer)
6602 err = &smithy.DeserializationError{
6603 Err: fmt.Errorf("failed to decode response body, %w", err),
6604 Snapshot: snapshot.Bytes(),
6605 }
6606 return err
6607 }
6608
6609 errorBody.Seek(0, io.SeekStart)
6610 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
6611 errorCode = restjson.SanitizeErrorCode(typ)
6612 }
6613 if len(bodyInfo.Message) != 0 {
6614 errorMessage = bodyInfo.Message
6615 }
6616 switch {
6617 case strings.EqualFold("AccessDeniedException", errorCode):
6618 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6619
6620 case strings.EqualFold("AccountSetupInProgressException", errorCode):
6621 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
6622
6623 case strings.EqualFold("InvalidInputException", errorCode):
6624 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
6625
6626 case strings.EqualFold("NotFoundException", errorCode):
6627 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
6628
6629 case strings.EqualFold("OperationFailureException", errorCode):
6630 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
6631
6632 case strings.EqualFold("RegionSetupInProgressException", errorCode):
6633 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
6634
6635 case strings.EqualFold("ServiceException", errorCode):
6636 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
6637
6638 case strings.EqualFold("UnauthenticatedException", errorCode):
6639 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
6640
6641 default:
6642 genericError := &smithy.GenericAPIError{
6643 Code: errorCode,
6644 Message: errorMessage,
6645 }
6646 return genericError
6647
6648 }
6649 }
6650
6651 type awsAwsjson11_deserializeOpDeleteRelationalDatabase struct {
6652 }
6653
6654 func (*awsAwsjson11_deserializeOpDeleteRelationalDatabase) ID() string {
6655 return "OperationDeserializer"
6656 }
6657
6658 func (m *awsAwsjson11_deserializeOpDeleteRelationalDatabase) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6659 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6660 ) {
6661 out, metadata, err = next.HandleDeserialize(ctx, in)
6662 if err != nil {
6663 return out, metadata, err
6664 }
6665
6666 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
6667 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
6668 defer endTimer()
6669 defer span.End()
6670 response, ok := out.RawResponse.(*smithyhttp.Response)
6671 if !ok {
6672 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6673 }
6674
6675 if response.StatusCode < 200 || response.StatusCode >= 300 {
6676 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteRelationalDatabase(response, &metadata)
6677 }
6678 output := &DeleteRelationalDatabaseOutput{}
6679 out.Result = output
6680
6681 var buff [1024]byte
6682 ringBuffer := smithyio.NewRingBuffer(buff[:])
6683
6684 body := io.TeeReader(response.Body, ringBuffer)
6685 decoder := json.NewDecoder(body)
6686 decoder.UseNumber()
6687 var shape interface{}
6688 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6689 var snapshot bytes.Buffer
6690 io.Copy(&snapshot, ringBuffer)
6691 err = &smithy.DeserializationError{
6692 Err: fmt.Errorf("failed to decode response body, %w", err),
6693 Snapshot: snapshot.Bytes(),
6694 }
6695 return out, metadata, err
6696 }
6697
6698 err = awsAwsjson11_deserializeOpDocumentDeleteRelationalDatabaseOutput(&output, shape)
6699 if err != nil {
6700 var snapshot bytes.Buffer
6701 io.Copy(&snapshot, ringBuffer)
6702 err = &smithy.DeserializationError{
6703 Err: fmt.Errorf("failed to decode response body, %w", err),
6704 Snapshot: snapshot.Bytes(),
6705 }
6706 return out, metadata, err
6707 }
6708
6709 return out, metadata, err
6710 }
6711
6712 func awsAwsjson11_deserializeOpErrorDeleteRelationalDatabase(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6713 var errorBuffer bytes.Buffer
6714 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6715 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6716 }
6717 errorBody := bytes.NewReader(errorBuffer.Bytes())
6718
6719 errorCode := "UnknownError"
6720 errorMessage := errorCode
6721
6722 headerCode := response.Header.Get("X-Amzn-ErrorType")
6723
6724 var buff [1024]byte
6725 ringBuffer := smithyio.NewRingBuffer(buff[:])
6726
6727 body := io.TeeReader(errorBody, ringBuffer)
6728 decoder := json.NewDecoder(body)
6729 decoder.UseNumber()
6730 bodyInfo, err := getProtocolErrorInfo(decoder)
6731 if err != nil {
6732 var snapshot bytes.Buffer
6733 io.Copy(&snapshot, ringBuffer)
6734 err = &smithy.DeserializationError{
6735 Err: fmt.Errorf("failed to decode response body, %w", err),
6736 Snapshot: snapshot.Bytes(),
6737 }
6738 return err
6739 }
6740
6741 errorBody.Seek(0, io.SeekStart)
6742 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
6743 errorCode = restjson.SanitizeErrorCode(typ)
6744 }
6745 if len(bodyInfo.Message) != 0 {
6746 errorMessage = bodyInfo.Message
6747 }
6748 switch {
6749 case strings.EqualFold("AccessDeniedException", errorCode):
6750 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6751
6752 case strings.EqualFold("AccountSetupInProgressException", errorCode):
6753 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
6754
6755 case strings.EqualFold("InvalidInputException", errorCode):
6756 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
6757
6758 case strings.EqualFold("NotFoundException", errorCode):
6759 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
6760
6761 case strings.EqualFold("OperationFailureException", errorCode):
6762 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
6763
6764 case strings.EqualFold("RegionSetupInProgressException", errorCode):
6765 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
6766
6767 case strings.EqualFold("ServiceException", errorCode):
6768 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
6769
6770 case strings.EqualFold("UnauthenticatedException", errorCode):
6771 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
6772
6773 default:
6774 genericError := &smithy.GenericAPIError{
6775 Code: errorCode,
6776 Message: errorMessage,
6777 }
6778 return genericError
6779
6780 }
6781 }
6782
6783 type awsAwsjson11_deserializeOpDeleteRelationalDatabaseSnapshot struct {
6784 }
6785
6786 func (*awsAwsjson11_deserializeOpDeleteRelationalDatabaseSnapshot) ID() string {
6787 return "OperationDeserializer"
6788 }
6789
6790 func (m *awsAwsjson11_deserializeOpDeleteRelationalDatabaseSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6791 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6792 ) {
6793 out, metadata, err = next.HandleDeserialize(ctx, in)
6794 if err != nil {
6795 return out, metadata, err
6796 }
6797
6798 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
6799 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
6800 defer endTimer()
6801 defer span.End()
6802 response, ok := out.RawResponse.(*smithyhttp.Response)
6803 if !ok {
6804 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6805 }
6806
6807 if response.StatusCode < 200 || response.StatusCode >= 300 {
6808 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteRelationalDatabaseSnapshot(response, &metadata)
6809 }
6810 output := &DeleteRelationalDatabaseSnapshotOutput{}
6811 out.Result = output
6812
6813 var buff [1024]byte
6814 ringBuffer := smithyio.NewRingBuffer(buff[:])
6815
6816 body := io.TeeReader(response.Body, ringBuffer)
6817 decoder := json.NewDecoder(body)
6818 decoder.UseNumber()
6819 var shape interface{}
6820 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6821 var snapshot bytes.Buffer
6822 io.Copy(&snapshot, ringBuffer)
6823 err = &smithy.DeserializationError{
6824 Err: fmt.Errorf("failed to decode response body, %w", err),
6825 Snapshot: snapshot.Bytes(),
6826 }
6827 return out, metadata, err
6828 }
6829
6830 err = awsAwsjson11_deserializeOpDocumentDeleteRelationalDatabaseSnapshotOutput(&output, shape)
6831 if err != nil {
6832 var snapshot bytes.Buffer
6833 io.Copy(&snapshot, ringBuffer)
6834 err = &smithy.DeserializationError{
6835 Err: fmt.Errorf("failed to decode response body, %w", err),
6836 Snapshot: snapshot.Bytes(),
6837 }
6838 return out, metadata, err
6839 }
6840
6841 return out, metadata, err
6842 }
6843
6844 func awsAwsjson11_deserializeOpErrorDeleteRelationalDatabaseSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6845 var errorBuffer bytes.Buffer
6846 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6847 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6848 }
6849 errorBody := bytes.NewReader(errorBuffer.Bytes())
6850
6851 errorCode := "UnknownError"
6852 errorMessage := errorCode
6853
6854 headerCode := response.Header.Get("X-Amzn-ErrorType")
6855
6856 var buff [1024]byte
6857 ringBuffer := smithyio.NewRingBuffer(buff[:])
6858
6859 body := io.TeeReader(errorBody, ringBuffer)
6860 decoder := json.NewDecoder(body)
6861 decoder.UseNumber()
6862 bodyInfo, err := getProtocolErrorInfo(decoder)
6863 if err != nil {
6864 var snapshot bytes.Buffer
6865 io.Copy(&snapshot, ringBuffer)
6866 err = &smithy.DeserializationError{
6867 Err: fmt.Errorf("failed to decode response body, %w", err),
6868 Snapshot: snapshot.Bytes(),
6869 }
6870 return err
6871 }
6872
6873 errorBody.Seek(0, io.SeekStart)
6874 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
6875 errorCode = restjson.SanitizeErrorCode(typ)
6876 }
6877 if len(bodyInfo.Message) != 0 {
6878 errorMessage = bodyInfo.Message
6879 }
6880 switch {
6881 case strings.EqualFold("AccessDeniedException", errorCode):
6882 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6883
6884 case strings.EqualFold("AccountSetupInProgressException", errorCode):
6885 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
6886
6887 case strings.EqualFold("InvalidInputException", errorCode):
6888 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
6889
6890 case strings.EqualFold("NotFoundException", errorCode):
6891 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
6892
6893 case strings.EqualFold("OperationFailureException", errorCode):
6894 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
6895
6896 case strings.EqualFold("RegionSetupInProgressException", errorCode):
6897 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
6898
6899 case strings.EqualFold("ServiceException", errorCode):
6900 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
6901
6902 case strings.EqualFold("UnauthenticatedException", errorCode):
6903 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
6904
6905 default:
6906 genericError := &smithy.GenericAPIError{
6907 Code: errorCode,
6908 Message: errorMessage,
6909 }
6910 return genericError
6911
6912 }
6913 }
6914
6915 type awsAwsjson11_deserializeOpDetachCertificateFromDistribution struct {
6916 }
6917
6918 func (*awsAwsjson11_deserializeOpDetachCertificateFromDistribution) ID() string {
6919 return "OperationDeserializer"
6920 }
6921
6922 func (m *awsAwsjson11_deserializeOpDetachCertificateFromDistribution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6923 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6924 ) {
6925 out, metadata, err = next.HandleDeserialize(ctx, in)
6926 if err != nil {
6927 return out, metadata, err
6928 }
6929
6930 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
6931 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
6932 defer endTimer()
6933 defer span.End()
6934 response, ok := out.RawResponse.(*smithyhttp.Response)
6935 if !ok {
6936 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6937 }
6938
6939 if response.StatusCode < 200 || response.StatusCode >= 300 {
6940 return out, metadata, awsAwsjson11_deserializeOpErrorDetachCertificateFromDistribution(response, &metadata)
6941 }
6942 output := &DetachCertificateFromDistributionOutput{}
6943 out.Result = output
6944
6945 var buff [1024]byte
6946 ringBuffer := smithyio.NewRingBuffer(buff[:])
6947
6948 body := io.TeeReader(response.Body, ringBuffer)
6949 decoder := json.NewDecoder(body)
6950 decoder.UseNumber()
6951 var shape interface{}
6952 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6953 var snapshot bytes.Buffer
6954 io.Copy(&snapshot, ringBuffer)
6955 err = &smithy.DeserializationError{
6956 Err: fmt.Errorf("failed to decode response body, %w", err),
6957 Snapshot: snapshot.Bytes(),
6958 }
6959 return out, metadata, err
6960 }
6961
6962 err = awsAwsjson11_deserializeOpDocumentDetachCertificateFromDistributionOutput(&output, shape)
6963 if err != nil {
6964 var snapshot bytes.Buffer
6965 io.Copy(&snapshot, ringBuffer)
6966 err = &smithy.DeserializationError{
6967 Err: fmt.Errorf("failed to decode response body, %w", err),
6968 Snapshot: snapshot.Bytes(),
6969 }
6970 return out, metadata, err
6971 }
6972
6973 return out, metadata, err
6974 }
6975
6976 func awsAwsjson11_deserializeOpErrorDetachCertificateFromDistribution(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6977 var errorBuffer bytes.Buffer
6978 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6979 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6980 }
6981 errorBody := bytes.NewReader(errorBuffer.Bytes())
6982
6983 errorCode := "UnknownError"
6984 errorMessage := errorCode
6985
6986 headerCode := response.Header.Get("X-Amzn-ErrorType")
6987
6988 var buff [1024]byte
6989 ringBuffer := smithyio.NewRingBuffer(buff[:])
6990
6991 body := io.TeeReader(errorBody, ringBuffer)
6992 decoder := json.NewDecoder(body)
6993 decoder.UseNumber()
6994 bodyInfo, err := getProtocolErrorInfo(decoder)
6995 if err != nil {
6996 var snapshot bytes.Buffer
6997 io.Copy(&snapshot, ringBuffer)
6998 err = &smithy.DeserializationError{
6999 Err: fmt.Errorf("failed to decode response body, %w", err),
7000 Snapshot: snapshot.Bytes(),
7001 }
7002 return err
7003 }
7004
7005 errorBody.Seek(0, io.SeekStart)
7006 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
7007 errorCode = restjson.SanitizeErrorCode(typ)
7008 }
7009 if len(bodyInfo.Message) != 0 {
7010 errorMessage = bodyInfo.Message
7011 }
7012 switch {
7013 case strings.EqualFold("AccessDeniedException", errorCode):
7014 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
7015
7016 case strings.EqualFold("InvalidInputException", errorCode):
7017 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
7018
7019 case strings.EqualFold("NotFoundException", errorCode):
7020 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
7021
7022 case strings.EqualFold("OperationFailureException", errorCode):
7023 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
7024
7025 case strings.EqualFold("ServiceException", errorCode):
7026 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
7027
7028 case strings.EqualFold("UnauthenticatedException", errorCode):
7029 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
7030
7031 default:
7032 genericError := &smithy.GenericAPIError{
7033 Code: errorCode,
7034 Message: errorMessage,
7035 }
7036 return genericError
7037
7038 }
7039 }
7040
7041 type awsAwsjson11_deserializeOpDetachDisk struct {
7042 }
7043
7044 func (*awsAwsjson11_deserializeOpDetachDisk) ID() string {
7045 return "OperationDeserializer"
7046 }
7047
7048 func (m *awsAwsjson11_deserializeOpDetachDisk) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7049 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7050 ) {
7051 out, metadata, err = next.HandleDeserialize(ctx, in)
7052 if err != nil {
7053 return out, metadata, err
7054 }
7055
7056 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
7057 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
7058 defer endTimer()
7059 defer span.End()
7060 response, ok := out.RawResponse.(*smithyhttp.Response)
7061 if !ok {
7062 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7063 }
7064
7065 if response.StatusCode < 200 || response.StatusCode >= 300 {
7066 return out, metadata, awsAwsjson11_deserializeOpErrorDetachDisk(response, &metadata)
7067 }
7068 output := &DetachDiskOutput{}
7069 out.Result = output
7070
7071 var buff [1024]byte
7072 ringBuffer := smithyio.NewRingBuffer(buff[:])
7073
7074 body := io.TeeReader(response.Body, ringBuffer)
7075 decoder := json.NewDecoder(body)
7076 decoder.UseNumber()
7077 var shape interface{}
7078 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7079 var snapshot bytes.Buffer
7080 io.Copy(&snapshot, ringBuffer)
7081 err = &smithy.DeserializationError{
7082 Err: fmt.Errorf("failed to decode response body, %w", err),
7083 Snapshot: snapshot.Bytes(),
7084 }
7085 return out, metadata, err
7086 }
7087
7088 err = awsAwsjson11_deserializeOpDocumentDetachDiskOutput(&output, shape)
7089 if err != nil {
7090 var snapshot bytes.Buffer
7091 io.Copy(&snapshot, ringBuffer)
7092 err = &smithy.DeserializationError{
7093 Err: fmt.Errorf("failed to decode response body, %w", err),
7094 Snapshot: snapshot.Bytes(),
7095 }
7096 return out, metadata, err
7097 }
7098
7099 return out, metadata, err
7100 }
7101
7102 func awsAwsjson11_deserializeOpErrorDetachDisk(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7103 var errorBuffer bytes.Buffer
7104 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7105 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7106 }
7107 errorBody := bytes.NewReader(errorBuffer.Bytes())
7108
7109 errorCode := "UnknownError"
7110 errorMessage := errorCode
7111
7112 headerCode := response.Header.Get("X-Amzn-ErrorType")
7113
7114 var buff [1024]byte
7115 ringBuffer := smithyio.NewRingBuffer(buff[:])
7116
7117 body := io.TeeReader(errorBody, ringBuffer)
7118 decoder := json.NewDecoder(body)
7119 decoder.UseNumber()
7120 bodyInfo, err := getProtocolErrorInfo(decoder)
7121 if err != nil {
7122 var snapshot bytes.Buffer
7123 io.Copy(&snapshot, ringBuffer)
7124 err = &smithy.DeserializationError{
7125 Err: fmt.Errorf("failed to decode response body, %w", err),
7126 Snapshot: snapshot.Bytes(),
7127 }
7128 return err
7129 }
7130
7131 errorBody.Seek(0, io.SeekStart)
7132 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
7133 errorCode = restjson.SanitizeErrorCode(typ)
7134 }
7135 if len(bodyInfo.Message) != 0 {
7136 errorMessage = bodyInfo.Message
7137 }
7138 switch {
7139 case strings.EqualFold("AccessDeniedException", errorCode):
7140 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
7141
7142 case strings.EqualFold("AccountSetupInProgressException", errorCode):
7143 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
7144
7145 case strings.EqualFold("InvalidInputException", errorCode):
7146 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
7147
7148 case strings.EqualFold("NotFoundException", errorCode):
7149 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
7150
7151 case strings.EqualFold("OperationFailureException", errorCode):
7152 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
7153
7154 case strings.EqualFold("RegionSetupInProgressException", errorCode):
7155 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
7156
7157 case strings.EqualFold("ServiceException", errorCode):
7158 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
7159
7160 case strings.EqualFold("UnauthenticatedException", errorCode):
7161 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
7162
7163 default:
7164 genericError := &smithy.GenericAPIError{
7165 Code: errorCode,
7166 Message: errorMessage,
7167 }
7168 return genericError
7169
7170 }
7171 }
7172
7173 type awsAwsjson11_deserializeOpDetachInstancesFromLoadBalancer struct {
7174 }
7175
7176 func (*awsAwsjson11_deserializeOpDetachInstancesFromLoadBalancer) ID() string {
7177 return "OperationDeserializer"
7178 }
7179
7180 func (m *awsAwsjson11_deserializeOpDetachInstancesFromLoadBalancer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7181 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7182 ) {
7183 out, metadata, err = next.HandleDeserialize(ctx, in)
7184 if err != nil {
7185 return out, metadata, err
7186 }
7187
7188 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
7189 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
7190 defer endTimer()
7191 defer span.End()
7192 response, ok := out.RawResponse.(*smithyhttp.Response)
7193 if !ok {
7194 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7195 }
7196
7197 if response.StatusCode < 200 || response.StatusCode >= 300 {
7198 return out, metadata, awsAwsjson11_deserializeOpErrorDetachInstancesFromLoadBalancer(response, &metadata)
7199 }
7200 output := &DetachInstancesFromLoadBalancerOutput{}
7201 out.Result = output
7202
7203 var buff [1024]byte
7204 ringBuffer := smithyio.NewRingBuffer(buff[:])
7205
7206 body := io.TeeReader(response.Body, ringBuffer)
7207 decoder := json.NewDecoder(body)
7208 decoder.UseNumber()
7209 var shape interface{}
7210 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7211 var snapshot bytes.Buffer
7212 io.Copy(&snapshot, ringBuffer)
7213 err = &smithy.DeserializationError{
7214 Err: fmt.Errorf("failed to decode response body, %w", err),
7215 Snapshot: snapshot.Bytes(),
7216 }
7217 return out, metadata, err
7218 }
7219
7220 err = awsAwsjson11_deserializeOpDocumentDetachInstancesFromLoadBalancerOutput(&output, shape)
7221 if err != nil {
7222 var snapshot bytes.Buffer
7223 io.Copy(&snapshot, ringBuffer)
7224 err = &smithy.DeserializationError{
7225 Err: fmt.Errorf("failed to decode response body, %w", err),
7226 Snapshot: snapshot.Bytes(),
7227 }
7228 return out, metadata, err
7229 }
7230
7231 return out, metadata, err
7232 }
7233
7234 func awsAwsjson11_deserializeOpErrorDetachInstancesFromLoadBalancer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7235 var errorBuffer bytes.Buffer
7236 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7237 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7238 }
7239 errorBody := bytes.NewReader(errorBuffer.Bytes())
7240
7241 errorCode := "UnknownError"
7242 errorMessage := errorCode
7243
7244 headerCode := response.Header.Get("X-Amzn-ErrorType")
7245
7246 var buff [1024]byte
7247 ringBuffer := smithyio.NewRingBuffer(buff[:])
7248
7249 body := io.TeeReader(errorBody, ringBuffer)
7250 decoder := json.NewDecoder(body)
7251 decoder.UseNumber()
7252 bodyInfo, err := getProtocolErrorInfo(decoder)
7253 if err != nil {
7254 var snapshot bytes.Buffer
7255 io.Copy(&snapshot, ringBuffer)
7256 err = &smithy.DeserializationError{
7257 Err: fmt.Errorf("failed to decode response body, %w", err),
7258 Snapshot: snapshot.Bytes(),
7259 }
7260 return err
7261 }
7262
7263 errorBody.Seek(0, io.SeekStart)
7264 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
7265 errorCode = restjson.SanitizeErrorCode(typ)
7266 }
7267 if len(bodyInfo.Message) != 0 {
7268 errorMessage = bodyInfo.Message
7269 }
7270 switch {
7271 case strings.EqualFold("AccessDeniedException", errorCode):
7272 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
7273
7274 case strings.EqualFold("AccountSetupInProgressException", errorCode):
7275 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
7276
7277 case strings.EqualFold("InvalidInputException", errorCode):
7278 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
7279
7280 case strings.EqualFold("NotFoundException", errorCode):
7281 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
7282
7283 case strings.EqualFold("OperationFailureException", errorCode):
7284 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
7285
7286 case strings.EqualFold("RegionSetupInProgressException", errorCode):
7287 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
7288
7289 case strings.EqualFold("ServiceException", errorCode):
7290 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
7291
7292 case strings.EqualFold("UnauthenticatedException", errorCode):
7293 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
7294
7295 default:
7296 genericError := &smithy.GenericAPIError{
7297 Code: errorCode,
7298 Message: errorMessage,
7299 }
7300 return genericError
7301
7302 }
7303 }
7304
7305 type awsAwsjson11_deserializeOpDetachStaticIp struct {
7306 }
7307
7308 func (*awsAwsjson11_deserializeOpDetachStaticIp) ID() string {
7309 return "OperationDeserializer"
7310 }
7311
7312 func (m *awsAwsjson11_deserializeOpDetachStaticIp) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7313 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7314 ) {
7315 out, metadata, err = next.HandleDeserialize(ctx, in)
7316 if err != nil {
7317 return out, metadata, err
7318 }
7319
7320 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
7321 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
7322 defer endTimer()
7323 defer span.End()
7324 response, ok := out.RawResponse.(*smithyhttp.Response)
7325 if !ok {
7326 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7327 }
7328
7329 if response.StatusCode < 200 || response.StatusCode >= 300 {
7330 return out, metadata, awsAwsjson11_deserializeOpErrorDetachStaticIp(response, &metadata)
7331 }
7332 output := &DetachStaticIpOutput{}
7333 out.Result = output
7334
7335 var buff [1024]byte
7336 ringBuffer := smithyio.NewRingBuffer(buff[:])
7337
7338 body := io.TeeReader(response.Body, ringBuffer)
7339 decoder := json.NewDecoder(body)
7340 decoder.UseNumber()
7341 var shape interface{}
7342 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7343 var snapshot bytes.Buffer
7344 io.Copy(&snapshot, ringBuffer)
7345 err = &smithy.DeserializationError{
7346 Err: fmt.Errorf("failed to decode response body, %w", err),
7347 Snapshot: snapshot.Bytes(),
7348 }
7349 return out, metadata, err
7350 }
7351
7352 err = awsAwsjson11_deserializeOpDocumentDetachStaticIpOutput(&output, shape)
7353 if err != nil {
7354 var snapshot bytes.Buffer
7355 io.Copy(&snapshot, ringBuffer)
7356 err = &smithy.DeserializationError{
7357 Err: fmt.Errorf("failed to decode response body, %w", err),
7358 Snapshot: snapshot.Bytes(),
7359 }
7360 return out, metadata, err
7361 }
7362
7363 return out, metadata, err
7364 }
7365
7366 func awsAwsjson11_deserializeOpErrorDetachStaticIp(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7367 var errorBuffer bytes.Buffer
7368 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7369 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7370 }
7371 errorBody := bytes.NewReader(errorBuffer.Bytes())
7372
7373 errorCode := "UnknownError"
7374 errorMessage := errorCode
7375
7376 headerCode := response.Header.Get("X-Amzn-ErrorType")
7377
7378 var buff [1024]byte
7379 ringBuffer := smithyio.NewRingBuffer(buff[:])
7380
7381 body := io.TeeReader(errorBody, ringBuffer)
7382 decoder := json.NewDecoder(body)
7383 decoder.UseNumber()
7384 bodyInfo, err := getProtocolErrorInfo(decoder)
7385 if err != nil {
7386 var snapshot bytes.Buffer
7387 io.Copy(&snapshot, ringBuffer)
7388 err = &smithy.DeserializationError{
7389 Err: fmt.Errorf("failed to decode response body, %w", err),
7390 Snapshot: snapshot.Bytes(),
7391 }
7392 return err
7393 }
7394
7395 errorBody.Seek(0, io.SeekStart)
7396 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
7397 errorCode = restjson.SanitizeErrorCode(typ)
7398 }
7399 if len(bodyInfo.Message) != 0 {
7400 errorMessage = bodyInfo.Message
7401 }
7402 switch {
7403 case strings.EqualFold("AccessDeniedException", errorCode):
7404 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
7405
7406 case strings.EqualFold("AccountSetupInProgressException", errorCode):
7407 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
7408
7409 case strings.EqualFold("InvalidInputException", errorCode):
7410 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
7411
7412 case strings.EqualFold("NotFoundException", errorCode):
7413 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
7414
7415 case strings.EqualFold("OperationFailureException", errorCode):
7416 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
7417
7418 case strings.EqualFold("RegionSetupInProgressException", errorCode):
7419 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
7420
7421 case strings.EqualFold("ServiceException", errorCode):
7422 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
7423
7424 case strings.EqualFold("UnauthenticatedException", errorCode):
7425 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
7426
7427 default:
7428 genericError := &smithy.GenericAPIError{
7429 Code: errorCode,
7430 Message: errorMessage,
7431 }
7432 return genericError
7433
7434 }
7435 }
7436
7437 type awsAwsjson11_deserializeOpDisableAddOn struct {
7438 }
7439
7440 func (*awsAwsjson11_deserializeOpDisableAddOn) ID() string {
7441 return "OperationDeserializer"
7442 }
7443
7444 func (m *awsAwsjson11_deserializeOpDisableAddOn) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7445 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7446 ) {
7447 out, metadata, err = next.HandleDeserialize(ctx, in)
7448 if err != nil {
7449 return out, metadata, err
7450 }
7451
7452 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
7453 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
7454 defer endTimer()
7455 defer span.End()
7456 response, ok := out.RawResponse.(*smithyhttp.Response)
7457 if !ok {
7458 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7459 }
7460
7461 if response.StatusCode < 200 || response.StatusCode >= 300 {
7462 return out, metadata, awsAwsjson11_deserializeOpErrorDisableAddOn(response, &metadata)
7463 }
7464 output := &DisableAddOnOutput{}
7465 out.Result = output
7466
7467 var buff [1024]byte
7468 ringBuffer := smithyio.NewRingBuffer(buff[:])
7469
7470 body := io.TeeReader(response.Body, ringBuffer)
7471 decoder := json.NewDecoder(body)
7472 decoder.UseNumber()
7473 var shape interface{}
7474 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7475 var snapshot bytes.Buffer
7476 io.Copy(&snapshot, ringBuffer)
7477 err = &smithy.DeserializationError{
7478 Err: fmt.Errorf("failed to decode response body, %w", err),
7479 Snapshot: snapshot.Bytes(),
7480 }
7481 return out, metadata, err
7482 }
7483
7484 err = awsAwsjson11_deserializeOpDocumentDisableAddOnOutput(&output, shape)
7485 if err != nil {
7486 var snapshot bytes.Buffer
7487 io.Copy(&snapshot, ringBuffer)
7488 err = &smithy.DeserializationError{
7489 Err: fmt.Errorf("failed to decode response body, %w", err),
7490 Snapshot: snapshot.Bytes(),
7491 }
7492 return out, metadata, err
7493 }
7494
7495 return out, metadata, err
7496 }
7497
7498 func awsAwsjson11_deserializeOpErrorDisableAddOn(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7499 var errorBuffer bytes.Buffer
7500 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7501 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7502 }
7503 errorBody := bytes.NewReader(errorBuffer.Bytes())
7504
7505 errorCode := "UnknownError"
7506 errorMessage := errorCode
7507
7508 headerCode := response.Header.Get("X-Amzn-ErrorType")
7509
7510 var buff [1024]byte
7511 ringBuffer := smithyio.NewRingBuffer(buff[:])
7512
7513 body := io.TeeReader(errorBody, ringBuffer)
7514 decoder := json.NewDecoder(body)
7515 decoder.UseNumber()
7516 bodyInfo, err := getProtocolErrorInfo(decoder)
7517 if err != nil {
7518 var snapshot bytes.Buffer
7519 io.Copy(&snapshot, ringBuffer)
7520 err = &smithy.DeserializationError{
7521 Err: fmt.Errorf("failed to decode response body, %w", err),
7522 Snapshot: snapshot.Bytes(),
7523 }
7524 return err
7525 }
7526
7527 errorBody.Seek(0, io.SeekStart)
7528 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
7529 errorCode = restjson.SanitizeErrorCode(typ)
7530 }
7531 if len(bodyInfo.Message) != 0 {
7532 errorMessage = bodyInfo.Message
7533 }
7534 switch {
7535 case strings.EqualFold("AccessDeniedException", errorCode):
7536 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
7537
7538 case strings.EqualFold("InvalidInputException", errorCode):
7539 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
7540
7541 case strings.EqualFold("NotFoundException", errorCode):
7542 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
7543
7544 case strings.EqualFold("OperationFailureException", errorCode):
7545 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
7546
7547 case strings.EqualFold("RegionSetupInProgressException", errorCode):
7548 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
7549
7550 case strings.EqualFold("ServiceException", errorCode):
7551 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
7552
7553 case strings.EqualFold("UnauthenticatedException", errorCode):
7554 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
7555
7556 default:
7557 genericError := &smithy.GenericAPIError{
7558 Code: errorCode,
7559 Message: errorMessage,
7560 }
7561 return genericError
7562
7563 }
7564 }
7565
7566 type awsAwsjson11_deserializeOpDownloadDefaultKeyPair struct {
7567 }
7568
7569 func (*awsAwsjson11_deserializeOpDownloadDefaultKeyPair) ID() string {
7570 return "OperationDeserializer"
7571 }
7572
7573 func (m *awsAwsjson11_deserializeOpDownloadDefaultKeyPair) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7574 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7575 ) {
7576 out, metadata, err = next.HandleDeserialize(ctx, in)
7577 if err != nil {
7578 return out, metadata, err
7579 }
7580
7581 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
7582 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
7583 defer endTimer()
7584 defer span.End()
7585 response, ok := out.RawResponse.(*smithyhttp.Response)
7586 if !ok {
7587 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7588 }
7589
7590 if response.StatusCode < 200 || response.StatusCode >= 300 {
7591 return out, metadata, awsAwsjson11_deserializeOpErrorDownloadDefaultKeyPair(response, &metadata)
7592 }
7593 output := &DownloadDefaultKeyPairOutput{}
7594 out.Result = output
7595
7596 var buff [1024]byte
7597 ringBuffer := smithyio.NewRingBuffer(buff[:])
7598
7599 body := io.TeeReader(response.Body, ringBuffer)
7600 decoder := json.NewDecoder(body)
7601 decoder.UseNumber()
7602 var shape interface{}
7603 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7604 var snapshot bytes.Buffer
7605 io.Copy(&snapshot, ringBuffer)
7606 err = &smithy.DeserializationError{
7607 Err: fmt.Errorf("failed to decode response body, %w", err),
7608 Snapshot: snapshot.Bytes(),
7609 }
7610 return out, metadata, err
7611 }
7612
7613 err = awsAwsjson11_deserializeOpDocumentDownloadDefaultKeyPairOutput(&output, shape)
7614 if err != nil {
7615 var snapshot bytes.Buffer
7616 io.Copy(&snapshot, ringBuffer)
7617 err = &smithy.DeserializationError{
7618 Err: fmt.Errorf("failed to decode response body, %w", err),
7619 Snapshot: snapshot.Bytes(),
7620 }
7621 return out, metadata, err
7622 }
7623
7624 return out, metadata, err
7625 }
7626
7627 func awsAwsjson11_deserializeOpErrorDownloadDefaultKeyPair(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7628 var errorBuffer bytes.Buffer
7629 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7630 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7631 }
7632 errorBody := bytes.NewReader(errorBuffer.Bytes())
7633
7634 errorCode := "UnknownError"
7635 errorMessage := errorCode
7636
7637 headerCode := response.Header.Get("X-Amzn-ErrorType")
7638
7639 var buff [1024]byte
7640 ringBuffer := smithyio.NewRingBuffer(buff[:])
7641
7642 body := io.TeeReader(errorBody, ringBuffer)
7643 decoder := json.NewDecoder(body)
7644 decoder.UseNumber()
7645 bodyInfo, err := getProtocolErrorInfo(decoder)
7646 if err != nil {
7647 var snapshot bytes.Buffer
7648 io.Copy(&snapshot, ringBuffer)
7649 err = &smithy.DeserializationError{
7650 Err: fmt.Errorf("failed to decode response body, %w", err),
7651 Snapshot: snapshot.Bytes(),
7652 }
7653 return err
7654 }
7655
7656 errorBody.Seek(0, io.SeekStart)
7657 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
7658 errorCode = restjson.SanitizeErrorCode(typ)
7659 }
7660 if len(bodyInfo.Message) != 0 {
7661 errorMessage = bodyInfo.Message
7662 }
7663 switch {
7664 case strings.EqualFold("AccessDeniedException", errorCode):
7665 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
7666
7667 case strings.EqualFold("AccountSetupInProgressException", errorCode):
7668 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
7669
7670 case strings.EqualFold("InvalidInputException", errorCode):
7671 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
7672
7673 case strings.EqualFold("NotFoundException", errorCode):
7674 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
7675
7676 case strings.EqualFold("OperationFailureException", errorCode):
7677 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
7678
7679 case strings.EqualFold("RegionSetupInProgressException", errorCode):
7680 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
7681
7682 case strings.EqualFold("ServiceException", errorCode):
7683 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
7684
7685 case strings.EqualFold("UnauthenticatedException", errorCode):
7686 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
7687
7688 default:
7689 genericError := &smithy.GenericAPIError{
7690 Code: errorCode,
7691 Message: errorMessage,
7692 }
7693 return genericError
7694
7695 }
7696 }
7697
7698 type awsAwsjson11_deserializeOpEnableAddOn struct {
7699 }
7700
7701 func (*awsAwsjson11_deserializeOpEnableAddOn) ID() string {
7702 return "OperationDeserializer"
7703 }
7704
7705 func (m *awsAwsjson11_deserializeOpEnableAddOn) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7706 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7707 ) {
7708 out, metadata, err = next.HandleDeserialize(ctx, in)
7709 if err != nil {
7710 return out, metadata, err
7711 }
7712
7713 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
7714 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
7715 defer endTimer()
7716 defer span.End()
7717 response, ok := out.RawResponse.(*smithyhttp.Response)
7718 if !ok {
7719 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7720 }
7721
7722 if response.StatusCode < 200 || response.StatusCode >= 300 {
7723 return out, metadata, awsAwsjson11_deserializeOpErrorEnableAddOn(response, &metadata)
7724 }
7725 output := &EnableAddOnOutput{}
7726 out.Result = output
7727
7728 var buff [1024]byte
7729 ringBuffer := smithyio.NewRingBuffer(buff[:])
7730
7731 body := io.TeeReader(response.Body, ringBuffer)
7732 decoder := json.NewDecoder(body)
7733 decoder.UseNumber()
7734 var shape interface{}
7735 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7736 var snapshot bytes.Buffer
7737 io.Copy(&snapshot, ringBuffer)
7738 err = &smithy.DeserializationError{
7739 Err: fmt.Errorf("failed to decode response body, %w", err),
7740 Snapshot: snapshot.Bytes(),
7741 }
7742 return out, metadata, err
7743 }
7744
7745 err = awsAwsjson11_deserializeOpDocumentEnableAddOnOutput(&output, shape)
7746 if err != nil {
7747 var snapshot bytes.Buffer
7748 io.Copy(&snapshot, ringBuffer)
7749 err = &smithy.DeserializationError{
7750 Err: fmt.Errorf("failed to decode response body, %w", err),
7751 Snapshot: snapshot.Bytes(),
7752 }
7753 return out, metadata, err
7754 }
7755
7756 return out, metadata, err
7757 }
7758
7759 func awsAwsjson11_deserializeOpErrorEnableAddOn(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7760 var errorBuffer bytes.Buffer
7761 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7762 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7763 }
7764 errorBody := bytes.NewReader(errorBuffer.Bytes())
7765
7766 errorCode := "UnknownError"
7767 errorMessage := errorCode
7768
7769 headerCode := response.Header.Get("X-Amzn-ErrorType")
7770
7771 var buff [1024]byte
7772 ringBuffer := smithyio.NewRingBuffer(buff[:])
7773
7774 body := io.TeeReader(errorBody, ringBuffer)
7775 decoder := json.NewDecoder(body)
7776 decoder.UseNumber()
7777 bodyInfo, err := getProtocolErrorInfo(decoder)
7778 if err != nil {
7779 var snapshot bytes.Buffer
7780 io.Copy(&snapshot, ringBuffer)
7781 err = &smithy.DeserializationError{
7782 Err: fmt.Errorf("failed to decode response body, %w", err),
7783 Snapshot: snapshot.Bytes(),
7784 }
7785 return err
7786 }
7787
7788 errorBody.Seek(0, io.SeekStart)
7789 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
7790 errorCode = restjson.SanitizeErrorCode(typ)
7791 }
7792 if len(bodyInfo.Message) != 0 {
7793 errorMessage = bodyInfo.Message
7794 }
7795 switch {
7796 case strings.EqualFold("AccessDeniedException", errorCode):
7797 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
7798
7799 case strings.EqualFold("InvalidInputException", errorCode):
7800 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
7801
7802 case strings.EqualFold("NotFoundException", errorCode):
7803 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
7804
7805 case strings.EqualFold("OperationFailureException", errorCode):
7806 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
7807
7808 case strings.EqualFold("RegionSetupInProgressException", errorCode):
7809 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
7810
7811 case strings.EqualFold("ServiceException", errorCode):
7812 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
7813
7814 case strings.EqualFold("UnauthenticatedException", errorCode):
7815 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
7816
7817 default:
7818 genericError := &smithy.GenericAPIError{
7819 Code: errorCode,
7820 Message: errorMessage,
7821 }
7822 return genericError
7823
7824 }
7825 }
7826
7827 type awsAwsjson11_deserializeOpExportSnapshot struct {
7828 }
7829
7830 func (*awsAwsjson11_deserializeOpExportSnapshot) ID() string {
7831 return "OperationDeserializer"
7832 }
7833
7834 func (m *awsAwsjson11_deserializeOpExportSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7835 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7836 ) {
7837 out, metadata, err = next.HandleDeserialize(ctx, in)
7838 if err != nil {
7839 return out, metadata, err
7840 }
7841
7842 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
7843 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
7844 defer endTimer()
7845 defer span.End()
7846 response, ok := out.RawResponse.(*smithyhttp.Response)
7847 if !ok {
7848 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7849 }
7850
7851 if response.StatusCode < 200 || response.StatusCode >= 300 {
7852 return out, metadata, awsAwsjson11_deserializeOpErrorExportSnapshot(response, &metadata)
7853 }
7854 output := &ExportSnapshotOutput{}
7855 out.Result = output
7856
7857 var buff [1024]byte
7858 ringBuffer := smithyio.NewRingBuffer(buff[:])
7859
7860 body := io.TeeReader(response.Body, ringBuffer)
7861 decoder := json.NewDecoder(body)
7862 decoder.UseNumber()
7863 var shape interface{}
7864 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7865 var snapshot bytes.Buffer
7866 io.Copy(&snapshot, ringBuffer)
7867 err = &smithy.DeserializationError{
7868 Err: fmt.Errorf("failed to decode response body, %w", err),
7869 Snapshot: snapshot.Bytes(),
7870 }
7871 return out, metadata, err
7872 }
7873
7874 err = awsAwsjson11_deserializeOpDocumentExportSnapshotOutput(&output, shape)
7875 if err != nil {
7876 var snapshot bytes.Buffer
7877 io.Copy(&snapshot, ringBuffer)
7878 err = &smithy.DeserializationError{
7879 Err: fmt.Errorf("failed to decode response body, %w", err),
7880 Snapshot: snapshot.Bytes(),
7881 }
7882 return out, metadata, err
7883 }
7884
7885 return out, metadata, err
7886 }
7887
7888 func awsAwsjson11_deserializeOpErrorExportSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7889 var errorBuffer bytes.Buffer
7890 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7891 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7892 }
7893 errorBody := bytes.NewReader(errorBuffer.Bytes())
7894
7895 errorCode := "UnknownError"
7896 errorMessage := errorCode
7897
7898 headerCode := response.Header.Get("X-Amzn-ErrorType")
7899
7900 var buff [1024]byte
7901 ringBuffer := smithyio.NewRingBuffer(buff[:])
7902
7903 body := io.TeeReader(errorBody, ringBuffer)
7904 decoder := json.NewDecoder(body)
7905 decoder.UseNumber()
7906 bodyInfo, err := getProtocolErrorInfo(decoder)
7907 if err != nil {
7908 var snapshot bytes.Buffer
7909 io.Copy(&snapshot, ringBuffer)
7910 err = &smithy.DeserializationError{
7911 Err: fmt.Errorf("failed to decode response body, %w", err),
7912 Snapshot: snapshot.Bytes(),
7913 }
7914 return err
7915 }
7916
7917 errorBody.Seek(0, io.SeekStart)
7918 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
7919 errorCode = restjson.SanitizeErrorCode(typ)
7920 }
7921 if len(bodyInfo.Message) != 0 {
7922 errorMessage = bodyInfo.Message
7923 }
7924 switch {
7925 case strings.EqualFold("AccessDeniedException", errorCode):
7926 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
7927
7928 case strings.EqualFold("AccountSetupInProgressException", errorCode):
7929 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
7930
7931 case strings.EqualFold("InvalidInputException", errorCode):
7932 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
7933
7934 case strings.EqualFold("NotFoundException", errorCode):
7935 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
7936
7937 case strings.EqualFold("OperationFailureException", errorCode):
7938 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
7939
7940 case strings.EqualFold("RegionSetupInProgressException", errorCode):
7941 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
7942
7943 case strings.EqualFold("ServiceException", errorCode):
7944 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
7945
7946 case strings.EqualFold("UnauthenticatedException", errorCode):
7947 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
7948
7949 default:
7950 genericError := &smithy.GenericAPIError{
7951 Code: errorCode,
7952 Message: errorMessage,
7953 }
7954 return genericError
7955
7956 }
7957 }
7958
7959 type awsAwsjson11_deserializeOpGetActiveNames struct {
7960 }
7961
7962 func (*awsAwsjson11_deserializeOpGetActiveNames) ID() string {
7963 return "OperationDeserializer"
7964 }
7965
7966 func (m *awsAwsjson11_deserializeOpGetActiveNames) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7967 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7968 ) {
7969 out, metadata, err = next.HandleDeserialize(ctx, in)
7970 if err != nil {
7971 return out, metadata, err
7972 }
7973
7974 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
7975 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
7976 defer endTimer()
7977 defer span.End()
7978 response, ok := out.RawResponse.(*smithyhttp.Response)
7979 if !ok {
7980 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7981 }
7982
7983 if response.StatusCode < 200 || response.StatusCode >= 300 {
7984 return out, metadata, awsAwsjson11_deserializeOpErrorGetActiveNames(response, &metadata)
7985 }
7986 output := &GetActiveNamesOutput{}
7987 out.Result = output
7988
7989 var buff [1024]byte
7990 ringBuffer := smithyio.NewRingBuffer(buff[:])
7991
7992 body := io.TeeReader(response.Body, ringBuffer)
7993 decoder := json.NewDecoder(body)
7994 decoder.UseNumber()
7995 var shape interface{}
7996 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7997 var snapshot bytes.Buffer
7998 io.Copy(&snapshot, ringBuffer)
7999 err = &smithy.DeserializationError{
8000 Err: fmt.Errorf("failed to decode response body, %w", err),
8001 Snapshot: snapshot.Bytes(),
8002 }
8003 return out, metadata, err
8004 }
8005
8006 err = awsAwsjson11_deserializeOpDocumentGetActiveNamesOutput(&output, shape)
8007 if err != nil {
8008 var snapshot bytes.Buffer
8009 io.Copy(&snapshot, ringBuffer)
8010 err = &smithy.DeserializationError{
8011 Err: fmt.Errorf("failed to decode response body, %w", err),
8012 Snapshot: snapshot.Bytes(),
8013 }
8014 return out, metadata, err
8015 }
8016
8017 return out, metadata, err
8018 }
8019
8020 func awsAwsjson11_deserializeOpErrorGetActiveNames(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8021 var errorBuffer bytes.Buffer
8022 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8023 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8024 }
8025 errorBody := bytes.NewReader(errorBuffer.Bytes())
8026
8027 errorCode := "UnknownError"
8028 errorMessage := errorCode
8029
8030 headerCode := response.Header.Get("X-Amzn-ErrorType")
8031
8032 var buff [1024]byte
8033 ringBuffer := smithyio.NewRingBuffer(buff[:])
8034
8035 body := io.TeeReader(errorBody, ringBuffer)
8036 decoder := json.NewDecoder(body)
8037 decoder.UseNumber()
8038 bodyInfo, err := getProtocolErrorInfo(decoder)
8039 if err != nil {
8040 var snapshot bytes.Buffer
8041 io.Copy(&snapshot, ringBuffer)
8042 err = &smithy.DeserializationError{
8043 Err: fmt.Errorf("failed to decode response body, %w", err),
8044 Snapshot: snapshot.Bytes(),
8045 }
8046 return err
8047 }
8048
8049 errorBody.Seek(0, io.SeekStart)
8050 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
8051 errorCode = restjson.SanitizeErrorCode(typ)
8052 }
8053 if len(bodyInfo.Message) != 0 {
8054 errorMessage = bodyInfo.Message
8055 }
8056 switch {
8057 case strings.EqualFold("AccessDeniedException", errorCode):
8058 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
8059
8060 case strings.EqualFold("AccountSetupInProgressException", errorCode):
8061 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
8062
8063 case strings.EqualFold("InvalidInputException", errorCode):
8064 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
8065
8066 case strings.EqualFold("NotFoundException", errorCode):
8067 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
8068
8069 case strings.EqualFold("OperationFailureException", errorCode):
8070 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
8071
8072 case strings.EqualFold("RegionSetupInProgressException", errorCode):
8073 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
8074
8075 case strings.EqualFold("ServiceException", errorCode):
8076 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
8077
8078 case strings.EqualFold("UnauthenticatedException", errorCode):
8079 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
8080
8081 default:
8082 genericError := &smithy.GenericAPIError{
8083 Code: errorCode,
8084 Message: errorMessage,
8085 }
8086 return genericError
8087
8088 }
8089 }
8090
8091 type awsAwsjson11_deserializeOpGetAlarms struct {
8092 }
8093
8094 func (*awsAwsjson11_deserializeOpGetAlarms) ID() string {
8095 return "OperationDeserializer"
8096 }
8097
8098 func (m *awsAwsjson11_deserializeOpGetAlarms) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8099 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8100 ) {
8101 out, metadata, err = next.HandleDeserialize(ctx, in)
8102 if err != nil {
8103 return out, metadata, err
8104 }
8105
8106 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
8107 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
8108 defer endTimer()
8109 defer span.End()
8110 response, ok := out.RawResponse.(*smithyhttp.Response)
8111 if !ok {
8112 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8113 }
8114
8115 if response.StatusCode < 200 || response.StatusCode >= 300 {
8116 return out, metadata, awsAwsjson11_deserializeOpErrorGetAlarms(response, &metadata)
8117 }
8118 output := &GetAlarmsOutput{}
8119 out.Result = output
8120
8121 var buff [1024]byte
8122 ringBuffer := smithyio.NewRingBuffer(buff[:])
8123
8124 body := io.TeeReader(response.Body, ringBuffer)
8125 decoder := json.NewDecoder(body)
8126 decoder.UseNumber()
8127 var shape interface{}
8128 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8129 var snapshot bytes.Buffer
8130 io.Copy(&snapshot, ringBuffer)
8131 err = &smithy.DeserializationError{
8132 Err: fmt.Errorf("failed to decode response body, %w", err),
8133 Snapshot: snapshot.Bytes(),
8134 }
8135 return out, metadata, err
8136 }
8137
8138 err = awsAwsjson11_deserializeOpDocumentGetAlarmsOutput(&output, shape)
8139 if err != nil {
8140 var snapshot bytes.Buffer
8141 io.Copy(&snapshot, ringBuffer)
8142 err = &smithy.DeserializationError{
8143 Err: fmt.Errorf("failed to decode response body, %w", err),
8144 Snapshot: snapshot.Bytes(),
8145 }
8146 return out, metadata, err
8147 }
8148
8149 return out, metadata, err
8150 }
8151
8152 func awsAwsjson11_deserializeOpErrorGetAlarms(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8153 var errorBuffer bytes.Buffer
8154 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8155 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8156 }
8157 errorBody := bytes.NewReader(errorBuffer.Bytes())
8158
8159 errorCode := "UnknownError"
8160 errorMessage := errorCode
8161
8162 headerCode := response.Header.Get("X-Amzn-ErrorType")
8163
8164 var buff [1024]byte
8165 ringBuffer := smithyio.NewRingBuffer(buff[:])
8166
8167 body := io.TeeReader(errorBody, ringBuffer)
8168 decoder := json.NewDecoder(body)
8169 decoder.UseNumber()
8170 bodyInfo, err := getProtocolErrorInfo(decoder)
8171 if err != nil {
8172 var snapshot bytes.Buffer
8173 io.Copy(&snapshot, ringBuffer)
8174 err = &smithy.DeserializationError{
8175 Err: fmt.Errorf("failed to decode response body, %w", err),
8176 Snapshot: snapshot.Bytes(),
8177 }
8178 return err
8179 }
8180
8181 errorBody.Seek(0, io.SeekStart)
8182 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
8183 errorCode = restjson.SanitizeErrorCode(typ)
8184 }
8185 if len(bodyInfo.Message) != 0 {
8186 errorMessage = bodyInfo.Message
8187 }
8188 switch {
8189 case strings.EqualFold("AccessDeniedException", errorCode):
8190 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
8191
8192 case strings.EqualFold("InvalidInputException", errorCode):
8193 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
8194
8195 case strings.EqualFold("NotFoundException", errorCode):
8196 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
8197
8198 case strings.EqualFold("OperationFailureException", errorCode):
8199 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
8200
8201 case strings.EqualFold("RegionSetupInProgressException", errorCode):
8202 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
8203
8204 case strings.EqualFold("ServiceException", errorCode):
8205 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
8206
8207 case strings.EqualFold("UnauthenticatedException", errorCode):
8208 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
8209
8210 default:
8211 genericError := &smithy.GenericAPIError{
8212 Code: errorCode,
8213 Message: errorMessage,
8214 }
8215 return genericError
8216
8217 }
8218 }
8219
8220 type awsAwsjson11_deserializeOpGetAutoSnapshots struct {
8221 }
8222
8223 func (*awsAwsjson11_deserializeOpGetAutoSnapshots) ID() string {
8224 return "OperationDeserializer"
8225 }
8226
8227 func (m *awsAwsjson11_deserializeOpGetAutoSnapshots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8228 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8229 ) {
8230 out, metadata, err = next.HandleDeserialize(ctx, in)
8231 if err != nil {
8232 return out, metadata, err
8233 }
8234
8235 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
8236 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
8237 defer endTimer()
8238 defer span.End()
8239 response, ok := out.RawResponse.(*smithyhttp.Response)
8240 if !ok {
8241 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8242 }
8243
8244 if response.StatusCode < 200 || response.StatusCode >= 300 {
8245 return out, metadata, awsAwsjson11_deserializeOpErrorGetAutoSnapshots(response, &metadata)
8246 }
8247 output := &GetAutoSnapshotsOutput{}
8248 out.Result = output
8249
8250 var buff [1024]byte
8251 ringBuffer := smithyio.NewRingBuffer(buff[:])
8252
8253 body := io.TeeReader(response.Body, ringBuffer)
8254 decoder := json.NewDecoder(body)
8255 decoder.UseNumber()
8256 var shape interface{}
8257 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8258 var snapshot bytes.Buffer
8259 io.Copy(&snapshot, ringBuffer)
8260 err = &smithy.DeserializationError{
8261 Err: fmt.Errorf("failed to decode response body, %w", err),
8262 Snapshot: snapshot.Bytes(),
8263 }
8264 return out, metadata, err
8265 }
8266
8267 err = awsAwsjson11_deserializeOpDocumentGetAutoSnapshotsOutput(&output, shape)
8268 if err != nil {
8269 var snapshot bytes.Buffer
8270 io.Copy(&snapshot, ringBuffer)
8271 err = &smithy.DeserializationError{
8272 Err: fmt.Errorf("failed to decode response body, %w", err),
8273 Snapshot: snapshot.Bytes(),
8274 }
8275 return out, metadata, err
8276 }
8277
8278 return out, metadata, err
8279 }
8280
8281 func awsAwsjson11_deserializeOpErrorGetAutoSnapshots(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8282 var errorBuffer bytes.Buffer
8283 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8284 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8285 }
8286 errorBody := bytes.NewReader(errorBuffer.Bytes())
8287
8288 errorCode := "UnknownError"
8289 errorMessage := errorCode
8290
8291 headerCode := response.Header.Get("X-Amzn-ErrorType")
8292
8293 var buff [1024]byte
8294 ringBuffer := smithyio.NewRingBuffer(buff[:])
8295
8296 body := io.TeeReader(errorBody, ringBuffer)
8297 decoder := json.NewDecoder(body)
8298 decoder.UseNumber()
8299 bodyInfo, err := getProtocolErrorInfo(decoder)
8300 if err != nil {
8301 var snapshot bytes.Buffer
8302 io.Copy(&snapshot, ringBuffer)
8303 err = &smithy.DeserializationError{
8304 Err: fmt.Errorf("failed to decode response body, %w", err),
8305 Snapshot: snapshot.Bytes(),
8306 }
8307 return err
8308 }
8309
8310 errorBody.Seek(0, io.SeekStart)
8311 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
8312 errorCode = restjson.SanitizeErrorCode(typ)
8313 }
8314 if len(bodyInfo.Message) != 0 {
8315 errorMessage = bodyInfo.Message
8316 }
8317 switch {
8318 case strings.EqualFold("AccessDeniedException", errorCode):
8319 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
8320
8321 case strings.EqualFold("InvalidInputException", errorCode):
8322 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
8323
8324 case strings.EqualFold("NotFoundException", errorCode):
8325 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
8326
8327 case strings.EqualFold("OperationFailureException", errorCode):
8328 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
8329
8330 case strings.EqualFold("RegionSetupInProgressException", errorCode):
8331 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
8332
8333 case strings.EqualFold("ServiceException", errorCode):
8334 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
8335
8336 case strings.EqualFold("UnauthenticatedException", errorCode):
8337 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
8338
8339 default:
8340 genericError := &smithy.GenericAPIError{
8341 Code: errorCode,
8342 Message: errorMessage,
8343 }
8344 return genericError
8345
8346 }
8347 }
8348
8349 type awsAwsjson11_deserializeOpGetBlueprints struct {
8350 }
8351
8352 func (*awsAwsjson11_deserializeOpGetBlueprints) ID() string {
8353 return "OperationDeserializer"
8354 }
8355
8356 func (m *awsAwsjson11_deserializeOpGetBlueprints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8357 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8358 ) {
8359 out, metadata, err = next.HandleDeserialize(ctx, in)
8360 if err != nil {
8361 return out, metadata, err
8362 }
8363
8364 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
8365 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
8366 defer endTimer()
8367 defer span.End()
8368 response, ok := out.RawResponse.(*smithyhttp.Response)
8369 if !ok {
8370 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8371 }
8372
8373 if response.StatusCode < 200 || response.StatusCode >= 300 {
8374 return out, metadata, awsAwsjson11_deserializeOpErrorGetBlueprints(response, &metadata)
8375 }
8376 output := &GetBlueprintsOutput{}
8377 out.Result = output
8378
8379 var buff [1024]byte
8380 ringBuffer := smithyio.NewRingBuffer(buff[:])
8381
8382 body := io.TeeReader(response.Body, ringBuffer)
8383 decoder := json.NewDecoder(body)
8384 decoder.UseNumber()
8385 var shape interface{}
8386 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8387 var snapshot bytes.Buffer
8388 io.Copy(&snapshot, ringBuffer)
8389 err = &smithy.DeserializationError{
8390 Err: fmt.Errorf("failed to decode response body, %w", err),
8391 Snapshot: snapshot.Bytes(),
8392 }
8393 return out, metadata, err
8394 }
8395
8396 err = awsAwsjson11_deserializeOpDocumentGetBlueprintsOutput(&output, shape)
8397 if err != nil {
8398 var snapshot bytes.Buffer
8399 io.Copy(&snapshot, ringBuffer)
8400 err = &smithy.DeserializationError{
8401 Err: fmt.Errorf("failed to decode response body, %w", err),
8402 Snapshot: snapshot.Bytes(),
8403 }
8404 return out, metadata, err
8405 }
8406
8407 return out, metadata, err
8408 }
8409
8410 func awsAwsjson11_deserializeOpErrorGetBlueprints(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8411 var errorBuffer bytes.Buffer
8412 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8413 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8414 }
8415 errorBody := bytes.NewReader(errorBuffer.Bytes())
8416
8417 errorCode := "UnknownError"
8418 errorMessage := errorCode
8419
8420 headerCode := response.Header.Get("X-Amzn-ErrorType")
8421
8422 var buff [1024]byte
8423 ringBuffer := smithyio.NewRingBuffer(buff[:])
8424
8425 body := io.TeeReader(errorBody, ringBuffer)
8426 decoder := json.NewDecoder(body)
8427 decoder.UseNumber()
8428 bodyInfo, err := getProtocolErrorInfo(decoder)
8429 if err != nil {
8430 var snapshot bytes.Buffer
8431 io.Copy(&snapshot, ringBuffer)
8432 err = &smithy.DeserializationError{
8433 Err: fmt.Errorf("failed to decode response body, %w", err),
8434 Snapshot: snapshot.Bytes(),
8435 }
8436 return err
8437 }
8438
8439 errorBody.Seek(0, io.SeekStart)
8440 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
8441 errorCode = restjson.SanitizeErrorCode(typ)
8442 }
8443 if len(bodyInfo.Message) != 0 {
8444 errorMessage = bodyInfo.Message
8445 }
8446 switch {
8447 case strings.EqualFold("AccessDeniedException", errorCode):
8448 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
8449
8450 case strings.EqualFold("AccountSetupInProgressException", errorCode):
8451 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
8452
8453 case strings.EqualFold("InvalidInputException", errorCode):
8454 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
8455
8456 case strings.EqualFold("NotFoundException", errorCode):
8457 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
8458
8459 case strings.EqualFold("OperationFailureException", errorCode):
8460 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
8461
8462 case strings.EqualFold("RegionSetupInProgressException", errorCode):
8463 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
8464
8465 case strings.EqualFold("ServiceException", errorCode):
8466 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
8467
8468 case strings.EqualFold("UnauthenticatedException", errorCode):
8469 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
8470
8471 default:
8472 genericError := &smithy.GenericAPIError{
8473 Code: errorCode,
8474 Message: errorMessage,
8475 }
8476 return genericError
8477
8478 }
8479 }
8480
8481 type awsAwsjson11_deserializeOpGetBucketAccessKeys struct {
8482 }
8483
8484 func (*awsAwsjson11_deserializeOpGetBucketAccessKeys) ID() string {
8485 return "OperationDeserializer"
8486 }
8487
8488 func (m *awsAwsjson11_deserializeOpGetBucketAccessKeys) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8489 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8490 ) {
8491 out, metadata, err = next.HandleDeserialize(ctx, in)
8492 if err != nil {
8493 return out, metadata, err
8494 }
8495
8496 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
8497 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
8498 defer endTimer()
8499 defer span.End()
8500 response, ok := out.RawResponse.(*smithyhttp.Response)
8501 if !ok {
8502 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8503 }
8504
8505 if response.StatusCode < 200 || response.StatusCode >= 300 {
8506 return out, metadata, awsAwsjson11_deserializeOpErrorGetBucketAccessKeys(response, &metadata)
8507 }
8508 output := &GetBucketAccessKeysOutput{}
8509 out.Result = output
8510
8511 var buff [1024]byte
8512 ringBuffer := smithyio.NewRingBuffer(buff[:])
8513
8514 body := io.TeeReader(response.Body, ringBuffer)
8515 decoder := json.NewDecoder(body)
8516 decoder.UseNumber()
8517 var shape interface{}
8518 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8519 var snapshot bytes.Buffer
8520 io.Copy(&snapshot, ringBuffer)
8521 err = &smithy.DeserializationError{
8522 Err: fmt.Errorf("failed to decode response body, %w", err),
8523 Snapshot: snapshot.Bytes(),
8524 }
8525 return out, metadata, err
8526 }
8527
8528 err = awsAwsjson11_deserializeOpDocumentGetBucketAccessKeysOutput(&output, shape)
8529 if err != nil {
8530 var snapshot bytes.Buffer
8531 io.Copy(&snapshot, ringBuffer)
8532 err = &smithy.DeserializationError{
8533 Err: fmt.Errorf("failed to decode response body, %w", err),
8534 Snapshot: snapshot.Bytes(),
8535 }
8536 return out, metadata, err
8537 }
8538
8539 return out, metadata, err
8540 }
8541
8542 func awsAwsjson11_deserializeOpErrorGetBucketAccessKeys(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8543 var errorBuffer bytes.Buffer
8544 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8545 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8546 }
8547 errorBody := bytes.NewReader(errorBuffer.Bytes())
8548
8549 errorCode := "UnknownError"
8550 errorMessage := errorCode
8551
8552 headerCode := response.Header.Get("X-Amzn-ErrorType")
8553
8554 var buff [1024]byte
8555 ringBuffer := smithyio.NewRingBuffer(buff[:])
8556
8557 body := io.TeeReader(errorBody, ringBuffer)
8558 decoder := json.NewDecoder(body)
8559 decoder.UseNumber()
8560 bodyInfo, err := getProtocolErrorInfo(decoder)
8561 if err != nil {
8562 var snapshot bytes.Buffer
8563 io.Copy(&snapshot, ringBuffer)
8564 err = &smithy.DeserializationError{
8565 Err: fmt.Errorf("failed to decode response body, %w", err),
8566 Snapshot: snapshot.Bytes(),
8567 }
8568 return err
8569 }
8570
8571 errorBody.Seek(0, io.SeekStart)
8572 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
8573 errorCode = restjson.SanitizeErrorCode(typ)
8574 }
8575 if len(bodyInfo.Message) != 0 {
8576 errorMessage = bodyInfo.Message
8577 }
8578 switch {
8579 case strings.EqualFold("AccessDeniedException", errorCode):
8580 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
8581
8582 case strings.EqualFold("InvalidInputException", errorCode):
8583 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
8584
8585 case strings.EqualFold("NotFoundException", errorCode):
8586 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
8587
8588 case strings.EqualFold("RegionSetupInProgressException", errorCode):
8589 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
8590
8591 case strings.EqualFold("ServiceException", errorCode):
8592 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
8593
8594 case strings.EqualFold("UnauthenticatedException", errorCode):
8595 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
8596
8597 default:
8598 genericError := &smithy.GenericAPIError{
8599 Code: errorCode,
8600 Message: errorMessage,
8601 }
8602 return genericError
8603
8604 }
8605 }
8606
8607 type awsAwsjson11_deserializeOpGetBucketBundles struct {
8608 }
8609
8610 func (*awsAwsjson11_deserializeOpGetBucketBundles) ID() string {
8611 return "OperationDeserializer"
8612 }
8613
8614 func (m *awsAwsjson11_deserializeOpGetBucketBundles) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8615 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8616 ) {
8617 out, metadata, err = next.HandleDeserialize(ctx, in)
8618 if err != nil {
8619 return out, metadata, err
8620 }
8621
8622 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
8623 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
8624 defer endTimer()
8625 defer span.End()
8626 response, ok := out.RawResponse.(*smithyhttp.Response)
8627 if !ok {
8628 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8629 }
8630
8631 if response.StatusCode < 200 || response.StatusCode >= 300 {
8632 return out, metadata, awsAwsjson11_deserializeOpErrorGetBucketBundles(response, &metadata)
8633 }
8634 output := &GetBucketBundlesOutput{}
8635 out.Result = output
8636
8637 var buff [1024]byte
8638 ringBuffer := smithyio.NewRingBuffer(buff[:])
8639
8640 body := io.TeeReader(response.Body, ringBuffer)
8641 decoder := json.NewDecoder(body)
8642 decoder.UseNumber()
8643 var shape interface{}
8644 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8645 var snapshot bytes.Buffer
8646 io.Copy(&snapshot, ringBuffer)
8647 err = &smithy.DeserializationError{
8648 Err: fmt.Errorf("failed to decode response body, %w", err),
8649 Snapshot: snapshot.Bytes(),
8650 }
8651 return out, metadata, err
8652 }
8653
8654 err = awsAwsjson11_deserializeOpDocumentGetBucketBundlesOutput(&output, shape)
8655 if err != nil {
8656 var snapshot bytes.Buffer
8657 io.Copy(&snapshot, ringBuffer)
8658 err = &smithy.DeserializationError{
8659 Err: fmt.Errorf("failed to decode response body, %w", err),
8660 Snapshot: snapshot.Bytes(),
8661 }
8662 return out, metadata, err
8663 }
8664
8665 return out, metadata, err
8666 }
8667
8668 func awsAwsjson11_deserializeOpErrorGetBucketBundles(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8669 var errorBuffer bytes.Buffer
8670 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8671 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8672 }
8673 errorBody := bytes.NewReader(errorBuffer.Bytes())
8674
8675 errorCode := "UnknownError"
8676 errorMessage := errorCode
8677
8678 headerCode := response.Header.Get("X-Amzn-ErrorType")
8679
8680 var buff [1024]byte
8681 ringBuffer := smithyio.NewRingBuffer(buff[:])
8682
8683 body := io.TeeReader(errorBody, ringBuffer)
8684 decoder := json.NewDecoder(body)
8685 decoder.UseNumber()
8686 bodyInfo, err := getProtocolErrorInfo(decoder)
8687 if err != nil {
8688 var snapshot bytes.Buffer
8689 io.Copy(&snapshot, ringBuffer)
8690 err = &smithy.DeserializationError{
8691 Err: fmt.Errorf("failed to decode response body, %w", err),
8692 Snapshot: snapshot.Bytes(),
8693 }
8694 return err
8695 }
8696
8697 errorBody.Seek(0, io.SeekStart)
8698 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
8699 errorCode = restjson.SanitizeErrorCode(typ)
8700 }
8701 if len(bodyInfo.Message) != 0 {
8702 errorMessage = bodyInfo.Message
8703 }
8704 switch {
8705 case strings.EqualFold("AccessDeniedException", errorCode):
8706 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
8707
8708 case strings.EqualFold("InvalidInputException", errorCode):
8709 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
8710
8711 case strings.EqualFold("RegionSetupInProgressException", errorCode):
8712 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
8713
8714 case strings.EqualFold("ServiceException", errorCode):
8715 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
8716
8717 case strings.EqualFold("UnauthenticatedException", errorCode):
8718 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
8719
8720 default:
8721 genericError := &smithy.GenericAPIError{
8722 Code: errorCode,
8723 Message: errorMessage,
8724 }
8725 return genericError
8726
8727 }
8728 }
8729
8730 type awsAwsjson11_deserializeOpGetBucketMetricData struct {
8731 }
8732
8733 func (*awsAwsjson11_deserializeOpGetBucketMetricData) ID() string {
8734 return "OperationDeserializer"
8735 }
8736
8737 func (m *awsAwsjson11_deserializeOpGetBucketMetricData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8738 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8739 ) {
8740 out, metadata, err = next.HandleDeserialize(ctx, in)
8741 if err != nil {
8742 return out, metadata, err
8743 }
8744
8745 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
8746 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
8747 defer endTimer()
8748 defer span.End()
8749 response, ok := out.RawResponse.(*smithyhttp.Response)
8750 if !ok {
8751 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8752 }
8753
8754 if response.StatusCode < 200 || response.StatusCode >= 300 {
8755 return out, metadata, awsAwsjson11_deserializeOpErrorGetBucketMetricData(response, &metadata)
8756 }
8757 output := &GetBucketMetricDataOutput{}
8758 out.Result = output
8759
8760 var buff [1024]byte
8761 ringBuffer := smithyio.NewRingBuffer(buff[:])
8762
8763 body := io.TeeReader(response.Body, ringBuffer)
8764 decoder := json.NewDecoder(body)
8765 decoder.UseNumber()
8766 var shape interface{}
8767 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8768 var snapshot bytes.Buffer
8769 io.Copy(&snapshot, ringBuffer)
8770 err = &smithy.DeserializationError{
8771 Err: fmt.Errorf("failed to decode response body, %w", err),
8772 Snapshot: snapshot.Bytes(),
8773 }
8774 return out, metadata, err
8775 }
8776
8777 err = awsAwsjson11_deserializeOpDocumentGetBucketMetricDataOutput(&output, shape)
8778 if err != nil {
8779 var snapshot bytes.Buffer
8780 io.Copy(&snapshot, ringBuffer)
8781 err = &smithy.DeserializationError{
8782 Err: fmt.Errorf("failed to decode response body, %w", err),
8783 Snapshot: snapshot.Bytes(),
8784 }
8785 return out, metadata, err
8786 }
8787
8788 return out, metadata, err
8789 }
8790
8791 func awsAwsjson11_deserializeOpErrorGetBucketMetricData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8792 var errorBuffer bytes.Buffer
8793 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8794 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8795 }
8796 errorBody := bytes.NewReader(errorBuffer.Bytes())
8797
8798 errorCode := "UnknownError"
8799 errorMessage := errorCode
8800
8801 headerCode := response.Header.Get("X-Amzn-ErrorType")
8802
8803 var buff [1024]byte
8804 ringBuffer := smithyio.NewRingBuffer(buff[:])
8805
8806 body := io.TeeReader(errorBody, ringBuffer)
8807 decoder := json.NewDecoder(body)
8808 decoder.UseNumber()
8809 bodyInfo, err := getProtocolErrorInfo(decoder)
8810 if err != nil {
8811 var snapshot bytes.Buffer
8812 io.Copy(&snapshot, ringBuffer)
8813 err = &smithy.DeserializationError{
8814 Err: fmt.Errorf("failed to decode response body, %w", err),
8815 Snapshot: snapshot.Bytes(),
8816 }
8817 return err
8818 }
8819
8820 errorBody.Seek(0, io.SeekStart)
8821 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
8822 errorCode = restjson.SanitizeErrorCode(typ)
8823 }
8824 if len(bodyInfo.Message) != 0 {
8825 errorMessage = bodyInfo.Message
8826 }
8827 switch {
8828 case strings.EqualFold("AccessDeniedException", errorCode):
8829 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
8830
8831 case strings.EqualFold("InvalidInputException", errorCode):
8832 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
8833
8834 case strings.EqualFold("NotFoundException", errorCode):
8835 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
8836
8837 case strings.EqualFold("RegionSetupInProgressException", errorCode):
8838 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
8839
8840 case strings.EqualFold("ServiceException", errorCode):
8841 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
8842
8843 case strings.EqualFold("UnauthenticatedException", errorCode):
8844 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
8845
8846 default:
8847 genericError := &smithy.GenericAPIError{
8848 Code: errorCode,
8849 Message: errorMessage,
8850 }
8851 return genericError
8852
8853 }
8854 }
8855
8856 type awsAwsjson11_deserializeOpGetBuckets struct {
8857 }
8858
8859 func (*awsAwsjson11_deserializeOpGetBuckets) ID() string {
8860 return "OperationDeserializer"
8861 }
8862
8863 func (m *awsAwsjson11_deserializeOpGetBuckets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8864 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8865 ) {
8866 out, metadata, err = next.HandleDeserialize(ctx, in)
8867 if err != nil {
8868 return out, metadata, err
8869 }
8870
8871 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
8872 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
8873 defer endTimer()
8874 defer span.End()
8875 response, ok := out.RawResponse.(*smithyhttp.Response)
8876 if !ok {
8877 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8878 }
8879
8880 if response.StatusCode < 200 || response.StatusCode >= 300 {
8881 return out, metadata, awsAwsjson11_deserializeOpErrorGetBuckets(response, &metadata)
8882 }
8883 output := &GetBucketsOutput{}
8884 out.Result = output
8885
8886 var buff [1024]byte
8887 ringBuffer := smithyio.NewRingBuffer(buff[:])
8888
8889 body := io.TeeReader(response.Body, ringBuffer)
8890 decoder := json.NewDecoder(body)
8891 decoder.UseNumber()
8892 var shape interface{}
8893 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8894 var snapshot bytes.Buffer
8895 io.Copy(&snapshot, ringBuffer)
8896 err = &smithy.DeserializationError{
8897 Err: fmt.Errorf("failed to decode response body, %w", err),
8898 Snapshot: snapshot.Bytes(),
8899 }
8900 return out, metadata, err
8901 }
8902
8903 err = awsAwsjson11_deserializeOpDocumentGetBucketsOutput(&output, shape)
8904 if err != nil {
8905 var snapshot bytes.Buffer
8906 io.Copy(&snapshot, ringBuffer)
8907 err = &smithy.DeserializationError{
8908 Err: fmt.Errorf("failed to decode response body, %w", err),
8909 Snapshot: snapshot.Bytes(),
8910 }
8911 return out, metadata, err
8912 }
8913
8914 return out, metadata, err
8915 }
8916
8917 func awsAwsjson11_deserializeOpErrorGetBuckets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8918 var errorBuffer bytes.Buffer
8919 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8920 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8921 }
8922 errorBody := bytes.NewReader(errorBuffer.Bytes())
8923
8924 errorCode := "UnknownError"
8925 errorMessage := errorCode
8926
8927 headerCode := response.Header.Get("X-Amzn-ErrorType")
8928
8929 var buff [1024]byte
8930 ringBuffer := smithyio.NewRingBuffer(buff[:])
8931
8932 body := io.TeeReader(errorBody, ringBuffer)
8933 decoder := json.NewDecoder(body)
8934 decoder.UseNumber()
8935 bodyInfo, err := getProtocolErrorInfo(decoder)
8936 if err != nil {
8937 var snapshot bytes.Buffer
8938 io.Copy(&snapshot, ringBuffer)
8939 err = &smithy.DeserializationError{
8940 Err: fmt.Errorf("failed to decode response body, %w", err),
8941 Snapshot: snapshot.Bytes(),
8942 }
8943 return err
8944 }
8945
8946 errorBody.Seek(0, io.SeekStart)
8947 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
8948 errorCode = restjson.SanitizeErrorCode(typ)
8949 }
8950 if len(bodyInfo.Message) != 0 {
8951 errorMessage = bodyInfo.Message
8952 }
8953 switch {
8954 case strings.EqualFold("AccessDeniedException", errorCode):
8955 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
8956
8957 case strings.EqualFold("InvalidInputException", errorCode):
8958 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
8959
8960 case strings.EqualFold("NotFoundException", errorCode):
8961 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
8962
8963 case strings.EqualFold("RegionSetupInProgressException", errorCode):
8964 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
8965
8966 case strings.EqualFold("ServiceException", errorCode):
8967 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
8968
8969 case strings.EqualFold("UnauthenticatedException", errorCode):
8970 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
8971
8972 default:
8973 genericError := &smithy.GenericAPIError{
8974 Code: errorCode,
8975 Message: errorMessage,
8976 }
8977 return genericError
8978
8979 }
8980 }
8981
8982 type awsAwsjson11_deserializeOpGetBundles struct {
8983 }
8984
8985 func (*awsAwsjson11_deserializeOpGetBundles) ID() string {
8986 return "OperationDeserializer"
8987 }
8988
8989 func (m *awsAwsjson11_deserializeOpGetBundles) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8990 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8991 ) {
8992 out, metadata, err = next.HandleDeserialize(ctx, in)
8993 if err != nil {
8994 return out, metadata, err
8995 }
8996
8997 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
8998 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
8999 defer endTimer()
9000 defer span.End()
9001 response, ok := out.RawResponse.(*smithyhttp.Response)
9002 if !ok {
9003 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9004 }
9005
9006 if response.StatusCode < 200 || response.StatusCode >= 300 {
9007 return out, metadata, awsAwsjson11_deserializeOpErrorGetBundles(response, &metadata)
9008 }
9009 output := &GetBundlesOutput{}
9010 out.Result = output
9011
9012 var buff [1024]byte
9013 ringBuffer := smithyio.NewRingBuffer(buff[:])
9014
9015 body := io.TeeReader(response.Body, ringBuffer)
9016 decoder := json.NewDecoder(body)
9017 decoder.UseNumber()
9018 var shape interface{}
9019 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9020 var snapshot bytes.Buffer
9021 io.Copy(&snapshot, ringBuffer)
9022 err = &smithy.DeserializationError{
9023 Err: fmt.Errorf("failed to decode response body, %w", err),
9024 Snapshot: snapshot.Bytes(),
9025 }
9026 return out, metadata, err
9027 }
9028
9029 err = awsAwsjson11_deserializeOpDocumentGetBundlesOutput(&output, shape)
9030 if err != nil {
9031 var snapshot bytes.Buffer
9032 io.Copy(&snapshot, ringBuffer)
9033 err = &smithy.DeserializationError{
9034 Err: fmt.Errorf("failed to decode response body, %w", err),
9035 Snapshot: snapshot.Bytes(),
9036 }
9037 return out, metadata, err
9038 }
9039
9040 return out, metadata, err
9041 }
9042
9043 func awsAwsjson11_deserializeOpErrorGetBundles(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9044 var errorBuffer bytes.Buffer
9045 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9046 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9047 }
9048 errorBody := bytes.NewReader(errorBuffer.Bytes())
9049
9050 errorCode := "UnknownError"
9051 errorMessage := errorCode
9052
9053 headerCode := response.Header.Get("X-Amzn-ErrorType")
9054
9055 var buff [1024]byte
9056 ringBuffer := smithyio.NewRingBuffer(buff[:])
9057
9058 body := io.TeeReader(errorBody, ringBuffer)
9059 decoder := json.NewDecoder(body)
9060 decoder.UseNumber()
9061 bodyInfo, err := getProtocolErrorInfo(decoder)
9062 if err != nil {
9063 var snapshot bytes.Buffer
9064 io.Copy(&snapshot, ringBuffer)
9065 err = &smithy.DeserializationError{
9066 Err: fmt.Errorf("failed to decode response body, %w", err),
9067 Snapshot: snapshot.Bytes(),
9068 }
9069 return err
9070 }
9071
9072 errorBody.Seek(0, io.SeekStart)
9073 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
9074 errorCode = restjson.SanitizeErrorCode(typ)
9075 }
9076 if len(bodyInfo.Message) != 0 {
9077 errorMessage = bodyInfo.Message
9078 }
9079 switch {
9080 case strings.EqualFold("AccessDeniedException", errorCode):
9081 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
9082
9083 case strings.EqualFold("AccountSetupInProgressException", errorCode):
9084 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
9085
9086 case strings.EqualFold("InvalidInputException", errorCode):
9087 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
9088
9089 case strings.EqualFold("NotFoundException", errorCode):
9090 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
9091
9092 case strings.EqualFold("OperationFailureException", errorCode):
9093 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
9094
9095 case strings.EqualFold("RegionSetupInProgressException", errorCode):
9096 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
9097
9098 case strings.EqualFold("ServiceException", errorCode):
9099 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
9100
9101 case strings.EqualFold("UnauthenticatedException", errorCode):
9102 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
9103
9104 default:
9105 genericError := &smithy.GenericAPIError{
9106 Code: errorCode,
9107 Message: errorMessage,
9108 }
9109 return genericError
9110
9111 }
9112 }
9113
9114 type awsAwsjson11_deserializeOpGetCertificates struct {
9115 }
9116
9117 func (*awsAwsjson11_deserializeOpGetCertificates) ID() string {
9118 return "OperationDeserializer"
9119 }
9120
9121 func (m *awsAwsjson11_deserializeOpGetCertificates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9122 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9123 ) {
9124 out, metadata, err = next.HandleDeserialize(ctx, in)
9125 if err != nil {
9126 return out, metadata, err
9127 }
9128
9129 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
9130 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
9131 defer endTimer()
9132 defer span.End()
9133 response, ok := out.RawResponse.(*smithyhttp.Response)
9134 if !ok {
9135 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9136 }
9137
9138 if response.StatusCode < 200 || response.StatusCode >= 300 {
9139 return out, metadata, awsAwsjson11_deserializeOpErrorGetCertificates(response, &metadata)
9140 }
9141 output := &GetCertificatesOutput{}
9142 out.Result = output
9143
9144 var buff [1024]byte
9145 ringBuffer := smithyio.NewRingBuffer(buff[:])
9146
9147 body := io.TeeReader(response.Body, ringBuffer)
9148 decoder := json.NewDecoder(body)
9149 decoder.UseNumber()
9150 var shape interface{}
9151 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9152 var snapshot bytes.Buffer
9153 io.Copy(&snapshot, ringBuffer)
9154 err = &smithy.DeserializationError{
9155 Err: fmt.Errorf("failed to decode response body, %w", err),
9156 Snapshot: snapshot.Bytes(),
9157 }
9158 return out, metadata, err
9159 }
9160
9161 err = awsAwsjson11_deserializeOpDocumentGetCertificatesOutput(&output, shape)
9162 if err != nil {
9163 var snapshot bytes.Buffer
9164 io.Copy(&snapshot, ringBuffer)
9165 err = &smithy.DeserializationError{
9166 Err: fmt.Errorf("failed to decode response body, %w", err),
9167 Snapshot: snapshot.Bytes(),
9168 }
9169 return out, metadata, err
9170 }
9171
9172 return out, metadata, err
9173 }
9174
9175 func awsAwsjson11_deserializeOpErrorGetCertificates(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9176 var errorBuffer bytes.Buffer
9177 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9178 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9179 }
9180 errorBody := bytes.NewReader(errorBuffer.Bytes())
9181
9182 errorCode := "UnknownError"
9183 errorMessage := errorCode
9184
9185 headerCode := response.Header.Get("X-Amzn-ErrorType")
9186
9187 var buff [1024]byte
9188 ringBuffer := smithyio.NewRingBuffer(buff[:])
9189
9190 body := io.TeeReader(errorBody, ringBuffer)
9191 decoder := json.NewDecoder(body)
9192 decoder.UseNumber()
9193 bodyInfo, err := getProtocolErrorInfo(decoder)
9194 if err != nil {
9195 var snapshot bytes.Buffer
9196 io.Copy(&snapshot, ringBuffer)
9197 err = &smithy.DeserializationError{
9198 Err: fmt.Errorf("failed to decode response body, %w", err),
9199 Snapshot: snapshot.Bytes(),
9200 }
9201 return err
9202 }
9203
9204 errorBody.Seek(0, io.SeekStart)
9205 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
9206 errorCode = restjson.SanitizeErrorCode(typ)
9207 }
9208 if len(bodyInfo.Message) != 0 {
9209 errorMessage = bodyInfo.Message
9210 }
9211 switch {
9212 case strings.EqualFold("AccessDeniedException", errorCode):
9213 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
9214
9215 case strings.EqualFold("InvalidInputException", errorCode):
9216 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
9217
9218 case strings.EqualFold("NotFoundException", errorCode):
9219 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
9220
9221 case strings.EqualFold("RegionSetupInProgressException", errorCode):
9222 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
9223
9224 case strings.EqualFold("ServiceException", errorCode):
9225 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
9226
9227 case strings.EqualFold("UnauthenticatedException", errorCode):
9228 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
9229
9230 default:
9231 genericError := &smithy.GenericAPIError{
9232 Code: errorCode,
9233 Message: errorMessage,
9234 }
9235 return genericError
9236
9237 }
9238 }
9239
9240 type awsAwsjson11_deserializeOpGetCloudFormationStackRecords struct {
9241 }
9242
9243 func (*awsAwsjson11_deserializeOpGetCloudFormationStackRecords) ID() string {
9244 return "OperationDeserializer"
9245 }
9246
9247 func (m *awsAwsjson11_deserializeOpGetCloudFormationStackRecords) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9248 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9249 ) {
9250 out, metadata, err = next.HandleDeserialize(ctx, in)
9251 if err != nil {
9252 return out, metadata, err
9253 }
9254
9255 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
9256 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
9257 defer endTimer()
9258 defer span.End()
9259 response, ok := out.RawResponse.(*smithyhttp.Response)
9260 if !ok {
9261 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9262 }
9263
9264 if response.StatusCode < 200 || response.StatusCode >= 300 {
9265 return out, metadata, awsAwsjson11_deserializeOpErrorGetCloudFormationStackRecords(response, &metadata)
9266 }
9267 output := &GetCloudFormationStackRecordsOutput{}
9268 out.Result = output
9269
9270 var buff [1024]byte
9271 ringBuffer := smithyio.NewRingBuffer(buff[:])
9272
9273 body := io.TeeReader(response.Body, ringBuffer)
9274 decoder := json.NewDecoder(body)
9275 decoder.UseNumber()
9276 var shape interface{}
9277 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9278 var snapshot bytes.Buffer
9279 io.Copy(&snapshot, ringBuffer)
9280 err = &smithy.DeserializationError{
9281 Err: fmt.Errorf("failed to decode response body, %w", err),
9282 Snapshot: snapshot.Bytes(),
9283 }
9284 return out, metadata, err
9285 }
9286
9287 err = awsAwsjson11_deserializeOpDocumentGetCloudFormationStackRecordsOutput(&output, shape)
9288 if err != nil {
9289 var snapshot bytes.Buffer
9290 io.Copy(&snapshot, ringBuffer)
9291 err = &smithy.DeserializationError{
9292 Err: fmt.Errorf("failed to decode response body, %w", err),
9293 Snapshot: snapshot.Bytes(),
9294 }
9295 return out, metadata, err
9296 }
9297
9298 return out, metadata, err
9299 }
9300
9301 func awsAwsjson11_deserializeOpErrorGetCloudFormationStackRecords(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9302 var errorBuffer bytes.Buffer
9303 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9304 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9305 }
9306 errorBody := bytes.NewReader(errorBuffer.Bytes())
9307
9308 errorCode := "UnknownError"
9309 errorMessage := errorCode
9310
9311 headerCode := response.Header.Get("X-Amzn-ErrorType")
9312
9313 var buff [1024]byte
9314 ringBuffer := smithyio.NewRingBuffer(buff[:])
9315
9316 body := io.TeeReader(errorBody, ringBuffer)
9317 decoder := json.NewDecoder(body)
9318 decoder.UseNumber()
9319 bodyInfo, err := getProtocolErrorInfo(decoder)
9320 if err != nil {
9321 var snapshot bytes.Buffer
9322 io.Copy(&snapshot, ringBuffer)
9323 err = &smithy.DeserializationError{
9324 Err: fmt.Errorf("failed to decode response body, %w", err),
9325 Snapshot: snapshot.Bytes(),
9326 }
9327 return err
9328 }
9329
9330 errorBody.Seek(0, io.SeekStart)
9331 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
9332 errorCode = restjson.SanitizeErrorCode(typ)
9333 }
9334 if len(bodyInfo.Message) != 0 {
9335 errorMessage = bodyInfo.Message
9336 }
9337 switch {
9338 case strings.EqualFold("AccessDeniedException", errorCode):
9339 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
9340
9341 case strings.EqualFold("AccountSetupInProgressException", errorCode):
9342 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
9343
9344 case strings.EqualFold("InvalidInputException", errorCode):
9345 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
9346
9347 case strings.EqualFold("NotFoundException", errorCode):
9348 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
9349
9350 case strings.EqualFold("OperationFailureException", errorCode):
9351 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
9352
9353 case strings.EqualFold("RegionSetupInProgressException", errorCode):
9354 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
9355
9356 case strings.EqualFold("ServiceException", errorCode):
9357 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
9358
9359 case strings.EqualFold("UnauthenticatedException", errorCode):
9360 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
9361
9362 default:
9363 genericError := &smithy.GenericAPIError{
9364 Code: errorCode,
9365 Message: errorMessage,
9366 }
9367 return genericError
9368
9369 }
9370 }
9371
9372 type awsAwsjson11_deserializeOpGetContactMethods struct {
9373 }
9374
9375 func (*awsAwsjson11_deserializeOpGetContactMethods) ID() string {
9376 return "OperationDeserializer"
9377 }
9378
9379 func (m *awsAwsjson11_deserializeOpGetContactMethods) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9380 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9381 ) {
9382 out, metadata, err = next.HandleDeserialize(ctx, in)
9383 if err != nil {
9384 return out, metadata, err
9385 }
9386
9387 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
9388 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
9389 defer endTimer()
9390 defer span.End()
9391 response, ok := out.RawResponse.(*smithyhttp.Response)
9392 if !ok {
9393 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9394 }
9395
9396 if response.StatusCode < 200 || response.StatusCode >= 300 {
9397 return out, metadata, awsAwsjson11_deserializeOpErrorGetContactMethods(response, &metadata)
9398 }
9399 output := &GetContactMethodsOutput{}
9400 out.Result = output
9401
9402 var buff [1024]byte
9403 ringBuffer := smithyio.NewRingBuffer(buff[:])
9404
9405 body := io.TeeReader(response.Body, ringBuffer)
9406 decoder := json.NewDecoder(body)
9407 decoder.UseNumber()
9408 var shape interface{}
9409 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9410 var snapshot bytes.Buffer
9411 io.Copy(&snapshot, ringBuffer)
9412 err = &smithy.DeserializationError{
9413 Err: fmt.Errorf("failed to decode response body, %w", err),
9414 Snapshot: snapshot.Bytes(),
9415 }
9416 return out, metadata, err
9417 }
9418
9419 err = awsAwsjson11_deserializeOpDocumentGetContactMethodsOutput(&output, shape)
9420 if err != nil {
9421 var snapshot bytes.Buffer
9422 io.Copy(&snapshot, ringBuffer)
9423 err = &smithy.DeserializationError{
9424 Err: fmt.Errorf("failed to decode response body, %w", err),
9425 Snapshot: snapshot.Bytes(),
9426 }
9427 return out, metadata, err
9428 }
9429
9430 return out, metadata, err
9431 }
9432
9433 func awsAwsjson11_deserializeOpErrorGetContactMethods(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9434 var errorBuffer bytes.Buffer
9435 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9436 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9437 }
9438 errorBody := bytes.NewReader(errorBuffer.Bytes())
9439
9440 errorCode := "UnknownError"
9441 errorMessage := errorCode
9442
9443 headerCode := response.Header.Get("X-Amzn-ErrorType")
9444
9445 var buff [1024]byte
9446 ringBuffer := smithyio.NewRingBuffer(buff[:])
9447
9448 body := io.TeeReader(errorBody, ringBuffer)
9449 decoder := json.NewDecoder(body)
9450 decoder.UseNumber()
9451 bodyInfo, err := getProtocolErrorInfo(decoder)
9452 if err != nil {
9453 var snapshot bytes.Buffer
9454 io.Copy(&snapshot, ringBuffer)
9455 err = &smithy.DeserializationError{
9456 Err: fmt.Errorf("failed to decode response body, %w", err),
9457 Snapshot: snapshot.Bytes(),
9458 }
9459 return err
9460 }
9461
9462 errorBody.Seek(0, io.SeekStart)
9463 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
9464 errorCode = restjson.SanitizeErrorCode(typ)
9465 }
9466 if len(bodyInfo.Message) != 0 {
9467 errorMessage = bodyInfo.Message
9468 }
9469 switch {
9470 case strings.EqualFold("AccessDeniedException", errorCode):
9471 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
9472
9473 case strings.EqualFold("InvalidInputException", errorCode):
9474 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
9475
9476 case strings.EqualFold("NotFoundException", errorCode):
9477 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
9478
9479 case strings.EqualFold("OperationFailureException", errorCode):
9480 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
9481
9482 case strings.EqualFold("RegionSetupInProgressException", errorCode):
9483 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
9484
9485 case strings.EqualFold("ServiceException", errorCode):
9486 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
9487
9488 case strings.EqualFold("UnauthenticatedException", errorCode):
9489 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
9490
9491 default:
9492 genericError := &smithy.GenericAPIError{
9493 Code: errorCode,
9494 Message: errorMessage,
9495 }
9496 return genericError
9497
9498 }
9499 }
9500
9501 type awsAwsjson11_deserializeOpGetContainerAPIMetadata struct {
9502 }
9503
9504 func (*awsAwsjson11_deserializeOpGetContainerAPIMetadata) ID() string {
9505 return "OperationDeserializer"
9506 }
9507
9508 func (m *awsAwsjson11_deserializeOpGetContainerAPIMetadata) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9509 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9510 ) {
9511 out, metadata, err = next.HandleDeserialize(ctx, in)
9512 if err != nil {
9513 return out, metadata, err
9514 }
9515
9516 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
9517 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
9518 defer endTimer()
9519 defer span.End()
9520 response, ok := out.RawResponse.(*smithyhttp.Response)
9521 if !ok {
9522 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9523 }
9524
9525 if response.StatusCode < 200 || response.StatusCode >= 300 {
9526 return out, metadata, awsAwsjson11_deserializeOpErrorGetContainerAPIMetadata(response, &metadata)
9527 }
9528 output := &GetContainerAPIMetadataOutput{}
9529 out.Result = output
9530
9531 var buff [1024]byte
9532 ringBuffer := smithyio.NewRingBuffer(buff[:])
9533
9534 body := io.TeeReader(response.Body, ringBuffer)
9535 decoder := json.NewDecoder(body)
9536 decoder.UseNumber()
9537 var shape interface{}
9538 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9539 var snapshot bytes.Buffer
9540 io.Copy(&snapshot, ringBuffer)
9541 err = &smithy.DeserializationError{
9542 Err: fmt.Errorf("failed to decode response body, %w", err),
9543 Snapshot: snapshot.Bytes(),
9544 }
9545 return out, metadata, err
9546 }
9547
9548 err = awsAwsjson11_deserializeOpDocumentGetContainerAPIMetadataOutput(&output, shape)
9549 if err != nil {
9550 var snapshot bytes.Buffer
9551 io.Copy(&snapshot, ringBuffer)
9552 err = &smithy.DeserializationError{
9553 Err: fmt.Errorf("failed to decode response body, %w", err),
9554 Snapshot: snapshot.Bytes(),
9555 }
9556 return out, metadata, err
9557 }
9558
9559 return out, metadata, err
9560 }
9561
9562 func awsAwsjson11_deserializeOpErrorGetContainerAPIMetadata(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9563 var errorBuffer bytes.Buffer
9564 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9565 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9566 }
9567 errorBody := bytes.NewReader(errorBuffer.Bytes())
9568
9569 errorCode := "UnknownError"
9570 errorMessage := errorCode
9571
9572 headerCode := response.Header.Get("X-Amzn-ErrorType")
9573
9574 var buff [1024]byte
9575 ringBuffer := smithyio.NewRingBuffer(buff[:])
9576
9577 body := io.TeeReader(errorBody, ringBuffer)
9578 decoder := json.NewDecoder(body)
9579 decoder.UseNumber()
9580 bodyInfo, err := getProtocolErrorInfo(decoder)
9581 if err != nil {
9582 var snapshot bytes.Buffer
9583 io.Copy(&snapshot, ringBuffer)
9584 err = &smithy.DeserializationError{
9585 Err: fmt.Errorf("failed to decode response body, %w", err),
9586 Snapshot: snapshot.Bytes(),
9587 }
9588 return err
9589 }
9590
9591 errorBody.Seek(0, io.SeekStart)
9592 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
9593 errorCode = restjson.SanitizeErrorCode(typ)
9594 }
9595 if len(bodyInfo.Message) != 0 {
9596 errorMessage = bodyInfo.Message
9597 }
9598 switch {
9599 case strings.EqualFold("AccessDeniedException", errorCode):
9600 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
9601
9602 case strings.EqualFold("RegionSetupInProgressException", errorCode):
9603 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
9604
9605 case strings.EqualFold("ServiceException", errorCode):
9606 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
9607
9608 case strings.EqualFold("UnauthenticatedException", errorCode):
9609 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
9610
9611 default:
9612 genericError := &smithy.GenericAPIError{
9613 Code: errorCode,
9614 Message: errorMessage,
9615 }
9616 return genericError
9617
9618 }
9619 }
9620
9621 type awsAwsjson11_deserializeOpGetContainerImages struct {
9622 }
9623
9624 func (*awsAwsjson11_deserializeOpGetContainerImages) ID() string {
9625 return "OperationDeserializer"
9626 }
9627
9628 func (m *awsAwsjson11_deserializeOpGetContainerImages) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9629 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9630 ) {
9631 out, metadata, err = next.HandleDeserialize(ctx, in)
9632 if err != nil {
9633 return out, metadata, err
9634 }
9635
9636 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
9637 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
9638 defer endTimer()
9639 defer span.End()
9640 response, ok := out.RawResponse.(*smithyhttp.Response)
9641 if !ok {
9642 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9643 }
9644
9645 if response.StatusCode < 200 || response.StatusCode >= 300 {
9646 return out, metadata, awsAwsjson11_deserializeOpErrorGetContainerImages(response, &metadata)
9647 }
9648 output := &GetContainerImagesOutput{}
9649 out.Result = output
9650
9651 var buff [1024]byte
9652 ringBuffer := smithyio.NewRingBuffer(buff[:])
9653
9654 body := io.TeeReader(response.Body, ringBuffer)
9655 decoder := json.NewDecoder(body)
9656 decoder.UseNumber()
9657 var shape interface{}
9658 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9659 var snapshot bytes.Buffer
9660 io.Copy(&snapshot, ringBuffer)
9661 err = &smithy.DeserializationError{
9662 Err: fmt.Errorf("failed to decode response body, %w", err),
9663 Snapshot: snapshot.Bytes(),
9664 }
9665 return out, metadata, err
9666 }
9667
9668 err = awsAwsjson11_deserializeOpDocumentGetContainerImagesOutput(&output, shape)
9669 if err != nil {
9670 var snapshot bytes.Buffer
9671 io.Copy(&snapshot, ringBuffer)
9672 err = &smithy.DeserializationError{
9673 Err: fmt.Errorf("failed to decode response body, %w", err),
9674 Snapshot: snapshot.Bytes(),
9675 }
9676 return out, metadata, err
9677 }
9678
9679 return out, metadata, err
9680 }
9681
9682 func awsAwsjson11_deserializeOpErrorGetContainerImages(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9683 var errorBuffer bytes.Buffer
9684 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9685 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9686 }
9687 errorBody := bytes.NewReader(errorBuffer.Bytes())
9688
9689 errorCode := "UnknownError"
9690 errorMessage := errorCode
9691
9692 headerCode := response.Header.Get("X-Amzn-ErrorType")
9693
9694 var buff [1024]byte
9695 ringBuffer := smithyio.NewRingBuffer(buff[:])
9696
9697 body := io.TeeReader(errorBody, ringBuffer)
9698 decoder := json.NewDecoder(body)
9699 decoder.UseNumber()
9700 bodyInfo, err := getProtocolErrorInfo(decoder)
9701 if err != nil {
9702 var snapshot bytes.Buffer
9703 io.Copy(&snapshot, ringBuffer)
9704 err = &smithy.DeserializationError{
9705 Err: fmt.Errorf("failed to decode response body, %w", err),
9706 Snapshot: snapshot.Bytes(),
9707 }
9708 return err
9709 }
9710
9711 errorBody.Seek(0, io.SeekStart)
9712 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
9713 errorCode = restjson.SanitizeErrorCode(typ)
9714 }
9715 if len(bodyInfo.Message) != 0 {
9716 errorMessage = bodyInfo.Message
9717 }
9718 switch {
9719 case strings.EqualFold("AccessDeniedException", errorCode):
9720 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
9721
9722 case strings.EqualFold("InvalidInputException", errorCode):
9723 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
9724
9725 case strings.EqualFold("NotFoundException", errorCode):
9726 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
9727
9728 case strings.EqualFold("RegionSetupInProgressException", errorCode):
9729 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
9730
9731 case strings.EqualFold("ServiceException", errorCode):
9732 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
9733
9734 case strings.EqualFold("UnauthenticatedException", errorCode):
9735 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
9736
9737 default:
9738 genericError := &smithy.GenericAPIError{
9739 Code: errorCode,
9740 Message: errorMessage,
9741 }
9742 return genericError
9743
9744 }
9745 }
9746
9747 type awsAwsjson11_deserializeOpGetContainerLog struct {
9748 }
9749
9750 func (*awsAwsjson11_deserializeOpGetContainerLog) ID() string {
9751 return "OperationDeserializer"
9752 }
9753
9754 func (m *awsAwsjson11_deserializeOpGetContainerLog) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9755 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9756 ) {
9757 out, metadata, err = next.HandleDeserialize(ctx, in)
9758 if err != nil {
9759 return out, metadata, err
9760 }
9761
9762 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
9763 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
9764 defer endTimer()
9765 defer span.End()
9766 response, ok := out.RawResponse.(*smithyhttp.Response)
9767 if !ok {
9768 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9769 }
9770
9771 if response.StatusCode < 200 || response.StatusCode >= 300 {
9772 return out, metadata, awsAwsjson11_deserializeOpErrorGetContainerLog(response, &metadata)
9773 }
9774 output := &GetContainerLogOutput{}
9775 out.Result = output
9776
9777 var buff [1024]byte
9778 ringBuffer := smithyio.NewRingBuffer(buff[:])
9779
9780 body := io.TeeReader(response.Body, ringBuffer)
9781 decoder := json.NewDecoder(body)
9782 decoder.UseNumber()
9783 var shape interface{}
9784 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9785 var snapshot bytes.Buffer
9786 io.Copy(&snapshot, ringBuffer)
9787 err = &smithy.DeserializationError{
9788 Err: fmt.Errorf("failed to decode response body, %w", err),
9789 Snapshot: snapshot.Bytes(),
9790 }
9791 return out, metadata, err
9792 }
9793
9794 err = awsAwsjson11_deserializeOpDocumentGetContainerLogOutput(&output, shape)
9795 if err != nil {
9796 var snapshot bytes.Buffer
9797 io.Copy(&snapshot, ringBuffer)
9798 err = &smithy.DeserializationError{
9799 Err: fmt.Errorf("failed to decode response body, %w", err),
9800 Snapshot: snapshot.Bytes(),
9801 }
9802 return out, metadata, err
9803 }
9804
9805 return out, metadata, err
9806 }
9807
9808 func awsAwsjson11_deserializeOpErrorGetContainerLog(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9809 var errorBuffer bytes.Buffer
9810 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9811 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9812 }
9813 errorBody := bytes.NewReader(errorBuffer.Bytes())
9814
9815 errorCode := "UnknownError"
9816 errorMessage := errorCode
9817
9818 headerCode := response.Header.Get("X-Amzn-ErrorType")
9819
9820 var buff [1024]byte
9821 ringBuffer := smithyio.NewRingBuffer(buff[:])
9822
9823 body := io.TeeReader(errorBody, ringBuffer)
9824 decoder := json.NewDecoder(body)
9825 decoder.UseNumber()
9826 bodyInfo, err := getProtocolErrorInfo(decoder)
9827 if err != nil {
9828 var snapshot bytes.Buffer
9829 io.Copy(&snapshot, ringBuffer)
9830 err = &smithy.DeserializationError{
9831 Err: fmt.Errorf("failed to decode response body, %w", err),
9832 Snapshot: snapshot.Bytes(),
9833 }
9834 return err
9835 }
9836
9837 errorBody.Seek(0, io.SeekStart)
9838 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
9839 errorCode = restjson.SanitizeErrorCode(typ)
9840 }
9841 if len(bodyInfo.Message) != 0 {
9842 errorMessage = bodyInfo.Message
9843 }
9844 switch {
9845 case strings.EqualFold("AccessDeniedException", errorCode):
9846 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
9847
9848 case strings.EqualFold("InvalidInputException", errorCode):
9849 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
9850
9851 case strings.EqualFold("NotFoundException", errorCode):
9852 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
9853
9854 case strings.EqualFold("RegionSetupInProgressException", errorCode):
9855 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
9856
9857 case strings.EqualFold("ServiceException", errorCode):
9858 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
9859
9860 case strings.EqualFold("UnauthenticatedException", errorCode):
9861 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
9862
9863 default:
9864 genericError := &smithy.GenericAPIError{
9865 Code: errorCode,
9866 Message: errorMessage,
9867 }
9868 return genericError
9869
9870 }
9871 }
9872
9873 type awsAwsjson11_deserializeOpGetContainerServiceDeployments struct {
9874 }
9875
9876 func (*awsAwsjson11_deserializeOpGetContainerServiceDeployments) ID() string {
9877 return "OperationDeserializer"
9878 }
9879
9880 func (m *awsAwsjson11_deserializeOpGetContainerServiceDeployments) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9881 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9882 ) {
9883 out, metadata, err = next.HandleDeserialize(ctx, in)
9884 if err != nil {
9885 return out, metadata, err
9886 }
9887
9888 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
9889 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
9890 defer endTimer()
9891 defer span.End()
9892 response, ok := out.RawResponse.(*smithyhttp.Response)
9893 if !ok {
9894 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9895 }
9896
9897 if response.StatusCode < 200 || response.StatusCode >= 300 {
9898 return out, metadata, awsAwsjson11_deserializeOpErrorGetContainerServiceDeployments(response, &metadata)
9899 }
9900 output := &GetContainerServiceDeploymentsOutput{}
9901 out.Result = output
9902
9903 var buff [1024]byte
9904 ringBuffer := smithyio.NewRingBuffer(buff[:])
9905
9906 body := io.TeeReader(response.Body, ringBuffer)
9907 decoder := json.NewDecoder(body)
9908 decoder.UseNumber()
9909 var shape interface{}
9910 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9911 var snapshot bytes.Buffer
9912 io.Copy(&snapshot, ringBuffer)
9913 err = &smithy.DeserializationError{
9914 Err: fmt.Errorf("failed to decode response body, %w", err),
9915 Snapshot: snapshot.Bytes(),
9916 }
9917 return out, metadata, err
9918 }
9919
9920 err = awsAwsjson11_deserializeOpDocumentGetContainerServiceDeploymentsOutput(&output, shape)
9921 if err != nil {
9922 var snapshot bytes.Buffer
9923 io.Copy(&snapshot, ringBuffer)
9924 err = &smithy.DeserializationError{
9925 Err: fmt.Errorf("failed to decode response body, %w", err),
9926 Snapshot: snapshot.Bytes(),
9927 }
9928 return out, metadata, err
9929 }
9930
9931 return out, metadata, err
9932 }
9933
9934 func awsAwsjson11_deserializeOpErrorGetContainerServiceDeployments(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9935 var errorBuffer bytes.Buffer
9936 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9937 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9938 }
9939 errorBody := bytes.NewReader(errorBuffer.Bytes())
9940
9941 errorCode := "UnknownError"
9942 errorMessage := errorCode
9943
9944 headerCode := response.Header.Get("X-Amzn-ErrorType")
9945
9946 var buff [1024]byte
9947 ringBuffer := smithyio.NewRingBuffer(buff[:])
9948
9949 body := io.TeeReader(errorBody, ringBuffer)
9950 decoder := json.NewDecoder(body)
9951 decoder.UseNumber()
9952 bodyInfo, err := getProtocolErrorInfo(decoder)
9953 if err != nil {
9954 var snapshot bytes.Buffer
9955 io.Copy(&snapshot, ringBuffer)
9956 err = &smithy.DeserializationError{
9957 Err: fmt.Errorf("failed to decode response body, %w", err),
9958 Snapshot: snapshot.Bytes(),
9959 }
9960 return err
9961 }
9962
9963 errorBody.Seek(0, io.SeekStart)
9964 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
9965 errorCode = restjson.SanitizeErrorCode(typ)
9966 }
9967 if len(bodyInfo.Message) != 0 {
9968 errorMessage = bodyInfo.Message
9969 }
9970 switch {
9971 case strings.EqualFold("AccessDeniedException", errorCode):
9972 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
9973
9974 case strings.EqualFold("InvalidInputException", errorCode):
9975 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
9976
9977 case strings.EqualFold("NotFoundException", errorCode):
9978 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
9979
9980 case strings.EqualFold("RegionSetupInProgressException", errorCode):
9981 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
9982
9983 case strings.EqualFold("ServiceException", errorCode):
9984 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
9985
9986 case strings.EqualFold("UnauthenticatedException", errorCode):
9987 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
9988
9989 default:
9990 genericError := &smithy.GenericAPIError{
9991 Code: errorCode,
9992 Message: errorMessage,
9993 }
9994 return genericError
9995
9996 }
9997 }
9998
9999 type awsAwsjson11_deserializeOpGetContainerServiceMetricData struct {
10000 }
10001
10002 func (*awsAwsjson11_deserializeOpGetContainerServiceMetricData) ID() string {
10003 return "OperationDeserializer"
10004 }
10005
10006 func (m *awsAwsjson11_deserializeOpGetContainerServiceMetricData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10007 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10008 ) {
10009 out, metadata, err = next.HandleDeserialize(ctx, in)
10010 if err != nil {
10011 return out, metadata, err
10012 }
10013
10014 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
10015 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
10016 defer endTimer()
10017 defer span.End()
10018 response, ok := out.RawResponse.(*smithyhttp.Response)
10019 if !ok {
10020 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10021 }
10022
10023 if response.StatusCode < 200 || response.StatusCode >= 300 {
10024 return out, metadata, awsAwsjson11_deserializeOpErrorGetContainerServiceMetricData(response, &metadata)
10025 }
10026 output := &GetContainerServiceMetricDataOutput{}
10027 out.Result = output
10028
10029 var buff [1024]byte
10030 ringBuffer := smithyio.NewRingBuffer(buff[:])
10031
10032 body := io.TeeReader(response.Body, ringBuffer)
10033 decoder := json.NewDecoder(body)
10034 decoder.UseNumber()
10035 var shape interface{}
10036 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10037 var snapshot bytes.Buffer
10038 io.Copy(&snapshot, ringBuffer)
10039 err = &smithy.DeserializationError{
10040 Err: fmt.Errorf("failed to decode response body, %w", err),
10041 Snapshot: snapshot.Bytes(),
10042 }
10043 return out, metadata, err
10044 }
10045
10046 err = awsAwsjson11_deserializeOpDocumentGetContainerServiceMetricDataOutput(&output, shape)
10047 if err != nil {
10048 var snapshot bytes.Buffer
10049 io.Copy(&snapshot, ringBuffer)
10050 err = &smithy.DeserializationError{
10051 Err: fmt.Errorf("failed to decode response body, %w", err),
10052 Snapshot: snapshot.Bytes(),
10053 }
10054 return out, metadata, err
10055 }
10056
10057 return out, metadata, err
10058 }
10059
10060 func awsAwsjson11_deserializeOpErrorGetContainerServiceMetricData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10061 var errorBuffer bytes.Buffer
10062 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10063 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10064 }
10065 errorBody := bytes.NewReader(errorBuffer.Bytes())
10066
10067 errorCode := "UnknownError"
10068 errorMessage := errorCode
10069
10070 headerCode := response.Header.Get("X-Amzn-ErrorType")
10071
10072 var buff [1024]byte
10073 ringBuffer := smithyio.NewRingBuffer(buff[:])
10074
10075 body := io.TeeReader(errorBody, ringBuffer)
10076 decoder := json.NewDecoder(body)
10077 decoder.UseNumber()
10078 bodyInfo, err := getProtocolErrorInfo(decoder)
10079 if err != nil {
10080 var snapshot bytes.Buffer
10081 io.Copy(&snapshot, ringBuffer)
10082 err = &smithy.DeserializationError{
10083 Err: fmt.Errorf("failed to decode response body, %w", err),
10084 Snapshot: snapshot.Bytes(),
10085 }
10086 return err
10087 }
10088
10089 errorBody.Seek(0, io.SeekStart)
10090 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
10091 errorCode = restjson.SanitizeErrorCode(typ)
10092 }
10093 if len(bodyInfo.Message) != 0 {
10094 errorMessage = bodyInfo.Message
10095 }
10096 switch {
10097 case strings.EqualFold("AccessDeniedException", errorCode):
10098 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
10099
10100 case strings.EqualFold("InvalidInputException", errorCode):
10101 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
10102
10103 case strings.EqualFold("NotFoundException", errorCode):
10104 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
10105
10106 case strings.EqualFold("RegionSetupInProgressException", errorCode):
10107 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
10108
10109 case strings.EqualFold("ServiceException", errorCode):
10110 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
10111
10112 case strings.EqualFold("UnauthenticatedException", errorCode):
10113 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
10114
10115 default:
10116 genericError := &smithy.GenericAPIError{
10117 Code: errorCode,
10118 Message: errorMessage,
10119 }
10120 return genericError
10121
10122 }
10123 }
10124
10125 type awsAwsjson11_deserializeOpGetContainerServicePowers struct {
10126 }
10127
10128 func (*awsAwsjson11_deserializeOpGetContainerServicePowers) ID() string {
10129 return "OperationDeserializer"
10130 }
10131
10132 func (m *awsAwsjson11_deserializeOpGetContainerServicePowers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10133 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10134 ) {
10135 out, metadata, err = next.HandleDeserialize(ctx, in)
10136 if err != nil {
10137 return out, metadata, err
10138 }
10139
10140 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
10141 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
10142 defer endTimer()
10143 defer span.End()
10144 response, ok := out.RawResponse.(*smithyhttp.Response)
10145 if !ok {
10146 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10147 }
10148
10149 if response.StatusCode < 200 || response.StatusCode >= 300 {
10150 return out, metadata, awsAwsjson11_deserializeOpErrorGetContainerServicePowers(response, &metadata)
10151 }
10152 output := &GetContainerServicePowersOutput{}
10153 out.Result = output
10154
10155 var buff [1024]byte
10156 ringBuffer := smithyio.NewRingBuffer(buff[:])
10157
10158 body := io.TeeReader(response.Body, ringBuffer)
10159 decoder := json.NewDecoder(body)
10160 decoder.UseNumber()
10161 var shape interface{}
10162 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10163 var snapshot bytes.Buffer
10164 io.Copy(&snapshot, ringBuffer)
10165 err = &smithy.DeserializationError{
10166 Err: fmt.Errorf("failed to decode response body, %w", err),
10167 Snapshot: snapshot.Bytes(),
10168 }
10169 return out, metadata, err
10170 }
10171
10172 err = awsAwsjson11_deserializeOpDocumentGetContainerServicePowersOutput(&output, shape)
10173 if err != nil {
10174 var snapshot bytes.Buffer
10175 io.Copy(&snapshot, ringBuffer)
10176 err = &smithy.DeserializationError{
10177 Err: fmt.Errorf("failed to decode response body, %w", err),
10178 Snapshot: snapshot.Bytes(),
10179 }
10180 return out, metadata, err
10181 }
10182
10183 return out, metadata, err
10184 }
10185
10186 func awsAwsjson11_deserializeOpErrorGetContainerServicePowers(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10187 var errorBuffer bytes.Buffer
10188 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10189 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10190 }
10191 errorBody := bytes.NewReader(errorBuffer.Bytes())
10192
10193 errorCode := "UnknownError"
10194 errorMessage := errorCode
10195
10196 headerCode := response.Header.Get("X-Amzn-ErrorType")
10197
10198 var buff [1024]byte
10199 ringBuffer := smithyio.NewRingBuffer(buff[:])
10200
10201 body := io.TeeReader(errorBody, ringBuffer)
10202 decoder := json.NewDecoder(body)
10203 decoder.UseNumber()
10204 bodyInfo, err := getProtocolErrorInfo(decoder)
10205 if err != nil {
10206 var snapshot bytes.Buffer
10207 io.Copy(&snapshot, ringBuffer)
10208 err = &smithy.DeserializationError{
10209 Err: fmt.Errorf("failed to decode response body, %w", err),
10210 Snapshot: snapshot.Bytes(),
10211 }
10212 return err
10213 }
10214
10215 errorBody.Seek(0, io.SeekStart)
10216 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
10217 errorCode = restjson.SanitizeErrorCode(typ)
10218 }
10219 if len(bodyInfo.Message) != 0 {
10220 errorMessage = bodyInfo.Message
10221 }
10222 switch {
10223 case strings.EqualFold("AccessDeniedException", errorCode):
10224 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
10225
10226 case strings.EqualFold("InvalidInputException", errorCode):
10227 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
10228
10229 case strings.EqualFold("NotFoundException", errorCode):
10230 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
10231
10232 case strings.EqualFold("RegionSetupInProgressException", errorCode):
10233 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
10234
10235 case strings.EqualFold("ServiceException", errorCode):
10236 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
10237
10238 case strings.EqualFold("UnauthenticatedException", errorCode):
10239 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
10240
10241 default:
10242 genericError := &smithy.GenericAPIError{
10243 Code: errorCode,
10244 Message: errorMessage,
10245 }
10246 return genericError
10247
10248 }
10249 }
10250
10251 type awsAwsjson11_deserializeOpGetContainerServices struct {
10252 }
10253
10254 func (*awsAwsjson11_deserializeOpGetContainerServices) ID() string {
10255 return "OperationDeserializer"
10256 }
10257
10258 func (m *awsAwsjson11_deserializeOpGetContainerServices) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10259 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10260 ) {
10261 out, metadata, err = next.HandleDeserialize(ctx, in)
10262 if err != nil {
10263 return out, metadata, err
10264 }
10265
10266 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
10267 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
10268 defer endTimer()
10269 defer span.End()
10270 response, ok := out.RawResponse.(*smithyhttp.Response)
10271 if !ok {
10272 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10273 }
10274
10275 if response.StatusCode < 200 || response.StatusCode >= 300 {
10276 return out, metadata, awsAwsjson11_deserializeOpErrorGetContainerServices(response, &metadata)
10277 }
10278 output := &GetContainerServicesOutput{}
10279 out.Result = output
10280
10281 var buff [1024]byte
10282 ringBuffer := smithyio.NewRingBuffer(buff[:])
10283
10284 body := io.TeeReader(response.Body, ringBuffer)
10285 decoder := json.NewDecoder(body)
10286 decoder.UseNumber()
10287 var shape interface{}
10288 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10289 var snapshot bytes.Buffer
10290 io.Copy(&snapshot, ringBuffer)
10291 err = &smithy.DeserializationError{
10292 Err: fmt.Errorf("failed to decode response body, %w", err),
10293 Snapshot: snapshot.Bytes(),
10294 }
10295 return out, metadata, err
10296 }
10297
10298 err = awsAwsjson11_deserializeOpDocumentGetContainerServicesOutput(&output, shape)
10299 if err != nil {
10300 var snapshot bytes.Buffer
10301 io.Copy(&snapshot, ringBuffer)
10302 err = &smithy.DeserializationError{
10303 Err: fmt.Errorf("failed to decode response body, %w", err),
10304 Snapshot: snapshot.Bytes(),
10305 }
10306 return out, metadata, err
10307 }
10308
10309 return out, metadata, err
10310 }
10311
10312 func awsAwsjson11_deserializeOpErrorGetContainerServices(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10313 var errorBuffer bytes.Buffer
10314 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10315 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10316 }
10317 errorBody := bytes.NewReader(errorBuffer.Bytes())
10318
10319 errorCode := "UnknownError"
10320 errorMessage := errorCode
10321
10322 headerCode := response.Header.Get("X-Amzn-ErrorType")
10323
10324 var buff [1024]byte
10325 ringBuffer := smithyio.NewRingBuffer(buff[:])
10326
10327 body := io.TeeReader(errorBody, ringBuffer)
10328 decoder := json.NewDecoder(body)
10329 decoder.UseNumber()
10330 bodyInfo, err := getProtocolErrorInfo(decoder)
10331 if err != nil {
10332 var snapshot bytes.Buffer
10333 io.Copy(&snapshot, ringBuffer)
10334 err = &smithy.DeserializationError{
10335 Err: fmt.Errorf("failed to decode response body, %w", err),
10336 Snapshot: snapshot.Bytes(),
10337 }
10338 return err
10339 }
10340
10341 errorBody.Seek(0, io.SeekStart)
10342 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
10343 errorCode = restjson.SanitizeErrorCode(typ)
10344 }
10345 if len(bodyInfo.Message) != 0 {
10346 errorMessage = bodyInfo.Message
10347 }
10348 switch {
10349 case strings.EqualFold("AccessDeniedException", errorCode):
10350 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
10351
10352 case strings.EqualFold("InvalidInputException", errorCode):
10353 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
10354
10355 case strings.EqualFold("NotFoundException", errorCode):
10356 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
10357
10358 case strings.EqualFold("RegionSetupInProgressException", errorCode):
10359 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
10360
10361 case strings.EqualFold("ServiceException", errorCode):
10362 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
10363
10364 case strings.EqualFold("UnauthenticatedException", errorCode):
10365 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
10366
10367 default:
10368 genericError := &smithy.GenericAPIError{
10369 Code: errorCode,
10370 Message: errorMessage,
10371 }
10372 return genericError
10373
10374 }
10375 }
10376
10377 type awsAwsjson11_deserializeOpGetCostEstimate struct {
10378 }
10379
10380 func (*awsAwsjson11_deserializeOpGetCostEstimate) ID() string {
10381 return "OperationDeserializer"
10382 }
10383
10384 func (m *awsAwsjson11_deserializeOpGetCostEstimate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10385 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10386 ) {
10387 out, metadata, err = next.HandleDeserialize(ctx, in)
10388 if err != nil {
10389 return out, metadata, err
10390 }
10391
10392 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
10393 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
10394 defer endTimer()
10395 defer span.End()
10396 response, ok := out.RawResponse.(*smithyhttp.Response)
10397 if !ok {
10398 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10399 }
10400
10401 if response.StatusCode < 200 || response.StatusCode >= 300 {
10402 return out, metadata, awsAwsjson11_deserializeOpErrorGetCostEstimate(response, &metadata)
10403 }
10404 output := &GetCostEstimateOutput{}
10405 out.Result = output
10406
10407 var buff [1024]byte
10408 ringBuffer := smithyio.NewRingBuffer(buff[:])
10409
10410 body := io.TeeReader(response.Body, ringBuffer)
10411 decoder := json.NewDecoder(body)
10412 decoder.UseNumber()
10413 var shape interface{}
10414 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10415 var snapshot bytes.Buffer
10416 io.Copy(&snapshot, ringBuffer)
10417 err = &smithy.DeserializationError{
10418 Err: fmt.Errorf("failed to decode response body, %w", err),
10419 Snapshot: snapshot.Bytes(),
10420 }
10421 return out, metadata, err
10422 }
10423
10424 err = awsAwsjson11_deserializeOpDocumentGetCostEstimateOutput(&output, shape)
10425 if err != nil {
10426 var snapshot bytes.Buffer
10427 io.Copy(&snapshot, ringBuffer)
10428 err = &smithy.DeserializationError{
10429 Err: fmt.Errorf("failed to decode response body, %w", err),
10430 Snapshot: snapshot.Bytes(),
10431 }
10432 return out, metadata, err
10433 }
10434
10435 return out, metadata, err
10436 }
10437
10438 func awsAwsjson11_deserializeOpErrorGetCostEstimate(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10439 var errorBuffer bytes.Buffer
10440 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10441 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10442 }
10443 errorBody := bytes.NewReader(errorBuffer.Bytes())
10444
10445 errorCode := "UnknownError"
10446 errorMessage := errorCode
10447
10448 headerCode := response.Header.Get("X-Amzn-ErrorType")
10449
10450 var buff [1024]byte
10451 ringBuffer := smithyio.NewRingBuffer(buff[:])
10452
10453 body := io.TeeReader(errorBody, ringBuffer)
10454 decoder := json.NewDecoder(body)
10455 decoder.UseNumber()
10456 bodyInfo, err := getProtocolErrorInfo(decoder)
10457 if err != nil {
10458 var snapshot bytes.Buffer
10459 io.Copy(&snapshot, ringBuffer)
10460 err = &smithy.DeserializationError{
10461 Err: fmt.Errorf("failed to decode response body, %w", err),
10462 Snapshot: snapshot.Bytes(),
10463 }
10464 return err
10465 }
10466
10467 errorBody.Seek(0, io.SeekStart)
10468 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
10469 errorCode = restjson.SanitizeErrorCode(typ)
10470 }
10471 if len(bodyInfo.Message) != 0 {
10472 errorMessage = bodyInfo.Message
10473 }
10474 switch {
10475 case strings.EqualFold("AccessDeniedException", errorCode):
10476 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
10477
10478 case strings.EqualFold("InvalidInputException", errorCode):
10479 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
10480
10481 case strings.EqualFold("NotFoundException", errorCode):
10482 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
10483
10484 case strings.EqualFold("RegionSetupInProgressException", errorCode):
10485 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
10486
10487 case strings.EqualFold("ServiceException", errorCode):
10488 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
10489
10490 case strings.EqualFold("UnauthenticatedException", errorCode):
10491 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
10492
10493 default:
10494 genericError := &smithy.GenericAPIError{
10495 Code: errorCode,
10496 Message: errorMessage,
10497 }
10498 return genericError
10499
10500 }
10501 }
10502
10503 type awsAwsjson11_deserializeOpGetDisk struct {
10504 }
10505
10506 func (*awsAwsjson11_deserializeOpGetDisk) ID() string {
10507 return "OperationDeserializer"
10508 }
10509
10510 func (m *awsAwsjson11_deserializeOpGetDisk) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10511 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10512 ) {
10513 out, metadata, err = next.HandleDeserialize(ctx, in)
10514 if err != nil {
10515 return out, metadata, err
10516 }
10517
10518 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
10519 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
10520 defer endTimer()
10521 defer span.End()
10522 response, ok := out.RawResponse.(*smithyhttp.Response)
10523 if !ok {
10524 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10525 }
10526
10527 if response.StatusCode < 200 || response.StatusCode >= 300 {
10528 return out, metadata, awsAwsjson11_deserializeOpErrorGetDisk(response, &metadata)
10529 }
10530 output := &GetDiskOutput{}
10531 out.Result = output
10532
10533 var buff [1024]byte
10534 ringBuffer := smithyio.NewRingBuffer(buff[:])
10535
10536 body := io.TeeReader(response.Body, ringBuffer)
10537 decoder := json.NewDecoder(body)
10538 decoder.UseNumber()
10539 var shape interface{}
10540 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10541 var snapshot bytes.Buffer
10542 io.Copy(&snapshot, ringBuffer)
10543 err = &smithy.DeserializationError{
10544 Err: fmt.Errorf("failed to decode response body, %w", err),
10545 Snapshot: snapshot.Bytes(),
10546 }
10547 return out, metadata, err
10548 }
10549
10550 err = awsAwsjson11_deserializeOpDocumentGetDiskOutput(&output, shape)
10551 if err != nil {
10552 var snapshot bytes.Buffer
10553 io.Copy(&snapshot, ringBuffer)
10554 err = &smithy.DeserializationError{
10555 Err: fmt.Errorf("failed to decode response body, %w", err),
10556 Snapshot: snapshot.Bytes(),
10557 }
10558 return out, metadata, err
10559 }
10560
10561 return out, metadata, err
10562 }
10563
10564 func awsAwsjson11_deserializeOpErrorGetDisk(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10565 var errorBuffer bytes.Buffer
10566 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10567 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10568 }
10569 errorBody := bytes.NewReader(errorBuffer.Bytes())
10570
10571 errorCode := "UnknownError"
10572 errorMessage := errorCode
10573
10574 headerCode := response.Header.Get("X-Amzn-ErrorType")
10575
10576 var buff [1024]byte
10577 ringBuffer := smithyio.NewRingBuffer(buff[:])
10578
10579 body := io.TeeReader(errorBody, ringBuffer)
10580 decoder := json.NewDecoder(body)
10581 decoder.UseNumber()
10582 bodyInfo, err := getProtocolErrorInfo(decoder)
10583 if err != nil {
10584 var snapshot bytes.Buffer
10585 io.Copy(&snapshot, ringBuffer)
10586 err = &smithy.DeserializationError{
10587 Err: fmt.Errorf("failed to decode response body, %w", err),
10588 Snapshot: snapshot.Bytes(),
10589 }
10590 return err
10591 }
10592
10593 errorBody.Seek(0, io.SeekStart)
10594 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
10595 errorCode = restjson.SanitizeErrorCode(typ)
10596 }
10597 if len(bodyInfo.Message) != 0 {
10598 errorMessage = bodyInfo.Message
10599 }
10600 switch {
10601 case strings.EqualFold("AccessDeniedException", errorCode):
10602 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
10603
10604 case strings.EqualFold("AccountSetupInProgressException", errorCode):
10605 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
10606
10607 case strings.EqualFold("InvalidInputException", errorCode):
10608 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
10609
10610 case strings.EqualFold("NotFoundException", errorCode):
10611 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
10612
10613 case strings.EqualFold("OperationFailureException", errorCode):
10614 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
10615
10616 case strings.EqualFold("RegionSetupInProgressException", errorCode):
10617 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
10618
10619 case strings.EqualFold("ServiceException", errorCode):
10620 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
10621
10622 case strings.EqualFold("UnauthenticatedException", errorCode):
10623 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
10624
10625 default:
10626 genericError := &smithy.GenericAPIError{
10627 Code: errorCode,
10628 Message: errorMessage,
10629 }
10630 return genericError
10631
10632 }
10633 }
10634
10635 type awsAwsjson11_deserializeOpGetDisks struct {
10636 }
10637
10638 func (*awsAwsjson11_deserializeOpGetDisks) ID() string {
10639 return "OperationDeserializer"
10640 }
10641
10642 func (m *awsAwsjson11_deserializeOpGetDisks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10643 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10644 ) {
10645 out, metadata, err = next.HandleDeserialize(ctx, in)
10646 if err != nil {
10647 return out, metadata, err
10648 }
10649
10650 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
10651 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
10652 defer endTimer()
10653 defer span.End()
10654 response, ok := out.RawResponse.(*smithyhttp.Response)
10655 if !ok {
10656 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10657 }
10658
10659 if response.StatusCode < 200 || response.StatusCode >= 300 {
10660 return out, metadata, awsAwsjson11_deserializeOpErrorGetDisks(response, &metadata)
10661 }
10662 output := &GetDisksOutput{}
10663 out.Result = output
10664
10665 var buff [1024]byte
10666 ringBuffer := smithyio.NewRingBuffer(buff[:])
10667
10668 body := io.TeeReader(response.Body, ringBuffer)
10669 decoder := json.NewDecoder(body)
10670 decoder.UseNumber()
10671 var shape interface{}
10672 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10673 var snapshot bytes.Buffer
10674 io.Copy(&snapshot, ringBuffer)
10675 err = &smithy.DeserializationError{
10676 Err: fmt.Errorf("failed to decode response body, %w", err),
10677 Snapshot: snapshot.Bytes(),
10678 }
10679 return out, metadata, err
10680 }
10681
10682 err = awsAwsjson11_deserializeOpDocumentGetDisksOutput(&output, shape)
10683 if err != nil {
10684 var snapshot bytes.Buffer
10685 io.Copy(&snapshot, ringBuffer)
10686 err = &smithy.DeserializationError{
10687 Err: fmt.Errorf("failed to decode response body, %w", err),
10688 Snapshot: snapshot.Bytes(),
10689 }
10690 return out, metadata, err
10691 }
10692
10693 return out, metadata, err
10694 }
10695
10696 func awsAwsjson11_deserializeOpErrorGetDisks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10697 var errorBuffer bytes.Buffer
10698 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10699 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10700 }
10701 errorBody := bytes.NewReader(errorBuffer.Bytes())
10702
10703 errorCode := "UnknownError"
10704 errorMessage := errorCode
10705
10706 headerCode := response.Header.Get("X-Amzn-ErrorType")
10707
10708 var buff [1024]byte
10709 ringBuffer := smithyio.NewRingBuffer(buff[:])
10710
10711 body := io.TeeReader(errorBody, ringBuffer)
10712 decoder := json.NewDecoder(body)
10713 decoder.UseNumber()
10714 bodyInfo, err := getProtocolErrorInfo(decoder)
10715 if err != nil {
10716 var snapshot bytes.Buffer
10717 io.Copy(&snapshot, ringBuffer)
10718 err = &smithy.DeserializationError{
10719 Err: fmt.Errorf("failed to decode response body, %w", err),
10720 Snapshot: snapshot.Bytes(),
10721 }
10722 return err
10723 }
10724
10725 errorBody.Seek(0, io.SeekStart)
10726 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
10727 errorCode = restjson.SanitizeErrorCode(typ)
10728 }
10729 if len(bodyInfo.Message) != 0 {
10730 errorMessage = bodyInfo.Message
10731 }
10732 switch {
10733 case strings.EqualFold("AccessDeniedException", errorCode):
10734 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
10735
10736 case strings.EqualFold("AccountSetupInProgressException", errorCode):
10737 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
10738
10739 case strings.EqualFold("InvalidInputException", errorCode):
10740 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
10741
10742 case strings.EqualFold("NotFoundException", errorCode):
10743 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
10744
10745 case strings.EqualFold("OperationFailureException", errorCode):
10746 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
10747
10748 case strings.EqualFold("RegionSetupInProgressException", errorCode):
10749 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
10750
10751 case strings.EqualFold("ServiceException", errorCode):
10752 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
10753
10754 case strings.EqualFold("UnauthenticatedException", errorCode):
10755 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
10756
10757 default:
10758 genericError := &smithy.GenericAPIError{
10759 Code: errorCode,
10760 Message: errorMessage,
10761 }
10762 return genericError
10763
10764 }
10765 }
10766
10767 type awsAwsjson11_deserializeOpGetDiskSnapshot struct {
10768 }
10769
10770 func (*awsAwsjson11_deserializeOpGetDiskSnapshot) ID() string {
10771 return "OperationDeserializer"
10772 }
10773
10774 func (m *awsAwsjson11_deserializeOpGetDiskSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10775 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10776 ) {
10777 out, metadata, err = next.HandleDeserialize(ctx, in)
10778 if err != nil {
10779 return out, metadata, err
10780 }
10781
10782 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
10783 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
10784 defer endTimer()
10785 defer span.End()
10786 response, ok := out.RawResponse.(*smithyhttp.Response)
10787 if !ok {
10788 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10789 }
10790
10791 if response.StatusCode < 200 || response.StatusCode >= 300 {
10792 return out, metadata, awsAwsjson11_deserializeOpErrorGetDiskSnapshot(response, &metadata)
10793 }
10794 output := &GetDiskSnapshotOutput{}
10795 out.Result = output
10796
10797 var buff [1024]byte
10798 ringBuffer := smithyio.NewRingBuffer(buff[:])
10799
10800 body := io.TeeReader(response.Body, ringBuffer)
10801 decoder := json.NewDecoder(body)
10802 decoder.UseNumber()
10803 var shape interface{}
10804 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10805 var snapshot bytes.Buffer
10806 io.Copy(&snapshot, ringBuffer)
10807 err = &smithy.DeserializationError{
10808 Err: fmt.Errorf("failed to decode response body, %w", err),
10809 Snapshot: snapshot.Bytes(),
10810 }
10811 return out, metadata, err
10812 }
10813
10814 err = awsAwsjson11_deserializeOpDocumentGetDiskSnapshotOutput(&output, shape)
10815 if err != nil {
10816 var snapshot bytes.Buffer
10817 io.Copy(&snapshot, ringBuffer)
10818 err = &smithy.DeserializationError{
10819 Err: fmt.Errorf("failed to decode response body, %w", err),
10820 Snapshot: snapshot.Bytes(),
10821 }
10822 return out, metadata, err
10823 }
10824
10825 return out, metadata, err
10826 }
10827
10828 func awsAwsjson11_deserializeOpErrorGetDiskSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10829 var errorBuffer bytes.Buffer
10830 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10831 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10832 }
10833 errorBody := bytes.NewReader(errorBuffer.Bytes())
10834
10835 errorCode := "UnknownError"
10836 errorMessage := errorCode
10837
10838 headerCode := response.Header.Get("X-Amzn-ErrorType")
10839
10840 var buff [1024]byte
10841 ringBuffer := smithyio.NewRingBuffer(buff[:])
10842
10843 body := io.TeeReader(errorBody, ringBuffer)
10844 decoder := json.NewDecoder(body)
10845 decoder.UseNumber()
10846 bodyInfo, err := getProtocolErrorInfo(decoder)
10847 if err != nil {
10848 var snapshot bytes.Buffer
10849 io.Copy(&snapshot, ringBuffer)
10850 err = &smithy.DeserializationError{
10851 Err: fmt.Errorf("failed to decode response body, %w", err),
10852 Snapshot: snapshot.Bytes(),
10853 }
10854 return err
10855 }
10856
10857 errorBody.Seek(0, io.SeekStart)
10858 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
10859 errorCode = restjson.SanitizeErrorCode(typ)
10860 }
10861 if len(bodyInfo.Message) != 0 {
10862 errorMessage = bodyInfo.Message
10863 }
10864 switch {
10865 case strings.EqualFold("AccessDeniedException", errorCode):
10866 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
10867
10868 case strings.EqualFold("AccountSetupInProgressException", errorCode):
10869 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
10870
10871 case strings.EqualFold("InvalidInputException", errorCode):
10872 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
10873
10874 case strings.EqualFold("NotFoundException", errorCode):
10875 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
10876
10877 case strings.EqualFold("OperationFailureException", errorCode):
10878 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
10879
10880 case strings.EqualFold("RegionSetupInProgressException", errorCode):
10881 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
10882
10883 case strings.EqualFold("ServiceException", errorCode):
10884 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
10885
10886 case strings.EqualFold("UnauthenticatedException", errorCode):
10887 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
10888
10889 default:
10890 genericError := &smithy.GenericAPIError{
10891 Code: errorCode,
10892 Message: errorMessage,
10893 }
10894 return genericError
10895
10896 }
10897 }
10898
10899 type awsAwsjson11_deserializeOpGetDiskSnapshots struct {
10900 }
10901
10902 func (*awsAwsjson11_deserializeOpGetDiskSnapshots) ID() string {
10903 return "OperationDeserializer"
10904 }
10905
10906 func (m *awsAwsjson11_deserializeOpGetDiskSnapshots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10907 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10908 ) {
10909 out, metadata, err = next.HandleDeserialize(ctx, in)
10910 if err != nil {
10911 return out, metadata, err
10912 }
10913
10914 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
10915 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
10916 defer endTimer()
10917 defer span.End()
10918 response, ok := out.RawResponse.(*smithyhttp.Response)
10919 if !ok {
10920 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10921 }
10922
10923 if response.StatusCode < 200 || response.StatusCode >= 300 {
10924 return out, metadata, awsAwsjson11_deserializeOpErrorGetDiskSnapshots(response, &metadata)
10925 }
10926 output := &GetDiskSnapshotsOutput{}
10927 out.Result = output
10928
10929 var buff [1024]byte
10930 ringBuffer := smithyio.NewRingBuffer(buff[:])
10931
10932 body := io.TeeReader(response.Body, ringBuffer)
10933 decoder := json.NewDecoder(body)
10934 decoder.UseNumber()
10935 var shape interface{}
10936 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10937 var snapshot bytes.Buffer
10938 io.Copy(&snapshot, ringBuffer)
10939 err = &smithy.DeserializationError{
10940 Err: fmt.Errorf("failed to decode response body, %w", err),
10941 Snapshot: snapshot.Bytes(),
10942 }
10943 return out, metadata, err
10944 }
10945
10946 err = awsAwsjson11_deserializeOpDocumentGetDiskSnapshotsOutput(&output, shape)
10947 if err != nil {
10948 var snapshot bytes.Buffer
10949 io.Copy(&snapshot, ringBuffer)
10950 err = &smithy.DeserializationError{
10951 Err: fmt.Errorf("failed to decode response body, %w", err),
10952 Snapshot: snapshot.Bytes(),
10953 }
10954 return out, metadata, err
10955 }
10956
10957 return out, metadata, err
10958 }
10959
10960 func awsAwsjson11_deserializeOpErrorGetDiskSnapshots(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10961 var errorBuffer bytes.Buffer
10962 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10963 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10964 }
10965 errorBody := bytes.NewReader(errorBuffer.Bytes())
10966
10967 errorCode := "UnknownError"
10968 errorMessage := errorCode
10969
10970 headerCode := response.Header.Get("X-Amzn-ErrorType")
10971
10972 var buff [1024]byte
10973 ringBuffer := smithyio.NewRingBuffer(buff[:])
10974
10975 body := io.TeeReader(errorBody, ringBuffer)
10976 decoder := json.NewDecoder(body)
10977 decoder.UseNumber()
10978 bodyInfo, err := getProtocolErrorInfo(decoder)
10979 if err != nil {
10980 var snapshot bytes.Buffer
10981 io.Copy(&snapshot, ringBuffer)
10982 err = &smithy.DeserializationError{
10983 Err: fmt.Errorf("failed to decode response body, %w", err),
10984 Snapshot: snapshot.Bytes(),
10985 }
10986 return err
10987 }
10988
10989 errorBody.Seek(0, io.SeekStart)
10990 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
10991 errorCode = restjson.SanitizeErrorCode(typ)
10992 }
10993 if len(bodyInfo.Message) != 0 {
10994 errorMessage = bodyInfo.Message
10995 }
10996 switch {
10997 case strings.EqualFold("AccessDeniedException", errorCode):
10998 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
10999
11000 case strings.EqualFold("AccountSetupInProgressException", errorCode):
11001 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
11002
11003 case strings.EqualFold("InvalidInputException", errorCode):
11004 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
11005
11006 case strings.EqualFold("NotFoundException", errorCode):
11007 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
11008
11009 case strings.EqualFold("OperationFailureException", errorCode):
11010 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
11011
11012 case strings.EqualFold("RegionSetupInProgressException", errorCode):
11013 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
11014
11015 case strings.EqualFold("ServiceException", errorCode):
11016 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
11017
11018 case strings.EqualFold("UnauthenticatedException", errorCode):
11019 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
11020
11021 default:
11022 genericError := &smithy.GenericAPIError{
11023 Code: errorCode,
11024 Message: errorMessage,
11025 }
11026 return genericError
11027
11028 }
11029 }
11030
11031 type awsAwsjson11_deserializeOpGetDistributionBundles struct {
11032 }
11033
11034 func (*awsAwsjson11_deserializeOpGetDistributionBundles) ID() string {
11035 return "OperationDeserializer"
11036 }
11037
11038 func (m *awsAwsjson11_deserializeOpGetDistributionBundles) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
11039 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
11040 ) {
11041 out, metadata, err = next.HandleDeserialize(ctx, in)
11042 if err != nil {
11043 return out, metadata, err
11044 }
11045
11046 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
11047 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
11048 defer endTimer()
11049 defer span.End()
11050 response, ok := out.RawResponse.(*smithyhttp.Response)
11051 if !ok {
11052 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
11053 }
11054
11055 if response.StatusCode < 200 || response.StatusCode >= 300 {
11056 return out, metadata, awsAwsjson11_deserializeOpErrorGetDistributionBundles(response, &metadata)
11057 }
11058 output := &GetDistributionBundlesOutput{}
11059 out.Result = output
11060
11061 var buff [1024]byte
11062 ringBuffer := smithyio.NewRingBuffer(buff[:])
11063
11064 body := io.TeeReader(response.Body, ringBuffer)
11065 decoder := json.NewDecoder(body)
11066 decoder.UseNumber()
11067 var shape interface{}
11068 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
11069 var snapshot bytes.Buffer
11070 io.Copy(&snapshot, ringBuffer)
11071 err = &smithy.DeserializationError{
11072 Err: fmt.Errorf("failed to decode response body, %w", err),
11073 Snapshot: snapshot.Bytes(),
11074 }
11075 return out, metadata, err
11076 }
11077
11078 err = awsAwsjson11_deserializeOpDocumentGetDistributionBundlesOutput(&output, shape)
11079 if err != nil {
11080 var snapshot bytes.Buffer
11081 io.Copy(&snapshot, ringBuffer)
11082 err = &smithy.DeserializationError{
11083 Err: fmt.Errorf("failed to decode response body, %w", err),
11084 Snapshot: snapshot.Bytes(),
11085 }
11086 return out, metadata, err
11087 }
11088
11089 return out, metadata, err
11090 }
11091
11092 func awsAwsjson11_deserializeOpErrorGetDistributionBundles(response *smithyhttp.Response, metadata *middleware.Metadata) error {
11093 var errorBuffer bytes.Buffer
11094 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
11095 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
11096 }
11097 errorBody := bytes.NewReader(errorBuffer.Bytes())
11098
11099 errorCode := "UnknownError"
11100 errorMessage := errorCode
11101
11102 headerCode := response.Header.Get("X-Amzn-ErrorType")
11103
11104 var buff [1024]byte
11105 ringBuffer := smithyio.NewRingBuffer(buff[:])
11106
11107 body := io.TeeReader(errorBody, ringBuffer)
11108 decoder := json.NewDecoder(body)
11109 decoder.UseNumber()
11110 bodyInfo, err := getProtocolErrorInfo(decoder)
11111 if err != nil {
11112 var snapshot bytes.Buffer
11113 io.Copy(&snapshot, ringBuffer)
11114 err = &smithy.DeserializationError{
11115 Err: fmt.Errorf("failed to decode response body, %w", err),
11116 Snapshot: snapshot.Bytes(),
11117 }
11118 return err
11119 }
11120
11121 errorBody.Seek(0, io.SeekStart)
11122 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
11123 errorCode = restjson.SanitizeErrorCode(typ)
11124 }
11125 if len(bodyInfo.Message) != 0 {
11126 errorMessage = bodyInfo.Message
11127 }
11128 switch {
11129 case strings.EqualFold("AccessDeniedException", errorCode):
11130 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
11131
11132 case strings.EqualFold("InvalidInputException", errorCode):
11133 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
11134
11135 case strings.EqualFold("NotFoundException", errorCode):
11136 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
11137
11138 case strings.EqualFold("OperationFailureException", errorCode):
11139 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
11140
11141 case strings.EqualFold("ServiceException", errorCode):
11142 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
11143
11144 case strings.EqualFold("UnauthenticatedException", errorCode):
11145 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
11146
11147 default:
11148 genericError := &smithy.GenericAPIError{
11149 Code: errorCode,
11150 Message: errorMessage,
11151 }
11152 return genericError
11153
11154 }
11155 }
11156
11157 type awsAwsjson11_deserializeOpGetDistributionLatestCacheReset struct {
11158 }
11159
11160 func (*awsAwsjson11_deserializeOpGetDistributionLatestCacheReset) ID() string {
11161 return "OperationDeserializer"
11162 }
11163
11164 func (m *awsAwsjson11_deserializeOpGetDistributionLatestCacheReset) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
11165 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
11166 ) {
11167 out, metadata, err = next.HandleDeserialize(ctx, in)
11168 if err != nil {
11169 return out, metadata, err
11170 }
11171
11172 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
11173 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
11174 defer endTimer()
11175 defer span.End()
11176 response, ok := out.RawResponse.(*smithyhttp.Response)
11177 if !ok {
11178 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
11179 }
11180
11181 if response.StatusCode < 200 || response.StatusCode >= 300 {
11182 return out, metadata, awsAwsjson11_deserializeOpErrorGetDistributionLatestCacheReset(response, &metadata)
11183 }
11184 output := &GetDistributionLatestCacheResetOutput{}
11185 out.Result = output
11186
11187 var buff [1024]byte
11188 ringBuffer := smithyio.NewRingBuffer(buff[:])
11189
11190 body := io.TeeReader(response.Body, ringBuffer)
11191 decoder := json.NewDecoder(body)
11192 decoder.UseNumber()
11193 var shape interface{}
11194 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
11195 var snapshot bytes.Buffer
11196 io.Copy(&snapshot, ringBuffer)
11197 err = &smithy.DeserializationError{
11198 Err: fmt.Errorf("failed to decode response body, %w", err),
11199 Snapshot: snapshot.Bytes(),
11200 }
11201 return out, metadata, err
11202 }
11203
11204 err = awsAwsjson11_deserializeOpDocumentGetDistributionLatestCacheResetOutput(&output, shape)
11205 if err != nil {
11206 var snapshot bytes.Buffer
11207 io.Copy(&snapshot, ringBuffer)
11208 err = &smithy.DeserializationError{
11209 Err: fmt.Errorf("failed to decode response body, %w", err),
11210 Snapshot: snapshot.Bytes(),
11211 }
11212 return out, metadata, err
11213 }
11214
11215 return out, metadata, err
11216 }
11217
11218 func awsAwsjson11_deserializeOpErrorGetDistributionLatestCacheReset(response *smithyhttp.Response, metadata *middleware.Metadata) error {
11219 var errorBuffer bytes.Buffer
11220 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
11221 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
11222 }
11223 errorBody := bytes.NewReader(errorBuffer.Bytes())
11224
11225 errorCode := "UnknownError"
11226 errorMessage := errorCode
11227
11228 headerCode := response.Header.Get("X-Amzn-ErrorType")
11229
11230 var buff [1024]byte
11231 ringBuffer := smithyio.NewRingBuffer(buff[:])
11232
11233 body := io.TeeReader(errorBody, ringBuffer)
11234 decoder := json.NewDecoder(body)
11235 decoder.UseNumber()
11236 bodyInfo, err := getProtocolErrorInfo(decoder)
11237 if err != nil {
11238 var snapshot bytes.Buffer
11239 io.Copy(&snapshot, ringBuffer)
11240 err = &smithy.DeserializationError{
11241 Err: fmt.Errorf("failed to decode response body, %w", err),
11242 Snapshot: snapshot.Bytes(),
11243 }
11244 return err
11245 }
11246
11247 errorBody.Seek(0, io.SeekStart)
11248 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
11249 errorCode = restjson.SanitizeErrorCode(typ)
11250 }
11251 if len(bodyInfo.Message) != 0 {
11252 errorMessage = bodyInfo.Message
11253 }
11254 switch {
11255 case strings.EqualFold("AccessDeniedException", errorCode):
11256 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
11257
11258 case strings.EqualFold("InvalidInputException", errorCode):
11259 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
11260
11261 case strings.EqualFold("NotFoundException", errorCode):
11262 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
11263
11264 case strings.EqualFold("OperationFailureException", errorCode):
11265 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
11266
11267 case strings.EqualFold("ServiceException", errorCode):
11268 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
11269
11270 case strings.EqualFold("UnauthenticatedException", errorCode):
11271 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
11272
11273 default:
11274 genericError := &smithy.GenericAPIError{
11275 Code: errorCode,
11276 Message: errorMessage,
11277 }
11278 return genericError
11279
11280 }
11281 }
11282
11283 type awsAwsjson11_deserializeOpGetDistributionMetricData struct {
11284 }
11285
11286 func (*awsAwsjson11_deserializeOpGetDistributionMetricData) ID() string {
11287 return "OperationDeserializer"
11288 }
11289
11290 func (m *awsAwsjson11_deserializeOpGetDistributionMetricData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
11291 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
11292 ) {
11293 out, metadata, err = next.HandleDeserialize(ctx, in)
11294 if err != nil {
11295 return out, metadata, err
11296 }
11297
11298 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
11299 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
11300 defer endTimer()
11301 defer span.End()
11302 response, ok := out.RawResponse.(*smithyhttp.Response)
11303 if !ok {
11304 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
11305 }
11306
11307 if response.StatusCode < 200 || response.StatusCode >= 300 {
11308 return out, metadata, awsAwsjson11_deserializeOpErrorGetDistributionMetricData(response, &metadata)
11309 }
11310 output := &GetDistributionMetricDataOutput{}
11311 out.Result = output
11312
11313 var buff [1024]byte
11314 ringBuffer := smithyio.NewRingBuffer(buff[:])
11315
11316 body := io.TeeReader(response.Body, ringBuffer)
11317 decoder := json.NewDecoder(body)
11318 decoder.UseNumber()
11319 var shape interface{}
11320 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
11321 var snapshot bytes.Buffer
11322 io.Copy(&snapshot, ringBuffer)
11323 err = &smithy.DeserializationError{
11324 Err: fmt.Errorf("failed to decode response body, %w", err),
11325 Snapshot: snapshot.Bytes(),
11326 }
11327 return out, metadata, err
11328 }
11329
11330 err = awsAwsjson11_deserializeOpDocumentGetDistributionMetricDataOutput(&output, shape)
11331 if err != nil {
11332 var snapshot bytes.Buffer
11333 io.Copy(&snapshot, ringBuffer)
11334 err = &smithy.DeserializationError{
11335 Err: fmt.Errorf("failed to decode response body, %w", err),
11336 Snapshot: snapshot.Bytes(),
11337 }
11338 return out, metadata, err
11339 }
11340
11341 return out, metadata, err
11342 }
11343
11344 func awsAwsjson11_deserializeOpErrorGetDistributionMetricData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
11345 var errorBuffer bytes.Buffer
11346 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
11347 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
11348 }
11349 errorBody := bytes.NewReader(errorBuffer.Bytes())
11350
11351 errorCode := "UnknownError"
11352 errorMessage := errorCode
11353
11354 headerCode := response.Header.Get("X-Amzn-ErrorType")
11355
11356 var buff [1024]byte
11357 ringBuffer := smithyio.NewRingBuffer(buff[:])
11358
11359 body := io.TeeReader(errorBody, ringBuffer)
11360 decoder := json.NewDecoder(body)
11361 decoder.UseNumber()
11362 bodyInfo, err := getProtocolErrorInfo(decoder)
11363 if err != nil {
11364 var snapshot bytes.Buffer
11365 io.Copy(&snapshot, ringBuffer)
11366 err = &smithy.DeserializationError{
11367 Err: fmt.Errorf("failed to decode response body, %w", err),
11368 Snapshot: snapshot.Bytes(),
11369 }
11370 return err
11371 }
11372
11373 errorBody.Seek(0, io.SeekStart)
11374 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
11375 errorCode = restjson.SanitizeErrorCode(typ)
11376 }
11377 if len(bodyInfo.Message) != 0 {
11378 errorMessage = bodyInfo.Message
11379 }
11380 switch {
11381 case strings.EqualFold("AccessDeniedException", errorCode):
11382 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
11383
11384 case strings.EqualFold("InvalidInputException", errorCode):
11385 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
11386
11387 case strings.EqualFold("NotFoundException", errorCode):
11388 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
11389
11390 case strings.EqualFold("OperationFailureException", errorCode):
11391 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
11392
11393 case strings.EqualFold("ServiceException", errorCode):
11394 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
11395
11396 case strings.EqualFold("UnauthenticatedException", errorCode):
11397 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
11398
11399 default:
11400 genericError := &smithy.GenericAPIError{
11401 Code: errorCode,
11402 Message: errorMessage,
11403 }
11404 return genericError
11405
11406 }
11407 }
11408
11409 type awsAwsjson11_deserializeOpGetDistributions struct {
11410 }
11411
11412 func (*awsAwsjson11_deserializeOpGetDistributions) ID() string {
11413 return "OperationDeserializer"
11414 }
11415
11416 func (m *awsAwsjson11_deserializeOpGetDistributions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
11417 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
11418 ) {
11419 out, metadata, err = next.HandleDeserialize(ctx, in)
11420 if err != nil {
11421 return out, metadata, err
11422 }
11423
11424 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
11425 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
11426 defer endTimer()
11427 defer span.End()
11428 response, ok := out.RawResponse.(*smithyhttp.Response)
11429 if !ok {
11430 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
11431 }
11432
11433 if response.StatusCode < 200 || response.StatusCode >= 300 {
11434 return out, metadata, awsAwsjson11_deserializeOpErrorGetDistributions(response, &metadata)
11435 }
11436 output := &GetDistributionsOutput{}
11437 out.Result = output
11438
11439 var buff [1024]byte
11440 ringBuffer := smithyio.NewRingBuffer(buff[:])
11441
11442 body := io.TeeReader(response.Body, ringBuffer)
11443 decoder := json.NewDecoder(body)
11444 decoder.UseNumber()
11445 var shape interface{}
11446 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
11447 var snapshot bytes.Buffer
11448 io.Copy(&snapshot, ringBuffer)
11449 err = &smithy.DeserializationError{
11450 Err: fmt.Errorf("failed to decode response body, %w", err),
11451 Snapshot: snapshot.Bytes(),
11452 }
11453 return out, metadata, err
11454 }
11455
11456 err = awsAwsjson11_deserializeOpDocumentGetDistributionsOutput(&output, shape)
11457 if err != nil {
11458 var snapshot bytes.Buffer
11459 io.Copy(&snapshot, ringBuffer)
11460 err = &smithy.DeserializationError{
11461 Err: fmt.Errorf("failed to decode response body, %w", err),
11462 Snapshot: snapshot.Bytes(),
11463 }
11464 return out, metadata, err
11465 }
11466
11467 return out, metadata, err
11468 }
11469
11470 func awsAwsjson11_deserializeOpErrorGetDistributions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
11471 var errorBuffer bytes.Buffer
11472 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
11473 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
11474 }
11475 errorBody := bytes.NewReader(errorBuffer.Bytes())
11476
11477 errorCode := "UnknownError"
11478 errorMessage := errorCode
11479
11480 headerCode := response.Header.Get("X-Amzn-ErrorType")
11481
11482 var buff [1024]byte
11483 ringBuffer := smithyio.NewRingBuffer(buff[:])
11484
11485 body := io.TeeReader(errorBody, ringBuffer)
11486 decoder := json.NewDecoder(body)
11487 decoder.UseNumber()
11488 bodyInfo, err := getProtocolErrorInfo(decoder)
11489 if err != nil {
11490 var snapshot bytes.Buffer
11491 io.Copy(&snapshot, ringBuffer)
11492 err = &smithy.DeserializationError{
11493 Err: fmt.Errorf("failed to decode response body, %w", err),
11494 Snapshot: snapshot.Bytes(),
11495 }
11496 return err
11497 }
11498
11499 errorBody.Seek(0, io.SeekStart)
11500 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
11501 errorCode = restjson.SanitizeErrorCode(typ)
11502 }
11503 if len(bodyInfo.Message) != 0 {
11504 errorMessage = bodyInfo.Message
11505 }
11506 switch {
11507 case strings.EqualFold("AccessDeniedException", errorCode):
11508 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
11509
11510 case strings.EqualFold("InvalidInputException", errorCode):
11511 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
11512
11513 case strings.EqualFold("NotFoundException", errorCode):
11514 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
11515
11516 case strings.EqualFold("OperationFailureException", errorCode):
11517 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
11518
11519 case strings.EqualFold("ServiceException", errorCode):
11520 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
11521
11522 case strings.EqualFold("UnauthenticatedException", errorCode):
11523 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
11524
11525 default:
11526 genericError := &smithy.GenericAPIError{
11527 Code: errorCode,
11528 Message: errorMessage,
11529 }
11530 return genericError
11531
11532 }
11533 }
11534
11535 type awsAwsjson11_deserializeOpGetDomain struct {
11536 }
11537
11538 func (*awsAwsjson11_deserializeOpGetDomain) ID() string {
11539 return "OperationDeserializer"
11540 }
11541
11542 func (m *awsAwsjson11_deserializeOpGetDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
11543 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
11544 ) {
11545 out, metadata, err = next.HandleDeserialize(ctx, in)
11546 if err != nil {
11547 return out, metadata, err
11548 }
11549
11550 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
11551 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
11552 defer endTimer()
11553 defer span.End()
11554 response, ok := out.RawResponse.(*smithyhttp.Response)
11555 if !ok {
11556 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
11557 }
11558
11559 if response.StatusCode < 200 || response.StatusCode >= 300 {
11560 return out, metadata, awsAwsjson11_deserializeOpErrorGetDomain(response, &metadata)
11561 }
11562 output := &GetDomainOutput{}
11563 out.Result = output
11564
11565 var buff [1024]byte
11566 ringBuffer := smithyio.NewRingBuffer(buff[:])
11567
11568 body := io.TeeReader(response.Body, ringBuffer)
11569 decoder := json.NewDecoder(body)
11570 decoder.UseNumber()
11571 var shape interface{}
11572 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
11573 var snapshot bytes.Buffer
11574 io.Copy(&snapshot, ringBuffer)
11575 err = &smithy.DeserializationError{
11576 Err: fmt.Errorf("failed to decode response body, %w", err),
11577 Snapshot: snapshot.Bytes(),
11578 }
11579 return out, metadata, err
11580 }
11581
11582 err = awsAwsjson11_deserializeOpDocumentGetDomainOutput(&output, shape)
11583 if err != nil {
11584 var snapshot bytes.Buffer
11585 io.Copy(&snapshot, ringBuffer)
11586 err = &smithy.DeserializationError{
11587 Err: fmt.Errorf("failed to decode response body, %w", err),
11588 Snapshot: snapshot.Bytes(),
11589 }
11590 return out, metadata, err
11591 }
11592
11593 return out, metadata, err
11594 }
11595
11596 func awsAwsjson11_deserializeOpErrorGetDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error {
11597 var errorBuffer bytes.Buffer
11598 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
11599 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
11600 }
11601 errorBody := bytes.NewReader(errorBuffer.Bytes())
11602
11603 errorCode := "UnknownError"
11604 errorMessage := errorCode
11605
11606 headerCode := response.Header.Get("X-Amzn-ErrorType")
11607
11608 var buff [1024]byte
11609 ringBuffer := smithyio.NewRingBuffer(buff[:])
11610
11611 body := io.TeeReader(errorBody, ringBuffer)
11612 decoder := json.NewDecoder(body)
11613 decoder.UseNumber()
11614 bodyInfo, err := getProtocolErrorInfo(decoder)
11615 if err != nil {
11616 var snapshot bytes.Buffer
11617 io.Copy(&snapshot, ringBuffer)
11618 err = &smithy.DeserializationError{
11619 Err: fmt.Errorf("failed to decode response body, %w", err),
11620 Snapshot: snapshot.Bytes(),
11621 }
11622 return err
11623 }
11624
11625 errorBody.Seek(0, io.SeekStart)
11626 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
11627 errorCode = restjson.SanitizeErrorCode(typ)
11628 }
11629 if len(bodyInfo.Message) != 0 {
11630 errorMessage = bodyInfo.Message
11631 }
11632 switch {
11633 case strings.EqualFold("AccessDeniedException", errorCode):
11634 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
11635
11636 case strings.EqualFold("AccountSetupInProgressException", errorCode):
11637 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
11638
11639 case strings.EqualFold("InvalidInputException", errorCode):
11640 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
11641
11642 case strings.EqualFold("NotFoundException", errorCode):
11643 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
11644
11645 case strings.EqualFold("OperationFailureException", errorCode):
11646 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
11647
11648 case strings.EqualFold("RegionSetupInProgressException", errorCode):
11649 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
11650
11651 case strings.EqualFold("ServiceException", errorCode):
11652 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
11653
11654 case strings.EqualFold("UnauthenticatedException", errorCode):
11655 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
11656
11657 default:
11658 genericError := &smithy.GenericAPIError{
11659 Code: errorCode,
11660 Message: errorMessage,
11661 }
11662 return genericError
11663
11664 }
11665 }
11666
11667 type awsAwsjson11_deserializeOpGetDomains struct {
11668 }
11669
11670 func (*awsAwsjson11_deserializeOpGetDomains) ID() string {
11671 return "OperationDeserializer"
11672 }
11673
11674 func (m *awsAwsjson11_deserializeOpGetDomains) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
11675 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
11676 ) {
11677 out, metadata, err = next.HandleDeserialize(ctx, in)
11678 if err != nil {
11679 return out, metadata, err
11680 }
11681
11682 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
11683 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
11684 defer endTimer()
11685 defer span.End()
11686 response, ok := out.RawResponse.(*smithyhttp.Response)
11687 if !ok {
11688 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
11689 }
11690
11691 if response.StatusCode < 200 || response.StatusCode >= 300 {
11692 return out, metadata, awsAwsjson11_deserializeOpErrorGetDomains(response, &metadata)
11693 }
11694 output := &GetDomainsOutput{}
11695 out.Result = output
11696
11697 var buff [1024]byte
11698 ringBuffer := smithyio.NewRingBuffer(buff[:])
11699
11700 body := io.TeeReader(response.Body, ringBuffer)
11701 decoder := json.NewDecoder(body)
11702 decoder.UseNumber()
11703 var shape interface{}
11704 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
11705 var snapshot bytes.Buffer
11706 io.Copy(&snapshot, ringBuffer)
11707 err = &smithy.DeserializationError{
11708 Err: fmt.Errorf("failed to decode response body, %w", err),
11709 Snapshot: snapshot.Bytes(),
11710 }
11711 return out, metadata, err
11712 }
11713
11714 err = awsAwsjson11_deserializeOpDocumentGetDomainsOutput(&output, shape)
11715 if err != nil {
11716 var snapshot bytes.Buffer
11717 io.Copy(&snapshot, ringBuffer)
11718 err = &smithy.DeserializationError{
11719 Err: fmt.Errorf("failed to decode response body, %w", err),
11720 Snapshot: snapshot.Bytes(),
11721 }
11722 return out, metadata, err
11723 }
11724
11725 return out, metadata, err
11726 }
11727
11728 func awsAwsjson11_deserializeOpErrorGetDomains(response *smithyhttp.Response, metadata *middleware.Metadata) error {
11729 var errorBuffer bytes.Buffer
11730 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
11731 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
11732 }
11733 errorBody := bytes.NewReader(errorBuffer.Bytes())
11734
11735 errorCode := "UnknownError"
11736 errorMessage := errorCode
11737
11738 headerCode := response.Header.Get("X-Amzn-ErrorType")
11739
11740 var buff [1024]byte
11741 ringBuffer := smithyio.NewRingBuffer(buff[:])
11742
11743 body := io.TeeReader(errorBody, ringBuffer)
11744 decoder := json.NewDecoder(body)
11745 decoder.UseNumber()
11746 bodyInfo, err := getProtocolErrorInfo(decoder)
11747 if err != nil {
11748 var snapshot bytes.Buffer
11749 io.Copy(&snapshot, ringBuffer)
11750 err = &smithy.DeserializationError{
11751 Err: fmt.Errorf("failed to decode response body, %w", err),
11752 Snapshot: snapshot.Bytes(),
11753 }
11754 return err
11755 }
11756
11757 errorBody.Seek(0, io.SeekStart)
11758 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
11759 errorCode = restjson.SanitizeErrorCode(typ)
11760 }
11761 if len(bodyInfo.Message) != 0 {
11762 errorMessage = bodyInfo.Message
11763 }
11764 switch {
11765 case strings.EqualFold("AccessDeniedException", errorCode):
11766 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
11767
11768 case strings.EqualFold("AccountSetupInProgressException", errorCode):
11769 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
11770
11771 case strings.EqualFold("InvalidInputException", errorCode):
11772 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
11773
11774 case strings.EqualFold("NotFoundException", errorCode):
11775 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
11776
11777 case strings.EqualFold("OperationFailureException", errorCode):
11778 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
11779
11780 case strings.EqualFold("RegionSetupInProgressException", errorCode):
11781 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
11782
11783 case strings.EqualFold("ServiceException", errorCode):
11784 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
11785
11786 case strings.EqualFold("UnauthenticatedException", errorCode):
11787 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
11788
11789 default:
11790 genericError := &smithy.GenericAPIError{
11791 Code: errorCode,
11792 Message: errorMessage,
11793 }
11794 return genericError
11795
11796 }
11797 }
11798
11799 type awsAwsjson11_deserializeOpGetExportSnapshotRecords struct {
11800 }
11801
11802 func (*awsAwsjson11_deserializeOpGetExportSnapshotRecords) ID() string {
11803 return "OperationDeserializer"
11804 }
11805
11806 func (m *awsAwsjson11_deserializeOpGetExportSnapshotRecords) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
11807 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
11808 ) {
11809 out, metadata, err = next.HandleDeserialize(ctx, in)
11810 if err != nil {
11811 return out, metadata, err
11812 }
11813
11814 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
11815 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
11816 defer endTimer()
11817 defer span.End()
11818 response, ok := out.RawResponse.(*smithyhttp.Response)
11819 if !ok {
11820 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
11821 }
11822
11823 if response.StatusCode < 200 || response.StatusCode >= 300 {
11824 return out, metadata, awsAwsjson11_deserializeOpErrorGetExportSnapshotRecords(response, &metadata)
11825 }
11826 output := &GetExportSnapshotRecordsOutput{}
11827 out.Result = output
11828
11829 var buff [1024]byte
11830 ringBuffer := smithyio.NewRingBuffer(buff[:])
11831
11832 body := io.TeeReader(response.Body, ringBuffer)
11833 decoder := json.NewDecoder(body)
11834 decoder.UseNumber()
11835 var shape interface{}
11836 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
11837 var snapshot bytes.Buffer
11838 io.Copy(&snapshot, ringBuffer)
11839 err = &smithy.DeserializationError{
11840 Err: fmt.Errorf("failed to decode response body, %w", err),
11841 Snapshot: snapshot.Bytes(),
11842 }
11843 return out, metadata, err
11844 }
11845
11846 err = awsAwsjson11_deserializeOpDocumentGetExportSnapshotRecordsOutput(&output, shape)
11847 if err != nil {
11848 var snapshot bytes.Buffer
11849 io.Copy(&snapshot, ringBuffer)
11850 err = &smithy.DeserializationError{
11851 Err: fmt.Errorf("failed to decode response body, %w", err),
11852 Snapshot: snapshot.Bytes(),
11853 }
11854 return out, metadata, err
11855 }
11856
11857 return out, metadata, err
11858 }
11859
11860 func awsAwsjson11_deserializeOpErrorGetExportSnapshotRecords(response *smithyhttp.Response, metadata *middleware.Metadata) error {
11861 var errorBuffer bytes.Buffer
11862 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
11863 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
11864 }
11865 errorBody := bytes.NewReader(errorBuffer.Bytes())
11866
11867 errorCode := "UnknownError"
11868 errorMessage := errorCode
11869
11870 headerCode := response.Header.Get("X-Amzn-ErrorType")
11871
11872 var buff [1024]byte
11873 ringBuffer := smithyio.NewRingBuffer(buff[:])
11874
11875 body := io.TeeReader(errorBody, ringBuffer)
11876 decoder := json.NewDecoder(body)
11877 decoder.UseNumber()
11878 bodyInfo, err := getProtocolErrorInfo(decoder)
11879 if err != nil {
11880 var snapshot bytes.Buffer
11881 io.Copy(&snapshot, ringBuffer)
11882 err = &smithy.DeserializationError{
11883 Err: fmt.Errorf("failed to decode response body, %w", err),
11884 Snapshot: snapshot.Bytes(),
11885 }
11886 return err
11887 }
11888
11889 errorBody.Seek(0, io.SeekStart)
11890 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
11891 errorCode = restjson.SanitizeErrorCode(typ)
11892 }
11893 if len(bodyInfo.Message) != 0 {
11894 errorMessage = bodyInfo.Message
11895 }
11896 switch {
11897 case strings.EqualFold("AccessDeniedException", errorCode):
11898 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
11899
11900 case strings.EqualFold("AccountSetupInProgressException", errorCode):
11901 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
11902
11903 case strings.EqualFold("InvalidInputException", errorCode):
11904 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
11905
11906 case strings.EqualFold("NotFoundException", errorCode):
11907 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
11908
11909 case strings.EqualFold("OperationFailureException", errorCode):
11910 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
11911
11912 case strings.EqualFold("RegionSetupInProgressException", errorCode):
11913 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
11914
11915 case strings.EqualFold("ServiceException", errorCode):
11916 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
11917
11918 case strings.EqualFold("UnauthenticatedException", errorCode):
11919 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
11920
11921 default:
11922 genericError := &smithy.GenericAPIError{
11923 Code: errorCode,
11924 Message: errorMessage,
11925 }
11926 return genericError
11927
11928 }
11929 }
11930
11931 type awsAwsjson11_deserializeOpGetInstance struct {
11932 }
11933
11934 func (*awsAwsjson11_deserializeOpGetInstance) ID() string {
11935 return "OperationDeserializer"
11936 }
11937
11938 func (m *awsAwsjson11_deserializeOpGetInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
11939 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
11940 ) {
11941 out, metadata, err = next.HandleDeserialize(ctx, in)
11942 if err != nil {
11943 return out, metadata, err
11944 }
11945
11946 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
11947 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
11948 defer endTimer()
11949 defer span.End()
11950 response, ok := out.RawResponse.(*smithyhttp.Response)
11951 if !ok {
11952 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
11953 }
11954
11955 if response.StatusCode < 200 || response.StatusCode >= 300 {
11956 return out, metadata, awsAwsjson11_deserializeOpErrorGetInstance(response, &metadata)
11957 }
11958 output := &GetInstanceOutput{}
11959 out.Result = output
11960
11961 var buff [1024]byte
11962 ringBuffer := smithyio.NewRingBuffer(buff[:])
11963
11964 body := io.TeeReader(response.Body, ringBuffer)
11965 decoder := json.NewDecoder(body)
11966 decoder.UseNumber()
11967 var shape interface{}
11968 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
11969 var snapshot bytes.Buffer
11970 io.Copy(&snapshot, ringBuffer)
11971 err = &smithy.DeserializationError{
11972 Err: fmt.Errorf("failed to decode response body, %w", err),
11973 Snapshot: snapshot.Bytes(),
11974 }
11975 return out, metadata, err
11976 }
11977
11978 err = awsAwsjson11_deserializeOpDocumentGetInstanceOutput(&output, shape)
11979 if err != nil {
11980 var snapshot bytes.Buffer
11981 io.Copy(&snapshot, ringBuffer)
11982 err = &smithy.DeserializationError{
11983 Err: fmt.Errorf("failed to decode response body, %w", err),
11984 Snapshot: snapshot.Bytes(),
11985 }
11986 return out, metadata, err
11987 }
11988
11989 return out, metadata, err
11990 }
11991
11992 func awsAwsjson11_deserializeOpErrorGetInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
11993 var errorBuffer bytes.Buffer
11994 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
11995 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
11996 }
11997 errorBody := bytes.NewReader(errorBuffer.Bytes())
11998
11999 errorCode := "UnknownError"
12000 errorMessage := errorCode
12001
12002 headerCode := response.Header.Get("X-Amzn-ErrorType")
12003
12004 var buff [1024]byte
12005 ringBuffer := smithyio.NewRingBuffer(buff[:])
12006
12007 body := io.TeeReader(errorBody, ringBuffer)
12008 decoder := json.NewDecoder(body)
12009 decoder.UseNumber()
12010 bodyInfo, err := getProtocolErrorInfo(decoder)
12011 if err != nil {
12012 var snapshot bytes.Buffer
12013 io.Copy(&snapshot, ringBuffer)
12014 err = &smithy.DeserializationError{
12015 Err: fmt.Errorf("failed to decode response body, %w", err),
12016 Snapshot: snapshot.Bytes(),
12017 }
12018 return err
12019 }
12020
12021 errorBody.Seek(0, io.SeekStart)
12022 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
12023 errorCode = restjson.SanitizeErrorCode(typ)
12024 }
12025 if len(bodyInfo.Message) != 0 {
12026 errorMessage = bodyInfo.Message
12027 }
12028 switch {
12029 case strings.EqualFold("AccessDeniedException", errorCode):
12030 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
12031
12032 case strings.EqualFold("AccountSetupInProgressException", errorCode):
12033 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
12034
12035 case strings.EqualFold("InvalidInputException", errorCode):
12036 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
12037
12038 case strings.EqualFold("NotFoundException", errorCode):
12039 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
12040
12041 case strings.EqualFold("OperationFailureException", errorCode):
12042 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
12043
12044 case strings.EqualFold("RegionSetupInProgressException", errorCode):
12045 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
12046
12047 case strings.EqualFold("ServiceException", errorCode):
12048 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
12049
12050 case strings.EqualFold("UnauthenticatedException", errorCode):
12051 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
12052
12053 default:
12054 genericError := &smithy.GenericAPIError{
12055 Code: errorCode,
12056 Message: errorMessage,
12057 }
12058 return genericError
12059
12060 }
12061 }
12062
12063 type awsAwsjson11_deserializeOpGetInstanceAccessDetails struct {
12064 }
12065
12066 func (*awsAwsjson11_deserializeOpGetInstanceAccessDetails) ID() string {
12067 return "OperationDeserializer"
12068 }
12069
12070 func (m *awsAwsjson11_deserializeOpGetInstanceAccessDetails) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
12071 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
12072 ) {
12073 out, metadata, err = next.HandleDeserialize(ctx, in)
12074 if err != nil {
12075 return out, metadata, err
12076 }
12077
12078 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
12079 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
12080 defer endTimer()
12081 defer span.End()
12082 response, ok := out.RawResponse.(*smithyhttp.Response)
12083 if !ok {
12084 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
12085 }
12086
12087 if response.StatusCode < 200 || response.StatusCode >= 300 {
12088 return out, metadata, awsAwsjson11_deserializeOpErrorGetInstanceAccessDetails(response, &metadata)
12089 }
12090 output := &GetInstanceAccessDetailsOutput{}
12091 out.Result = output
12092
12093 var buff [1024]byte
12094 ringBuffer := smithyio.NewRingBuffer(buff[:])
12095
12096 body := io.TeeReader(response.Body, ringBuffer)
12097 decoder := json.NewDecoder(body)
12098 decoder.UseNumber()
12099 var shape interface{}
12100 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
12101 var snapshot bytes.Buffer
12102 io.Copy(&snapshot, ringBuffer)
12103 err = &smithy.DeserializationError{
12104 Err: fmt.Errorf("failed to decode response body, %w", err),
12105 Snapshot: snapshot.Bytes(),
12106 }
12107 return out, metadata, err
12108 }
12109
12110 err = awsAwsjson11_deserializeOpDocumentGetInstanceAccessDetailsOutput(&output, shape)
12111 if err != nil {
12112 var snapshot bytes.Buffer
12113 io.Copy(&snapshot, ringBuffer)
12114 err = &smithy.DeserializationError{
12115 Err: fmt.Errorf("failed to decode response body, %w", err),
12116 Snapshot: snapshot.Bytes(),
12117 }
12118 return out, metadata, err
12119 }
12120
12121 return out, metadata, err
12122 }
12123
12124 func awsAwsjson11_deserializeOpErrorGetInstanceAccessDetails(response *smithyhttp.Response, metadata *middleware.Metadata) error {
12125 var errorBuffer bytes.Buffer
12126 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
12127 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
12128 }
12129 errorBody := bytes.NewReader(errorBuffer.Bytes())
12130
12131 errorCode := "UnknownError"
12132 errorMessage := errorCode
12133
12134 headerCode := response.Header.Get("X-Amzn-ErrorType")
12135
12136 var buff [1024]byte
12137 ringBuffer := smithyio.NewRingBuffer(buff[:])
12138
12139 body := io.TeeReader(errorBody, ringBuffer)
12140 decoder := json.NewDecoder(body)
12141 decoder.UseNumber()
12142 bodyInfo, err := getProtocolErrorInfo(decoder)
12143 if err != nil {
12144 var snapshot bytes.Buffer
12145 io.Copy(&snapshot, ringBuffer)
12146 err = &smithy.DeserializationError{
12147 Err: fmt.Errorf("failed to decode response body, %w", err),
12148 Snapshot: snapshot.Bytes(),
12149 }
12150 return err
12151 }
12152
12153 errorBody.Seek(0, io.SeekStart)
12154 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
12155 errorCode = restjson.SanitizeErrorCode(typ)
12156 }
12157 if len(bodyInfo.Message) != 0 {
12158 errorMessage = bodyInfo.Message
12159 }
12160 switch {
12161 case strings.EqualFold("AccessDeniedException", errorCode):
12162 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
12163
12164 case strings.EqualFold("AccountSetupInProgressException", errorCode):
12165 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
12166
12167 case strings.EqualFold("InvalidInputException", errorCode):
12168 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
12169
12170 case strings.EqualFold("NotFoundException", errorCode):
12171 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
12172
12173 case strings.EqualFold("OperationFailureException", errorCode):
12174 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
12175
12176 case strings.EqualFold("RegionSetupInProgressException", errorCode):
12177 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
12178
12179 case strings.EqualFold("ServiceException", errorCode):
12180 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
12181
12182 case strings.EqualFold("UnauthenticatedException", errorCode):
12183 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
12184
12185 default:
12186 genericError := &smithy.GenericAPIError{
12187 Code: errorCode,
12188 Message: errorMessage,
12189 }
12190 return genericError
12191
12192 }
12193 }
12194
12195 type awsAwsjson11_deserializeOpGetInstanceMetricData struct {
12196 }
12197
12198 func (*awsAwsjson11_deserializeOpGetInstanceMetricData) ID() string {
12199 return "OperationDeserializer"
12200 }
12201
12202 func (m *awsAwsjson11_deserializeOpGetInstanceMetricData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
12203 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
12204 ) {
12205 out, metadata, err = next.HandleDeserialize(ctx, in)
12206 if err != nil {
12207 return out, metadata, err
12208 }
12209
12210 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
12211 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
12212 defer endTimer()
12213 defer span.End()
12214 response, ok := out.RawResponse.(*smithyhttp.Response)
12215 if !ok {
12216 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
12217 }
12218
12219 if response.StatusCode < 200 || response.StatusCode >= 300 {
12220 return out, metadata, awsAwsjson11_deserializeOpErrorGetInstanceMetricData(response, &metadata)
12221 }
12222 output := &GetInstanceMetricDataOutput{}
12223 out.Result = output
12224
12225 var buff [1024]byte
12226 ringBuffer := smithyio.NewRingBuffer(buff[:])
12227
12228 body := io.TeeReader(response.Body, ringBuffer)
12229 decoder := json.NewDecoder(body)
12230 decoder.UseNumber()
12231 var shape interface{}
12232 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
12233 var snapshot bytes.Buffer
12234 io.Copy(&snapshot, ringBuffer)
12235 err = &smithy.DeserializationError{
12236 Err: fmt.Errorf("failed to decode response body, %w", err),
12237 Snapshot: snapshot.Bytes(),
12238 }
12239 return out, metadata, err
12240 }
12241
12242 err = awsAwsjson11_deserializeOpDocumentGetInstanceMetricDataOutput(&output, shape)
12243 if err != nil {
12244 var snapshot bytes.Buffer
12245 io.Copy(&snapshot, ringBuffer)
12246 err = &smithy.DeserializationError{
12247 Err: fmt.Errorf("failed to decode response body, %w", err),
12248 Snapshot: snapshot.Bytes(),
12249 }
12250 return out, metadata, err
12251 }
12252
12253 return out, metadata, err
12254 }
12255
12256 func awsAwsjson11_deserializeOpErrorGetInstanceMetricData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
12257 var errorBuffer bytes.Buffer
12258 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
12259 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
12260 }
12261 errorBody := bytes.NewReader(errorBuffer.Bytes())
12262
12263 errorCode := "UnknownError"
12264 errorMessage := errorCode
12265
12266 headerCode := response.Header.Get("X-Amzn-ErrorType")
12267
12268 var buff [1024]byte
12269 ringBuffer := smithyio.NewRingBuffer(buff[:])
12270
12271 body := io.TeeReader(errorBody, ringBuffer)
12272 decoder := json.NewDecoder(body)
12273 decoder.UseNumber()
12274 bodyInfo, err := getProtocolErrorInfo(decoder)
12275 if err != nil {
12276 var snapshot bytes.Buffer
12277 io.Copy(&snapshot, ringBuffer)
12278 err = &smithy.DeserializationError{
12279 Err: fmt.Errorf("failed to decode response body, %w", err),
12280 Snapshot: snapshot.Bytes(),
12281 }
12282 return err
12283 }
12284
12285 errorBody.Seek(0, io.SeekStart)
12286 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
12287 errorCode = restjson.SanitizeErrorCode(typ)
12288 }
12289 if len(bodyInfo.Message) != 0 {
12290 errorMessage = bodyInfo.Message
12291 }
12292 switch {
12293 case strings.EqualFold("AccessDeniedException", errorCode):
12294 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
12295
12296 case strings.EqualFold("AccountSetupInProgressException", errorCode):
12297 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
12298
12299 case strings.EqualFold("InvalidInputException", errorCode):
12300 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
12301
12302 case strings.EqualFold("NotFoundException", errorCode):
12303 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
12304
12305 case strings.EqualFold("OperationFailureException", errorCode):
12306 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
12307
12308 case strings.EqualFold("RegionSetupInProgressException", errorCode):
12309 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
12310
12311 case strings.EqualFold("ServiceException", errorCode):
12312 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
12313
12314 case strings.EqualFold("UnauthenticatedException", errorCode):
12315 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
12316
12317 default:
12318 genericError := &smithy.GenericAPIError{
12319 Code: errorCode,
12320 Message: errorMessage,
12321 }
12322 return genericError
12323
12324 }
12325 }
12326
12327 type awsAwsjson11_deserializeOpGetInstancePortStates struct {
12328 }
12329
12330 func (*awsAwsjson11_deserializeOpGetInstancePortStates) ID() string {
12331 return "OperationDeserializer"
12332 }
12333
12334 func (m *awsAwsjson11_deserializeOpGetInstancePortStates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
12335 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
12336 ) {
12337 out, metadata, err = next.HandleDeserialize(ctx, in)
12338 if err != nil {
12339 return out, metadata, err
12340 }
12341
12342 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
12343 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
12344 defer endTimer()
12345 defer span.End()
12346 response, ok := out.RawResponse.(*smithyhttp.Response)
12347 if !ok {
12348 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
12349 }
12350
12351 if response.StatusCode < 200 || response.StatusCode >= 300 {
12352 return out, metadata, awsAwsjson11_deserializeOpErrorGetInstancePortStates(response, &metadata)
12353 }
12354 output := &GetInstancePortStatesOutput{}
12355 out.Result = output
12356
12357 var buff [1024]byte
12358 ringBuffer := smithyio.NewRingBuffer(buff[:])
12359
12360 body := io.TeeReader(response.Body, ringBuffer)
12361 decoder := json.NewDecoder(body)
12362 decoder.UseNumber()
12363 var shape interface{}
12364 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
12365 var snapshot bytes.Buffer
12366 io.Copy(&snapshot, ringBuffer)
12367 err = &smithy.DeserializationError{
12368 Err: fmt.Errorf("failed to decode response body, %w", err),
12369 Snapshot: snapshot.Bytes(),
12370 }
12371 return out, metadata, err
12372 }
12373
12374 err = awsAwsjson11_deserializeOpDocumentGetInstancePortStatesOutput(&output, shape)
12375 if err != nil {
12376 var snapshot bytes.Buffer
12377 io.Copy(&snapshot, ringBuffer)
12378 err = &smithy.DeserializationError{
12379 Err: fmt.Errorf("failed to decode response body, %w", err),
12380 Snapshot: snapshot.Bytes(),
12381 }
12382 return out, metadata, err
12383 }
12384
12385 return out, metadata, err
12386 }
12387
12388 func awsAwsjson11_deserializeOpErrorGetInstancePortStates(response *smithyhttp.Response, metadata *middleware.Metadata) error {
12389 var errorBuffer bytes.Buffer
12390 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
12391 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
12392 }
12393 errorBody := bytes.NewReader(errorBuffer.Bytes())
12394
12395 errorCode := "UnknownError"
12396 errorMessage := errorCode
12397
12398 headerCode := response.Header.Get("X-Amzn-ErrorType")
12399
12400 var buff [1024]byte
12401 ringBuffer := smithyio.NewRingBuffer(buff[:])
12402
12403 body := io.TeeReader(errorBody, ringBuffer)
12404 decoder := json.NewDecoder(body)
12405 decoder.UseNumber()
12406 bodyInfo, err := getProtocolErrorInfo(decoder)
12407 if err != nil {
12408 var snapshot bytes.Buffer
12409 io.Copy(&snapshot, ringBuffer)
12410 err = &smithy.DeserializationError{
12411 Err: fmt.Errorf("failed to decode response body, %w", err),
12412 Snapshot: snapshot.Bytes(),
12413 }
12414 return err
12415 }
12416
12417 errorBody.Seek(0, io.SeekStart)
12418 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
12419 errorCode = restjson.SanitizeErrorCode(typ)
12420 }
12421 if len(bodyInfo.Message) != 0 {
12422 errorMessage = bodyInfo.Message
12423 }
12424 switch {
12425 case strings.EqualFold("AccessDeniedException", errorCode):
12426 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
12427
12428 case strings.EqualFold("AccountSetupInProgressException", errorCode):
12429 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
12430
12431 case strings.EqualFold("InvalidInputException", errorCode):
12432 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
12433
12434 case strings.EqualFold("NotFoundException", errorCode):
12435 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
12436
12437 case strings.EqualFold("OperationFailureException", errorCode):
12438 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
12439
12440 case strings.EqualFold("RegionSetupInProgressException", errorCode):
12441 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
12442
12443 case strings.EqualFold("ServiceException", errorCode):
12444 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
12445
12446 case strings.EqualFold("UnauthenticatedException", errorCode):
12447 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
12448
12449 default:
12450 genericError := &smithy.GenericAPIError{
12451 Code: errorCode,
12452 Message: errorMessage,
12453 }
12454 return genericError
12455
12456 }
12457 }
12458
12459 type awsAwsjson11_deserializeOpGetInstances struct {
12460 }
12461
12462 func (*awsAwsjson11_deserializeOpGetInstances) ID() string {
12463 return "OperationDeserializer"
12464 }
12465
12466 func (m *awsAwsjson11_deserializeOpGetInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
12467 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
12468 ) {
12469 out, metadata, err = next.HandleDeserialize(ctx, in)
12470 if err != nil {
12471 return out, metadata, err
12472 }
12473
12474 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
12475 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
12476 defer endTimer()
12477 defer span.End()
12478 response, ok := out.RawResponse.(*smithyhttp.Response)
12479 if !ok {
12480 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
12481 }
12482
12483 if response.StatusCode < 200 || response.StatusCode >= 300 {
12484 return out, metadata, awsAwsjson11_deserializeOpErrorGetInstances(response, &metadata)
12485 }
12486 output := &GetInstancesOutput{}
12487 out.Result = output
12488
12489 var buff [1024]byte
12490 ringBuffer := smithyio.NewRingBuffer(buff[:])
12491
12492 body := io.TeeReader(response.Body, ringBuffer)
12493 decoder := json.NewDecoder(body)
12494 decoder.UseNumber()
12495 var shape interface{}
12496 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
12497 var snapshot bytes.Buffer
12498 io.Copy(&snapshot, ringBuffer)
12499 err = &smithy.DeserializationError{
12500 Err: fmt.Errorf("failed to decode response body, %w", err),
12501 Snapshot: snapshot.Bytes(),
12502 }
12503 return out, metadata, err
12504 }
12505
12506 err = awsAwsjson11_deserializeOpDocumentGetInstancesOutput(&output, shape)
12507 if err != nil {
12508 var snapshot bytes.Buffer
12509 io.Copy(&snapshot, ringBuffer)
12510 err = &smithy.DeserializationError{
12511 Err: fmt.Errorf("failed to decode response body, %w", err),
12512 Snapshot: snapshot.Bytes(),
12513 }
12514 return out, metadata, err
12515 }
12516
12517 return out, metadata, err
12518 }
12519
12520 func awsAwsjson11_deserializeOpErrorGetInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
12521 var errorBuffer bytes.Buffer
12522 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
12523 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
12524 }
12525 errorBody := bytes.NewReader(errorBuffer.Bytes())
12526
12527 errorCode := "UnknownError"
12528 errorMessage := errorCode
12529
12530 headerCode := response.Header.Get("X-Amzn-ErrorType")
12531
12532 var buff [1024]byte
12533 ringBuffer := smithyio.NewRingBuffer(buff[:])
12534
12535 body := io.TeeReader(errorBody, ringBuffer)
12536 decoder := json.NewDecoder(body)
12537 decoder.UseNumber()
12538 bodyInfo, err := getProtocolErrorInfo(decoder)
12539 if err != nil {
12540 var snapshot bytes.Buffer
12541 io.Copy(&snapshot, ringBuffer)
12542 err = &smithy.DeserializationError{
12543 Err: fmt.Errorf("failed to decode response body, %w", err),
12544 Snapshot: snapshot.Bytes(),
12545 }
12546 return err
12547 }
12548
12549 errorBody.Seek(0, io.SeekStart)
12550 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
12551 errorCode = restjson.SanitizeErrorCode(typ)
12552 }
12553 if len(bodyInfo.Message) != 0 {
12554 errorMessage = bodyInfo.Message
12555 }
12556 switch {
12557 case strings.EqualFold("AccessDeniedException", errorCode):
12558 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
12559
12560 case strings.EqualFold("AccountSetupInProgressException", errorCode):
12561 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
12562
12563 case strings.EqualFold("InvalidInputException", errorCode):
12564 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
12565
12566 case strings.EqualFold("NotFoundException", errorCode):
12567 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
12568
12569 case strings.EqualFold("OperationFailureException", errorCode):
12570 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
12571
12572 case strings.EqualFold("RegionSetupInProgressException", errorCode):
12573 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
12574
12575 case strings.EqualFold("ServiceException", errorCode):
12576 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
12577
12578 case strings.EqualFold("UnauthenticatedException", errorCode):
12579 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
12580
12581 default:
12582 genericError := &smithy.GenericAPIError{
12583 Code: errorCode,
12584 Message: errorMessage,
12585 }
12586 return genericError
12587
12588 }
12589 }
12590
12591 type awsAwsjson11_deserializeOpGetInstanceSnapshot struct {
12592 }
12593
12594 func (*awsAwsjson11_deserializeOpGetInstanceSnapshot) ID() string {
12595 return "OperationDeserializer"
12596 }
12597
12598 func (m *awsAwsjson11_deserializeOpGetInstanceSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
12599 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
12600 ) {
12601 out, metadata, err = next.HandleDeserialize(ctx, in)
12602 if err != nil {
12603 return out, metadata, err
12604 }
12605
12606 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
12607 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
12608 defer endTimer()
12609 defer span.End()
12610 response, ok := out.RawResponse.(*smithyhttp.Response)
12611 if !ok {
12612 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
12613 }
12614
12615 if response.StatusCode < 200 || response.StatusCode >= 300 {
12616 return out, metadata, awsAwsjson11_deserializeOpErrorGetInstanceSnapshot(response, &metadata)
12617 }
12618 output := &GetInstanceSnapshotOutput{}
12619 out.Result = output
12620
12621 var buff [1024]byte
12622 ringBuffer := smithyio.NewRingBuffer(buff[:])
12623
12624 body := io.TeeReader(response.Body, ringBuffer)
12625 decoder := json.NewDecoder(body)
12626 decoder.UseNumber()
12627 var shape interface{}
12628 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
12629 var snapshot bytes.Buffer
12630 io.Copy(&snapshot, ringBuffer)
12631 err = &smithy.DeserializationError{
12632 Err: fmt.Errorf("failed to decode response body, %w", err),
12633 Snapshot: snapshot.Bytes(),
12634 }
12635 return out, metadata, err
12636 }
12637
12638 err = awsAwsjson11_deserializeOpDocumentGetInstanceSnapshotOutput(&output, shape)
12639 if err != nil {
12640 var snapshot bytes.Buffer
12641 io.Copy(&snapshot, ringBuffer)
12642 err = &smithy.DeserializationError{
12643 Err: fmt.Errorf("failed to decode response body, %w", err),
12644 Snapshot: snapshot.Bytes(),
12645 }
12646 return out, metadata, err
12647 }
12648
12649 return out, metadata, err
12650 }
12651
12652 func awsAwsjson11_deserializeOpErrorGetInstanceSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
12653 var errorBuffer bytes.Buffer
12654 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
12655 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
12656 }
12657 errorBody := bytes.NewReader(errorBuffer.Bytes())
12658
12659 errorCode := "UnknownError"
12660 errorMessage := errorCode
12661
12662 headerCode := response.Header.Get("X-Amzn-ErrorType")
12663
12664 var buff [1024]byte
12665 ringBuffer := smithyio.NewRingBuffer(buff[:])
12666
12667 body := io.TeeReader(errorBody, ringBuffer)
12668 decoder := json.NewDecoder(body)
12669 decoder.UseNumber()
12670 bodyInfo, err := getProtocolErrorInfo(decoder)
12671 if err != nil {
12672 var snapshot bytes.Buffer
12673 io.Copy(&snapshot, ringBuffer)
12674 err = &smithy.DeserializationError{
12675 Err: fmt.Errorf("failed to decode response body, %w", err),
12676 Snapshot: snapshot.Bytes(),
12677 }
12678 return err
12679 }
12680
12681 errorBody.Seek(0, io.SeekStart)
12682 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
12683 errorCode = restjson.SanitizeErrorCode(typ)
12684 }
12685 if len(bodyInfo.Message) != 0 {
12686 errorMessage = bodyInfo.Message
12687 }
12688 switch {
12689 case strings.EqualFold("AccessDeniedException", errorCode):
12690 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
12691
12692 case strings.EqualFold("AccountSetupInProgressException", errorCode):
12693 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
12694
12695 case strings.EqualFold("InvalidInputException", errorCode):
12696 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
12697
12698 case strings.EqualFold("NotFoundException", errorCode):
12699 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
12700
12701 case strings.EqualFold("OperationFailureException", errorCode):
12702 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
12703
12704 case strings.EqualFold("RegionSetupInProgressException", errorCode):
12705 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
12706
12707 case strings.EqualFold("ServiceException", errorCode):
12708 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
12709
12710 case strings.EqualFold("UnauthenticatedException", errorCode):
12711 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
12712
12713 default:
12714 genericError := &smithy.GenericAPIError{
12715 Code: errorCode,
12716 Message: errorMessage,
12717 }
12718 return genericError
12719
12720 }
12721 }
12722
12723 type awsAwsjson11_deserializeOpGetInstanceSnapshots struct {
12724 }
12725
12726 func (*awsAwsjson11_deserializeOpGetInstanceSnapshots) ID() string {
12727 return "OperationDeserializer"
12728 }
12729
12730 func (m *awsAwsjson11_deserializeOpGetInstanceSnapshots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
12731 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
12732 ) {
12733 out, metadata, err = next.HandleDeserialize(ctx, in)
12734 if err != nil {
12735 return out, metadata, err
12736 }
12737
12738 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
12739 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
12740 defer endTimer()
12741 defer span.End()
12742 response, ok := out.RawResponse.(*smithyhttp.Response)
12743 if !ok {
12744 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
12745 }
12746
12747 if response.StatusCode < 200 || response.StatusCode >= 300 {
12748 return out, metadata, awsAwsjson11_deserializeOpErrorGetInstanceSnapshots(response, &metadata)
12749 }
12750 output := &GetInstanceSnapshotsOutput{}
12751 out.Result = output
12752
12753 var buff [1024]byte
12754 ringBuffer := smithyio.NewRingBuffer(buff[:])
12755
12756 body := io.TeeReader(response.Body, ringBuffer)
12757 decoder := json.NewDecoder(body)
12758 decoder.UseNumber()
12759 var shape interface{}
12760 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
12761 var snapshot bytes.Buffer
12762 io.Copy(&snapshot, ringBuffer)
12763 err = &smithy.DeserializationError{
12764 Err: fmt.Errorf("failed to decode response body, %w", err),
12765 Snapshot: snapshot.Bytes(),
12766 }
12767 return out, metadata, err
12768 }
12769
12770 err = awsAwsjson11_deserializeOpDocumentGetInstanceSnapshotsOutput(&output, shape)
12771 if err != nil {
12772 var snapshot bytes.Buffer
12773 io.Copy(&snapshot, ringBuffer)
12774 err = &smithy.DeserializationError{
12775 Err: fmt.Errorf("failed to decode response body, %w", err),
12776 Snapshot: snapshot.Bytes(),
12777 }
12778 return out, metadata, err
12779 }
12780
12781 return out, metadata, err
12782 }
12783
12784 func awsAwsjson11_deserializeOpErrorGetInstanceSnapshots(response *smithyhttp.Response, metadata *middleware.Metadata) error {
12785 var errorBuffer bytes.Buffer
12786 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
12787 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
12788 }
12789 errorBody := bytes.NewReader(errorBuffer.Bytes())
12790
12791 errorCode := "UnknownError"
12792 errorMessage := errorCode
12793
12794 headerCode := response.Header.Get("X-Amzn-ErrorType")
12795
12796 var buff [1024]byte
12797 ringBuffer := smithyio.NewRingBuffer(buff[:])
12798
12799 body := io.TeeReader(errorBody, ringBuffer)
12800 decoder := json.NewDecoder(body)
12801 decoder.UseNumber()
12802 bodyInfo, err := getProtocolErrorInfo(decoder)
12803 if err != nil {
12804 var snapshot bytes.Buffer
12805 io.Copy(&snapshot, ringBuffer)
12806 err = &smithy.DeserializationError{
12807 Err: fmt.Errorf("failed to decode response body, %w", err),
12808 Snapshot: snapshot.Bytes(),
12809 }
12810 return err
12811 }
12812
12813 errorBody.Seek(0, io.SeekStart)
12814 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
12815 errorCode = restjson.SanitizeErrorCode(typ)
12816 }
12817 if len(bodyInfo.Message) != 0 {
12818 errorMessage = bodyInfo.Message
12819 }
12820 switch {
12821 case strings.EqualFold("AccessDeniedException", errorCode):
12822 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
12823
12824 case strings.EqualFold("AccountSetupInProgressException", errorCode):
12825 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
12826
12827 case strings.EqualFold("InvalidInputException", errorCode):
12828 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
12829
12830 case strings.EqualFold("NotFoundException", errorCode):
12831 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
12832
12833 case strings.EqualFold("OperationFailureException", errorCode):
12834 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
12835
12836 case strings.EqualFold("RegionSetupInProgressException", errorCode):
12837 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
12838
12839 case strings.EqualFold("ServiceException", errorCode):
12840 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
12841
12842 case strings.EqualFold("UnauthenticatedException", errorCode):
12843 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
12844
12845 default:
12846 genericError := &smithy.GenericAPIError{
12847 Code: errorCode,
12848 Message: errorMessage,
12849 }
12850 return genericError
12851
12852 }
12853 }
12854
12855 type awsAwsjson11_deserializeOpGetInstanceState struct {
12856 }
12857
12858 func (*awsAwsjson11_deserializeOpGetInstanceState) ID() string {
12859 return "OperationDeserializer"
12860 }
12861
12862 func (m *awsAwsjson11_deserializeOpGetInstanceState) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
12863 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
12864 ) {
12865 out, metadata, err = next.HandleDeserialize(ctx, in)
12866 if err != nil {
12867 return out, metadata, err
12868 }
12869
12870 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
12871 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
12872 defer endTimer()
12873 defer span.End()
12874 response, ok := out.RawResponse.(*smithyhttp.Response)
12875 if !ok {
12876 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
12877 }
12878
12879 if response.StatusCode < 200 || response.StatusCode >= 300 {
12880 return out, metadata, awsAwsjson11_deserializeOpErrorGetInstanceState(response, &metadata)
12881 }
12882 output := &GetInstanceStateOutput{}
12883 out.Result = output
12884
12885 var buff [1024]byte
12886 ringBuffer := smithyio.NewRingBuffer(buff[:])
12887
12888 body := io.TeeReader(response.Body, ringBuffer)
12889 decoder := json.NewDecoder(body)
12890 decoder.UseNumber()
12891 var shape interface{}
12892 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
12893 var snapshot bytes.Buffer
12894 io.Copy(&snapshot, ringBuffer)
12895 err = &smithy.DeserializationError{
12896 Err: fmt.Errorf("failed to decode response body, %w", err),
12897 Snapshot: snapshot.Bytes(),
12898 }
12899 return out, metadata, err
12900 }
12901
12902 err = awsAwsjson11_deserializeOpDocumentGetInstanceStateOutput(&output, shape)
12903 if err != nil {
12904 var snapshot bytes.Buffer
12905 io.Copy(&snapshot, ringBuffer)
12906 err = &smithy.DeserializationError{
12907 Err: fmt.Errorf("failed to decode response body, %w", err),
12908 Snapshot: snapshot.Bytes(),
12909 }
12910 return out, metadata, err
12911 }
12912
12913 return out, metadata, err
12914 }
12915
12916 func awsAwsjson11_deserializeOpErrorGetInstanceState(response *smithyhttp.Response, metadata *middleware.Metadata) error {
12917 var errorBuffer bytes.Buffer
12918 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
12919 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
12920 }
12921 errorBody := bytes.NewReader(errorBuffer.Bytes())
12922
12923 errorCode := "UnknownError"
12924 errorMessage := errorCode
12925
12926 headerCode := response.Header.Get("X-Amzn-ErrorType")
12927
12928 var buff [1024]byte
12929 ringBuffer := smithyio.NewRingBuffer(buff[:])
12930
12931 body := io.TeeReader(errorBody, ringBuffer)
12932 decoder := json.NewDecoder(body)
12933 decoder.UseNumber()
12934 bodyInfo, err := getProtocolErrorInfo(decoder)
12935 if err != nil {
12936 var snapshot bytes.Buffer
12937 io.Copy(&snapshot, ringBuffer)
12938 err = &smithy.DeserializationError{
12939 Err: fmt.Errorf("failed to decode response body, %w", err),
12940 Snapshot: snapshot.Bytes(),
12941 }
12942 return err
12943 }
12944
12945 errorBody.Seek(0, io.SeekStart)
12946 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
12947 errorCode = restjson.SanitizeErrorCode(typ)
12948 }
12949 if len(bodyInfo.Message) != 0 {
12950 errorMessage = bodyInfo.Message
12951 }
12952 switch {
12953 case strings.EqualFold("AccessDeniedException", errorCode):
12954 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
12955
12956 case strings.EqualFold("AccountSetupInProgressException", errorCode):
12957 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
12958
12959 case strings.EqualFold("InvalidInputException", errorCode):
12960 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
12961
12962 case strings.EqualFold("NotFoundException", errorCode):
12963 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
12964
12965 case strings.EqualFold("OperationFailureException", errorCode):
12966 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
12967
12968 case strings.EqualFold("RegionSetupInProgressException", errorCode):
12969 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
12970
12971 case strings.EqualFold("ServiceException", errorCode):
12972 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
12973
12974 case strings.EqualFold("UnauthenticatedException", errorCode):
12975 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
12976
12977 default:
12978 genericError := &smithy.GenericAPIError{
12979 Code: errorCode,
12980 Message: errorMessage,
12981 }
12982 return genericError
12983
12984 }
12985 }
12986
12987 type awsAwsjson11_deserializeOpGetKeyPair struct {
12988 }
12989
12990 func (*awsAwsjson11_deserializeOpGetKeyPair) ID() string {
12991 return "OperationDeserializer"
12992 }
12993
12994 func (m *awsAwsjson11_deserializeOpGetKeyPair) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
12995 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
12996 ) {
12997 out, metadata, err = next.HandleDeserialize(ctx, in)
12998 if err != nil {
12999 return out, metadata, err
13000 }
13001
13002 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
13003 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
13004 defer endTimer()
13005 defer span.End()
13006 response, ok := out.RawResponse.(*smithyhttp.Response)
13007 if !ok {
13008 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
13009 }
13010
13011 if response.StatusCode < 200 || response.StatusCode >= 300 {
13012 return out, metadata, awsAwsjson11_deserializeOpErrorGetKeyPair(response, &metadata)
13013 }
13014 output := &GetKeyPairOutput{}
13015 out.Result = output
13016
13017 var buff [1024]byte
13018 ringBuffer := smithyio.NewRingBuffer(buff[:])
13019
13020 body := io.TeeReader(response.Body, ringBuffer)
13021 decoder := json.NewDecoder(body)
13022 decoder.UseNumber()
13023 var shape interface{}
13024 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
13025 var snapshot bytes.Buffer
13026 io.Copy(&snapshot, ringBuffer)
13027 err = &smithy.DeserializationError{
13028 Err: fmt.Errorf("failed to decode response body, %w", err),
13029 Snapshot: snapshot.Bytes(),
13030 }
13031 return out, metadata, err
13032 }
13033
13034 err = awsAwsjson11_deserializeOpDocumentGetKeyPairOutput(&output, shape)
13035 if err != nil {
13036 var snapshot bytes.Buffer
13037 io.Copy(&snapshot, ringBuffer)
13038 err = &smithy.DeserializationError{
13039 Err: fmt.Errorf("failed to decode response body, %w", err),
13040 Snapshot: snapshot.Bytes(),
13041 }
13042 return out, metadata, err
13043 }
13044
13045 return out, metadata, err
13046 }
13047
13048 func awsAwsjson11_deserializeOpErrorGetKeyPair(response *smithyhttp.Response, metadata *middleware.Metadata) error {
13049 var errorBuffer bytes.Buffer
13050 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
13051 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
13052 }
13053 errorBody := bytes.NewReader(errorBuffer.Bytes())
13054
13055 errorCode := "UnknownError"
13056 errorMessage := errorCode
13057
13058 headerCode := response.Header.Get("X-Amzn-ErrorType")
13059
13060 var buff [1024]byte
13061 ringBuffer := smithyio.NewRingBuffer(buff[:])
13062
13063 body := io.TeeReader(errorBody, ringBuffer)
13064 decoder := json.NewDecoder(body)
13065 decoder.UseNumber()
13066 bodyInfo, err := getProtocolErrorInfo(decoder)
13067 if err != nil {
13068 var snapshot bytes.Buffer
13069 io.Copy(&snapshot, ringBuffer)
13070 err = &smithy.DeserializationError{
13071 Err: fmt.Errorf("failed to decode response body, %w", err),
13072 Snapshot: snapshot.Bytes(),
13073 }
13074 return err
13075 }
13076
13077 errorBody.Seek(0, io.SeekStart)
13078 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
13079 errorCode = restjson.SanitizeErrorCode(typ)
13080 }
13081 if len(bodyInfo.Message) != 0 {
13082 errorMessage = bodyInfo.Message
13083 }
13084 switch {
13085 case strings.EqualFold("AccessDeniedException", errorCode):
13086 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
13087
13088 case strings.EqualFold("AccountSetupInProgressException", errorCode):
13089 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
13090
13091 case strings.EqualFold("InvalidInputException", errorCode):
13092 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
13093
13094 case strings.EqualFold("NotFoundException", errorCode):
13095 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
13096
13097 case strings.EqualFold("OperationFailureException", errorCode):
13098 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
13099
13100 case strings.EqualFold("RegionSetupInProgressException", errorCode):
13101 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
13102
13103 case strings.EqualFold("ServiceException", errorCode):
13104 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
13105
13106 case strings.EqualFold("UnauthenticatedException", errorCode):
13107 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
13108
13109 default:
13110 genericError := &smithy.GenericAPIError{
13111 Code: errorCode,
13112 Message: errorMessage,
13113 }
13114 return genericError
13115
13116 }
13117 }
13118
13119 type awsAwsjson11_deserializeOpGetKeyPairs struct {
13120 }
13121
13122 func (*awsAwsjson11_deserializeOpGetKeyPairs) ID() string {
13123 return "OperationDeserializer"
13124 }
13125
13126 func (m *awsAwsjson11_deserializeOpGetKeyPairs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
13127 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
13128 ) {
13129 out, metadata, err = next.HandleDeserialize(ctx, in)
13130 if err != nil {
13131 return out, metadata, err
13132 }
13133
13134 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
13135 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
13136 defer endTimer()
13137 defer span.End()
13138 response, ok := out.RawResponse.(*smithyhttp.Response)
13139 if !ok {
13140 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
13141 }
13142
13143 if response.StatusCode < 200 || response.StatusCode >= 300 {
13144 return out, metadata, awsAwsjson11_deserializeOpErrorGetKeyPairs(response, &metadata)
13145 }
13146 output := &GetKeyPairsOutput{}
13147 out.Result = output
13148
13149 var buff [1024]byte
13150 ringBuffer := smithyio.NewRingBuffer(buff[:])
13151
13152 body := io.TeeReader(response.Body, ringBuffer)
13153 decoder := json.NewDecoder(body)
13154 decoder.UseNumber()
13155 var shape interface{}
13156 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
13157 var snapshot bytes.Buffer
13158 io.Copy(&snapshot, ringBuffer)
13159 err = &smithy.DeserializationError{
13160 Err: fmt.Errorf("failed to decode response body, %w", err),
13161 Snapshot: snapshot.Bytes(),
13162 }
13163 return out, metadata, err
13164 }
13165
13166 err = awsAwsjson11_deserializeOpDocumentGetKeyPairsOutput(&output, shape)
13167 if err != nil {
13168 var snapshot bytes.Buffer
13169 io.Copy(&snapshot, ringBuffer)
13170 err = &smithy.DeserializationError{
13171 Err: fmt.Errorf("failed to decode response body, %w", err),
13172 Snapshot: snapshot.Bytes(),
13173 }
13174 return out, metadata, err
13175 }
13176
13177 return out, metadata, err
13178 }
13179
13180 func awsAwsjson11_deserializeOpErrorGetKeyPairs(response *smithyhttp.Response, metadata *middleware.Metadata) error {
13181 var errorBuffer bytes.Buffer
13182 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
13183 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
13184 }
13185 errorBody := bytes.NewReader(errorBuffer.Bytes())
13186
13187 errorCode := "UnknownError"
13188 errorMessage := errorCode
13189
13190 headerCode := response.Header.Get("X-Amzn-ErrorType")
13191
13192 var buff [1024]byte
13193 ringBuffer := smithyio.NewRingBuffer(buff[:])
13194
13195 body := io.TeeReader(errorBody, ringBuffer)
13196 decoder := json.NewDecoder(body)
13197 decoder.UseNumber()
13198 bodyInfo, err := getProtocolErrorInfo(decoder)
13199 if err != nil {
13200 var snapshot bytes.Buffer
13201 io.Copy(&snapshot, ringBuffer)
13202 err = &smithy.DeserializationError{
13203 Err: fmt.Errorf("failed to decode response body, %w", err),
13204 Snapshot: snapshot.Bytes(),
13205 }
13206 return err
13207 }
13208
13209 errorBody.Seek(0, io.SeekStart)
13210 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
13211 errorCode = restjson.SanitizeErrorCode(typ)
13212 }
13213 if len(bodyInfo.Message) != 0 {
13214 errorMessage = bodyInfo.Message
13215 }
13216 switch {
13217 case strings.EqualFold("AccessDeniedException", errorCode):
13218 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
13219
13220 case strings.EqualFold("AccountSetupInProgressException", errorCode):
13221 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
13222
13223 case strings.EqualFold("InvalidInputException", errorCode):
13224 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
13225
13226 case strings.EqualFold("NotFoundException", errorCode):
13227 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
13228
13229 case strings.EqualFold("OperationFailureException", errorCode):
13230 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
13231
13232 case strings.EqualFold("RegionSetupInProgressException", errorCode):
13233 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
13234
13235 case strings.EqualFold("ServiceException", errorCode):
13236 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
13237
13238 case strings.EqualFold("UnauthenticatedException", errorCode):
13239 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
13240
13241 default:
13242 genericError := &smithy.GenericAPIError{
13243 Code: errorCode,
13244 Message: errorMessage,
13245 }
13246 return genericError
13247
13248 }
13249 }
13250
13251 type awsAwsjson11_deserializeOpGetLoadBalancer struct {
13252 }
13253
13254 func (*awsAwsjson11_deserializeOpGetLoadBalancer) ID() string {
13255 return "OperationDeserializer"
13256 }
13257
13258 func (m *awsAwsjson11_deserializeOpGetLoadBalancer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
13259 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
13260 ) {
13261 out, metadata, err = next.HandleDeserialize(ctx, in)
13262 if err != nil {
13263 return out, metadata, err
13264 }
13265
13266 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
13267 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
13268 defer endTimer()
13269 defer span.End()
13270 response, ok := out.RawResponse.(*smithyhttp.Response)
13271 if !ok {
13272 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
13273 }
13274
13275 if response.StatusCode < 200 || response.StatusCode >= 300 {
13276 return out, metadata, awsAwsjson11_deserializeOpErrorGetLoadBalancer(response, &metadata)
13277 }
13278 output := &GetLoadBalancerOutput{}
13279 out.Result = output
13280
13281 var buff [1024]byte
13282 ringBuffer := smithyio.NewRingBuffer(buff[:])
13283
13284 body := io.TeeReader(response.Body, ringBuffer)
13285 decoder := json.NewDecoder(body)
13286 decoder.UseNumber()
13287 var shape interface{}
13288 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
13289 var snapshot bytes.Buffer
13290 io.Copy(&snapshot, ringBuffer)
13291 err = &smithy.DeserializationError{
13292 Err: fmt.Errorf("failed to decode response body, %w", err),
13293 Snapshot: snapshot.Bytes(),
13294 }
13295 return out, metadata, err
13296 }
13297
13298 err = awsAwsjson11_deserializeOpDocumentGetLoadBalancerOutput(&output, shape)
13299 if err != nil {
13300 var snapshot bytes.Buffer
13301 io.Copy(&snapshot, ringBuffer)
13302 err = &smithy.DeserializationError{
13303 Err: fmt.Errorf("failed to decode response body, %w", err),
13304 Snapshot: snapshot.Bytes(),
13305 }
13306 return out, metadata, err
13307 }
13308
13309 return out, metadata, err
13310 }
13311
13312 func awsAwsjson11_deserializeOpErrorGetLoadBalancer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
13313 var errorBuffer bytes.Buffer
13314 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
13315 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
13316 }
13317 errorBody := bytes.NewReader(errorBuffer.Bytes())
13318
13319 errorCode := "UnknownError"
13320 errorMessage := errorCode
13321
13322 headerCode := response.Header.Get("X-Amzn-ErrorType")
13323
13324 var buff [1024]byte
13325 ringBuffer := smithyio.NewRingBuffer(buff[:])
13326
13327 body := io.TeeReader(errorBody, ringBuffer)
13328 decoder := json.NewDecoder(body)
13329 decoder.UseNumber()
13330 bodyInfo, err := getProtocolErrorInfo(decoder)
13331 if err != nil {
13332 var snapshot bytes.Buffer
13333 io.Copy(&snapshot, ringBuffer)
13334 err = &smithy.DeserializationError{
13335 Err: fmt.Errorf("failed to decode response body, %w", err),
13336 Snapshot: snapshot.Bytes(),
13337 }
13338 return err
13339 }
13340
13341 errorBody.Seek(0, io.SeekStart)
13342 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
13343 errorCode = restjson.SanitizeErrorCode(typ)
13344 }
13345 if len(bodyInfo.Message) != 0 {
13346 errorMessage = bodyInfo.Message
13347 }
13348 switch {
13349 case strings.EqualFold("AccessDeniedException", errorCode):
13350 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
13351
13352 case strings.EqualFold("AccountSetupInProgressException", errorCode):
13353 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
13354
13355 case strings.EqualFold("InvalidInputException", errorCode):
13356 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
13357
13358 case strings.EqualFold("NotFoundException", errorCode):
13359 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
13360
13361 case strings.EqualFold("OperationFailureException", errorCode):
13362 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
13363
13364 case strings.EqualFold("RegionSetupInProgressException", errorCode):
13365 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
13366
13367 case strings.EqualFold("ServiceException", errorCode):
13368 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
13369
13370 case strings.EqualFold("UnauthenticatedException", errorCode):
13371 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
13372
13373 default:
13374 genericError := &smithy.GenericAPIError{
13375 Code: errorCode,
13376 Message: errorMessage,
13377 }
13378 return genericError
13379
13380 }
13381 }
13382
13383 type awsAwsjson11_deserializeOpGetLoadBalancerMetricData struct {
13384 }
13385
13386 func (*awsAwsjson11_deserializeOpGetLoadBalancerMetricData) ID() string {
13387 return "OperationDeserializer"
13388 }
13389
13390 func (m *awsAwsjson11_deserializeOpGetLoadBalancerMetricData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
13391 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
13392 ) {
13393 out, metadata, err = next.HandleDeserialize(ctx, in)
13394 if err != nil {
13395 return out, metadata, err
13396 }
13397
13398 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
13399 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
13400 defer endTimer()
13401 defer span.End()
13402 response, ok := out.RawResponse.(*smithyhttp.Response)
13403 if !ok {
13404 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
13405 }
13406
13407 if response.StatusCode < 200 || response.StatusCode >= 300 {
13408 return out, metadata, awsAwsjson11_deserializeOpErrorGetLoadBalancerMetricData(response, &metadata)
13409 }
13410 output := &GetLoadBalancerMetricDataOutput{}
13411 out.Result = output
13412
13413 var buff [1024]byte
13414 ringBuffer := smithyio.NewRingBuffer(buff[:])
13415
13416 body := io.TeeReader(response.Body, ringBuffer)
13417 decoder := json.NewDecoder(body)
13418 decoder.UseNumber()
13419 var shape interface{}
13420 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
13421 var snapshot bytes.Buffer
13422 io.Copy(&snapshot, ringBuffer)
13423 err = &smithy.DeserializationError{
13424 Err: fmt.Errorf("failed to decode response body, %w", err),
13425 Snapshot: snapshot.Bytes(),
13426 }
13427 return out, metadata, err
13428 }
13429
13430 err = awsAwsjson11_deserializeOpDocumentGetLoadBalancerMetricDataOutput(&output, shape)
13431 if err != nil {
13432 var snapshot bytes.Buffer
13433 io.Copy(&snapshot, ringBuffer)
13434 err = &smithy.DeserializationError{
13435 Err: fmt.Errorf("failed to decode response body, %w", err),
13436 Snapshot: snapshot.Bytes(),
13437 }
13438 return out, metadata, err
13439 }
13440
13441 return out, metadata, err
13442 }
13443
13444 func awsAwsjson11_deserializeOpErrorGetLoadBalancerMetricData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
13445 var errorBuffer bytes.Buffer
13446 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
13447 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
13448 }
13449 errorBody := bytes.NewReader(errorBuffer.Bytes())
13450
13451 errorCode := "UnknownError"
13452 errorMessage := errorCode
13453
13454 headerCode := response.Header.Get("X-Amzn-ErrorType")
13455
13456 var buff [1024]byte
13457 ringBuffer := smithyio.NewRingBuffer(buff[:])
13458
13459 body := io.TeeReader(errorBody, ringBuffer)
13460 decoder := json.NewDecoder(body)
13461 decoder.UseNumber()
13462 bodyInfo, err := getProtocolErrorInfo(decoder)
13463 if err != nil {
13464 var snapshot bytes.Buffer
13465 io.Copy(&snapshot, ringBuffer)
13466 err = &smithy.DeserializationError{
13467 Err: fmt.Errorf("failed to decode response body, %w", err),
13468 Snapshot: snapshot.Bytes(),
13469 }
13470 return err
13471 }
13472
13473 errorBody.Seek(0, io.SeekStart)
13474 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
13475 errorCode = restjson.SanitizeErrorCode(typ)
13476 }
13477 if len(bodyInfo.Message) != 0 {
13478 errorMessage = bodyInfo.Message
13479 }
13480 switch {
13481 case strings.EqualFold("AccessDeniedException", errorCode):
13482 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
13483
13484 case strings.EqualFold("AccountSetupInProgressException", errorCode):
13485 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
13486
13487 case strings.EqualFold("InvalidInputException", errorCode):
13488 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
13489
13490 case strings.EqualFold("NotFoundException", errorCode):
13491 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
13492
13493 case strings.EqualFold("OperationFailureException", errorCode):
13494 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
13495
13496 case strings.EqualFold("RegionSetupInProgressException", errorCode):
13497 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
13498
13499 case strings.EqualFold("ServiceException", errorCode):
13500 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
13501
13502 case strings.EqualFold("UnauthenticatedException", errorCode):
13503 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
13504
13505 default:
13506 genericError := &smithy.GenericAPIError{
13507 Code: errorCode,
13508 Message: errorMessage,
13509 }
13510 return genericError
13511
13512 }
13513 }
13514
13515 type awsAwsjson11_deserializeOpGetLoadBalancers struct {
13516 }
13517
13518 func (*awsAwsjson11_deserializeOpGetLoadBalancers) ID() string {
13519 return "OperationDeserializer"
13520 }
13521
13522 func (m *awsAwsjson11_deserializeOpGetLoadBalancers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
13523 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
13524 ) {
13525 out, metadata, err = next.HandleDeserialize(ctx, in)
13526 if err != nil {
13527 return out, metadata, err
13528 }
13529
13530 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
13531 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
13532 defer endTimer()
13533 defer span.End()
13534 response, ok := out.RawResponse.(*smithyhttp.Response)
13535 if !ok {
13536 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
13537 }
13538
13539 if response.StatusCode < 200 || response.StatusCode >= 300 {
13540 return out, metadata, awsAwsjson11_deserializeOpErrorGetLoadBalancers(response, &metadata)
13541 }
13542 output := &GetLoadBalancersOutput{}
13543 out.Result = output
13544
13545 var buff [1024]byte
13546 ringBuffer := smithyio.NewRingBuffer(buff[:])
13547
13548 body := io.TeeReader(response.Body, ringBuffer)
13549 decoder := json.NewDecoder(body)
13550 decoder.UseNumber()
13551 var shape interface{}
13552 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
13553 var snapshot bytes.Buffer
13554 io.Copy(&snapshot, ringBuffer)
13555 err = &smithy.DeserializationError{
13556 Err: fmt.Errorf("failed to decode response body, %w", err),
13557 Snapshot: snapshot.Bytes(),
13558 }
13559 return out, metadata, err
13560 }
13561
13562 err = awsAwsjson11_deserializeOpDocumentGetLoadBalancersOutput(&output, shape)
13563 if err != nil {
13564 var snapshot bytes.Buffer
13565 io.Copy(&snapshot, ringBuffer)
13566 err = &smithy.DeserializationError{
13567 Err: fmt.Errorf("failed to decode response body, %w", err),
13568 Snapshot: snapshot.Bytes(),
13569 }
13570 return out, metadata, err
13571 }
13572
13573 return out, metadata, err
13574 }
13575
13576 func awsAwsjson11_deserializeOpErrorGetLoadBalancers(response *smithyhttp.Response, metadata *middleware.Metadata) error {
13577 var errorBuffer bytes.Buffer
13578 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
13579 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
13580 }
13581 errorBody := bytes.NewReader(errorBuffer.Bytes())
13582
13583 errorCode := "UnknownError"
13584 errorMessage := errorCode
13585
13586 headerCode := response.Header.Get("X-Amzn-ErrorType")
13587
13588 var buff [1024]byte
13589 ringBuffer := smithyio.NewRingBuffer(buff[:])
13590
13591 body := io.TeeReader(errorBody, ringBuffer)
13592 decoder := json.NewDecoder(body)
13593 decoder.UseNumber()
13594 bodyInfo, err := getProtocolErrorInfo(decoder)
13595 if err != nil {
13596 var snapshot bytes.Buffer
13597 io.Copy(&snapshot, ringBuffer)
13598 err = &smithy.DeserializationError{
13599 Err: fmt.Errorf("failed to decode response body, %w", err),
13600 Snapshot: snapshot.Bytes(),
13601 }
13602 return err
13603 }
13604
13605 errorBody.Seek(0, io.SeekStart)
13606 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
13607 errorCode = restjson.SanitizeErrorCode(typ)
13608 }
13609 if len(bodyInfo.Message) != 0 {
13610 errorMessage = bodyInfo.Message
13611 }
13612 switch {
13613 case strings.EqualFold("AccessDeniedException", errorCode):
13614 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
13615
13616 case strings.EqualFold("AccountSetupInProgressException", errorCode):
13617 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
13618
13619 case strings.EqualFold("InvalidInputException", errorCode):
13620 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
13621
13622 case strings.EqualFold("NotFoundException", errorCode):
13623 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
13624
13625 case strings.EqualFold("OperationFailureException", errorCode):
13626 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
13627
13628 case strings.EqualFold("RegionSetupInProgressException", errorCode):
13629 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
13630
13631 case strings.EqualFold("ServiceException", errorCode):
13632 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
13633
13634 case strings.EqualFold("UnauthenticatedException", errorCode):
13635 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
13636
13637 default:
13638 genericError := &smithy.GenericAPIError{
13639 Code: errorCode,
13640 Message: errorMessage,
13641 }
13642 return genericError
13643
13644 }
13645 }
13646
13647 type awsAwsjson11_deserializeOpGetLoadBalancerTlsCertificates struct {
13648 }
13649
13650 func (*awsAwsjson11_deserializeOpGetLoadBalancerTlsCertificates) ID() string {
13651 return "OperationDeserializer"
13652 }
13653
13654 func (m *awsAwsjson11_deserializeOpGetLoadBalancerTlsCertificates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
13655 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
13656 ) {
13657 out, metadata, err = next.HandleDeserialize(ctx, in)
13658 if err != nil {
13659 return out, metadata, err
13660 }
13661
13662 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
13663 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
13664 defer endTimer()
13665 defer span.End()
13666 response, ok := out.RawResponse.(*smithyhttp.Response)
13667 if !ok {
13668 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
13669 }
13670
13671 if response.StatusCode < 200 || response.StatusCode >= 300 {
13672 return out, metadata, awsAwsjson11_deserializeOpErrorGetLoadBalancerTlsCertificates(response, &metadata)
13673 }
13674 output := &GetLoadBalancerTlsCertificatesOutput{}
13675 out.Result = output
13676
13677 var buff [1024]byte
13678 ringBuffer := smithyio.NewRingBuffer(buff[:])
13679
13680 body := io.TeeReader(response.Body, ringBuffer)
13681 decoder := json.NewDecoder(body)
13682 decoder.UseNumber()
13683 var shape interface{}
13684 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
13685 var snapshot bytes.Buffer
13686 io.Copy(&snapshot, ringBuffer)
13687 err = &smithy.DeserializationError{
13688 Err: fmt.Errorf("failed to decode response body, %w", err),
13689 Snapshot: snapshot.Bytes(),
13690 }
13691 return out, metadata, err
13692 }
13693
13694 err = awsAwsjson11_deserializeOpDocumentGetLoadBalancerTlsCertificatesOutput(&output, shape)
13695 if err != nil {
13696 var snapshot bytes.Buffer
13697 io.Copy(&snapshot, ringBuffer)
13698 err = &smithy.DeserializationError{
13699 Err: fmt.Errorf("failed to decode response body, %w", err),
13700 Snapshot: snapshot.Bytes(),
13701 }
13702 return out, metadata, err
13703 }
13704
13705 return out, metadata, err
13706 }
13707
13708 func awsAwsjson11_deserializeOpErrorGetLoadBalancerTlsCertificates(response *smithyhttp.Response, metadata *middleware.Metadata) error {
13709 var errorBuffer bytes.Buffer
13710 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
13711 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
13712 }
13713 errorBody := bytes.NewReader(errorBuffer.Bytes())
13714
13715 errorCode := "UnknownError"
13716 errorMessage := errorCode
13717
13718 headerCode := response.Header.Get("X-Amzn-ErrorType")
13719
13720 var buff [1024]byte
13721 ringBuffer := smithyio.NewRingBuffer(buff[:])
13722
13723 body := io.TeeReader(errorBody, ringBuffer)
13724 decoder := json.NewDecoder(body)
13725 decoder.UseNumber()
13726 bodyInfo, err := getProtocolErrorInfo(decoder)
13727 if err != nil {
13728 var snapshot bytes.Buffer
13729 io.Copy(&snapshot, ringBuffer)
13730 err = &smithy.DeserializationError{
13731 Err: fmt.Errorf("failed to decode response body, %w", err),
13732 Snapshot: snapshot.Bytes(),
13733 }
13734 return err
13735 }
13736
13737 errorBody.Seek(0, io.SeekStart)
13738 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
13739 errorCode = restjson.SanitizeErrorCode(typ)
13740 }
13741 if len(bodyInfo.Message) != 0 {
13742 errorMessage = bodyInfo.Message
13743 }
13744 switch {
13745 case strings.EqualFold("AccessDeniedException", errorCode):
13746 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
13747
13748 case strings.EqualFold("AccountSetupInProgressException", errorCode):
13749 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
13750
13751 case strings.EqualFold("InvalidInputException", errorCode):
13752 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
13753
13754 case strings.EqualFold("NotFoundException", errorCode):
13755 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
13756
13757 case strings.EqualFold("OperationFailureException", errorCode):
13758 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
13759
13760 case strings.EqualFold("RegionSetupInProgressException", errorCode):
13761 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
13762
13763 case strings.EqualFold("ServiceException", errorCode):
13764 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
13765
13766 case strings.EqualFold("UnauthenticatedException", errorCode):
13767 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
13768
13769 default:
13770 genericError := &smithy.GenericAPIError{
13771 Code: errorCode,
13772 Message: errorMessage,
13773 }
13774 return genericError
13775
13776 }
13777 }
13778
13779 type awsAwsjson11_deserializeOpGetLoadBalancerTlsPolicies struct {
13780 }
13781
13782 func (*awsAwsjson11_deserializeOpGetLoadBalancerTlsPolicies) ID() string {
13783 return "OperationDeserializer"
13784 }
13785
13786 func (m *awsAwsjson11_deserializeOpGetLoadBalancerTlsPolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
13787 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
13788 ) {
13789 out, metadata, err = next.HandleDeserialize(ctx, in)
13790 if err != nil {
13791 return out, metadata, err
13792 }
13793
13794 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
13795 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
13796 defer endTimer()
13797 defer span.End()
13798 response, ok := out.RawResponse.(*smithyhttp.Response)
13799 if !ok {
13800 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
13801 }
13802
13803 if response.StatusCode < 200 || response.StatusCode >= 300 {
13804 return out, metadata, awsAwsjson11_deserializeOpErrorGetLoadBalancerTlsPolicies(response, &metadata)
13805 }
13806 output := &GetLoadBalancerTlsPoliciesOutput{}
13807 out.Result = output
13808
13809 var buff [1024]byte
13810 ringBuffer := smithyio.NewRingBuffer(buff[:])
13811
13812 body := io.TeeReader(response.Body, ringBuffer)
13813 decoder := json.NewDecoder(body)
13814 decoder.UseNumber()
13815 var shape interface{}
13816 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
13817 var snapshot bytes.Buffer
13818 io.Copy(&snapshot, ringBuffer)
13819 err = &smithy.DeserializationError{
13820 Err: fmt.Errorf("failed to decode response body, %w", err),
13821 Snapshot: snapshot.Bytes(),
13822 }
13823 return out, metadata, err
13824 }
13825
13826 err = awsAwsjson11_deserializeOpDocumentGetLoadBalancerTlsPoliciesOutput(&output, shape)
13827 if err != nil {
13828 var snapshot bytes.Buffer
13829 io.Copy(&snapshot, ringBuffer)
13830 err = &smithy.DeserializationError{
13831 Err: fmt.Errorf("failed to decode response body, %w", err),
13832 Snapshot: snapshot.Bytes(),
13833 }
13834 return out, metadata, err
13835 }
13836
13837 return out, metadata, err
13838 }
13839
13840 func awsAwsjson11_deserializeOpErrorGetLoadBalancerTlsPolicies(response *smithyhttp.Response, metadata *middleware.Metadata) error {
13841 var errorBuffer bytes.Buffer
13842 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
13843 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
13844 }
13845 errorBody := bytes.NewReader(errorBuffer.Bytes())
13846
13847 errorCode := "UnknownError"
13848 errorMessage := errorCode
13849
13850 headerCode := response.Header.Get("X-Amzn-ErrorType")
13851
13852 var buff [1024]byte
13853 ringBuffer := smithyio.NewRingBuffer(buff[:])
13854
13855 body := io.TeeReader(errorBody, ringBuffer)
13856 decoder := json.NewDecoder(body)
13857 decoder.UseNumber()
13858 bodyInfo, err := getProtocolErrorInfo(decoder)
13859 if err != nil {
13860 var snapshot bytes.Buffer
13861 io.Copy(&snapshot, ringBuffer)
13862 err = &smithy.DeserializationError{
13863 Err: fmt.Errorf("failed to decode response body, %w", err),
13864 Snapshot: snapshot.Bytes(),
13865 }
13866 return err
13867 }
13868
13869 errorBody.Seek(0, io.SeekStart)
13870 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
13871 errorCode = restjson.SanitizeErrorCode(typ)
13872 }
13873 if len(bodyInfo.Message) != 0 {
13874 errorMessage = bodyInfo.Message
13875 }
13876 switch {
13877 case strings.EqualFold("AccessDeniedException", errorCode):
13878 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
13879
13880 case strings.EqualFold("AccountSetupInProgressException", errorCode):
13881 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
13882
13883 case strings.EqualFold("InvalidInputException", errorCode):
13884 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
13885
13886 case strings.EqualFold("RegionSetupInProgressException", errorCode):
13887 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
13888
13889 case strings.EqualFold("ServiceException", errorCode):
13890 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
13891
13892 case strings.EqualFold("UnauthenticatedException", errorCode):
13893 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
13894
13895 default:
13896 genericError := &smithy.GenericAPIError{
13897 Code: errorCode,
13898 Message: errorMessage,
13899 }
13900 return genericError
13901
13902 }
13903 }
13904
13905 type awsAwsjson11_deserializeOpGetOperation struct {
13906 }
13907
13908 func (*awsAwsjson11_deserializeOpGetOperation) ID() string {
13909 return "OperationDeserializer"
13910 }
13911
13912 func (m *awsAwsjson11_deserializeOpGetOperation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
13913 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
13914 ) {
13915 out, metadata, err = next.HandleDeserialize(ctx, in)
13916 if err != nil {
13917 return out, metadata, err
13918 }
13919
13920 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
13921 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
13922 defer endTimer()
13923 defer span.End()
13924 response, ok := out.RawResponse.(*smithyhttp.Response)
13925 if !ok {
13926 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
13927 }
13928
13929 if response.StatusCode < 200 || response.StatusCode >= 300 {
13930 return out, metadata, awsAwsjson11_deserializeOpErrorGetOperation(response, &metadata)
13931 }
13932 output := &GetOperationOutput{}
13933 out.Result = output
13934
13935 var buff [1024]byte
13936 ringBuffer := smithyio.NewRingBuffer(buff[:])
13937
13938 body := io.TeeReader(response.Body, ringBuffer)
13939 decoder := json.NewDecoder(body)
13940 decoder.UseNumber()
13941 var shape interface{}
13942 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
13943 var snapshot bytes.Buffer
13944 io.Copy(&snapshot, ringBuffer)
13945 err = &smithy.DeserializationError{
13946 Err: fmt.Errorf("failed to decode response body, %w", err),
13947 Snapshot: snapshot.Bytes(),
13948 }
13949 return out, metadata, err
13950 }
13951
13952 err = awsAwsjson11_deserializeOpDocumentGetOperationOutput(&output, shape)
13953 if err != nil {
13954 var snapshot bytes.Buffer
13955 io.Copy(&snapshot, ringBuffer)
13956 err = &smithy.DeserializationError{
13957 Err: fmt.Errorf("failed to decode response body, %w", err),
13958 Snapshot: snapshot.Bytes(),
13959 }
13960 return out, metadata, err
13961 }
13962
13963 return out, metadata, err
13964 }
13965
13966 func awsAwsjson11_deserializeOpErrorGetOperation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
13967 var errorBuffer bytes.Buffer
13968 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
13969 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
13970 }
13971 errorBody := bytes.NewReader(errorBuffer.Bytes())
13972
13973 errorCode := "UnknownError"
13974 errorMessage := errorCode
13975
13976 headerCode := response.Header.Get("X-Amzn-ErrorType")
13977
13978 var buff [1024]byte
13979 ringBuffer := smithyio.NewRingBuffer(buff[:])
13980
13981 body := io.TeeReader(errorBody, ringBuffer)
13982 decoder := json.NewDecoder(body)
13983 decoder.UseNumber()
13984 bodyInfo, err := getProtocolErrorInfo(decoder)
13985 if err != nil {
13986 var snapshot bytes.Buffer
13987 io.Copy(&snapshot, ringBuffer)
13988 err = &smithy.DeserializationError{
13989 Err: fmt.Errorf("failed to decode response body, %w", err),
13990 Snapshot: snapshot.Bytes(),
13991 }
13992 return err
13993 }
13994
13995 errorBody.Seek(0, io.SeekStart)
13996 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
13997 errorCode = restjson.SanitizeErrorCode(typ)
13998 }
13999 if len(bodyInfo.Message) != 0 {
14000 errorMessage = bodyInfo.Message
14001 }
14002 switch {
14003 case strings.EqualFold("AccessDeniedException", errorCode):
14004 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
14005
14006 case strings.EqualFold("AccountSetupInProgressException", errorCode):
14007 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
14008
14009 case strings.EqualFold("InvalidInputException", errorCode):
14010 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
14011
14012 case strings.EqualFold("NotFoundException", errorCode):
14013 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
14014
14015 case strings.EqualFold("OperationFailureException", errorCode):
14016 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
14017
14018 case strings.EqualFold("RegionSetupInProgressException", errorCode):
14019 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
14020
14021 case strings.EqualFold("ServiceException", errorCode):
14022 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
14023
14024 case strings.EqualFold("UnauthenticatedException", errorCode):
14025 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
14026
14027 default:
14028 genericError := &smithy.GenericAPIError{
14029 Code: errorCode,
14030 Message: errorMessage,
14031 }
14032 return genericError
14033
14034 }
14035 }
14036
14037 type awsAwsjson11_deserializeOpGetOperations struct {
14038 }
14039
14040 func (*awsAwsjson11_deserializeOpGetOperations) ID() string {
14041 return "OperationDeserializer"
14042 }
14043
14044 func (m *awsAwsjson11_deserializeOpGetOperations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
14045 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
14046 ) {
14047 out, metadata, err = next.HandleDeserialize(ctx, in)
14048 if err != nil {
14049 return out, metadata, err
14050 }
14051
14052 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
14053 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
14054 defer endTimer()
14055 defer span.End()
14056 response, ok := out.RawResponse.(*smithyhttp.Response)
14057 if !ok {
14058 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
14059 }
14060
14061 if response.StatusCode < 200 || response.StatusCode >= 300 {
14062 return out, metadata, awsAwsjson11_deserializeOpErrorGetOperations(response, &metadata)
14063 }
14064 output := &GetOperationsOutput{}
14065 out.Result = output
14066
14067 var buff [1024]byte
14068 ringBuffer := smithyio.NewRingBuffer(buff[:])
14069
14070 body := io.TeeReader(response.Body, ringBuffer)
14071 decoder := json.NewDecoder(body)
14072 decoder.UseNumber()
14073 var shape interface{}
14074 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
14075 var snapshot bytes.Buffer
14076 io.Copy(&snapshot, ringBuffer)
14077 err = &smithy.DeserializationError{
14078 Err: fmt.Errorf("failed to decode response body, %w", err),
14079 Snapshot: snapshot.Bytes(),
14080 }
14081 return out, metadata, err
14082 }
14083
14084 err = awsAwsjson11_deserializeOpDocumentGetOperationsOutput(&output, shape)
14085 if err != nil {
14086 var snapshot bytes.Buffer
14087 io.Copy(&snapshot, ringBuffer)
14088 err = &smithy.DeserializationError{
14089 Err: fmt.Errorf("failed to decode response body, %w", err),
14090 Snapshot: snapshot.Bytes(),
14091 }
14092 return out, metadata, err
14093 }
14094
14095 return out, metadata, err
14096 }
14097
14098 func awsAwsjson11_deserializeOpErrorGetOperations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
14099 var errorBuffer bytes.Buffer
14100 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
14101 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
14102 }
14103 errorBody := bytes.NewReader(errorBuffer.Bytes())
14104
14105 errorCode := "UnknownError"
14106 errorMessage := errorCode
14107
14108 headerCode := response.Header.Get("X-Amzn-ErrorType")
14109
14110 var buff [1024]byte
14111 ringBuffer := smithyio.NewRingBuffer(buff[:])
14112
14113 body := io.TeeReader(errorBody, ringBuffer)
14114 decoder := json.NewDecoder(body)
14115 decoder.UseNumber()
14116 bodyInfo, err := getProtocolErrorInfo(decoder)
14117 if err != nil {
14118 var snapshot bytes.Buffer
14119 io.Copy(&snapshot, ringBuffer)
14120 err = &smithy.DeserializationError{
14121 Err: fmt.Errorf("failed to decode response body, %w", err),
14122 Snapshot: snapshot.Bytes(),
14123 }
14124 return err
14125 }
14126
14127 errorBody.Seek(0, io.SeekStart)
14128 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
14129 errorCode = restjson.SanitizeErrorCode(typ)
14130 }
14131 if len(bodyInfo.Message) != 0 {
14132 errorMessage = bodyInfo.Message
14133 }
14134 switch {
14135 case strings.EqualFold("AccessDeniedException", errorCode):
14136 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
14137
14138 case strings.EqualFold("AccountSetupInProgressException", errorCode):
14139 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
14140
14141 case strings.EqualFold("InvalidInputException", errorCode):
14142 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
14143
14144 case strings.EqualFold("NotFoundException", errorCode):
14145 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
14146
14147 case strings.EqualFold("OperationFailureException", errorCode):
14148 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
14149
14150 case strings.EqualFold("RegionSetupInProgressException", errorCode):
14151 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
14152
14153 case strings.EqualFold("ServiceException", errorCode):
14154 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
14155
14156 case strings.EqualFold("UnauthenticatedException", errorCode):
14157 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
14158
14159 default:
14160 genericError := &smithy.GenericAPIError{
14161 Code: errorCode,
14162 Message: errorMessage,
14163 }
14164 return genericError
14165
14166 }
14167 }
14168
14169 type awsAwsjson11_deserializeOpGetOperationsForResource struct {
14170 }
14171
14172 func (*awsAwsjson11_deserializeOpGetOperationsForResource) ID() string {
14173 return "OperationDeserializer"
14174 }
14175
14176 func (m *awsAwsjson11_deserializeOpGetOperationsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
14177 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
14178 ) {
14179 out, metadata, err = next.HandleDeserialize(ctx, in)
14180 if err != nil {
14181 return out, metadata, err
14182 }
14183
14184 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
14185 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
14186 defer endTimer()
14187 defer span.End()
14188 response, ok := out.RawResponse.(*smithyhttp.Response)
14189 if !ok {
14190 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
14191 }
14192
14193 if response.StatusCode < 200 || response.StatusCode >= 300 {
14194 return out, metadata, awsAwsjson11_deserializeOpErrorGetOperationsForResource(response, &metadata)
14195 }
14196 output := &GetOperationsForResourceOutput{}
14197 out.Result = output
14198
14199 var buff [1024]byte
14200 ringBuffer := smithyio.NewRingBuffer(buff[:])
14201
14202 body := io.TeeReader(response.Body, ringBuffer)
14203 decoder := json.NewDecoder(body)
14204 decoder.UseNumber()
14205 var shape interface{}
14206 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
14207 var snapshot bytes.Buffer
14208 io.Copy(&snapshot, ringBuffer)
14209 err = &smithy.DeserializationError{
14210 Err: fmt.Errorf("failed to decode response body, %w", err),
14211 Snapshot: snapshot.Bytes(),
14212 }
14213 return out, metadata, err
14214 }
14215
14216 err = awsAwsjson11_deserializeOpDocumentGetOperationsForResourceOutput(&output, shape)
14217 if err != nil {
14218 var snapshot bytes.Buffer
14219 io.Copy(&snapshot, ringBuffer)
14220 err = &smithy.DeserializationError{
14221 Err: fmt.Errorf("failed to decode response body, %w", err),
14222 Snapshot: snapshot.Bytes(),
14223 }
14224 return out, metadata, err
14225 }
14226
14227 return out, metadata, err
14228 }
14229
14230 func awsAwsjson11_deserializeOpErrorGetOperationsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
14231 var errorBuffer bytes.Buffer
14232 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
14233 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
14234 }
14235 errorBody := bytes.NewReader(errorBuffer.Bytes())
14236
14237 errorCode := "UnknownError"
14238 errorMessage := errorCode
14239
14240 headerCode := response.Header.Get("X-Amzn-ErrorType")
14241
14242 var buff [1024]byte
14243 ringBuffer := smithyio.NewRingBuffer(buff[:])
14244
14245 body := io.TeeReader(errorBody, ringBuffer)
14246 decoder := json.NewDecoder(body)
14247 decoder.UseNumber()
14248 bodyInfo, err := getProtocolErrorInfo(decoder)
14249 if err != nil {
14250 var snapshot bytes.Buffer
14251 io.Copy(&snapshot, ringBuffer)
14252 err = &smithy.DeserializationError{
14253 Err: fmt.Errorf("failed to decode response body, %w", err),
14254 Snapshot: snapshot.Bytes(),
14255 }
14256 return err
14257 }
14258
14259 errorBody.Seek(0, io.SeekStart)
14260 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
14261 errorCode = restjson.SanitizeErrorCode(typ)
14262 }
14263 if len(bodyInfo.Message) != 0 {
14264 errorMessage = bodyInfo.Message
14265 }
14266 switch {
14267 case strings.EqualFold("AccessDeniedException", errorCode):
14268 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
14269
14270 case strings.EqualFold("AccountSetupInProgressException", errorCode):
14271 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
14272
14273 case strings.EqualFold("InvalidInputException", errorCode):
14274 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
14275
14276 case strings.EqualFold("NotFoundException", errorCode):
14277 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
14278
14279 case strings.EqualFold("OperationFailureException", errorCode):
14280 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
14281
14282 case strings.EqualFold("RegionSetupInProgressException", errorCode):
14283 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
14284
14285 case strings.EqualFold("ServiceException", errorCode):
14286 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
14287
14288 case strings.EqualFold("UnauthenticatedException", errorCode):
14289 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
14290
14291 default:
14292 genericError := &smithy.GenericAPIError{
14293 Code: errorCode,
14294 Message: errorMessage,
14295 }
14296 return genericError
14297
14298 }
14299 }
14300
14301 type awsAwsjson11_deserializeOpGetRegions struct {
14302 }
14303
14304 func (*awsAwsjson11_deserializeOpGetRegions) ID() string {
14305 return "OperationDeserializer"
14306 }
14307
14308 func (m *awsAwsjson11_deserializeOpGetRegions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
14309 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
14310 ) {
14311 out, metadata, err = next.HandleDeserialize(ctx, in)
14312 if err != nil {
14313 return out, metadata, err
14314 }
14315
14316 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
14317 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
14318 defer endTimer()
14319 defer span.End()
14320 response, ok := out.RawResponse.(*smithyhttp.Response)
14321 if !ok {
14322 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
14323 }
14324
14325 if response.StatusCode < 200 || response.StatusCode >= 300 {
14326 return out, metadata, awsAwsjson11_deserializeOpErrorGetRegions(response, &metadata)
14327 }
14328 output := &GetRegionsOutput{}
14329 out.Result = output
14330
14331 var buff [1024]byte
14332 ringBuffer := smithyio.NewRingBuffer(buff[:])
14333
14334 body := io.TeeReader(response.Body, ringBuffer)
14335 decoder := json.NewDecoder(body)
14336 decoder.UseNumber()
14337 var shape interface{}
14338 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
14339 var snapshot bytes.Buffer
14340 io.Copy(&snapshot, ringBuffer)
14341 err = &smithy.DeserializationError{
14342 Err: fmt.Errorf("failed to decode response body, %w", err),
14343 Snapshot: snapshot.Bytes(),
14344 }
14345 return out, metadata, err
14346 }
14347
14348 err = awsAwsjson11_deserializeOpDocumentGetRegionsOutput(&output, shape)
14349 if err != nil {
14350 var snapshot bytes.Buffer
14351 io.Copy(&snapshot, ringBuffer)
14352 err = &smithy.DeserializationError{
14353 Err: fmt.Errorf("failed to decode response body, %w", err),
14354 Snapshot: snapshot.Bytes(),
14355 }
14356 return out, metadata, err
14357 }
14358
14359 return out, metadata, err
14360 }
14361
14362 func awsAwsjson11_deserializeOpErrorGetRegions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
14363 var errorBuffer bytes.Buffer
14364 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
14365 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
14366 }
14367 errorBody := bytes.NewReader(errorBuffer.Bytes())
14368
14369 errorCode := "UnknownError"
14370 errorMessage := errorCode
14371
14372 headerCode := response.Header.Get("X-Amzn-ErrorType")
14373
14374 var buff [1024]byte
14375 ringBuffer := smithyio.NewRingBuffer(buff[:])
14376
14377 body := io.TeeReader(errorBody, ringBuffer)
14378 decoder := json.NewDecoder(body)
14379 decoder.UseNumber()
14380 bodyInfo, err := getProtocolErrorInfo(decoder)
14381 if err != nil {
14382 var snapshot bytes.Buffer
14383 io.Copy(&snapshot, ringBuffer)
14384 err = &smithy.DeserializationError{
14385 Err: fmt.Errorf("failed to decode response body, %w", err),
14386 Snapshot: snapshot.Bytes(),
14387 }
14388 return err
14389 }
14390
14391 errorBody.Seek(0, io.SeekStart)
14392 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
14393 errorCode = restjson.SanitizeErrorCode(typ)
14394 }
14395 if len(bodyInfo.Message) != 0 {
14396 errorMessage = bodyInfo.Message
14397 }
14398 switch {
14399 case strings.EqualFold("AccessDeniedException", errorCode):
14400 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
14401
14402 case strings.EqualFold("AccountSetupInProgressException", errorCode):
14403 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
14404
14405 case strings.EqualFold("InvalidInputException", errorCode):
14406 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
14407
14408 case strings.EqualFold("NotFoundException", errorCode):
14409 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
14410
14411 case strings.EqualFold("OperationFailureException", errorCode):
14412 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
14413
14414 case strings.EqualFold("RegionSetupInProgressException", errorCode):
14415 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
14416
14417 case strings.EqualFold("ServiceException", errorCode):
14418 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
14419
14420 case strings.EqualFold("UnauthenticatedException", errorCode):
14421 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
14422
14423 default:
14424 genericError := &smithy.GenericAPIError{
14425 Code: errorCode,
14426 Message: errorMessage,
14427 }
14428 return genericError
14429
14430 }
14431 }
14432
14433 type awsAwsjson11_deserializeOpGetRelationalDatabase struct {
14434 }
14435
14436 func (*awsAwsjson11_deserializeOpGetRelationalDatabase) ID() string {
14437 return "OperationDeserializer"
14438 }
14439
14440 func (m *awsAwsjson11_deserializeOpGetRelationalDatabase) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
14441 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
14442 ) {
14443 out, metadata, err = next.HandleDeserialize(ctx, in)
14444 if err != nil {
14445 return out, metadata, err
14446 }
14447
14448 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
14449 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
14450 defer endTimer()
14451 defer span.End()
14452 response, ok := out.RawResponse.(*smithyhttp.Response)
14453 if !ok {
14454 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
14455 }
14456
14457 if response.StatusCode < 200 || response.StatusCode >= 300 {
14458 return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabase(response, &metadata)
14459 }
14460 output := &GetRelationalDatabaseOutput{}
14461 out.Result = output
14462
14463 var buff [1024]byte
14464 ringBuffer := smithyio.NewRingBuffer(buff[:])
14465
14466 body := io.TeeReader(response.Body, ringBuffer)
14467 decoder := json.NewDecoder(body)
14468 decoder.UseNumber()
14469 var shape interface{}
14470 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
14471 var snapshot bytes.Buffer
14472 io.Copy(&snapshot, ringBuffer)
14473 err = &smithy.DeserializationError{
14474 Err: fmt.Errorf("failed to decode response body, %w", err),
14475 Snapshot: snapshot.Bytes(),
14476 }
14477 return out, metadata, err
14478 }
14479
14480 err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseOutput(&output, shape)
14481 if err != nil {
14482 var snapshot bytes.Buffer
14483 io.Copy(&snapshot, ringBuffer)
14484 err = &smithy.DeserializationError{
14485 Err: fmt.Errorf("failed to decode response body, %w", err),
14486 Snapshot: snapshot.Bytes(),
14487 }
14488 return out, metadata, err
14489 }
14490
14491 return out, metadata, err
14492 }
14493
14494 func awsAwsjson11_deserializeOpErrorGetRelationalDatabase(response *smithyhttp.Response, metadata *middleware.Metadata) error {
14495 var errorBuffer bytes.Buffer
14496 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
14497 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
14498 }
14499 errorBody := bytes.NewReader(errorBuffer.Bytes())
14500
14501 errorCode := "UnknownError"
14502 errorMessage := errorCode
14503
14504 headerCode := response.Header.Get("X-Amzn-ErrorType")
14505
14506 var buff [1024]byte
14507 ringBuffer := smithyio.NewRingBuffer(buff[:])
14508
14509 body := io.TeeReader(errorBody, ringBuffer)
14510 decoder := json.NewDecoder(body)
14511 decoder.UseNumber()
14512 bodyInfo, err := getProtocolErrorInfo(decoder)
14513 if err != nil {
14514 var snapshot bytes.Buffer
14515 io.Copy(&snapshot, ringBuffer)
14516 err = &smithy.DeserializationError{
14517 Err: fmt.Errorf("failed to decode response body, %w", err),
14518 Snapshot: snapshot.Bytes(),
14519 }
14520 return err
14521 }
14522
14523 errorBody.Seek(0, io.SeekStart)
14524 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
14525 errorCode = restjson.SanitizeErrorCode(typ)
14526 }
14527 if len(bodyInfo.Message) != 0 {
14528 errorMessage = bodyInfo.Message
14529 }
14530 switch {
14531 case strings.EqualFold("AccessDeniedException", errorCode):
14532 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
14533
14534 case strings.EqualFold("AccountSetupInProgressException", errorCode):
14535 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
14536
14537 case strings.EqualFold("InvalidInputException", errorCode):
14538 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
14539
14540 case strings.EqualFold("NotFoundException", errorCode):
14541 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
14542
14543 case strings.EqualFold("OperationFailureException", errorCode):
14544 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
14545
14546 case strings.EqualFold("RegionSetupInProgressException", errorCode):
14547 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
14548
14549 case strings.EqualFold("ServiceException", errorCode):
14550 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
14551
14552 case strings.EqualFold("UnauthenticatedException", errorCode):
14553 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
14554
14555 default:
14556 genericError := &smithy.GenericAPIError{
14557 Code: errorCode,
14558 Message: errorMessage,
14559 }
14560 return genericError
14561
14562 }
14563 }
14564
14565 type awsAwsjson11_deserializeOpGetRelationalDatabaseBlueprints struct {
14566 }
14567
14568 func (*awsAwsjson11_deserializeOpGetRelationalDatabaseBlueprints) ID() string {
14569 return "OperationDeserializer"
14570 }
14571
14572 func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseBlueprints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
14573 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
14574 ) {
14575 out, metadata, err = next.HandleDeserialize(ctx, in)
14576 if err != nil {
14577 return out, metadata, err
14578 }
14579
14580 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
14581 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
14582 defer endTimer()
14583 defer span.End()
14584 response, ok := out.RawResponse.(*smithyhttp.Response)
14585 if !ok {
14586 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
14587 }
14588
14589 if response.StatusCode < 200 || response.StatusCode >= 300 {
14590 return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseBlueprints(response, &metadata)
14591 }
14592 output := &GetRelationalDatabaseBlueprintsOutput{}
14593 out.Result = output
14594
14595 var buff [1024]byte
14596 ringBuffer := smithyio.NewRingBuffer(buff[:])
14597
14598 body := io.TeeReader(response.Body, ringBuffer)
14599 decoder := json.NewDecoder(body)
14600 decoder.UseNumber()
14601 var shape interface{}
14602 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
14603 var snapshot bytes.Buffer
14604 io.Copy(&snapshot, ringBuffer)
14605 err = &smithy.DeserializationError{
14606 Err: fmt.Errorf("failed to decode response body, %w", err),
14607 Snapshot: snapshot.Bytes(),
14608 }
14609 return out, metadata, err
14610 }
14611
14612 err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseBlueprintsOutput(&output, shape)
14613 if err != nil {
14614 var snapshot bytes.Buffer
14615 io.Copy(&snapshot, ringBuffer)
14616 err = &smithy.DeserializationError{
14617 Err: fmt.Errorf("failed to decode response body, %w", err),
14618 Snapshot: snapshot.Bytes(),
14619 }
14620 return out, metadata, err
14621 }
14622
14623 return out, metadata, err
14624 }
14625
14626 func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseBlueprints(response *smithyhttp.Response, metadata *middleware.Metadata) error {
14627 var errorBuffer bytes.Buffer
14628 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
14629 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
14630 }
14631 errorBody := bytes.NewReader(errorBuffer.Bytes())
14632
14633 errorCode := "UnknownError"
14634 errorMessage := errorCode
14635
14636 headerCode := response.Header.Get("X-Amzn-ErrorType")
14637
14638 var buff [1024]byte
14639 ringBuffer := smithyio.NewRingBuffer(buff[:])
14640
14641 body := io.TeeReader(errorBody, ringBuffer)
14642 decoder := json.NewDecoder(body)
14643 decoder.UseNumber()
14644 bodyInfo, err := getProtocolErrorInfo(decoder)
14645 if err != nil {
14646 var snapshot bytes.Buffer
14647 io.Copy(&snapshot, ringBuffer)
14648 err = &smithy.DeserializationError{
14649 Err: fmt.Errorf("failed to decode response body, %w", err),
14650 Snapshot: snapshot.Bytes(),
14651 }
14652 return err
14653 }
14654
14655 errorBody.Seek(0, io.SeekStart)
14656 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
14657 errorCode = restjson.SanitizeErrorCode(typ)
14658 }
14659 if len(bodyInfo.Message) != 0 {
14660 errorMessage = bodyInfo.Message
14661 }
14662 switch {
14663 case strings.EqualFold("AccessDeniedException", errorCode):
14664 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
14665
14666 case strings.EqualFold("AccountSetupInProgressException", errorCode):
14667 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
14668
14669 case strings.EqualFold("InvalidInputException", errorCode):
14670 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
14671
14672 case strings.EqualFold("NotFoundException", errorCode):
14673 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
14674
14675 case strings.EqualFold("OperationFailureException", errorCode):
14676 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
14677
14678 case strings.EqualFold("RegionSetupInProgressException", errorCode):
14679 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
14680
14681 case strings.EqualFold("ServiceException", errorCode):
14682 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
14683
14684 case strings.EqualFold("UnauthenticatedException", errorCode):
14685 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
14686
14687 default:
14688 genericError := &smithy.GenericAPIError{
14689 Code: errorCode,
14690 Message: errorMessage,
14691 }
14692 return genericError
14693
14694 }
14695 }
14696
14697 type awsAwsjson11_deserializeOpGetRelationalDatabaseBundles struct {
14698 }
14699
14700 func (*awsAwsjson11_deserializeOpGetRelationalDatabaseBundles) ID() string {
14701 return "OperationDeserializer"
14702 }
14703
14704 func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseBundles) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
14705 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
14706 ) {
14707 out, metadata, err = next.HandleDeserialize(ctx, in)
14708 if err != nil {
14709 return out, metadata, err
14710 }
14711
14712 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
14713 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
14714 defer endTimer()
14715 defer span.End()
14716 response, ok := out.RawResponse.(*smithyhttp.Response)
14717 if !ok {
14718 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
14719 }
14720
14721 if response.StatusCode < 200 || response.StatusCode >= 300 {
14722 return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseBundles(response, &metadata)
14723 }
14724 output := &GetRelationalDatabaseBundlesOutput{}
14725 out.Result = output
14726
14727 var buff [1024]byte
14728 ringBuffer := smithyio.NewRingBuffer(buff[:])
14729
14730 body := io.TeeReader(response.Body, ringBuffer)
14731 decoder := json.NewDecoder(body)
14732 decoder.UseNumber()
14733 var shape interface{}
14734 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
14735 var snapshot bytes.Buffer
14736 io.Copy(&snapshot, ringBuffer)
14737 err = &smithy.DeserializationError{
14738 Err: fmt.Errorf("failed to decode response body, %w", err),
14739 Snapshot: snapshot.Bytes(),
14740 }
14741 return out, metadata, err
14742 }
14743
14744 err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseBundlesOutput(&output, shape)
14745 if err != nil {
14746 var snapshot bytes.Buffer
14747 io.Copy(&snapshot, ringBuffer)
14748 err = &smithy.DeserializationError{
14749 Err: fmt.Errorf("failed to decode response body, %w", err),
14750 Snapshot: snapshot.Bytes(),
14751 }
14752 return out, metadata, err
14753 }
14754
14755 return out, metadata, err
14756 }
14757
14758 func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseBundles(response *smithyhttp.Response, metadata *middleware.Metadata) error {
14759 var errorBuffer bytes.Buffer
14760 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
14761 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
14762 }
14763 errorBody := bytes.NewReader(errorBuffer.Bytes())
14764
14765 errorCode := "UnknownError"
14766 errorMessage := errorCode
14767
14768 headerCode := response.Header.Get("X-Amzn-ErrorType")
14769
14770 var buff [1024]byte
14771 ringBuffer := smithyio.NewRingBuffer(buff[:])
14772
14773 body := io.TeeReader(errorBody, ringBuffer)
14774 decoder := json.NewDecoder(body)
14775 decoder.UseNumber()
14776 bodyInfo, err := getProtocolErrorInfo(decoder)
14777 if err != nil {
14778 var snapshot bytes.Buffer
14779 io.Copy(&snapshot, ringBuffer)
14780 err = &smithy.DeserializationError{
14781 Err: fmt.Errorf("failed to decode response body, %w", err),
14782 Snapshot: snapshot.Bytes(),
14783 }
14784 return err
14785 }
14786
14787 errorBody.Seek(0, io.SeekStart)
14788 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
14789 errorCode = restjson.SanitizeErrorCode(typ)
14790 }
14791 if len(bodyInfo.Message) != 0 {
14792 errorMessage = bodyInfo.Message
14793 }
14794 switch {
14795 case strings.EqualFold("AccessDeniedException", errorCode):
14796 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
14797
14798 case strings.EqualFold("AccountSetupInProgressException", errorCode):
14799 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
14800
14801 case strings.EqualFold("InvalidInputException", errorCode):
14802 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
14803
14804 case strings.EqualFold("NotFoundException", errorCode):
14805 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
14806
14807 case strings.EqualFold("OperationFailureException", errorCode):
14808 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
14809
14810 case strings.EqualFold("RegionSetupInProgressException", errorCode):
14811 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
14812
14813 case strings.EqualFold("ServiceException", errorCode):
14814 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
14815
14816 case strings.EqualFold("UnauthenticatedException", errorCode):
14817 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
14818
14819 default:
14820 genericError := &smithy.GenericAPIError{
14821 Code: errorCode,
14822 Message: errorMessage,
14823 }
14824 return genericError
14825
14826 }
14827 }
14828
14829 type awsAwsjson11_deserializeOpGetRelationalDatabaseEvents struct {
14830 }
14831
14832 func (*awsAwsjson11_deserializeOpGetRelationalDatabaseEvents) ID() string {
14833 return "OperationDeserializer"
14834 }
14835
14836 func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseEvents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
14837 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
14838 ) {
14839 out, metadata, err = next.HandleDeserialize(ctx, in)
14840 if err != nil {
14841 return out, metadata, err
14842 }
14843
14844 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
14845 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
14846 defer endTimer()
14847 defer span.End()
14848 response, ok := out.RawResponse.(*smithyhttp.Response)
14849 if !ok {
14850 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
14851 }
14852
14853 if response.StatusCode < 200 || response.StatusCode >= 300 {
14854 return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseEvents(response, &metadata)
14855 }
14856 output := &GetRelationalDatabaseEventsOutput{}
14857 out.Result = output
14858
14859 var buff [1024]byte
14860 ringBuffer := smithyio.NewRingBuffer(buff[:])
14861
14862 body := io.TeeReader(response.Body, ringBuffer)
14863 decoder := json.NewDecoder(body)
14864 decoder.UseNumber()
14865 var shape interface{}
14866 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
14867 var snapshot bytes.Buffer
14868 io.Copy(&snapshot, ringBuffer)
14869 err = &smithy.DeserializationError{
14870 Err: fmt.Errorf("failed to decode response body, %w", err),
14871 Snapshot: snapshot.Bytes(),
14872 }
14873 return out, metadata, err
14874 }
14875
14876 err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseEventsOutput(&output, shape)
14877 if err != nil {
14878 var snapshot bytes.Buffer
14879 io.Copy(&snapshot, ringBuffer)
14880 err = &smithy.DeserializationError{
14881 Err: fmt.Errorf("failed to decode response body, %w", err),
14882 Snapshot: snapshot.Bytes(),
14883 }
14884 return out, metadata, err
14885 }
14886
14887 return out, metadata, err
14888 }
14889
14890 func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseEvents(response *smithyhttp.Response, metadata *middleware.Metadata) error {
14891 var errorBuffer bytes.Buffer
14892 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
14893 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
14894 }
14895 errorBody := bytes.NewReader(errorBuffer.Bytes())
14896
14897 errorCode := "UnknownError"
14898 errorMessage := errorCode
14899
14900 headerCode := response.Header.Get("X-Amzn-ErrorType")
14901
14902 var buff [1024]byte
14903 ringBuffer := smithyio.NewRingBuffer(buff[:])
14904
14905 body := io.TeeReader(errorBody, ringBuffer)
14906 decoder := json.NewDecoder(body)
14907 decoder.UseNumber()
14908 bodyInfo, err := getProtocolErrorInfo(decoder)
14909 if err != nil {
14910 var snapshot bytes.Buffer
14911 io.Copy(&snapshot, ringBuffer)
14912 err = &smithy.DeserializationError{
14913 Err: fmt.Errorf("failed to decode response body, %w", err),
14914 Snapshot: snapshot.Bytes(),
14915 }
14916 return err
14917 }
14918
14919 errorBody.Seek(0, io.SeekStart)
14920 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
14921 errorCode = restjson.SanitizeErrorCode(typ)
14922 }
14923 if len(bodyInfo.Message) != 0 {
14924 errorMessage = bodyInfo.Message
14925 }
14926 switch {
14927 case strings.EqualFold("AccessDeniedException", errorCode):
14928 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
14929
14930 case strings.EqualFold("AccountSetupInProgressException", errorCode):
14931 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
14932
14933 case strings.EqualFold("InvalidInputException", errorCode):
14934 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
14935
14936 case strings.EqualFold("NotFoundException", errorCode):
14937 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
14938
14939 case strings.EqualFold("OperationFailureException", errorCode):
14940 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
14941
14942 case strings.EqualFold("RegionSetupInProgressException", errorCode):
14943 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
14944
14945 case strings.EqualFold("ServiceException", errorCode):
14946 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
14947
14948 case strings.EqualFold("UnauthenticatedException", errorCode):
14949 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
14950
14951 default:
14952 genericError := &smithy.GenericAPIError{
14953 Code: errorCode,
14954 Message: errorMessage,
14955 }
14956 return genericError
14957
14958 }
14959 }
14960
14961 type awsAwsjson11_deserializeOpGetRelationalDatabaseLogEvents struct {
14962 }
14963
14964 func (*awsAwsjson11_deserializeOpGetRelationalDatabaseLogEvents) ID() string {
14965 return "OperationDeserializer"
14966 }
14967
14968 func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseLogEvents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
14969 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
14970 ) {
14971 out, metadata, err = next.HandleDeserialize(ctx, in)
14972 if err != nil {
14973 return out, metadata, err
14974 }
14975
14976 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
14977 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
14978 defer endTimer()
14979 defer span.End()
14980 response, ok := out.RawResponse.(*smithyhttp.Response)
14981 if !ok {
14982 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
14983 }
14984
14985 if response.StatusCode < 200 || response.StatusCode >= 300 {
14986 return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseLogEvents(response, &metadata)
14987 }
14988 output := &GetRelationalDatabaseLogEventsOutput{}
14989 out.Result = output
14990
14991 var buff [1024]byte
14992 ringBuffer := smithyio.NewRingBuffer(buff[:])
14993
14994 body := io.TeeReader(response.Body, ringBuffer)
14995 decoder := json.NewDecoder(body)
14996 decoder.UseNumber()
14997 var shape interface{}
14998 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
14999 var snapshot bytes.Buffer
15000 io.Copy(&snapshot, ringBuffer)
15001 err = &smithy.DeserializationError{
15002 Err: fmt.Errorf("failed to decode response body, %w", err),
15003 Snapshot: snapshot.Bytes(),
15004 }
15005 return out, metadata, err
15006 }
15007
15008 err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseLogEventsOutput(&output, shape)
15009 if err != nil {
15010 var snapshot bytes.Buffer
15011 io.Copy(&snapshot, ringBuffer)
15012 err = &smithy.DeserializationError{
15013 Err: fmt.Errorf("failed to decode response body, %w", err),
15014 Snapshot: snapshot.Bytes(),
15015 }
15016 return out, metadata, err
15017 }
15018
15019 return out, metadata, err
15020 }
15021
15022 func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseLogEvents(response *smithyhttp.Response, metadata *middleware.Metadata) error {
15023 var errorBuffer bytes.Buffer
15024 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
15025 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
15026 }
15027 errorBody := bytes.NewReader(errorBuffer.Bytes())
15028
15029 errorCode := "UnknownError"
15030 errorMessage := errorCode
15031
15032 headerCode := response.Header.Get("X-Amzn-ErrorType")
15033
15034 var buff [1024]byte
15035 ringBuffer := smithyio.NewRingBuffer(buff[:])
15036
15037 body := io.TeeReader(errorBody, ringBuffer)
15038 decoder := json.NewDecoder(body)
15039 decoder.UseNumber()
15040 bodyInfo, err := getProtocolErrorInfo(decoder)
15041 if err != nil {
15042 var snapshot bytes.Buffer
15043 io.Copy(&snapshot, ringBuffer)
15044 err = &smithy.DeserializationError{
15045 Err: fmt.Errorf("failed to decode response body, %w", err),
15046 Snapshot: snapshot.Bytes(),
15047 }
15048 return err
15049 }
15050
15051 errorBody.Seek(0, io.SeekStart)
15052 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
15053 errorCode = restjson.SanitizeErrorCode(typ)
15054 }
15055 if len(bodyInfo.Message) != 0 {
15056 errorMessage = bodyInfo.Message
15057 }
15058 switch {
15059 case strings.EqualFold("AccessDeniedException", errorCode):
15060 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
15061
15062 case strings.EqualFold("AccountSetupInProgressException", errorCode):
15063 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
15064
15065 case strings.EqualFold("InvalidInputException", errorCode):
15066 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
15067
15068 case strings.EqualFold("NotFoundException", errorCode):
15069 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
15070
15071 case strings.EqualFold("OperationFailureException", errorCode):
15072 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
15073
15074 case strings.EqualFold("RegionSetupInProgressException", errorCode):
15075 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
15076
15077 case strings.EqualFold("ServiceException", errorCode):
15078 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
15079
15080 case strings.EqualFold("UnauthenticatedException", errorCode):
15081 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
15082
15083 default:
15084 genericError := &smithy.GenericAPIError{
15085 Code: errorCode,
15086 Message: errorMessage,
15087 }
15088 return genericError
15089
15090 }
15091 }
15092
15093 type awsAwsjson11_deserializeOpGetRelationalDatabaseLogStreams struct {
15094 }
15095
15096 func (*awsAwsjson11_deserializeOpGetRelationalDatabaseLogStreams) ID() string {
15097 return "OperationDeserializer"
15098 }
15099
15100 func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseLogStreams) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
15101 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
15102 ) {
15103 out, metadata, err = next.HandleDeserialize(ctx, in)
15104 if err != nil {
15105 return out, metadata, err
15106 }
15107
15108 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
15109 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
15110 defer endTimer()
15111 defer span.End()
15112 response, ok := out.RawResponse.(*smithyhttp.Response)
15113 if !ok {
15114 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
15115 }
15116
15117 if response.StatusCode < 200 || response.StatusCode >= 300 {
15118 return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseLogStreams(response, &metadata)
15119 }
15120 output := &GetRelationalDatabaseLogStreamsOutput{}
15121 out.Result = output
15122
15123 var buff [1024]byte
15124 ringBuffer := smithyio.NewRingBuffer(buff[:])
15125
15126 body := io.TeeReader(response.Body, ringBuffer)
15127 decoder := json.NewDecoder(body)
15128 decoder.UseNumber()
15129 var shape interface{}
15130 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
15131 var snapshot bytes.Buffer
15132 io.Copy(&snapshot, ringBuffer)
15133 err = &smithy.DeserializationError{
15134 Err: fmt.Errorf("failed to decode response body, %w", err),
15135 Snapshot: snapshot.Bytes(),
15136 }
15137 return out, metadata, err
15138 }
15139
15140 err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseLogStreamsOutput(&output, shape)
15141 if err != nil {
15142 var snapshot bytes.Buffer
15143 io.Copy(&snapshot, ringBuffer)
15144 err = &smithy.DeserializationError{
15145 Err: fmt.Errorf("failed to decode response body, %w", err),
15146 Snapshot: snapshot.Bytes(),
15147 }
15148 return out, metadata, err
15149 }
15150
15151 return out, metadata, err
15152 }
15153
15154 func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseLogStreams(response *smithyhttp.Response, metadata *middleware.Metadata) error {
15155 var errorBuffer bytes.Buffer
15156 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
15157 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
15158 }
15159 errorBody := bytes.NewReader(errorBuffer.Bytes())
15160
15161 errorCode := "UnknownError"
15162 errorMessage := errorCode
15163
15164 headerCode := response.Header.Get("X-Amzn-ErrorType")
15165
15166 var buff [1024]byte
15167 ringBuffer := smithyio.NewRingBuffer(buff[:])
15168
15169 body := io.TeeReader(errorBody, ringBuffer)
15170 decoder := json.NewDecoder(body)
15171 decoder.UseNumber()
15172 bodyInfo, err := getProtocolErrorInfo(decoder)
15173 if err != nil {
15174 var snapshot bytes.Buffer
15175 io.Copy(&snapshot, ringBuffer)
15176 err = &smithy.DeserializationError{
15177 Err: fmt.Errorf("failed to decode response body, %w", err),
15178 Snapshot: snapshot.Bytes(),
15179 }
15180 return err
15181 }
15182
15183 errorBody.Seek(0, io.SeekStart)
15184 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
15185 errorCode = restjson.SanitizeErrorCode(typ)
15186 }
15187 if len(bodyInfo.Message) != 0 {
15188 errorMessage = bodyInfo.Message
15189 }
15190 switch {
15191 case strings.EqualFold("AccessDeniedException", errorCode):
15192 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
15193
15194 case strings.EqualFold("AccountSetupInProgressException", errorCode):
15195 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
15196
15197 case strings.EqualFold("InvalidInputException", errorCode):
15198 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
15199
15200 case strings.EqualFold("NotFoundException", errorCode):
15201 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
15202
15203 case strings.EqualFold("OperationFailureException", errorCode):
15204 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
15205
15206 case strings.EqualFold("RegionSetupInProgressException", errorCode):
15207 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
15208
15209 case strings.EqualFold("ServiceException", errorCode):
15210 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
15211
15212 case strings.EqualFold("UnauthenticatedException", errorCode):
15213 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
15214
15215 default:
15216 genericError := &smithy.GenericAPIError{
15217 Code: errorCode,
15218 Message: errorMessage,
15219 }
15220 return genericError
15221
15222 }
15223 }
15224
15225 type awsAwsjson11_deserializeOpGetRelationalDatabaseMasterUserPassword struct {
15226 }
15227
15228 func (*awsAwsjson11_deserializeOpGetRelationalDatabaseMasterUserPassword) ID() string {
15229 return "OperationDeserializer"
15230 }
15231
15232 func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseMasterUserPassword) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
15233 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
15234 ) {
15235 out, metadata, err = next.HandleDeserialize(ctx, in)
15236 if err != nil {
15237 return out, metadata, err
15238 }
15239
15240 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
15241 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
15242 defer endTimer()
15243 defer span.End()
15244 response, ok := out.RawResponse.(*smithyhttp.Response)
15245 if !ok {
15246 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
15247 }
15248
15249 if response.StatusCode < 200 || response.StatusCode >= 300 {
15250 return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseMasterUserPassword(response, &metadata)
15251 }
15252 output := &GetRelationalDatabaseMasterUserPasswordOutput{}
15253 out.Result = output
15254
15255 var buff [1024]byte
15256 ringBuffer := smithyio.NewRingBuffer(buff[:])
15257
15258 body := io.TeeReader(response.Body, ringBuffer)
15259 decoder := json.NewDecoder(body)
15260 decoder.UseNumber()
15261 var shape interface{}
15262 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
15263 var snapshot bytes.Buffer
15264 io.Copy(&snapshot, ringBuffer)
15265 err = &smithy.DeserializationError{
15266 Err: fmt.Errorf("failed to decode response body, %w", err),
15267 Snapshot: snapshot.Bytes(),
15268 }
15269 return out, metadata, err
15270 }
15271
15272 err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseMasterUserPasswordOutput(&output, shape)
15273 if err != nil {
15274 var snapshot bytes.Buffer
15275 io.Copy(&snapshot, ringBuffer)
15276 err = &smithy.DeserializationError{
15277 Err: fmt.Errorf("failed to decode response body, %w", err),
15278 Snapshot: snapshot.Bytes(),
15279 }
15280 return out, metadata, err
15281 }
15282
15283 return out, metadata, err
15284 }
15285
15286 func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseMasterUserPassword(response *smithyhttp.Response, metadata *middleware.Metadata) error {
15287 var errorBuffer bytes.Buffer
15288 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
15289 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
15290 }
15291 errorBody := bytes.NewReader(errorBuffer.Bytes())
15292
15293 errorCode := "UnknownError"
15294 errorMessage := errorCode
15295
15296 headerCode := response.Header.Get("X-Amzn-ErrorType")
15297
15298 var buff [1024]byte
15299 ringBuffer := smithyio.NewRingBuffer(buff[:])
15300
15301 body := io.TeeReader(errorBody, ringBuffer)
15302 decoder := json.NewDecoder(body)
15303 decoder.UseNumber()
15304 bodyInfo, err := getProtocolErrorInfo(decoder)
15305 if err != nil {
15306 var snapshot bytes.Buffer
15307 io.Copy(&snapshot, ringBuffer)
15308 err = &smithy.DeserializationError{
15309 Err: fmt.Errorf("failed to decode response body, %w", err),
15310 Snapshot: snapshot.Bytes(),
15311 }
15312 return err
15313 }
15314
15315 errorBody.Seek(0, io.SeekStart)
15316 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
15317 errorCode = restjson.SanitizeErrorCode(typ)
15318 }
15319 if len(bodyInfo.Message) != 0 {
15320 errorMessage = bodyInfo.Message
15321 }
15322 switch {
15323 case strings.EqualFold("AccessDeniedException", errorCode):
15324 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
15325
15326 case strings.EqualFold("AccountSetupInProgressException", errorCode):
15327 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
15328
15329 case strings.EqualFold("InvalidInputException", errorCode):
15330 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
15331
15332 case strings.EqualFold("NotFoundException", errorCode):
15333 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
15334
15335 case strings.EqualFold("OperationFailureException", errorCode):
15336 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
15337
15338 case strings.EqualFold("RegionSetupInProgressException", errorCode):
15339 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
15340
15341 case strings.EqualFold("ServiceException", errorCode):
15342 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
15343
15344 case strings.EqualFold("UnauthenticatedException", errorCode):
15345 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
15346
15347 default:
15348 genericError := &smithy.GenericAPIError{
15349 Code: errorCode,
15350 Message: errorMessage,
15351 }
15352 return genericError
15353
15354 }
15355 }
15356
15357 type awsAwsjson11_deserializeOpGetRelationalDatabaseMetricData struct {
15358 }
15359
15360 func (*awsAwsjson11_deserializeOpGetRelationalDatabaseMetricData) ID() string {
15361 return "OperationDeserializer"
15362 }
15363
15364 func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseMetricData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
15365 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
15366 ) {
15367 out, metadata, err = next.HandleDeserialize(ctx, in)
15368 if err != nil {
15369 return out, metadata, err
15370 }
15371
15372 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
15373 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
15374 defer endTimer()
15375 defer span.End()
15376 response, ok := out.RawResponse.(*smithyhttp.Response)
15377 if !ok {
15378 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
15379 }
15380
15381 if response.StatusCode < 200 || response.StatusCode >= 300 {
15382 return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseMetricData(response, &metadata)
15383 }
15384 output := &GetRelationalDatabaseMetricDataOutput{}
15385 out.Result = output
15386
15387 var buff [1024]byte
15388 ringBuffer := smithyio.NewRingBuffer(buff[:])
15389
15390 body := io.TeeReader(response.Body, ringBuffer)
15391 decoder := json.NewDecoder(body)
15392 decoder.UseNumber()
15393 var shape interface{}
15394 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
15395 var snapshot bytes.Buffer
15396 io.Copy(&snapshot, ringBuffer)
15397 err = &smithy.DeserializationError{
15398 Err: fmt.Errorf("failed to decode response body, %w", err),
15399 Snapshot: snapshot.Bytes(),
15400 }
15401 return out, metadata, err
15402 }
15403
15404 err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseMetricDataOutput(&output, shape)
15405 if err != nil {
15406 var snapshot bytes.Buffer
15407 io.Copy(&snapshot, ringBuffer)
15408 err = &smithy.DeserializationError{
15409 Err: fmt.Errorf("failed to decode response body, %w", err),
15410 Snapshot: snapshot.Bytes(),
15411 }
15412 return out, metadata, err
15413 }
15414
15415 return out, metadata, err
15416 }
15417
15418 func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseMetricData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
15419 var errorBuffer bytes.Buffer
15420 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
15421 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
15422 }
15423 errorBody := bytes.NewReader(errorBuffer.Bytes())
15424
15425 errorCode := "UnknownError"
15426 errorMessage := errorCode
15427
15428 headerCode := response.Header.Get("X-Amzn-ErrorType")
15429
15430 var buff [1024]byte
15431 ringBuffer := smithyio.NewRingBuffer(buff[:])
15432
15433 body := io.TeeReader(errorBody, ringBuffer)
15434 decoder := json.NewDecoder(body)
15435 decoder.UseNumber()
15436 bodyInfo, err := getProtocolErrorInfo(decoder)
15437 if err != nil {
15438 var snapshot bytes.Buffer
15439 io.Copy(&snapshot, ringBuffer)
15440 err = &smithy.DeserializationError{
15441 Err: fmt.Errorf("failed to decode response body, %w", err),
15442 Snapshot: snapshot.Bytes(),
15443 }
15444 return err
15445 }
15446
15447 errorBody.Seek(0, io.SeekStart)
15448 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
15449 errorCode = restjson.SanitizeErrorCode(typ)
15450 }
15451 if len(bodyInfo.Message) != 0 {
15452 errorMessage = bodyInfo.Message
15453 }
15454 switch {
15455 case strings.EqualFold("AccessDeniedException", errorCode):
15456 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
15457
15458 case strings.EqualFold("AccountSetupInProgressException", errorCode):
15459 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
15460
15461 case strings.EqualFold("InvalidInputException", errorCode):
15462 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
15463
15464 case strings.EqualFold("NotFoundException", errorCode):
15465 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
15466
15467 case strings.EqualFold("OperationFailureException", errorCode):
15468 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
15469
15470 case strings.EqualFold("RegionSetupInProgressException", errorCode):
15471 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
15472
15473 case strings.EqualFold("ServiceException", errorCode):
15474 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
15475
15476 case strings.EqualFold("UnauthenticatedException", errorCode):
15477 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
15478
15479 default:
15480 genericError := &smithy.GenericAPIError{
15481 Code: errorCode,
15482 Message: errorMessage,
15483 }
15484 return genericError
15485
15486 }
15487 }
15488
15489 type awsAwsjson11_deserializeOpGetRelationalDatabaseParameters struct {
15490 }
15491
15492 func (*awsAwsjson11_deserializeOpGetRelationalDatabaseParameters) ID() string {
15493 return "OperationDeserializer"
15494 }
15495
15496 func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseParameters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
15497 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
15498 ) {
15499 out, metadata, err = next.HandleDeserialize(ctx, in)
15500 if err != nil {
15501 return out, metadata, err
15502 }
15503
15504 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
15505 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
15506 defer endTimer()
15507 defer span.End()
15508 response, ok := out.RawResponse.(*smithyhttp.Response)
15509 if !ok {
15510 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
15511 }
15512
15513 if response.StatusCode < 200 || response.StatusCode >= 300 {
15514 return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseParameters(response, &metadata)
15515 }
15516 output := &GetRelationalDatabaseParametersOutput{}
15517 out.Result = output
15518
15519 var buff [1024]byte
15520 ringBuffer := smithyio.NewRingBuffer(buff[:])
15521
15522 body := io.TeeReader(response.Body, ringBuffer)
15523 decoder := json.NewDecoder(body)
15524 decoder.UseNumber()
15525 var shape interface{}
15526 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
15527 var snapshot bytes.Buffer
15528 io.Copy(&snapshot, ringBuffer)
15529 err = &smithy.DeserializationError{
15530 Err: fmt.Errorf("failed to decode response body, %w", err),
15531 Snapshot: snapshot.Bytes(),
15532 }
15533 return out, metadata, err
15534 }
15535
15536 err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseParametersOutput(&output, shape)
15537 if err != nil {
15538 var snapshot bytes.Buffer
15539 io.Copy(&snapshot, ringBuffer)
15540 err = &smithy.DeserializationError{
15541 Err: fmt.Errorf("failed to decode response body, %w", err),
15542 Snapshot: snapshot.Bytes(),
15543 }
15544 return out, metadata, err
15545 }
15546
15547 return out, metadata, err
15548 }
15549
15550 func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseParameters(response *smithyhttp.Response, metadata *middleware.Metadata) error {
15551 var errorBuffer bytes.Buffer
15552 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
15553 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
15554 }
15555 errorBody := bytes.NewReader(errorBuffer.Bytes())
15556
15557 errorCode := "UnknownError"
15558 errorMessage := errorCode
15559
15560 headerCode := response.Header.Get("X-Amzn-ErrorType")
15561
15562 var buff [1024]byte
15563 ringBuffer := smithyio.NewRingBuffer(buff[:])
15564
15565 body := io.TeeReader(errorBody, ringBuffer)
15566 decoder := json.NewDecoder(body)
15567 decoder.UseNumber()
15568 bodyInfo, err := getProtocolErrorInfo(decoder)
15569 if err != nil {
15570 var snapshot bytes.Buffer
15571 io.Copy(&snapshot, ringBuffer)
15572 err = &smithy.DeserializationError{
15573 Err: fmt.Errorf("failed to decode response body, %w", err),
15574 Snapshot: snapshot.Bytes(),
15575 }
15576 return err
15577 }
15578
15579 errorBody.Seek(0, io.SeekStart)
15580 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
15581 errorCode = restjson.SanitizeErrorCode(typ)
15582 }
15583 if len(bodyInfo.Message) != 0 {
15584 errorMessage = bodyInfo.Message
15585 }
15586 switch {
15587 case strings.EqualFold("AccessDeniedException", errorCode):
15588 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
15589
15590 case strings.EqualFold("AccountSetupInProgressException", errorCode):
15591 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
15592
15593 case strings.EqualFold("InvalidInputException", errorCode):
15594 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
15595
15596 case strings.EqualFold("NotFoundException", errorCode):
15597 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
15598
15599 case strings.EqualFold("OperationFailureException", errorCode):
15600 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
15601
15602 case strings.EqualFold("RegionSetupInProgressException", errorCode):
15603 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
15604
15605 case strings.EqualFold("ServiceException", errorCode):
15606 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
15607
15608 case strings.EqualFold("UnauthenticatedException", errorCode):
15609 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
15610
15611 default:
15612 genericError := &smithy.GenericAPIError{
15613 Code: errorCode,
15614 Message: errorMessage,
15615 }
15616 return genericError
15617
15618 }
15619 }
15620
15621 type awsAwsjson11_deserializeOpGetRelationalDatabases struct {
15622 }
15623
15624 func (*awsAwsjson11_deserializeOpGetRelationalDatabases) ID() string {
15625 return "OperationDeserializer"
15626 }
15627
15628 func (m *awsAwsjson11_deserializeOpGetRelationalDatabases) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
15629 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
15630 ) {
15631 out, metadata, err = next.HandleDeserialize(ctx, in)
15632 if err != nil {
15633 return out, metadata, err
15634 }
15635
15636 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
15637 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
15638 defer endTimer()
15639 defer span.End()
15640 response, ok := out.RawResponse.(*smithyhttp.Response)
15641 if !ok {
15642 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
15643 }
15644
15645 if response.StatusCode < 200 || response.StatusCode >= 300 {
15646 return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabases(response, &metadata)
15647 }
15648 output := &GetRelationalDatabasesOutput{}
15649 out.Result = output
15650
15651 var buff [1024]byte
15652 ringBuffer := smithyio.NewRingBuffer(buff[:])
15653
15654 body := io.TeeReader(response.Body, ringBuffer)
15655 decoder := json.NewDecoder(body)
15656 decoder.UseNumber()
15657 var shape interface{}
15658 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
15659 var snapshot bytes.Buffer
15660 io.Copy(&snapshot, ringBuffer)
15661 err = &smithy.DeserializationError{
15662 Err: fmt.Errorf("failed to decode response body, %w", err),
15663 Snapshot: snapshot.Bytes(),
15664 }
15665 return out, metadata, err
15666 }
15667
15668 err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabasesOutput(&output, shape)
15669 if err != nil {
15670 var snapshot bytes.Buffer
15671 io.Copy(&snapshot, ringBuffer)
15672 err = &smithy.DeserializationError{
15673 Err: fmt.Errorf("failed to decode response body, %w", err),
15674 Snapshot: snapshot.Bytes(),
15675 }
15676 return out, metadata, err
15677 }
15678
15679 return out, metadata, err
15680 }
15681
15682 func awsAwsjson11_deserializeOpErrorGetRelationalDatabases(response *smithyhttp.Response, metadata *middleware.Metadata) error {
15683 var errorBuffer bytes.Buffer
15684 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
15685 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
15686 }
15687 errorBody := bytes.NewReader(errorBuffer.Bytes())
15688
15689 errorCode := "UnknownError"
15690 errorMessage := errorCode
15691
15692 headerCode := response.Header.Get("X-Amzn-ErrorType")
15693
15694 var buff [1024]byte
15695 ringBuffer := smithyio.NewRingBuffer(buff[:])
15696
15697 body := io.TeeReader(errorBody, ringBuffer)
15698 decoder := json.NewDecoder(body)
15699 decoder.UseNumber()
15700 bodyInfo, err := getProtocolErrorInfo(decoder)
15701 if err != nil {
15702 var snapshot bytes.Buffer
15703 io.Copy(&snapshot, ringBuffer)
15704 err = &smithy.DeserializationError{
15705 Err: fmt.Errorf("failed to decode response body, %w", err),
15706 Snapshot: snapshot.Bytes(),
15707 }
15708 return err
15709 }
15710
15711 errorBody.Seek(0, io.SeekStart)
15712 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
15713 errorCode = restjson.SanitizeErrorCode(typ)
15714 }
15715 if len(bodyInfo.Message) != 0 {
15716 errorMessage = bodyInfo.Message
15717 }
15718 switch {
15719 case strings.EqualFold("AccessDeniedException", errorCode):
15720 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
15721
15722 case strings.EqualFold("AccountSetupInProgressException", errorCode):
15723 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
15724
15725 case strings.EqualFold("InvalidInputException", errorCode):
15726 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
15727
15728 case strings.EqualFold("NotFoundException", errorCode):
15729 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
15730
15731 case strings.EqualFold("OperationFailureException", errorCode):
15732 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
15733
15734 case strings.EqualFold("RegionSetupInProgressException", errorCode):
15735 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
15736
15737 case strings.EqualFold("ServiceException", errorCode):
15738 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
15739
15740 case strings.EqualFold("UnauthenticatedException", errorCode):
15741 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
15742
15743 default:
15744 genericError := &smithy.GenericAPIError{
15745 Code: errorCode,
15746 Message: errorMessage,
15747 }
15748 return genericError
15749
15750 }
15751 }
15752
15753 type awsAwsjson11_deserializeOpGetRelationalDatabaseSnapshot struct {
15754 }
15755
15756 func (*awsAwsjson11_deserializeOpGetRelationalDatabaseSnapshot) ID() string {
15757 return "OperationDeserializer"
15758 }
15759
15760 func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
15761 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
15762 ) {
15763 out, metadata, err = next.HandleDeserialize(ctx, in)
15764 if err != nil {
15765 return out, metadata, err
15766 }
15767
15768 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
15769 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
15770 defer endTimer()
15771 defer span.End()
15772 response, ok := out.RawResponse.(*smithyhttp.Response)
15773 if !ok {
15774 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
15775 }
15776
15777 if response.StatusCode < 200 || response.StatusCode >= 300 {
15778 return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseSnapshot(response, &metadata)
15779 }
15780 output := &GetRelationalDatabaseSnapshotOutput{}
15781 out.Result = output
15782
15783 var buff [1024]byte
15784 ringBuffer := smithyio.NewRingBuffer(buff[:])
15785
15786 body := io.TeeReader(response.Body, ringBuffer)
15787 decoder := json.NewDecoder(body)
15788 decoder.UseNumber()
15789 var shape interface{}
15790 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
15791 var snapshot bytes.Buffer
15792 io.Copy(&snapshot, ringBuffer)
15793 err = &smithy.DeserializationError{
15794 Err: fmt.Errorf("failed to decode response body, %w", err),
15795 Snapshot: snapshot.Bytes(),
15796 }
15797 return out, metadata, err
15798 }
15799
15800 err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseSnapshotOutput(&output, shape)
15801 if err != nil {
15802 var snapshot bytes.Buffer
15803 io.Copy(&snapshot, ringBuffer)
15804 err = &smithy.DeserializationError{
15805 Err: fmt.Errorf("failed to decode response body, %w", err),
15806 Snapshot: snapshot.Bytes(),
15807 }
15808 return out, metadata, err
15809 }
15810
15811 return out, metadata, err
15812 }
15813
15814 func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
15815 var errorBuffer bytes.Buffer
15816 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
15817 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
15818 }
15819 errorBody := bytes.NewReader(errorBuffer.Bytes())
15820
15821 errorCode := "UnknownError"
15822 errorMessage := errorCode
15823
15824 headerCode := response.Header.Get("X-Amzn-ErrorType")
15825
15826 var buff [1024]byte
15827 ringBuffer := smithyio.NewRingBuffer(buff[:])
15828
15829 body := io.TeeReader(errorBody, ringBuffer)
15830 decoder := json.NewDecoder(body)
15831 decoder.UseNumber()
15832 bodyInfo, err := getProtocolErrorInfo(decoder)
15833 if err != nil {
15834 var snapshot bytes.Buffer
15835 io.Copy(&snapshot, ringBuffer)
15836 err = &smithy.DeserializationError{
15837 Err: fmt.Errorf("failed to decode response body, %w", err),
15838 Snapshot: snapshot.Bytes(),
15839 }
15840 return err
15841 }
15842
15843 errorBody.Seek(0, io.SeekStart)
15844 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
15845 errorCode = restjson.SanitizeErrorCode(typ)
15846 }
15847 if len(bodyInfo.Message) != 0 {
15848 errorMessage = bodyInfo.Message
15849 }
15850 switch {
15851 case strings.EqualFold("AccessDeniedException", errorCode):
15852 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
15853
15854 case strings.EqualFold("AccountSetupInProgressException", errorCode):
15855 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
15856
15857 case strings.EqualFold("InvalidInputException", errorCode):
15858 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
15859
15860 case strings.EqualFold("NotFoundException", errorCode):
15861 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
15862
15863 case strings.EqualFold("OperationFailureException", errorCode):
15864 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
15865
15866 case strings.EqualFold("RegionSetupInProgressException", errorCode):
15867 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
15868
15869 case strings.EqualFold("ServiceException", errorCode):
15870 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
15871
15872 case strings.EqualFold("UnauthenticatedException", errorCode):
15873 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
15874
15875 default:
15876 genericError := &smithy.GenericAPIError{
15877 Code: errorCode,
15878 Message: errorMessage,
15879 }
15880 return genericError
15881
15882 }
15883 }
15884
15885 type awsAwsjson11_deserializeOpGetRelationalDatabaseSnapshots struct {
15886 }
15887
15888 func (*awsAwsjson11_deserializeOpGetRelationalDatabaseSnapshots) ID() string {
15889 return "OperationDeserializer"
15890 }
15891
15892 func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseSnapshots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
15893 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
15894 ) {
15895 out, metadata, err = next.HandleDeserialize(ctx, in)
15896 if err != nil {
15897 return out, metadata, err
15898 }
15899
15900 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
15901 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
15902 defer endTimer()
15903 defer span.End()
15904 response, ok := out.RawResponse.(*smithyhttp.Response)
15905 if !ok {
15906 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
15907 }
15908
15909 if response.StatusCode < 200 || response.StatusCode >= 300 {
15910 return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseSnapshots(response, &metadata)
15911 }
15912 output := &GetRelationalDatabaseSnapshotsOutput{}
15913 out.Result = output
15914
15915 var buff [1024]byte
15916 ringBuffer := smithyio.NewRingBuffer(buff[:])
15917
15918 body := io.TeeReader(response.Body, ringBuffer)
15919 decoder := json.NewDecoder(body)
15920 decoder.UseNumber()
15921 var shape interface{}
15922 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
15923 var snapshot bytes.Buffer
15924 io.Copy(&snapshot, ringBuffer)
15925 err = &smithy.DeserializationError{
15926 Err: fmt.Errorf("failed to decode response body, %w", err),
15927 Snapshot: snapshot.Bytes(),
15928 }
15929 return out, metadata, err
15930 }
15931
15932 err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseSnapshotsOutput(&output, shape)
15933 if err != nil {
15934 var snapshot bytes.Buffer
15935 io.Copy(&snapshot, ringBuffer)
15936 err = &smithy.DeserializationError{
15937 Err: fmt.Errorf("failed to decode response body, %w", err),
15938 Snapshot: snapshot.Bytes(),
15939 }
15940 return out, metadata, err
15941 }
15942
15943 return out, metadata, err
15944 }
15945
15946 func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseSnapshots(response *smithyhttp.Response, metadata *middleware.Metadata) error {
15947 var errorBuffer bytes.Buffer
15948 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
15949 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
15950 }
15951 errorBody := bytes.NewReader(errorBuffer.Bytes())
15952
15953 errorCode := "UnknownError"
15954 errorMessage := errorCode
15955
15956 headerCode := response.Header.Get("X-Amzn-ErrorType")
15957
15958 var buff [1024]byte
15959 ringBuffer := smithyio.NewRingBuffer(buff[:])
15960
15961 body := io.TeeReader(errorBody, ringBuffer)
15962 decoder := json.NewDecoder(body)
15963 decoder.UseNumber()
15964 bodyInfo, err := getProtocolErrorInfo(decoder)
15965 if err != nil {
15966 var snapshot bytes.Buffer
15967 io.Copy(&snapshot, ringBuffer)
15968 err = &smithy.DeserializationError{
15969 Err: fmt.Errorf("failed to decode response body, %w", err),
15970 Snapshot: snapshot.Bytes(),
15971 }
15972 return err
15973 }
15974
15975 errorBody.Seek(0, io.SeekStart)
15976 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
15977 errorCode = restjson.SanitizeErrorCode(typ)
15978 }
15979 if len(bodyInfo.Message) != 0 {
15980 errorMessage = bodyInfo.Message
15981 }
15982 switch {
15983 case strings.EqualFold("AccessDeniedException", errorCode):
15984 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
15985
15986 case strings.EqualFold("AccountSetupInProgressException", errorCode):
15987 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
15988
15989 case strings.EqualFold("InvalidInputException", errorCode):
15990 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
15991
15992 case strings.EqualFold("NotFoundException", errorCode):
15993 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
15994
15995 case strings.EqualFold("OperationFailureException", errorCode):
15996 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
15997
15998 case strings.EqualFold("RegionSetupInProgressException", errorCode):
15999 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
16000
16001 case strings.EqualFold("ServiceException", errorCode):
16002 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
16003
16004 case strings.EqualFold("UnauthenticatedException", errorCode):
16005 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
16006
16007 default:
16008 genericError := &smithy.GenericAPIError{
16009 Code: errorCode,
16010 Message: errorMessage,
16011 }
16012 return genericError
16013
16014 }
16015 }
16016
16017 type awsAwsjson11_deserializeOpGetSetupHistory struct {
16018 }
16019
16020 func (*awsAwsjson11_deserializeOpGetSetupHistory) ID() string {
16021 return "OperationDeserializer"
16022 }
16023
16024 func (m *awsAwsjson11_deserializeOpGetSetupHistory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
16025 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
16026 ) {
16027 out, metadata, err = next.HandleDeserialize(ctx, in)
16028 if err != nil {
16029 return out, metadata, err
16030 }
16031
16032 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
16033 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
16034 defer endTimer()
16035 defer span.End()
16036 response, ok := out.RawResponse.(*smithyhttp.Response)
16037 if !ok {
16038 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
16039 }
16040
16041 if response.StatusCode < 200 || response.StatusCode >= 300 {
16042 return out, metadata, awsAwsjson11_deserializeOpErrorGetSetupHistory(response, &metadata)
16043 }
16044 output := &GetSetupHistoryOutput{}
16045 out.Result = output
16046
16047 var buff [1024]byte
16048 ringBuffer := smithyio.NewRingBuffer(buff[:])
16049
16050 body := io.TeeReader(response.Body, ringBuffer)
16051 decoder := json.NewDecoder(body)
16052 decoder.UseNumber()
16053 var shape interface{}
16054 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
16055 var snapshot bytes.Buffer
16056 io.Copy(&snapshot, ringBuffer)
16057 err = &smithy.DeserializationError{
16058 Err: fmt.Errorf("failed to decode response body, %w", err),
16059 Snapshot: snapshot.Bytes(),
16060 }
16061 return out, metadata, err
16062 }
16063
16064 err = awsAwsjson11_deserializeOpDocumentGetSetupHistoryOutput(&output, shape)
16065 if err != nil {
16066 var snapshot bytes.Buffer
16067 io.Copy(&snapshot, ringBuffer)
16068 err = &smithy.DeserializationError{
16069 Err: fmt.Errorf("failed to decode response body, %w", err),
16070 Snapshot: snapshot.Bytes(),
16071 }
16072 return out, metadata, err
16073 }
16074
16075 return out, metadata, err
16076 }
16077
16078 func awsAwsjson11_deserializeOpErrorGetSetupHistory(response *smithyhttp.Response, metadata *middleware.Metadata) error {
16079 var errorBuffer bytes.Buffer
16080 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
16081 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
16082 }
16083 errorBody := bytes.NewReader(errorBuffer.Bytes())
16084
16085 errorCode := "UnknownError"
16086 errorMessage := errorCode
16087
16088 headerCode := response.Header.Get("X-Amzn-ErrorType")
16089
16090 var buff [1024]byte
16091 ringBuffer := smithyio.NewRingBuffer(buff[:])
16092
16093 body := io.TeeReader(errorBody, ringBuffer)
16094 decoder := json.NewDecoder(body)
16095 decoder.UseNumber()
16096 bodyInfo, err := getProtocolErrorInfo(decoder)
16097 if err != nil {
16098 var snapshot bytes.Buffer
16099 io.Copy(&snapshot, ringBuffer)
16100 err = &smithy.DeserializationError{
16101 Err: fmt.Errorf("failed to decode response body, %w", err),
16102 Snapshot: snapshot.Bytes(),
16103 }
16104 return err
16105 }
16106
16107 errorBody.Seek(0, io.SeekStart)
16108 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
16109 errorCode = restjson.SanitizeErrorCode(typ)
16110 }
16111 if len(bodyInfo.Message) != 0 {
16112 errorMessage = bodyInfo.Message
16113 }
16114 switch {
16115 case strings.EqualFold("AccessDeniedException", errorCode):
16116 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
16117
16118 case strings.EqualFold("InvalidInputException", errorCode):
16119 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
16120
16121 case strings.EqualFold("NotFoundException", errorCode):
16122 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
16123
16124 case strings.EqualFold("RegionSetupInProgressException", errorCode):
16125 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
16126
16127 case strings.EqualFold("ServiceException", errorCode):
16128 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
16129
16130 case strings.EqualFold("UnauthenticatedException", errorCode):
16131 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
16132
16133 default:
16134 genericError := &smithy.GenericAPIError{
16135 Code: errorCode,
16136 Message: errorMessage,
16137 }
16138 return genericError
16139
16140 }
16141 }
16142
16143 type awsAwsjson11_deserializeOpGetStaticIp struct {
16144 }
16145
16146 func (*awsAwsjson11_deserializeOpGetStaticIp) ID() string {
16147 return "OperationDeserializer"
16148 }
16149
16150 func (m *awsAwsjson11_deserializeOpGetStaticIp) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
16151 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
16152 ) {
16153 out, metadata, err = next.HandleDeserialize(ctx, in)
16154 if err != nil {
16155 return out, metadata, err
16156 }
16157
16158 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
16159 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
16160 defer endTimer()
16161 defer span.End()
16162 response, ok := out.RawResponse.(*smithyhttp.Response)
16163 if !ok {
16164 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
16165 }
16166
16167 if response.StatusCode < 200 || response.StatusCode >= 300 {
16168 return out, metadata, awsAwsjson11_deserializeOpErrorGetStaticIp(response, &metadata)
16169 }
16170 output := &GetStaticIpOutput{}
16171 out.Result = output
16172
16173 var buff [1024]byte
16174 ringBuffer := smithyio.NewRingBuffer(buff[:])
16175
16176 body := io.TeeReader(response.Body, ringBuffer)
16177 decoder := json.NewDecoder(body)
16178 decoder.UseNumber()
16179 var shape interface{}
16180 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
16181 var snapshot bytes.Buffer
16182 io.Copy(&snapshot, ringBuffer)
16183 err = &smithy.DeserializationError{
16184 Err: fmt.Errorf("failed to decode response body, %w", err),
16185 Snapshot: snapshot.Bytes(),
16186 }
16187 return out, metadata, err
16188 }
16189
16190 err = awsAwsjson11_deserializeOpDocumentGetStaticIpOutput(&output, shape)
16191 if err != nil {
16192 var snapshot bytes.Buffer
16193 io.Copy(&snapshot, ringBuffer)
16194 err = &smithy.DeserializationError{
16195 Err: fmt.Errorf("failed to decode response body, %w", err),
16196 Snapshot: snapshot.Bytes(),
16197 }
16198 return out, metadata, err
16199 }
16200
16201 return out, metadata, err
16202 }
16203
16204 func awsAwsjson11_deserializeOpErrorGetStaticIp(response *smithyhttp.Response, metadata *middleware.Metadata) error {
16205 var errorBuffer bytes.Buffer
16206 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
16207 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
16208 }
16209 errorBody := bytes.NewReader(errorBuffer.Bytes())
16210
16211 errorCode := "UnknownError"
16212 errorMessage := errorCode
16213
16214 headerCode := response.Header.Get("X-Amzn-ErrorType")
16215
16216 var buff [1024]byte
16217 ringBuffer := smithyio.NewRingBuffer(buff[:])
16218
16219 body := io.TeeReader(errorBody, ringBuffer)
16220 decoder := json.NewDecoder(body)
16221 decoder.UseNumber()
16222 bodyInfo, err := getProtocolErrorInfo(decoder)
16223 if err != nil {
16224 var snapshot bytes.Buffer
16225 io.Copy(&snapshot, ringBuffer)
16226 err = &smithy.DeserializationError{
16227 Err: fmt.Errorf("failed to decode response body, %w", err),
16228 Snapshot: snapshot.Bytes(),
16229 }
16230 return err
16231 }
16232
16233 errorBody.Seek(0, io.SeekStart)
16234 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
16235 errorCode = restjson.SanitizeErrorCode(typ)
16236 }
16237 if len(bodyInfo.Message) != 0 {
16238 errorMessage = bodyInfo.Message
16239 }
16240 switch {
16241 case strings.EqualFold("AccessDeniedException", errorCode):
16242 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
16243
16244 case strings.EqualFold("AccountSetupInProgressException", errorCode):
16245 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
16246
16247 case strings.EqualFold("InvalidInputException", errorCode):
16248 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
16249
16250 case strings.EqualFold("NotFoundException", errorCode):
16251 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
16252
16253 case strings.EqualFold("OperationFailureException", errorCode):
16254 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
16255
16256 case strings.EqualFold("RegionSetupInProgressException", errorCode):
16257 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
16258
16259 case strings.EqualFold("ServiceException", errorCode):
16260 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
16261
16262 case strings.EqualFold("UnauthenticatedException", errorCode):
16263 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
16264
16265 default:
16266 genericError := &smithy.GenericAPIError{
16267 Code: errorCode,
16268 Message: errorMessage,
16269 }
16270 return genericError
16271
16272 }
16273 }
16274
16275 type awsAwsjson11_deserializeOpGetStaticIps struct {
16276 }
16277
16278 func (*awsAwsjson11_deserializeOpGetStaticIps) ID() string {
16279 return "OperationDeserializer"
16280 }
16281
16282 func (m *awsAwsjson11_deserializeOpGetStaticIps) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
16283 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
16284 ) {
16285 out, metadata, err = next.HandleDeserialize(ctx, in)
16286 if err != nil {
16287 return out, metadata, err
16288 }
16289
16290 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
16291 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
16292 defer endTimer()
16293 defer span.End()
16294 response, ok := out.RawResponse.(*smithyhttp.Response)
16295 if !ok {
16296 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
16297 }
16298
16299 if response.StatusCode < 200 || response.StatusCode >= 300 {
16300 return out, metadata, awsAwsjson11_deserializeOpErrorGetStaticIps(response, &metadata)
16301 }
16302 output := &GetStaticIpsOutput{}
16303 out.Result = output
16304
16305 var buff [1024]byte
16306 ringBuffer := smithyio.NewRingBuffer(buff[:])
16307
16308 body := io.TeeReader(response.Body, ringBuffer)
16309 decoder := json.NewDecoder(body)
16310 decoder.UseNumber()
16311 var shape interface{}
16312 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
16313 var snapshot bytes.Buffer
16314 io.Copy(&snapshot, ringBuffer)
16315 err = &smithy.DeserializationError{
16316 Err: fmt.Errorf("failed to decode response body, %w", err),
16317 Snapshot: snapshot.Bytes(),
16318 }
16319 return out, metadata, err
16320 }
16321
16322 err = awsAwsjson11_deserializeOpDocumentGetStaticIpsOutput(&output, shape)
16323 if err != nil {
16324 var snapshot bytes.Buffer
16325 io.Copy(&snapshot, ringBuffer)
16326 err = &smithy.DeserializationError{
16327 Err: fmt.Errorf("failed to decode response body, %w", err),
16328 Snapshot: snapshot.Bytes(),
16329 }
16330 return out, metadata, err
16331 }
16332
16333 return out, metadata, err
16334 }
16335
16336 func awsAwsjson11_deserializeOpErrorGetStaticIps(response *smithyhttp.Response, metadata *middleware.Metadata) error {
16337 var errorBuffer bytes.Buffer
16338 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
16339 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
16340 }
16341 errorBody := bytes.NewReader(errorBuffer.Bytes())
16342
16343 errorCode := "UnknownError"
16344 errorMessage := errorCode
16345
16346 headerCode := response.Header.Get("X-Amzn-ErrorType")
16347
16348 var buff [1024]byte
16349 ringBuffer := smithyio.NewRingBuffer(buff[:])
16350
16351 body := io.TeeReader(errorBody, ringBuffer)
16352 decoder := json.NewDecoder(body)
16353 decoder.UseNumber()
16354 bodyInfo, err := getProtocolErrorInfo(decoder)
16355 if err != nil {
16356 var snapshot bytes.Buffer
16357 io.Copy(&snapshot, ringBuffer)
16358 err = &smithy.DeserializationError{
16359 Err: fmt.Errorf("failed to decode response body, %w", err),
16360 Snapshot: snapshot.Bytes(),
16361 }
16362 return err
16363 }
16364
16365 errorBody.Seek(0, io.SeekStart)
16366 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
16367 errorCode = restjson.SanitizeErrorCode(typ)
16368 }
16369 if len(bodyInfo.Message) != 0 {
16370 errorMessage = bodyInfo.Message
16371 }
16372 switch {
16373 case strings.EqualFold("AccessDeniedException", errorCode):
16374 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
16375
16376 case strings.EqualFold("AccountSetupInProgressException", errorCode):
16377 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
16378
16379 case strings.EqualFold("InvalidInputException", errorCode):
16380 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
16381
16382 case strings.EqualFold("NotFoundException", errorCode):
16383 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
16384
16385 case strings.EqualFold("OperationFailureException", errorCode):
16386 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
16387
16388 case strings.EqualFold("RegionSetupInProgressException", errorCode):
16389 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
16390
16391 case strings.EqualFold("ServiceException", errorCode):
16392 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
16393
16394 case strings.EqualFold("UnauthenticatedException", errorCode):
16395 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
16396
16397 default:
16398 genericError := &smithy.GenericAPIError{
16399 Code: errorCode,
16400 Message: errorMessage,
16401 }
16402 return genericError
16403
16404 }
16405 }
16406
16407 type awsAwsjson11_deserializeOpImportKeyPair struct {
16408 }
16409
16410 func (*awsAwsjson11_deserializeOpImportKeyPair) ID() string {
16411 return "OperationDeserializer"
16412 }
16413
16414 func (m *awsAwsjson11_deserializeOpImportKeyPair) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
16415 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
16416 ) {
16417 out, metadata, err = next.HandleDeserialize(ctx, in)
16418 if err != nil {
16419 return out, metadata, err
16420 }
16421
16422 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
16423 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
16424 defer endTimer()
16425 defer span.End()
16426 response, ok := out.RawResponse.(*smithyhttp.Response)
16427 if !ok {
16428 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
16429 }
16430
16431 if response.StatusCode < 200 || response.StatusCode >= 300 {
16432 return out, metadata, awsAwsjson11_deserializeOpErrorImportKeyPair(response, &metadata)
16433 }
16434 output := &ImportKeyPairOutput{}
16435 out.Result = output
16436
16437 var buff [1024]byte
16438 ringBuffer := smithyio.NewRingBuffer(buff[:])
16439
16440 body := io.TeeReader(response.Body, ringBuffer)
16441 decoder := json.NewDecoder(body)
16442 decoder.UseNumber()
16443 var shape interface{}
16444 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
16445 var snapshot bytes.Buffer
16446 io.Copy(&snapshot, ringBuffer)
16447 err = &smithy.DeserializationError{
16448 Err: fmt.Errorf("failed to decode response body, %w", err),
16449 Snapshot: snapshot.Bytes(),
16450 }
16451 return out, metadata, err
16452 }
16453
16454 err = awsAwsjson11_deserializeOpDocumentImportKeyPairOutput(&output, shape)
16455 if err != nil {
16456 var snapshot bytes.Buffer
16457 io.Copy(&snapshot, ringBuffer)
16458 err = &smithy.DeserializationError{
16459 Err: fmt.Errorf("failed to decode response body, %w", err),
16460 Snapshot: snapshot.Bytes(),
16461 }
16462 return out, metadata, err
16463 }
16464
16465 return out, metadata, err
16466 }
16467
16468 func awsAwsjson11_deserializeOpErrorImportKeyPair(response *smithyhttp.Response, metadata *middleware.Metadata) error {
16469 var errorBuffer bytes.Buffer
16470 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
16471 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
16472 }
16473 errorBody := bytes.NewReader(errorBuffer.Bytes())
16474
16475 errorCode := "UnknownError"
16476 errorMessage := errorCode
16477
16478 headerCode := response.Header.Get("X-Amzn-ErrorType")
16479
16480 var buff [1024]byte
16481 ringBuffer := smithyio.NewRingBuffer(buff[:])
16482
16483 body := io.TeeReader(errorBody, ringBuffer)
16484 decoder := json.NewDecoder(body)
16485 decoder.UseNumber()
16486 bodyInfo, err := getProtocolErrorInfo(decoder)
16487 if err != nil {
16488 var snapshot bytes.Buffer
16489 io.Copy(&snapshot, ringBuffer)
16490 err = &smithy.DeserializationError{
16491 Err: fmt.Errorf("failed to decode response body, %w", err),
16492 Snapshot: snapshot.Bytes(),
16493 }
16494 return err
16495 }
16496
16497 errorBody.Seek(0, io.SeekStart)
16498 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
16499 errorCode = restjson.SanitizeErrorCode(typ)
16500 }
16501 if len(bodyInfo.Message) != 0 {
16502 errorMessage = bodyInfo.Message
16503 }
16504 switch {
16505 case strings.EqualFold("AccessDeniedException", errorCode):
16506 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
16507
16508 case strings.EqualFold("AccountSetupInProgressException", errorCode):
16509 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
16510
16511 case strings.EqualFold("InvalidInputException", errorCode):
16512 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
16513
16514 case strings.EqualFold("NotFoundException", errorCode):
16515 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
16516
16517 case strings.EqualFold("OperationFailureException", errorCode):
16518 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
16519
16520 case strings.EqualFold("RegionSetupInProgressException", errorCode):
16521 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
16522
16523 case strings.EqualFold("ServiceException", errorCode):
16524 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
16525
16526 case strings.EqualFold("UnauthenticatedException", errorCode):
16527 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
16528
16529 default:
16530 genericError := &smithy.GenericAPIError{
16531 Code: errorCode,
16532 Message: errorMessage,
16533 }
16534 return genericError
16535
16536 }
16537 }
16538
16539 type awsAwsjson11_deserializeOpIsVpcPeered struct {
16540 }
16541
16542 func (*awsAwsjson11_deserializeOpIsVpcPeered) ID() string {
16543 return "OperationDeserializer"
16544 }
16545
16546 func (m *awsAwsjson11_deserializeOpIsVpcPeered) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
16547 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
16548 ) {
16549 out, metadata, err = next.HandleDeserialize(ctx, in)
16550 if err != nil {
16551 return out, metadata, err
16552 }
16553
16554 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
16555 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
16556 defer endTimer()
16557 defer span.End()
16558 response, ok := out.RawResponse.(*smithyhttp.Response)
16559 if !ok {
16560 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
16561 }
16562
16563 if response.StatusCode < 200 || response.StatusCode >= 300 {
16564 return out, metadata, awsAwsjson11_deserializeOpErrorIsVpcPeered(response, &metadata)
16565 }
16566 output := &IsVpcPeeredOutput{}
16567 out.Result = output
16568
16569 var buff [1024]byte
16570 ringBuffer := smithyio.NewRingBuffer(buff[:])
16571
16572 body := io.TeeReader(response.Body, ringBuffer)
16573 decoder := json.NewDecoder(body)
16574 decoder.UseNumber()
16575 var shape interface{}
16576 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
16577 var snapshot bytes.Buffer
16578 io.Copy(&snapshot, ringBuffer)
16579 err = &smithy.DeserializationError{
16580 Err: fmt.Errorf("failed to decode response body, %w", err),
16581 Snapshot: snapshot.Bytes(),
16582 }
16583 return out, metadata, err
16584 }
16585
16586 err = awsAwsjson11_deserializeOpDocumentIsVpcPeeredOutput(&output, shape)
16587 if err != nil {
16588 var snapshot bytes.Buffer
16589 io.Copy(&snapshot, ringBuffer)
16590 err = &smithy.DeserializationError{
16591 Err: fmt.Errorf("failed to decode response body, %w", err),
16592 Snapshot: snapshot.Bytes(),
16593 }
16594 return out, metadata, err
16595 }
16596
16597 return out, metadata, err
16598 }
16599
16600 func awsAwsjson11_deserializeOpErrorIsVpcPeered(response *smithyhttp.Response, metadata *middleware.Metadata) error {
16601 var errorBuffer bytes.Buffer
16602 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
16603 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
16604 }
16605 errorBody := bytes.NewReader(errorBuffer.Bytes())
16606
16607 errorCode := "UnknownError"
16608 errorMessage := errorCode
16609
16610 headerCode := response.Header.Get("X-Amzn-ErrorType")
16611
16612 var buff [1024]byte
16613 ringBuffer := smithyio.NewRingBuffer(buff[:])
16614
16615 body := io.TeeReader(errorBody, ringBuffer)
16616 decoder := json.NewDecoder(body)
16617 decoder.UseNumber()
16618 bodyInfo, err := getProtocolErrorInfo(decoder)
16619 if err != nil {
16620 var snapshot bytes.Buffer
16621 io.Copy(&snapshot, ringBuffer)
16622 err = &smithy.DeserializationError{
16623 Err: fmt.Errorf("failed to decode response body, %w", err),
16624 Snapshot: snapshot.Bytes(),
16625 }
16626 return err
16627 }
16628
16629 errorBody.Seek(0, io.SeekStart)
16630 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
16631 errorCode = restjson.SanitizeErrorCode(typ)
16632 }
16633 if len(bodyInfo.Message) != 0 {
16634 errorMessage = bodyInfo.Message
16635 }
16636 switch {
16637 case strings.EqualFold("AccessDeniedException", errorCode):
16638 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
16639
16640 case strings.EqualFold("AccountSetupInProgressException", errorCode):
16641 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
16642
16643 case strings.EqualFold("InvalidInputException", errorCode):
16644 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
16645
16646 case strings.EqualFold("NotFoundException", errorCode):
16647 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
16648
16649 case strings.EqualFold("OperationFailureException", errorCode):
16650 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
16651
16652 case strings.EqualFold("RegionSetupInProgressException", errorCode):
16653 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
16654
16655 case strings.EqualFold("ServiceException", errorCode):
16656 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
16657
16658 case strings.EqualFold("UnauthenticatedException", errorCode):
16659 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
16660
16661 default:
16662 genericError := &smithy.GenericAPIError{
16663 Code: errorCode,
16664 Message: errorMessage,
16665 }
16666 return genericError
16667
16668 }
16669 }
16670
16671 type awsAwsjson11_deserializeOpOpenInstancePublicPorts struct {
16672 }
16673
16674 func (*awsAwsjson11_deserializeOpOpenInstancePublicPorts) ID() string {
16675 return "OperationDeserializer"
16676 }
16677
16678 func (m *awsAwsjson11_deserializeOpOpenInstancePublicPorts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
16679 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
16680 ) {
16681 out, metadata, err = next.HandleDeserialize(ctx, in)
16682 if err != nil {
16683 return out, metadata, err
16684 }
16685
16686 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
16687 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
16688 defer endTimer()
16689 defer span.End()
16690 response, ok := out.RawResponse.(*smithyhttp.Response)
16691 if !ok {
16692 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
16693 }
16694
16695 if response.StatusCode < 200 || response.StatusCode >= 300 {
16696 return out, metadata, awsAwsjson11_deserializeOpErrorOpenInstancePublicPorts(response, &metadata)
16697 }
16698 output := &OpenInstancePublicPortsOutput{}
16699 out.Result = output
16700
16701 var buff [1024]byte
16702 ringBuffer := smithyio.NewRingBuffer(buff[:])
16703
16704 body := io.TeeReader(response.Body, ringBuffer)
16705 decoder := json.NewDecoder(body)
16706 decoder.UseNumber()
16707 var shape interface{}
16708 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
16709 var snapshot bytes.Buffer
16710 io.Copy(&snapshot, ringBuffer)
16711 err = &smithy.DeserializationError{
16712 Err: fmt.Errorf("failed to decode response body, %w", err),
16713 Snapshot: snapshot.Bytes(),
16714 }
16715 return out, metadata, err
16716 }
16717
16718 err = awsAwsjson11_deserializeOpDocumentOpenInstancePublicPortsOutput(&output, shape)
16719 if err != nil {
16720 var snapshot bytes.Buffer
16721 io.Copy(&snapshot, ringBuffer)
16722 err = &smithy.DeserializationError{
16723 Err: fmt.Errorf("failed to decode response body, %w", err),
16724 Snapshot: snapshot.Bytes(),
16725 }
16726 return out, metadata, err
16727 }
16728
16729 return out, metadata, err
16730 }
16731
16732 func awsAwsjson11_deserializeOpErrorOpenInstancePublicPorts(response *smithyhttp.Response, metadata *middleware.Metadata) error {
16733 var errorBuffer bytes.Buffer
16734 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
16735 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
16736 }
16737 errorBody := bytes.NewReader(errorBuffer.Bytes())
16738
16739 errorCode := "UnknownError"
16740 errorMessage := errorCode
16741
16742 headerCode := response.Header.Get("X-Amzn-ErrorType")
16743
16744 var buff [1024]byte
16745 ringBuffer := smithyio.NewRingBuffer(buff[:])
16746
16747 body := io.TeeReader(errorBody, ringBuffer)
16748 decoder := json.NewDecoder(body)
16749 decoder.UseNumber()
16750 bodyInfo, err := getProtocolErrorInfo(decoder)
16751 if err != nil {
16752 var snapshot bytes.Buffer
16753 io.Copy(&snapshot, ringBuffer)
16754 err = &smithy.DeserializationError{
16755 Err: fmt.Errorf("failed to decode response body, %w", err),
16756 Snapshot: snapshot.Bytes(),
16757 }
16758 return err
16759 }
16760
16761 errorBody.Seek(0, io.SeekStart)
16762 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
16763 errorCode = restjson.SanitizeErrorCode(typ)
16764 }
16765 if len(bodyInfo.Message) != 0 {
16766 errorMessage = bodyInfo.Message
16767 }
16768 switch {
16769 case strings.EqualFold("AccessDeniedException", errorCode):
16770 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
16771
16772 case strings.EqualFold("AccountSetupInProgressException", errorCode):
16773 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
16774
16775 case strings.EqualFold("InvalidInputException", errorCode):
16776 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
16777
16778 case strings.EqualFold("NotFoundException", errorCode):
16779 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
16780
16781 case strings.EqualFold("OperationFailureException", errorCode):
16782 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
16783
16784 case strings.EqualFold("RegionSetupInProgressException", errorCode):
16785 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
16786
16787 case strings.EqualFold("ServiceException", errorCode):
16788 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
16789
16790 case strings.EqualFold("UnauthenticatedException", errorCode):
16791 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
16792
16793 default:
16794 genericError := &smithy.GenericAPIError{
16795 Code: errorCode,
16796 Message: errorMessage,
16797 }
16798 return genericError
16799
16800 }
16801 }
16802
16803 type awsAwsjson11_deserializeOpPeerVpc struct {
16804 }
16805
16806 func (*awsAwsjson11_deserializeOpPeerVpc) ID() string {
16807 return "OperationDeserializer"
16808 }
16809
16810 func (m *awsAwsjson11_deserializeOpPeerVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
16811 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
16812 ) {
16813 out, metadata, err = next.HandleDeserialize(ctx, in)
16814 if err != nil {
16815 return out, metadata, err
16816 }
16817
16818 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
16819 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
16820 defer endTimer()
16821 defer span.End()
16822 response, ok := out.RawResponse.(*smithyhttp.Response)
16823 if !ok {
16824 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
16825 }
16826
16827 if response.StatusCode < 200 || response.StatusCode >= 300 {
16828 return out, metadata, awsAwsjson11_deserializeOpErrorPeerVpc(response, &metadata)
16829 }
16830 output := &PeerVpcOutput{}
16831 out.Result = output
16832
16833 var buff [1024]byte
16834 ringBuffer := smithyio.NewRingBuffer(buff[:])
16835
16836 body := io.TeeReader(response.Body, ringBuffer)
16837 decoder := json.NewDecoder(body)
16838 decoder.UseNumber()
16839 var shape interface{}
16840 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
16841 var snapshot bytes.Buffer
16842 io.Copy(&snapshot, ringBuffer)
16843 err = &smithy.DeserializationError{
16844 Err: fmt.Errorf("failed to decode response body, %w", err),
16845 Snapshot: snapshot.Bytes(),
16846 }
16847 return out, metadata, err
16848 }
16849
16850 err = awsAwsjson11_deserializeOpDocumentPeerVpcOutput(&output, shape)
16851 if err != nil {
16852 var snapshot bytes.Buffer
16853 io.Copy(&snapshot, ringBuffer)
16854 err = &smithy.DeserializationError{
16855 Err: fmt.Errorf("failed to decode response body, %w", err),
16856 Snapshot: snapshot.Bytes(),
16857 }
16858 return out, metadata, err
16859 }
16860
16861 return out, metadata, err
16862 }
16863
16864 func awsAwsjson11_deserializeOpErrorPeerVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error {
16865 var errorBuffer bytes.Buffer
16866 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
16867 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
16868 }
16869 errorBody := bytes.NewReader(errorBuffer.Bytes())
16870
16871 errorCode := "UnknownError"
16872 errorMessage := errorCode
16873
16874 headerCode := response.Header.Get("X-Amzn-ErrorType")
16875
16876 var buff [1024]byte
16877 ringBuffer := smithyio.NewRingBuffer(buff[:])
16878
16879 body := io.TeeReader(errorBody, ringBuffer)
16880 decoder := json.NewDecoder(body)
16881 decoder.UseNumber()
16882 bodyInfo, err := getProtocolErrorInfo(decoder)
16883 if err != nil {
16884 var snapshot bytes.Buffer
16885 io.Copy(&snapshot, ringBuffer)
16886 err = &smithy.DeserializationError{
16887 Err: fmt.Errorf("failed to decode response body, %w", err),
16888 Snapshot: snapshot.Bytes(),
16889 }
16890 return err
16891 }
16892
16893 errorBody.Seek(0, io.SeekStart)
16894 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
16895 errorCode = restjson.SanitizeErrorCode(typ)
16896 }
16897 if len(bodyInfo.Message) != 0 {
16898 errorMessage = bodyInfo.Message
16899 }
16900 switch {
16901 case strings.EqualFold("AccessDeniedException", errorCode):
16902 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
16903
16904 case strings.EqualFold("AccountSetupInProgressException", errorCode):
16905 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
16906
16907 case strings.EqualFold("InvalidInputException", errorCode):
16908 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
16909
16910 case strings.EqualFold("NotFoundException", errorCode):
16911 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
16912
16913 case strings.EqualFold("OperationFailureException", errorCode):
16914 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
16915
16916 case strings.EqualFold("RegionSetupInProgressException", errorCode):
16917 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
16918
16919 case strings.EqualFold("ServiceException", errorCode):
16920 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
16921
16922 case strings.EqualFold("UnauthenticatedException", errorCode):
16923 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
16924
16925 default:
16926 genericError := &smithy.GenericAPIError{
16927 Code: errorCode,
16928 Message: errorMessage,
16929 }
16930 return genericError
16931
16932 }
16933 }
16934
16935 type awsAwsjson11_deserializeOpPutAlarm struct {
16936 }
16937
16938 func (*awsAwsjson11_deserializeOpPutAlarm) ID() string {
16939 return "OperationDeserializer"
16940 }
16941
16942 func (m *awsAwsjson11_deserializeOpPutAlarm) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
16943 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
16944 ) {
16945 out, metadata, err = next.HandleDeserialize(ctx, in)
16946 if err != nil {
16947 return out, metadata, err
16948 }
16949
16950 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
16951 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
16952 defer endTimer()
16953 defer span.End()
16954 response, ok := out.RawResponse.(*smithyhttp.Response)
16955 if !ok {
16956 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
16957 }
16958
16959 if response.StatusCode < 200 || response.StatusCode >= 300 {
16960 return out, metadata, awsAwsjson11_deserializeOpErrorPutAlarm(response, &metadata)
16961 }
16962 output := &PutAlarmOutput{}
16963 out.Result = output
16964
16965 var buff [1024]byte
16966 ringBuffer := smithyio.NewRingBuffer(buff[:])
16967
16968 body := io.TeeReader(response.Body, ringBuffer)
16969 decoder := json.NewDecoder(body)
16970 decoder.UseNumber()
16971 var shape interface{}
16972 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
16973 var snapshot bytes.Buffer
16974 io.Copy(&snapshot, ringBuffer)
16975 err = &smithy.DeserializationError{
16976 Err: fmt.Errorf("failed to decode response body, %w", err),
16977 Snapshot: snapshot.Bytes(),
16978 }
16979 return out, metadata, err
16980 }
16981
16982 err = awsAwsjson11_deserializeOpDocumentPutAlarmOutput(&output, shape)
16983 if err != nil {
16984 var snapshot bytes.Buffer
16985 io.Copy(&snapshot, ringBuffer)
16986 err = &smithy.DeserializationError{
16987 Err: fmt.Errorf("failed to decode response body, %w", err),
16988 Snapshot: snapshot.Bytes(),
16989 }
16990 return out, metadata, err
16991 }
16992
16993 return out, metadata, err
16994 }
16995
16996 func awsAwsjson11_deserializeOpErrorPutAlarm(response *smithyhttp.Response, metadata *middleware.Metadata) error {
16997 var errorBuffer bytes.Buffer
16998 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
16999 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
17000 }
17001 errorBody := bytes.NewReader(errorBuffer.Bytes())
17002
17003 errorCode := "UnknownError"
17004 errorMessage := errorCode
17005
17006 headerCode := response.Header.Get("X-Amzn-ErrorType")
17007
17008 var buff [1024]byte
17009 ringBuffer := smithyio.NewRingBuffer(buff[:])
17010
17011 body := io.TeeReader(errorBody, ringBuffer)
17012 decoder := json.NewDecoder(body)
17013 decoder.UseNumber()
17014 bodyInfo, err := getProtocolErrorInfo(decoder)
17015 if err != nil {
17016 var snapshot bytes.Buffer
17017 io.Copy(&snapshot, ringBuffer)
17018 err = &smithy.DeserializationError{
17019 Err: fmt.Errorf("failed to decode response body, %w", err),
17020 Snapshot: snapshot.Bytes(),
17021 }
17022 return err
17023 }
17024
17025 errorBody.Seek(0, io.SeekStart)
17026 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
17027 errorCode = restjson.SanitizeErrorCode(typ)
17028 }
17029 if len(bodyInfo.Message) != 0 {
17030 errorMessage = bodyInfo.Message
17031 }
17032 switch {
17033 case strings.EqualFold("AccessDeniedException", errorCode):
17034 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
17035
17036 case strings.EqualFold("InvalidInputException", errorCode):
17037 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
17038
17039 case strings.EqualFold("NotFoundException", errorCode):
17040 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
17041
17042 case strings.EqualFold("OperationFailureException", errorCode):
17043 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
17044
17045 case strings.EqualFold("RegionSetupInProgressException", errorCode):
17046 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
17047
17048 case strings.EqualFold("ServiceException", errorCode):
17049 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
17050
17051 case strings.EqualFold("UnauthenticatedException", errorCode):
17052 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
17053
17054 default:
17055 genericError := &smithy.GenericAPIError{
17056 Code: errorCode,
17057 Message: errorMessage,
17058 }
17059 return genericError
17060
17061 }
17062 }
17063
17064 type awsAwsjson11_deserializeOpPutInstancePublicPorts struct {
17065 }
17066
17067 func (*awsAwsjson11_deserializeOpPutInstancePublicPorts) ID() string {
17068 return "OperationDeserializer"
17069 }
17070
17071 func (m *awsAwsjson11_deserializeOpPutInstancePublicPorts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
17072 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
17073 ) {
17074 out, metadata, err = next.HandleDeserialize(ctx, in)
17075 if err != nil {
17076 return out, metadata, err
17077 }
17078
17079 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
17080 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
17081 defer endTimer()
17082 defer span.End()
17083 response, ok := out.RawResponse.(*smithyhttp.Response)
17084 if !ok {
17085 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
17086 }
17087
17088 if response.StatusCode < 200 || response.StatusCode >= 300 {
17089 return out, metadata, awsAwsjson11_deserializeOpErrorPutInstancePublicPorts(response, &metadata)
17090 }
17091 output := &PutInstancePublicPortsOutput{}
17092 out.Result = output
17093
17094 var buff [1024]byte
17095 ringBuffer := smithyio.NewRingBuffer(buff[:])
17096
17097 body := io.TeeReader(response.Body, ringBuffer)
17098 decoder := json.NewDecoder(body)
17099 decoder.UseNumber()
17100 var shape interface{}
17101 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
17102 var snapshot bytes.Buffer
17103 io.Copy(&snapshot, ringBuffer)
17104 err = &smithy.DeserializationError{
17105 Err: fmt.Errorf("failed to decode response body, %w", err),
17106 Snapshot: snapshot.Bytes(),
17107 }
17108 return out, metadata, err
17109 }
17110
17111 err = awsAwsjson11_deserializeOpDocumentPutInstancePublicPortsOutput(&output, shape)
17112 if err != nil {
17113 var snapshot bytes.Buffer
17114 io.Copy(&snapshot, ringBuffer)
17115 err = &smithy.DeserializationError{
17116 Err: fmt.Errorf("failed to decode response body, %w", err),
17117 Snapshot: snapshot.Bytes(),
17118 }
17119 return out, metadata, err
17120 }
17121
17122 return out, metadata, err
17123 }
17124
17125 func awsAwsjson11_deserializeOpErrorPutInstancePublicPorts(response *smithyhttp.Response, metadata *middleware.Metadata) error {
17126 var errorBuffer bytes.Buffer
17127 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
17128 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
17129 }
17130 errorBody := bytes.NewReader(errorBuffer.Bytes())
17131
17132 errorCode := "UnknownError"
17133 errorMessage := errorCode
17134
17135 headerCode := response.Header.Get("X-Amzn-ErrorType")
17136
17137 var buff [1024]byte
17138 ringBuffer := smithyio.NewRingBuffer(buff[:])
17139
17140 body := io.TeeReader(errorBody, ringBuffer)
17141 decoder := json.NewDecoder(body)
17142 decoder.UseNumber()
17143 bodyInfo, err := getProtocolErrorInfo(decoder)
17144 if err != nil {
17145 var snapshot bytes.Buffer
17146 io.Copy(&snapshot, ringBuffer)
17147 err = &smithy.DeserializationError{
17148 Err: fmt.Errorf("failed to decode response body, %w", err),
17149 Snapshot: snapshot.Bytes(),
17150 }
17151 return err
17152 }
17153
17154 errorBody.Seek(0, io.SeekStart)
17155 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
17156 errorCode = restjson.SanitizeErrorCode(typ)
17157 }
17158 if len(bodyInfo.Message) != 0 {
17159 errorMessage = bodyInfo.Message
17160 }
17161 switch {
17162 case strings.EqualFold("AccessDeniedException", errorCode):
17163 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
17164
17165 case strings.EqualFold("AccountSetupInProgressException", errorCode):
17166 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
17167
17168 case strings.EqualFold("InvalidInputException", errorCode):
17169 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
17170
17171 case strings.EqualFold("NotFoundException", errorCode):
17172 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
17173
17174 case strings.EqualFold("OperationFailureException", errorCode):
17175 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
17176
17177 case strings.EqualFold("RegionSetupInProgressException", errorCode):
17178 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
17179
17180 case strings.EqualFold("ServiceException", errorCode):
17181 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
17182
17183 case strings.EqualFold("UnauthenticatedException", errorCode):
17184 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
17185
17186 default:
17187 genericError := &smithy.GenericAPIError{
17188 Code: errorCode,
17189 Message: errorMessage,
17190 }
17191 return genericError
17192
17193 }
17194 }
17195
17196 type awsAwsjson11_deserializeOpRebootInstance struct {
17197 }
17198
17199 func (*awsAwsjson11_deserializeOpRebootInstance) ID() string {
17200 return "OperationDeserializer"
17201 }
17202
17203 func (m *awsAwsjson11_deserializeOpRebootInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
17204 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
17205 ) {
17206 out, metadata, err = next.HandleDeserialize(ctx, in)
17207 if err != nil {
17208 return out, metadata, err
17209 }
17210
17211 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
17212 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
17213 defer endTimer()
17214 defer span.End()
17215 response, ok := out.RawResponse.(*smithyhttp.Response)
17216 if !ok {
17217 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
17218 }
17219
17220 if response.StatusCode < 200 || response.StatusCode >= 300 {
17221 return out, metadata, awsAwsjson11_deserializeOpErrorRebootInstance(response, &metadata)
17222 }
17223 output := &RebootInstanceOutput{}
17224 out.Result = output
17225
17226 var buff [1024]byte
17227 ringBuffer := smithyio.NewRingBuffer(buff[:])
17228
17229 body := io.TeeReader(response.Body, ringBuffer)
17230 decoder := json.NewDecoder(body)
17231 decoder.UseNumber()
17232 var shape interface{}
17233 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
17234 var snapshot bytes.Buffer
17235 io.Copy(&snapshot, ringBuffer)
17236 err = &smithy.DeserializationError{
17237 Err: fmt.Errorf("failed to decode response body, %w", err),
17238 Snapshot: snapshot.Bytes(),
17239 }
17240 return out, metadata, err
17241 }
17242
17243 err = awsAwsjson11_deserializeOpDocumentRebootInstanceOutput(&output, shape)
17244 if err != nil {
17245 var snapshot bytes.Buffer
17246 io.Copy(&snapshot, ringBuffer)
17247 err = &smithy.DeserializationError{
17248 Err: fmt.Errorf("failed to decode response body, %w", err),
17249 Snapshot: snapshot.Bytes(),
17250 }
17251 return out, metadata, err
17252 }
17253
17254 return out, metadata, err
17255 }
17256
17257 func awsAwsjson11_deserializeOpErrorRebootInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
17258 var errorBuffer bytes.Buffer
17259 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
17260 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
17261 }
17262 errorBody := bytes.NewReader(errorBuffer.Bytes())
17263
17264 errorCode := "UnknownError"
17265 errorMessage := errorCode
17266
17267 headerCode := response.Header.Get("X-Amzn-ErrorType")
17268
17269 var buff [1024]byte
17270 ringBuffer := smithyio.NewRingBuffer(buff[:])
17271
17272 body := io.TeeReader(errorBody, ringBuffer)
17273 decoder := json.NewDecoder(body)
17274 decoder.UseNumber()
17275 bodyInfo, err := getProtocolErrorInfo(decoder)
17276 if err != nil {
17277 var snapshot bytes.Buffer
17278 io.Copy(&snapshot, ringBuffer)
17279 err = &smithy.DeserializationError{
17280 Err: fmt.Errorf("failed to decode response body, %w", err),
17281 Snapshot: snapshot.Bytes(),
17282 }
17283 return err
17284 }
17285
17286 errorBody.Seek(0, io.SeekStart)
17287 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
17288 errorCode = restjson.SanitizeErrorCode(typ)
17289 }
17290 if len(bodyInfo.Message) != 0 {
17291 errorMessage = bodyInfo.Message
17292 }
17293 switch {
17294 case strings.EqualFold("AccessDeniedException", errorCode):
17295 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
17296
17297 case strings.EqualFold("AccountSetupInProgressException", errorCode):
17298 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
17299
17300 case strings.EqualFold("InvalidInputException", errorCode):
17301 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
17302
17303 case strings.EqualFold("NotFoundException", errorCode):
17304 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
17305
17306 case strings.EqualFold("OperationFailureException", errorCode):
17307 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
17308
17309 case strings.EqualFold("RegionSetupInProgressException", errorCode):
17310 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
17311
17312 case strings.EqualFold("ServiceException", errorCode):
17313 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
17314
17315 case strings.EqualFold("UnauthenticatedException", errorCode):
17316 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
17317
17318 default:
17319 genericError := &smithy.GenericAPIError{
17320 Code: errorCode,
17321 Message: errorMessage,
17322 }
17323 return genericError
17324
17325 }
17326 }
17327
17328 type awsAwsjson11_deserializeOpRebootRelationalDatabase struct {
17329 }
17330
17331 func (*awsAwsjson11_deserializeOpRebootRelationalDatabase) ID() string {
17332 return "OperationDeserializer"
17333 }
17334
17335 func (m *awsAwsjson11_deserializeOpRebootRelationalDatabase) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
17336 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
17337 ) {
17338 out, metadata, err = next.HandleDeserialize(ctx, in)
17339 if err != nil {
17340 return out, metadata, err
17341 }
17342
17343 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
17344 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
17345 defer endTimer()
17346 defer span.End()
17347 response, ok := out.RawResponse.(*smithyhttp.Response)
17348 if !ok {
17349 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
17350 }
17351
17352 if response.StatusCode < 200 || response.StatusCode >= 300 {
17353 return out, metadata, awsAwsjson11_deserializeOpErrorRebootRelationalDatabase(response, &metadata)
17354 }
17355 output := &RebootRelationalDatabaseOutput{}
17356 out.Result = output
17357
17358 var buff [1024]byte
17359 ringBuffer := smithyio.NewRingBuffer(buff[:])
17360
17361 body := io.TeeReader(response.Body, ringBuffer)
17362 decoder := json.NewDecoder(body)
17363 decoder.UseNumber()
17364 var shape interface{}
17365 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
17366 var snapshot bytes.Buffer
17367 io.Copy(&snapshot, ringBuffer)
17368 err = &smithy.DeserializationError{
17369 Err: fmt.Errorf("failed to decode response body, %w", err),
17370 Snapshot: snapshot.Bytes(),
17371 }
17372 return out, metadata, err
17373 }
17374
17375 err = awsAwsjson11_deserializeOpDocumentRebootRelationalDatabaseOutput(&output, shape)
17376 if err != nil {
17377 var snapshot bytes.Buffer
17378 io.Copy(&snapshot, ringBuffer)
17379 err = &smithy.DeserializationError{
17380 Err: fmt.Errorf("failed to decode response body, %w", err),
17381 Snapshot: snapshot.Bytes(),
17382 }
17383 return out, metadata, err
17384 }
17385
17386 return out, metadata, err
17387 }
17388
17389 func awsAwsjson11_deserializeOpErrorRebootRelationalDatabase(response *smithyhttp.Response, metadata *middleware.Metadata) error {
17390 var errorBuffer bytes.Buffer
17391 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
17392 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
17393 }
17394 errorBody := bytes.NewReader(errorBuffer.Bytes())
17395
17396 errorCode := "UnknownError"
17397 errorMessage := errorCode
17398
17399 headerCode := response.Header.Get("X-Amzn-ErrorType")
17400
17401 var buff [1024]byte
17402 ringBuffer := smithyio.NewRingBuffer(buff[:])
17403
17404 body := io.TeeReader(errorBody, ringBuffer)
17405 decoder := json.NewDecoder(body)
17406 decoder.UseNumber()
17407 bodyInfo, err := getProtocolErrorInfo(decoder)
17408 if err != nil {
17409 var snapshot bytes.Buffer
17410 io.Copy(&snapshot, ringBuffer)
17411 err = &smithy.DeserializationError{
17412 Err: fmt.Errorf("failed to decode response body, %w", err),
17413 Snapshot: snapshot.Bytes(),
17414 }
17415 return err
17416 }
17417
17418 errorBody.Seek(0, io.SeekStart)
17419 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
17420 errorCode = restjson.SanitizeErrorCode(typ)
17421 }
17422 if len(bodyInfo.Message) != 0 {
17423 errorMessage = bodyInfo.Message
17424 }
17425 switch {
17426 case strings.EqualFold("AccessDeniedException", errorCode):
17427 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
17428
17429 case strings.EqualFold("AccountSetupInProgressException", errorCode):
17430 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
17431
17432 case strings.EqualFold("InvalidInputException", errorCode):
17433 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
17434
17435 case strings.EqualFold("NotFoundException", errorCode):
17436 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
17437
17438 case strings.EqualFold("OperationFailureException", errorCode):
17439 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
17440
17441 case strings.EqualFold("RegionSetupInProgressException", errorCode):
17442 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
17443
17444 case strings.EqualFold("ServiceException", errorCode):
17445 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
17446
17447 case strings.EqualFold("UnauthenticatedException", errorCode):
17448 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
17449
17450 default:
17451 genericError := &smithy.GenericAPIError{
17452 Code: errorCode,
17453 Message: errorMessage,
17454 }
17455 return genericError
17456
17457 }
17458 }
17459
17460 type awsAwsjson11_deserializeOpRegisterContainerImage struct {
17461 }
17462
17463 func (*awsAwsjson11_deserializeOpRegisterContainerImage) ID() string {
17464 return "OperationDeserializer"
17465 }
17466
17467 func (m *awsAwsjson11_deserializeOpRegisterContainerImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
17468 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
17469 ) {
17470 out, metadata, err = next.HandleDeserialize(ctx, in)
17471 if err != nil {
17472 return out, metadata, err
17473 }
17474
17475 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
17476 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
17477 defer endTimer()
17478 defer span.End()
17479 response, ok := out.RawResponse.(*smithyhttp.Response)
17480 if !ok {
17481 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
17482 }
17483
17484 if response.StatusCode < 200 || response.StatusCode >= 300 {
17485 return out, metadata, awsAwsjson11_deserializeOpErrorRegisterContainerImage(response, &metadata)
17486 }
17487 output := &RegisterContainerImageOutput{}
17488 out.Result = output
17489
17490 var buff [1024]byte
17491 ringBuffer := smithyio.NewRingBuffer(buff[:])
17492
17493 body := io.TeeReader(response.Body, ringBuffer)
17494 decoder := json.NewDecoder(body)
17495 decoder.UseNumber()
17496 var shape interface{}
17497 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
17498 var snapshot bytes.Buffer
17499 io.Copy(&snapshot, ringBuffer)
17500 err = &smithy.DeserializationError{
17501 Err: fmt.Errorf("failed to decode response body, %w", err),
17502 Snapshot: snapshot.Bytes(),
17503 }
17504 return out, metadata, err
17505 }
17506
17507 err = awsAwsjson11_deserializeOpDocumentRegisterContainerImageOutput(&output, shape)
17508 if err != nil {
17509 var snapshot bytes.Buffer
17510 io.Copy(&snapshot, ringBuffer)
17511 err = &smithy.DeserializationError{
17512 Err: fmt.Errorf("failed to decode response body, %w", err),
17513 Snapshot: snapshot.Bytes(),
17514 }
17515 return out, metadata, err
17516 }
17517
17518 return out, metadata, err
17519 }
17520
17521 func awsAwsjson11_deserializeOpErrorRegisterContainerImage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
17522 var errorBuffer bytes.Buffer
17523 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
17524 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
17525 }
17526 errorBody := bytes.NewReader(errorBuffer.Bytes())
17527
17528 errorCode := "UnknownError"
17529 errorMessage := errorCode
17530
17531 headerCode := response.Header.Get("X-Amzn-ErrorType")
17532
17533 var buff [1024]byte
17534 ringBuffer := smithyio.NewRingBuffer(buff[:])
17535
17536 body := io.TeeReader(errorBody, ringBuffer)
17537 decoder := json.NewDecoder(body)
17538 decoder.UseNumber()
17539 bodyInfo, err := getProtocolErrorInfo(decoder)
17540 if err != nil {
17541 var snapshot bytes.Buffer
17542 io.Copy(&snapshot, ringBuffer)
17543 err = &smithy.DeserializationError{
17544 Err: fmt.Errorf("failed to decode response body, %w", err),
17545 Snapshot: snapshot.Bytes(),
17546 }
17547 return err
17548 }
17549
17550 errorBody.Seek(0, io.SeekStart)
17551 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
17552 errorCode = restjson.SanitizeErrorCode(typ)
17553 }
17554 if len(bodyInfo.Message) != 0 {
17555 errorMessage = bodyInfo.Message
17556 }
17557 switch {
17558 case strings.EqualFold("AccessDeniedException", errorCode):
17559 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
17560
17561 case strings.EqualFold("InvalidInputException", errorCode):
17562 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
17563
17564 case strings.EqualFold("NotFoundException", errorCode):
17565 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
17566
17567 case strings.EqualFold("RegionSetupInProgressException", errorCode):
17568 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
17569
17570 case strings.EqualFold("ServiceException", errorCode):
17571 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
17572
17573 case strings.EqualFold("UnauthenticatedException", errorCode):
17574 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
17575
17576 default:
17577 genericError := &smithy.GenericAPIError{
17578 Code: errorCode,
17579 Message: errorMessage,
17580 }
17581 return genericError
17582
17583 }
17584 }
17585
17586 type awsAwsjson11_deserializeOpReleaseStaticIp struct {
17587 }
17588
17589 func (*awsAwsjson11_deserializeOpReleaseStaticIp) ID() string {
17590 return "OperationDeserializer"
17591 }
17592
17593 func (m *awsAwsjson11_deserializeOpReleaseStaticIp) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
17594 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
17595 ) {
17596 out, metadata, err = next.HandleDeserialize(ctx, in)
17597 if err != nil {
17598 return out, metadata, err
17599 }
17600
17601 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
17602 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
17603 defer endTimer()
17604 defer span.End()
17605 response, ok := out.RawResponse.(*smithyhttp.Response)
17606 if !ok {
17607 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
17608 }
17609
17610 if response.StatusCode < 200 || response.StatusCode >= 300 {
17611 return out, metadata, awsAwsjson11_deserializeOpErrorReleaseStaticIp(response, &metadata)
17612 }
17613 output := &ReleaseStaticIpOutput{}
17614 out.Result = output
17615
17616 var buff [1024]byte
17617 ringBuffer := smithyio.NewRingBuffer(buff[:])
17618
17619 body := io.TeeReader(response.Body, ringBuffer)
17620 decoder := json.NewDecoder(body)
17621 decoder.UseNumber()
17622 var shape interface{}
17623 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
17624 var snapshot bytes.Buffer
17625 io.Copy(&snapshot, ringBuffer)
17626 err = &smithy.DeserializationError{
17627 Err: fmt.Errorf("failed to decode response body, %w", err),
17628 Snapshot: snapshot.Bytes(),
17629 }
17630 return out, metadata, err
17631 }
17632
17633 err = awsAwsjson11_deserializeOpDocumentReleaseStaticIpOutput(&output, shape)
17634 if err != nil {
17635 var snapshot bytes.Buffer
17636 io.Copy(&snapshot, ringBuffer)
17637 err = &smithy.DeserializationError{
17638 Err: fmt.Errorf("failed to decode response body, %w", err),
17639 Snapshot: snapshot.Bytes(),
17640 }
17641 return out, metadata, err
17642 }
17643
17644 return out, metadata, err
17645 }
17646
17647 func awsAwsjson11_deserializeOpErrorReleaseStaticIp(response *smithyhttp.Response, metadata *middleware.Metadata) error {
17648 var errorBuffer bytes.Buffer
17649 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
17650 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
17651 }
17652 errorBody := bytes.NewReader(errorBuffer.Bytes())
17653
17654 errorCode := "UnknownError"
17655 errorMessage := errorCode
17656
17657 headerCode := response.Header.Get("X-Amzn-ErrorType")
17658
17659 var buff [1024]byte
17660 ringBuffer := smithyio.NewRingBuffer(buff[:])
17661
17662 body := io.TeeReader(errorBody, ringBuffer)
17663 decoder := json.NewDecoder(body)
17664 decoder.UseNumber()
17665 bodyInfo, err := getProtocolErrorInfo(decoder)
17666 if err != nil {
17667 var snapshot bytes.Buffer
17668 io.Copy(&snapshot, ringBuffer)
17669 err = &smithy.DeserializationError{
17670 Err: fmt.Errorf("failed to decode response body, %w", err),
17671 Snapshot: snapshot.Bytes(),
17672 }
17673 return err
17674 }
17675
17676 errorBody.Seek(0, io.SeekStart)
17677 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
17678 errorCode = restjson.SanitizeErrorCode(typ)
17679 }
17680 if len(bodyInfo.Message) != 0 {
17681 errorMessage = bodyInfo.Message
17682 }
17683 switch {
17684 case strings.EqualFold("AccessDeniedException", errorCode):
17685 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
17686
17687 case strings.EqualFold("AccountSetupInProgressException", errorCode):
17688 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
17689
17690 case strings.EqualFold("InvalidInputException", errorCode):
17691 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
17692
17693 case strings.EqualFold("NotFoundException", errorCode):
17694 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
17695
17696 case strings.EqualFold("OperationFailureException", errorCode):
17697 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
17698
17699 case strings.EqualFold("RegionSetupInProgressException", errorCode):
17700 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
17701
17702 case strings.EqualFold("ServiceException", errorCode):
17703 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
17704
17705 case strings.EqualFold("UnauthenticatedException", errorCode):
17706 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
17707
17708 default:
17709 genericError := &smithy.GenericAPIError{
17710 Code: errorCode,
17711 Message: errorMessage,
17712 }
17713 return genericError
17714
17715 }
17716 }
17717
17718 type awsAwsjson11_deserializeOpResetDistributionCache struct {
17719 }
17720
17721 func (*awsAwsjson11_deserializeOpResetDistributionCache) ID() string {
17722 return "OperationDeserializer"
17723 }
17724
17725 func (m *awsAwsjson11_deserializeOpResetDistributionCache) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
17726 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
17727 ) {
17728 out, metadata, err = next.HandleDeserialize(ctx, in)
17729 if err != nil {
17730 return out, metadata, err
17731 }
17732
17733 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
17734 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
17735 defer endTimer()
17736 defer span.End()
17737 response, ok := out.RawResponse.(*smithyhttp.Response)
17738 if !ok {
17739 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
17740 }
17741
17742 if response.StatusCode < 200 || response.StatusCode >= 300 {
17743 return out, metadata, awsAwsjson11_deserializeOpErrorResetDistributionCache(response, &metadata)
17744 }
17745 output := &ResetDistributionCacheOutput{}
17746 out.Result = output
17747
17748 var buff [1024]byte
17749 ringBuffer := smithyio.NewRingBuffer(buff[:])
17750
17751 body := io.TeeReader(response.Body, ringBuffer)
17752 decoder := json.NewDecoder(body)
17753 decoder.UseNumber()
17754 var shape interface{}
17755 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
17756 var snapshot bytes.Buffer
17757 io.Copy(&snapshot, ringBuffer)
17758 err = &smithy.DeserializationError{
17759 Err: fmt.Errorf("failed to decode response body, %w", err),
17760 Snapshot: snapshot.Bytes(),
17761 }
17762 return out, metadata, err
17763 }
17764
17765 err = awsAwsjson11_deserializeOpDocumentResetDistributionCacheOutput(&output, shape)
17766 if err != nil {
17767 var snapshot bytes.Buffer
17768 io.Copy(&snapshot, ringBuffer)
17769 err = &smithy.DeserializationError{
17770 Err: fmt.Errorf("failed to decode response body, %w", err),
17771 Snapshot: snapshot.Bytes(),
17772 }
17773 return out, metadata, err
17774 }
17775
17776 return out, metadata, err
17777 }
17778
17779 func awsAwsjson11_deserializeOpErrorResetDistributionCache(response *smithyhttp.Response, metadata *middleware.Metadata) error {
17780 var errorBuffer bytes.Buffer
17781 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
17782 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
17783 }
17784 errorBody := bytes.NewReader(errorBuffer.Bytes())
17785
17786 errorCode := "UnknownError"
17787 errorMessage := errorCode
17788
17789 headerCode := response.Header.Get("X-Amzn-ErrorType")
17790
17791 var buff [1024]byte
17792 ringBuffer := smithyio.NewRingBuffer(buff[:])
17793
17794 body := io.TeeReader(errorBody, ringBuffer)
17795 decoder := json.NewDecoder(body)
17796 decoder.UseNumber()
17797 bodyInfo, err := getProtocolErrorInfo(decoder)
17798 if err != nil {
17799 var snapshot bytes.Buffer
17800 io.Copy(&snapshot, ringBuffer)
17801 err = &smithy.DeserializationError{
17802 Err: fmt.Errorf("failed to decode response body, %w", err),
17803 Snapshot: snapshot.Bytes(),
17804 }
17805 return err
17806 }
17807
17808 errorBody.Seek(0, io.SeekStart)
17809 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
17810 errorCode = restjson.SanitizeErrorCode(typ)
17811 }
17812 if len(bodyInfo.Message) != 0 {
17813 errorMessage = bodyInfo.Message
17814 }
17815 switch {
17816 case strings.EqualFold("AccessDeniedException", errorCode):
17817 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
17818
17819 case strings.EqualFold("InvalidInputException", errorCode):
17820 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
17821
17822 case strings.EqualFold("NotFoundException", errorCode):
17823 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
17824
17825 case strings.EqualFold("OperationFailureException", errorCode):
17826 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
17827
17828 case strings.EqualFold("ServiceException", errorCode):
17829 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
17830
17831 case strings.EqualFold("UnauthenticatedException", errorCode):
17832 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
17833
17834 default:
17835 genericError := &smithy.GenericAPIError{
17836 Code: errorCode,
17837 Message: errorMessage,
17838 }
17839 return genericError
17840
17841 }
17842 }
17843
17844 type awsAwsjson11_deserializeOpSendContactMethodVerification struct {
17845 }
17846
17847 func (*awsAwsjson11_deserializeOpSendContactMethodVerification) ID() string {
17848 return "OperationDeserializer"
17849 }
17850
17851 func (m *awsAwsjson11_deserializeOpSendContactMethodVerification) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
17852 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
17853 ) {
17854 out, metadata, err = next.HandleDeserialize(ctx, in)
17855 if err != nil {
17856 return out, metadata, err
17857 }
17858
17859 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
17860 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
17861 defer endTimer()
17862 defer span.End()
17863 response, ok := out.RawResponse.(*smithyhttp.Response)
17864 if !ok {
17865 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
17866 }
17867
17868 if response.StatusCode < 200 || response.StatusCode >= 300 {
17869 return out, metadata, awsAwsjson11_deserializeOpErrorSendContactMethodVerification(response, &metadata)
17870 }
17871 output := &SendContactMethodVerificationOutput{}
17872 out.Result = output
17873
17874 var buff [1024]byte
17875 ringBuffer := smithyio.NewRingBuffer(buff[:])
17876
17877 body := io.TeeReader(response.Body, ringBuffer)
17878 decoder := json.NewDecoder(body)
17879 decoder.UseNumber()
17880 var shape interface{}
17881 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
17882 var snapshot bytes.Buffer
17883 io.Copy(&snapshot, ringBuffer)
17884 err = &smithy.DeserializationError{
17885 Err: fmt.Errorf("failed to decode response body, %w", err),
17886 Snapshot: snapshot.Bytes(),
17887 }
17888 return out, metadata, err
17889 }
17890
17891 err = awsAwsjson11_deserializeOpDocumentSendContactMethodVerificationOutput(&output, shape)
17892 if err != nil {
17893 var snapshot bytes.Buffer
17894 io.Copy(&snapshot, ringBuffer)
17895 err = &smithy.DeserializationError{
17896 Err: fmt.Errorf("failed to decode response body, %w", err),
17897 Snapshot: snapshot.Bytes(),
17898 }
17899 return out, metadata, err
17900 }
17901
17902 return out, metadata, err
17903 }
17904
17905 func awsAwsjson11_deserializeOpErrorSendContactMethodVerification(response *smithyhttp.Response, metadata *middleware.Metadata) error {
17906 var errorBuffer bytes.Buffer
17907 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
17908 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
17909 }
17910 errorBody := bytes.NewReader(errorBuffer.Bytes())
17911
17912 errorCode := "UnknownError"
17913 errorMessage := errorCode
17914
17915 headerCode := response.Header.Get("X-Amzn-ErrorType")
17916
17917 var buff [1024]byte
17918 ringBuffer := smithyio.NewRingBuffer(buff[:])
17919
17920 body := io.TeeReader(errorBody, ringBuffer)
17921 decoder := json.NewDecoder(body)
17922 decoder.UseNumber()
17923 bodyInfo, err := getProtocolErrorInfo(decoder)
17924 if err != nil {
17925 var snapshot bytes.Buffer
17926 io.Copy(&snapshot, ringBuffer)
17927 err = &smithy.DeserializationError{
17928 Err: fmt.Errorf("failed to decode response body, %w", err),
17929 Snapshot: snapshot.Bytes(),
17930 }
17931 return err
17932 }
17933
17934 errorBody.Seek(0, io.SeekStart)
17935 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
17936 errorCode = restjson.SanitizeErrorCode(typ)
17937 }
17938 if len(bodyInfo.Message) != 0 {
17939 errorMessage = bodyInfo.Message
17940 }
17941 switch {
17942 case strings.EqualFold("AccessDeniedException", errorCode):
17943 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
17944
17945 case strings.EqualFold("InvalidInputException", errorCode):
17946 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
17947
17948 case strings.EqualFold("NotFoundException", errorCode):
17949 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
17950
17951 case strings.EqualFold("OperationFailureException", errorCode):
17952 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
17953
17954 case strings.EqualFold("RegionSetupInProgressException", errorCode):
17955 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
17956
17957 case strings.EqualFold("ServiceException", errorCode):
17958 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
17959
17960 case strings.EqualFold("UnauthenticatedException", errorCode):
17961 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
17962
17963 default:
17964 genericError := &smithy.GenericAPIError{
17965 Code: errorCode,
17966 Message: errorMessage,
17967 }
17968 return genericError
17969
17970 }
17971 }
17972
17973 type awsAwsjson11_deserializeOpSetIpAddressType struct {
17974 }
17975
17976 func (*awsAwsjson11_deserializeOpSetIpAddressType) ID() string {
17977 return "OperationDeserializer"
17978 }
17979
17980 func (m *awsAwsjson11_deserializeOpSetIpAddressType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
17981 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
17982 ) {
17983 out, metadata, err = next.HandleDeserialize(ctx, in)
17984 if err != nil {
17985 return out, metadata, err
17986 }
17987
17988 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
17989 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
17990 defer endTimer()
17991 defer span.End()
17992 response, ok := out.RawResponse.(*smithyhttp.Response)
17993 if !ok {
17994 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
17995 }
17996
17997 if response.StatusCode < 200 || response.StatusCode >= 300 {
17998 return out, metadata, awsAwsjson11_deserializeOpErrorSetIpAddressType(response, &metadata)
17999 }
18000 output := &SetIpAddressTypeOutput{}
18001 out.Result = output
18002
18003 var buff [1024]byte
18004 ringBuffer := smithyio.NewRingBuffer(buff[:])
18005
18006 body := io.TeeReader(response.Body, ringBuffer)
18007 decoder := json.NewDecoder(body)
18008 decoder.UseNumber()
18009 var shape interface{}
18010 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
18011 var snapshot bytes.Buffer
18012 io.Copy(&snapshot, ringBuffer)
18013 err = &smithy.DeserializationError{
18014 Err: fmt.Errorf("failed to decode response body, %w", err),
18015 Snapshot: snapshot.Bytes(),
18016 }
18017 return out, metadata, err
18018 }
18019
18020 err = awsAwsjson11_deserializeOpDocumentSetIpAddressTypeOutput(&output, shape)
18021 if err != nil {
18022 var snapshot bytes.Buffer
18023 io.Copy(&snapshot, ringBuffer)
18024 err = &smithy.DeserializationError{
18025 Err: fmt.Errorf("failed to decode response body, %w", err),
18026 Snapshot: snapshot.Bytes(),
18027 }
18028 return out, metadata, err
18029 }
18030
18031 return out, metadata, err
18032 }
18033
18034 func awsAwsjson11_deserializeOpErrorSetIpAddressType(response *smithyhttp.Response, metadata *middleware.Metadata) error {
18035 var errorBuffer bytes.Buffer
18036 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
18037 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
18038 }
18039 errorBody := bytes.NewReader(errorBuffer.Bytes())
18040
18041 errorCode := "UnknownError"
18042 errorMessage := errorCode
18043
18044 headerCode := response.Header.Get("X-Amzn-ErrorType")
18045
18046 var buff [1024]byte
18047 ringBuffer := smithyio.NewRingBuffer(buff[:])
18048
18049 body := io.TeeReader(errorBody, ringBuffer)
18050 decoder := json.NewDecoder(body)
18051 decoder.UseNumber()
18052 bodyInfo, err := getProtocolErrorInfo(decoder)
18053 if err != nil {
18054 var snapshot bytes.Buffer
18055 io.Copy(&snapshot, ringBuffer)
18056 err = &smithy.DeserializationError{
18057 Err: fmt.Errorf("failed to decode response body, %w", err),
18058 Snapshot: snapshot.Bytes(),
18059 }
18060 return err
18061 }
18062
18063 errorBody.Seek(0, io.SeekStart)
18064 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
18065 errorCode = restjson.SanitizeErrorCode(typ)
18066 }
18067 if len(bodyInfo.Message) != 0 {
18068 errorMessage = bodyInfo.Message
18069 }
18070 switch {
18071 case strings.EqualFold("AccessDeniedException", errorCode):
18072 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
18073
18074 case strings.EqualFold("AccountSetupInProgressException", errorCode):
18075 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
18076
18077 case strings.EqualFold("InvalidInputException", errorCode):
18078 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
18079
18080 case strings.EqualFold("NotFoundException", errorCode):
18081 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
18082
18083 case strings.EqualFold("OperationFailureException", errorCode):
18084 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
18085
18086 case strings.EqualFold("RegionSetupInProgressException", errorCode):
18087 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
18088
18089 case strings.EqualFold("ServiceException", errorCode):
18090 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
18091
18092 case strings.EqualFold("UnauthenticatedException", errorCode):
18093 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
18094
18095 default:
18096 genericError := &smithy.GenericAPIError{
18097 Code: errorCode,
18098 Message: errorMessage,
18099 }
18100 return genericError
18101
18102 }
18103 }
18104
18105 type awsAwsjson11_deserializeOpSetResourceAccessForBucket struct {
18106 }
18107
18108 func (*awsAwsjson11_deserializeOpSetResourceAccessForBucket) ID() string {
18109 return "OperationDeserializer"
18110 }
18111
18112 func (m *awsAwsjson11_deserializeOpSetResourceAccessForBucket) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
18113 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
18114 ) {
18115 out, metadata, err = next.HandleDeserialize(ctx, in)
18116 if err != nil {
18117 return out, metadata, err
18118 }
18119
18120 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
18121 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
18122 defer endTimer()
18123 defer span.End()
18124 response, ok := out.RawResponse.(*smithyhttp.Response)
18125 if !ok {
18126 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
18127 }
18128
18129 if response.StatusCode < 200 || response.StatusCode >= 300 {
18130 return out, metadata, awsAwsjson11_deserializeOpErrorSetResourceAccessForBucket(response, &metadata)
18131 }
18132 output := &SetResourceAccessForBucketOutput{}
18133 out.Result = output
18134
18135 var buff [1024]byte
18136 ringBuffer := smithyio.NewRingBuffer(buff[:])
18137
18138 body := io.TeeReader(response.Body, ringBuffer)
18139 decoder := json.NewDecoder(body)
18140 decoder.UseNumber()
18141 var shape interface{}
18142 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
18143 var snapshot bytes.Buffer
18144 io.Copy(&snapshot, ringBuffer)
18145 err = &smithy.DeserializationError{
18146 Err: fmt.Errorf("failed to decode response body, %w", err),
18147 Snapshot: snapshot.Bytes(),
18148 }
18149 return out, metadata, err
18150 }
18151
18152 err = awsAwsjson11_deserializeOpDocumentSetResourceAccessForBucketOutput(&output, shape)
18153 if err != nil {
18154 var snapshot bytes.Buffer
18155 io.Copy(&snapshot, ringBuffer)
18156 err = &smithy.DeserializationError{
18157 Err: fmt.Errorf("failed to decode response body, %w", err),
18158 Snapshot: snapshot.Bytes(),
18159 }
18160 return out, metadata, err
18161 }
18162
18163 return out, metadata, err
18164 }
18165
18166 func awsAwsjson11_deserializeOpErrorSetResourceAccessForBucket(response *smithyhttp.Response, metadata *middleware.Metadata) error {
18167 var errorBuffer bytes.Buffer
18168 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
18169 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
18170 }
18171 errorBody := bytes.NewReader(errorBuffer.Bytes())
18172
18173 errorCode := "UnknownError"
18174 errorMessage := errorCode
18175
18176 headerCode := response.Header.Get("X-Amzn-ErrorType")
18177
18178 var buff [1024]byte
18179 ringBuffer := smithyio.NewRingBuffer(buff[:])
18180
18181 body := io.TeeReader(errorBody, ringBuffer)
18182 decoder := json.NewDecoder(body)
18183 decoder.UseNumber()
18184 bodyInfo, err := getProtocolErrorInfo(decoder)
18185 if err != nil {
18186 var snapshot bytes.Buffer
18187 io.Copy(&snapshot, ringBuffer)
18188 err = &smithy.DeserializationError{
18189 Err: fmt.Errorf("failed to decode response body, %w", err),
18190 Snapshot: snapshot.Bytes(),
18191 }
18192 return err
18193 }
18194
18195 errorBody.Seek(0, io.SeekStart)
18196 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
18197 errorCode = restjson.SanitizeErrorCode(typ)
18198 }
18199 if len(bodyInfo.Message) != 0 {
18200 errorMessage = bodyInfo.Message
18201 }
18202 switch {
18203 case strings.EqualFold("AccessDeniedException", errorCode):
18204 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
18205
18206 case strings.EqualFold("InvalidInputException", errorCode):
18207 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
18208
18209 case strings.EqualFold("NotFoundException", errorCode):
18210 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
18211
18212 case strings.EqualFold("RegionSetupInProgressException", errorCode):
18213 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
18214
18215 case strings.EqualFold("ServiceException", errorCode):
18216 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
18217
18218 case strings.EqualFold("UnauthenticatedException", errorCode):
18219 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
18220
18221 default:
18222 genericError := &smithy.GenericAPIError{
18223 Code: errorCode,
18224 Message: errorMessage,
18225 }
18226 return genericError
18227
18228 }
18229 }
18230
18231 type awsAwsjson11_deserializeOpSetupInstanceHttps struct {
18232 }
18233
18234 func (*awsAwsjson11_deserializeOpSetupInstanceHttps) ID() string {
18235 return "OperationDeserializer"
18236 }
18237
18238 func (m *awsAwsjson11_deserializeOpSetupInstanceHttps) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
18239 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
18240 ) {
18241 out, metadata, err = next.HandleDeserialize(ctx, in)
18242 if err != nil {
18243 return out, metadata, err
18244 }
18245
18246 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
18247 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
18248 defer endTimer()
18249 defer span.End()
18250 response, ok := out.RawResponse.(*smithyhttp.Response)
18251 if !ok {
18252 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
18253 }
18254
18255 if response.StatusCode < 200 || response.StatusCode >= 300 {
18256 return out, metadata, awsAwsjson11_deserializeOpErrorSetupInstanceHttps(response, &metadata)
18257 }
18258 output := &SetupInstanceHttpsOutput{}
18259 out.Result = output
18260
18261 var buff [1024]byte
18262 ringBuffer := smithyio.NewRingBuffer(buff[:])
18263
18264 body := io.TeeReader(response.Body, ringBuffer)
18265 decoder := json.NewDecoder(body)
18266 decoder.UseNumber()
18267 var shape interface{}
18268 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
18269 var snapshot bytes.Buffer
18270 io.Copy(&snapshot, ringBuffer)
18271 err = &smithy.DeserializationError{
18272 Err: fmt.Errorf("failed to decode response body, %w", err),
18273 Snapshot: snapshot.Bytes(),
18274 }
18275 return out, metadata, err
18276 }
18277
18278 err = awsAwsjson11_deserializeOpDocumentSetupInstanceHttpsOutput(&output, shape)
18279 if err != nil {
18280 var snapshot bytes.Buffer
18281 io.Copy(&snapshot, ringBuffer)
18282 err = &smithy.DeserializationError{
18283 Err: fmt.Errorf("failed to decode response body, %w", err),
18284 Snapshot: snapshot.Bytes(),
18285 }
18286 return out, metadata, err
18287 }
18288
18289 return out, metadata, err
18290 }
18291
18292 func awsAwsjson11_deserializeOpErrorSetupInstanceHttps(response *smithyhttp.Response, metadata *middleware.Metadata) error {
18293 var errorBuffer bytes.Buffer
18294 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
18295 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
18296 }
18297 errorBody := bytes.NewReader(errorBuffer.Bytes())
18298
18299 errorCode := "UnknownError"
18300 errorMessage := errorCode
18301
18302 headerCode := response.Header.Get("X-Amzn-ErrorType")
18303
18304 var buff [1024]byte
18305 ringBuffer := smithyio.NewRingBuffer(buff[:])
18306
18307 body := io.TeeReader(errorBody, ringBuffer)
18308 decoder := json.NewDecoder(body)
18309 decoder.UseNumber()
18310 bodyInfo, err := getProtocolErrorInfo(decoder)
18311 if err != nil {
18312 var snapshot bytes.Buffer
18313 io.Copy(&snapshot, ringBuffer)
18314 err = &smithy.DeserializationError{
18315 Err: fmt.Errorf("failed to decode response body, %w", err),
18316 Snapshot: snapshot.Bytes(),
18317 }
18318 return err
18319 }
18320
18321 errorBody.Seek(0, io.SeekStart)
18322 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
18323 errorCode = restjson.SanitizeErrorCode(typ)
18324 }
18325 if len(bodyInfo.Message) != 0 {
18326 errorMessage = bodyInfo.Message
18327 }
18328 switch {
18329 case strings.EqualFold("AccessDeniedException", errorCode):
18330 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
18331
18332 case strings.EqualFold("InvalidInputException", errorCode):
18333 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
18334
18335 case strings.EqualFold("NotFoundException", errorCode):
18336 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
18337
18338 case strings.EqualFold("RegionSetupInProgressException", errorCode):
18339 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
18340
18341 case strings.EqualFold("ServiceException", errorCode):
18342 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
18343
18344 case strings.EqualFold("UnauthenticatedException", errorCode):
18345 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
18346
18347 default:
18348 genericError := &smithy.GenericAPIError{
18349 Code: errorCode,
18350 Message: errorMessage,
18351 }
18352 return genericError
18353
18354 }
18355 }
18356
18357 type awsAwsjson11_deserializeOpStartGUISession struct {
18358 }
18359
18360 func (*awsAwsjson11_deserializeOpStartGUISession) ID() string {
18361 return "OperationDeserializer"
18362 }
18363
18364 func (m *awsAwsjson11_deserializeOpStartGUISession) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
18365 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
18366 ) {
18367 out, metadata, err = next.HandleDeserialize(ctx, in)
18368 if err != nil {
18369 return out, metadata, err
18370 }
18371
18372 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
18373 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
18374 defer endTimer()
18375 defer span.End()
18376 response, ok := out.RawResponse.(*smithyhttp.Response)
18377 if !ok {
18378 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
18379 }
18380
18381 if response.StatusCode < 200 || response.StatusCode >= 300 {
18382 return out, metadata, awsAwsjson11_deserializeOpErrorStartGUISession(response, &metadata)
18383 }
18384 output := &StartGUISessionOutput{}
18385 out.Result = output
18386
18387 var buff [1024]byte
18388 ringBuffer := smithyio.NewRingBuffer(buff[:])
18389
18390 body := io.TeeReader(response.Body, ringBuffer)
18391 decoder := json.NewDecoder(body)
18392 decoder.UseNumber()
18393 var shape interface{}
18394 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
18395 var snapshot bytes.Buffer
18396 io.Copy(&snapshot, ringBuffer)
18397 err = &smithy.DeserializationError{
18398 Err: fmt.Errorf("failed to decode response body, %w", err),
18399 Snapshot: snapshot.Bytes(),
18400 }
18401 return out, metadata, err
18402 }
18403
18404 err = awsAwsjson11_deserializeOpDocumentStartGUISessionOutput(&output, shape)
18405 if err != nil {
18406 var snapshot bytes.Buffer
18407 io.Copy(&snapshot, ringBuffer)
18408 err = &smithy.DeserializationError{
18409 Err: fmt.Errorf("failed to decode response body, %w", err),
18410 Snapshot: snapshot.Bytes(),
18411 }
18412 return out, metadata, err
18413 }
18414
18415 return out, metadata, err
18416 }
18417
18418 func awsAwsjson11_deserializeOpErrorStartGUISession(response *smithyhttp.Response, metadata *middleware.Metadata) error {
18419 var errorBuffer bytes.Buffer
18420 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
18421 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
18422 }
18423 errorBody := bytes.NewReader(errorBuffer.Bytes())
18424
18425 errorCode := "UnknownError"
18426 errorMessage := errorCode
18427
18428 headerCode := response.Header.Get("X-Amzn-ErrorType")
18429
18430 var buff [1024]byte
18431 ringBuffer := smithyio.NewRingBuffer(buff[:])
18432
18433 body := io.TeeReader(errorBody, ringBuffer)
18434 decoder := json.NewDecoder(body)
18435 decoder.UseNumber()
18436 bodyInfo, err := getProtocolErrorInfo(decoder)
18437 if err != nil {
18438 var snapshot bytes.Buffer
18439 io.Copy(&snapshot, ringBuffer)
18440 err = &smithy.DeserializationError{
18441 Err: fmt.Errorf("failed to decode response body, %w", err),
18442 Snapshot: snapshot.Bytes(),
18443 }
18444 return err
18445 }
18446
18447 errorBody.Seek(0, io.SeekStart)
18448 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
18449 errorCode = restjson.SanitizeErrorCode(typ)
18450 }
18451 if len(bodyInfo.Message) != 0 {
18452 errorMessage = bodyInfo.Message
18453 }
18454 switch {
18455 case strings.EqualFold("AccessDeniedException", errorCode):
18456 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
18457
18458 case strings.EqualFold("InvalidInputException", errorCode):
18459 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
18460
18461 case strings.EqualFold("NotFoundException", errorCode):
18462 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
18463
18464 case strings.EqualFold("RegionSetupInProgressException", errorCode):
18465 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
18466
18467 case strings.EqualFold("ServiceException", errorCode):
18468 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
18469
18470 case strings.EqualFold("UnauthenticatedException", errorCode):
18471 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
18472
18473 default:
18474 genericError := &smithy.GenericAPIError{
18475 Code: errorCode,
18476 Message: errorMessage,
18477 }
18478 return genericError
18479
18480 }
18481 }
18482
18483 type awsAwsjson11_deserializeOpStartInstance struct {
18484 }
18485
18486 func (*awsAwsjson11_deserializeOpStartInstance) ID() string {
18487 return "OperationDeserializer"
18488 }
18489
18490 func (m *awsAwsjson11_deserializeOpStartInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
18491 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
18492 ) {
18493 out, metadata, err = next.HandleDeserialize(ctx, in)
18494 if err != nil {
18495 return out, metadata, err
18496 }
18497
18498 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
18499 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
18500 defer endTimer()
18501 defer span.End()
18502 response, ok := out.RawResponse.(*smithyhttp.Response)
18503 if !ok {
18504 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
18505 }
18506
18507 if response.StatusCode < 200 || response.StatusCode >= 300 {
18508 return out, metadata, awsAwsjson11_deserializeOpErrorStartInstance(response, &metadata)
18509 }
18510 output := &StartInstanceOutput{}
18511 out.Result = output
18512
18513 var buff [1024]byte
18514 ringBuffer := smithyio.NewRingBuffer(buff[:])
18515
18516 body := io.TeeReader(response.Body, ringBuffer)
18517 decoder := json.NewDecoder(body)
18518 decoder.UseNumber()
18519 var shape interface{}
18520 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
18521 var snapshot bytes.Buffer
18522 io.Copy(&snapshot, ringBuffer)
18523 err = &smithy.DeserializationError{
18524 Err: fmt.Errorf("failed to decode response body, %w", err),
18525 Snapshot: snapshot.Bytes(),
18526 }
18527 return out, metadata, err
18528 }
18529
18530 err = awsAwsjson11_deserializeOpDocumentStartInstanceOutput(&output, shape)
18531 if err != nil {
18532 var snapshot bytes.Buffer
18533 io.Copy(&snapshot, ringBuffer)
18534 err = &smithy.DeserializationError{
18535 Err: fmt.Errorf("failed to decode response body, %w", err),
18536 Snapshot: snapshot.Bytes(),
18537 }
18538 return out, metadata, err
18539 }
18540
18541 return out, metadata, err
18542 }
18543
18544 func awsAwsjson11_deserializeOpErrorStartInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
18545 var errorBuffer bytes.Buffer
18546 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
18547 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
18548 }
18549 errorBody := bytes.NewReader(errorBuffer.Bytes())
18550
18551 errorCode := "UnknownError"
18552 errorMessage := errorCode
18553
18554 headerCode := response.Header.Get("X-Amzn-ErrorType")
18555
18556 var buff [1024]byte
18557 ringBuffer := smithyio.NewRingBuffer(buff[:])
18558
18559 body := io.TeeReader(errorBody, ringBuffer)
18560 decoder := json.NewDecoder(body)
18561 decoder.UseNumber()
18562 bodyInfo, err := getProtocolErrorInfo(decoder)
18563 if err != nil {
18564 var snapshot bytes.Buffer
18565 io.Copy(&snapshot, ringBuffer)
18566 err = &smithy.DeserializationError{
18567 Err: fmt.Errorf("failed to decode response body, %w", err),
18568 Snapshot: snapshot.Bytes(),
18569 }
18570 return err
18571 }
18572
18573 errorBody.Seek(0, io.SeekStart)
18574 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
18575 errorCode = restjson.SanitizeErrorCode(typ)
18576 }
18577 if len(bodyInfo.Message) != 0 {
18578 errorMessage = bodyInfo.Message
18579 }
18580 switch {
18581 case strings.EqualFold("AccessDeniedException", errorCode):
18582 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
18583
18584 case strings.EqualFold("AccountSetupInProgressException", errorCode):
18585 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
18586
18587 case strings.EqualFold("InvalidInputException", errorCode):
18588 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
18589
18590 case strings.EqualFold("NotFoundException", errorCode):
18591 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
18592
18593 case strings.EqualFold("OperationFailureException", errorCode):
18594 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
18595
18596 case strings.EqualFold("RegionSetupInProgressException", errorCode):
18597 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
18598
18599 case strings.EqualFold("ServiceException", errorCode):
18600 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
18601
18602 case strings.EqualFold("UnauthenticatedException", errorCode):
18603 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
18604
18605 default:
18606 genericError := &smithy.GenericAPIError{
18607 Code: errorCode,
18608 Message: errorMessage,
18609 }
18610 return genericError
18611
18612 }
18613 }
18614
18615 type awsAwsjson11_deserializeOpStartRelationalDatabase struct {
18616 }
18617
18618 func (*awsAwsjson11_deserializeOpStartRelationalDatabase) ID() string {
18619 return "OperationDeserializer"
18620 }
18621
18622 func (m *awsAwsjson11_deserializeOpStartRelationalDatabase) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
18623 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
18624 ) {
18625 out, metadata, err = next.HandleDeserialize(ctx, in)
18626 if err != nil {
18627 return out, metadata, err
18628 }
18629
18630 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
18631 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
18632 defer endTimer()
18633 defer span.End()
18634 response, ok := out.RawResponse.(*smithyhttp.Response)
18635 if !ok {
18636 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
18637 }
18638
18639 if response.StatusCode < 200 || response.StatusCode >= 300 {
18640 return out, metadata, awsAwsjson11_deserializeOpErrorStartRelationalDatabase(response, &metadata)
18641 }
18642 output := &StartRelationalDatabaseOutput{}
18643 out.Result = output
18644
18645 var buff [1024]byte
18646 ringBuffer := smithyio.NewRingBuffer(buff[:])
18647
18648 body := io.TeeReader(response.Body, ringBuffer)
18649 decoder := json.NewDecoder(body)
18650 decoder.UseNumber()
18651 var shape interface{}
18652 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
18653 var snapshot bytes.Buffer
18654 io.Copy(&snapshot, ringBuffer)
18655 err = &smithy.DeserializationError{
18656 Err: fmt.Errorf("failed to decode response body, %w", err),
18657 Snapshot: snapshot.Bytes(),
18658 }
18659 return out, metadata, err
18660 }
18661
18662 err = awsAwsjson11_deserializeOpDocumentStartRelationalDatabaseOutput(&output, shape)
18663 if err != nil {
18664 var snapshot bytes.Buffer
18665 io.Copy(&snapshot, ringBuffer)
18666 err = &smithy.DeserializationError{
18667 Err: fmt.Errorf("failed to decode response body, %w", err),
18668 Snapshot: snapshot.Bytes(),
18669 }
18670 return out, metadata, err
18671 }
18672
18673 return out, metadata, err
18674 }
18675
18676 func awsAwsjson11_deserializeOpErrorStartRelationalDatabase(response *smithyhttp.Response, metadata *middleware.Metadata) error {
18677 var errorBuffer bytes.Buffer
18678 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
18679 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
18680 }
18681 errorBody := bytes.NewReader(errorBuffer.Bytes())
18682
18683 errorCode := "UnknownError"
18684 errorMessage := errorCode
18685
18686 headerCode := response.Header.Get("X-Amzn-ErrorType")
18687
18688 var buff [1024]byte
18689 ringBuffer := smithyio.NewRingBuffer(buff[:])
18690
18691 body := io.TeeReader(errorBody, ringBuffer)
18692 decoder := json.NewDecoder(body)
18693 decoder.UseNumber()
18694 bodyInfo, err := getProtocolErrorInfo(decoder)
18695 if err != nil {
18696 var snapshot bytes.Buffer
18697 io.Copy(&snapshot, ringBuffer)
18698 err = &smithy.DeserializationError{
18699 Err: fmt.Errorf("failed to decode response body, %w", err),
18700 Snapshot: snapshot.Bytes(),
18701 }
18702 return err
18703 }
18704
18705 errorBody.Seek(0, io.SeekStart)
18706 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
18707 errorCode = restjson.SanitizeErrorCode(typ)
18708 }
18709 if len(bodyInfo.Message) != 0 {
18710 errorMessage = bodyInfo.Message
18711 }
18712 switch {
18713 case strings.EqualFold("AccessDeniedException", errorCode):
18714 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
18715
18716 case strings.EqualFold("AccountSetupInProgressException", errorCode):
18717 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
18718
18719 case strings.EqualFold("InvalidInputException", errorCode):
18720 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
18721
18722 case strings.EqualFold("NotFoundException", errorCode):
18723 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
18724
18725 case strings.EqualFold("OperationFailureException", errorCode):
18726 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
18727
18728 case strings.EqualFold("RegionSetupInProgressException", errorCode):
18729 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
18730
18731 case strings.EqualFold("ServiceException", errorCode):
18732 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
18733
18734 case strings.EqualFold("UnauthenticatedException", errorCode):
18735 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
18736
18737 default:
18738 genericError := &smithy.GenericAPIError{
18739 Code: errorCode,
18740 Message: errorMessage,
18741 }
18742 return genericError
18743
18744 }
18745 }
18746
18747 type awsAwsjson11_deserializeOpStopGUISession struct {
18748 }
18749
18750 func (*awsAwsjson11_deserializeOpStopGUISession) ID() string {
18751 return "OperationDeserializer"
18752 }
18753
18754 func (m *awsAwsjson11_deserializeOpStopGUISession) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
18755 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
18756 ) {
18757 out, metadata, err = next.HandleDeserialize(ctx, in)
18758 if err != nil {
18759 return out, metadata, err
18760 }
18761
18762 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
18763 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
18764 defer endTimer()
18765 defer span.End()
18766 response, ok := out.RawResponse.(*smithyhttp.Response)
18767 if !ok {
18768 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
18769 }
18770
18771 if response.StatusCode < 200 || response.StatusCode >= 300 {
18772 return out, metadata, awsAwsjson11_deserializeOpErrorStopGUISession(response, &metadata)
18773 }
18774 output := &StopGUISessionOutput{}
18775 out.Result = output
18776
18777 var buff [1024]byte
18778 ringBuffer := smithyio.NewRingBuffer(buff[:])
18779
18780 body := io.TeeReader(response.Body, ringBuffer)
18781 decoder := json.NewDecoder(body)
18782 decoder.UseNumber()
18783 var shape interface{}
18784 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
18785 var snapshot bytes.Buffer
18786 io.Copy(&snapshot, ringBuffer)
18787 err = &smithy.DeserializationError{
18788 Err: fmt.Errorf("failed to decode response body, %w", err),
18789 Snapshot: snapshot.Bytes(),
18790 }
18791 return out, metadata, err
18792 }
18793
18794 err = awsAwsjson11_deserializeOpDocumentStopGUISessionOutput(&output, shape)
18795 if err != nil {
18796 var snapshot bytes.Buffer
18797 io.Copy(&snapshot, ringBuffer)
18798 err = &smithy.DeserializationError{
18799 Err: fmt.Errorf("failed to decode response body, %w", err),
18800 Snapshot: snapshot.Bytes(),
18801 }
18802 return out, metadata, err
18803 }
18804
18805 return out, metadata, err
18806 }
18807
18808 func awsAwsjson11_deserializeOpErrorStopGUISession(response *smithyhttp.Response, metadata *middleware.Metadata) error {
18809 var errorBuffer bytes.Buffer
18810 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
18811 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
18812 }
18813 errorBody := bytes.NewReader(errorBuffer.Bytes())
18814
18815 errorCode := "UnknownError"
18816 errorMessage := errorCode
18817
18818 headerCode := response.Header.Get("X-Amzn-ErrorType")
18819
18820 var buff [1024]byte
18821 ringBuffer := smithyio.NewRingBuffer(buff[:])
18822
18823 body := io.TeeReader(errorBody, ringBuffer)
18824 decoder := json.NewDecoder(body)
18825 decoder.UseNumber()
18826 bodyInfo, err := getProtocolErrorInfo(decoder)
18827 if err != nil {
18828 var snapshot bytes.Buffer
18829 io.Copy(&snapshot, ringBuffer)
18830 err = &smithy.DeserializationError{
18831 Err: fmt.Errorf("failed to decode response body, %w", err),
18832 Snapshot: snapshot.Bytes(),
18833 }
18834 return err
18835 }
18836
18837 errorBody.Seek(0, io.SeekStart)
18838 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
18839 errorCode = restjson.SanitizeErrorCode(typ)
18840 }
18841 if len(bodyInfo.Message) != 0 {
18842 errorMessage = bodyInfo.Message
18843 }
18844 switch {
18845 case strings.EqualFold("AccessDeniedException", errorCode):
18846 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
18847
18848 case strings.EqualFold("InvalidInputException", errorCode):
18849 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
18850
18851 case strings.EqualFold("NotFoundException", errorCode):
18852 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
18853
18854 case strings.EqualFold("RegionSetupInProgressException", errorCode):
18855 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
18856
18857 case strings.EqualFold("ServiceException", errorCode):
18858 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
18859
18860 case strings.EqualFold("UnauthenticatedException", errorCode):
18861 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
18862
18863 default:
18864 genericError := &smithy.GenericAPIError{
18865 Code: errorCode,
18866 Message: errorMessage,
18867 }
18868 return genericError
18869
18870 }
18871 }
18872
18873 type awsAwsjson11_deserializeOpStopInstance struct {
18874 }
18875
18876 func (*awsAwsjson11_deserializeOpStopInstance) ID() string {
18877 return "OperationDeserializer"
18878 }
18879
18880 func (m *awsAwsjson11_deserializeOpStopInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
18881 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
18882 ) {
18883 out, metadata, err = next.HandleDeserialize(ctx, in)
18884 if err != nil {
18885 return out, metadata, err
18886 }
18887
18888 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
18889 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
18890 defer endTimer()
18891 defer span.End()
18892 response, ok := out.RawResponse.(*smithyhttp.Response)
18893 if !ok {
18894 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
18895 }
18896
18897 if response.StatusCode < 200 || response.StatusCode >= 300 {
18898 return out, metadata, awsAwsjson11_deserializeOpErrorStopInstance(response, &metadata)
18899 }
18900 output := &StopInstanceOutput{}
18901 out.Result = output
18902
18903 var buff [1024]byte
18904 ringBuffer := smithyio.NewRingBuffer(buff[:])
18905
18906 body := io.TeeReader(response.Body, ringBuffer)
18907 decoder := json.NewDecoder(body)
18908 decoder.UseNumber()
18909 var shape interface{}
18910 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
18911 var snapshot bytes.Buffer
18912 io.Copy(&snapshot, ringBuffer)
18913 err = &smithy.DeserializationError{
18914 Err: fmt.Errorf("failed to decode response body, %w", err),
18915 Snapshot: snapshot.Bytes(),
18916 }
18917 return out, metadata, err
18918 }
18919
18920 err = awsAwsjson11_deserializeOpDocumentStopInstanceOutput(&output, shape)
18921 if err != nil {
18922 var snapshot bytes.Buffer
18923 io.Copy(&snapshot, ringBuffer)
18924 err = &smithy.DeserializationError{
18925 Err: fmt.Errorf("failed to decode response body, %w", err),
18926 Snapshot: snapshot.Bytes(),
18927 }
18928 return out, metadata, err
18929 }
18930
18931 return out, metadata, err
18932 }
18933
18934 func awsAwsjson11_deserializeOpErrorStopInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
18935 var errorBuffer bytes.Buffer
18936 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
18937 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
18938 }
18939 errorBody := bytes.NewReader(errorBuffer.Bytes())
18940
18941 errorCode := "UnknownError"
18942 errorMessage := errorCode
18943
18944 headerCode := response.Header.Get("X-Amzn-ErrorType")
18945
18946 var buff [1024]byte
18947 ringBuffer := smithyio.NewRingBuffer(buff[:])
18948
18949 body := io.TeeReader(errorBody, ringBuffer)
18950 decoder := json.NewDecoder(body)
18951 decoder.UseNumber()
18952 bodyInfo, err := getProtocolErrorInfo(decoder)
18953 if err != nil {
18954 var snapshot bytes.Buffer
18955 io.Copy(&snapshot, ringBuffer)
18956 err = &smithy.DeserializationError{
18957 Err: fmt.Errorf("failed to decode response body, %w", err),
18958 Snapshot: snapshot.Bytes(),
18959 }
18960 return err
18961 }
18962
18963 errorBody.Seek(0, io.SeekStart)
18964 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
18965 errorCode = restjson.SanitizeErrorCode(typ)
18966 }
18967 if len(bodyInfo.Message) != 0 {
18968 errorMessage = bodyInfo.Message
18969 }
18970 switch {
18971 case strings.EqualFold("AccessDeniedException", errorCode):
18972 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
18973
18974 case strings.EqualFold("AccountSetupInProgressException", errorCode):
18975 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
18976
18977 case strings.EqualFold("InvalidInputException", errorCode):
18978 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
18979
18980 case strings.EqualFold("NotFoundException", errorCode):
18981 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
18982
18983 case strings.EqualFold("OperationFailureException", errorCode):
18984 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
18985
18986 case strings.EqualFold("RegionSetupInProgressException", errorCode):
18987 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
18988
18989 case strings.EqualFold("ServiceException", errorCode):
18990 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
18991
18992 case strings.EqualFold("UnauthenticatedException", errorCode):
18993 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
18994
18995 default:
18996 genericError := &smithy.GenericAPIError{
18997 Code: errorCode,
18998 Message: errorMessage,
18999 }
19000 return genericError
19001
19002 }
19003 }
19004
19005 type awsAwsjson11_deserializeOpStopRelationalDatabase struct {
19006 }
19007
19008 func (*awsAwsjson11_deserializeOpStopRelationalDatabase) ID() string {
19009 return "OperationDeserializer"
19010 }
19011
19012 func (m *awsAwsjson11_deserializeOpStopRelationalDatabase) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
19013 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
19014 ) {
19015 out, metadata, err = next.HandleDeserialize(ctx, in)
19016 if err != nil {
19017 return out, metadata, err
19018 }
19019
19020 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
19021 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
19022 defer endTimer()
19023 defer span.End()
19024 response, ok := out.RawResponse.(*smithyhttp.Response)
19025 if !ok {
19026 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
19027 }
19028
19029 if response.StatusCode < 200 || response.StatusCode >= 300 {
19030 return out, metadata, awsAwsjson11_deserializeOpErrorStopRelationalDatabase(response, &metadata)
19031 }
19032 output := &StopRelationalDatabaseOutput{}
19033 out.Result = output
19034
19035 var buff [1024]byte
19036 ringBuffer := smithyio.NewRingBuffer(buff[:])
19037
19038 body := io.TeeReader(response.Body, ringBuffer)
19039 decoder := json.NewDecoder(body)
19040 decoder.UseNumber()
19041 var shape interface{}
19042 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
19043 var snapshot bytes.Buffer
19044 io.Copy(&snapshot, ringBuffer)
19045 err = &smithy.DeserializationError{
19046 Err: fmt.Errorf("failed to decode response body, %w", err),
19047 Snapshot: snapshot.Bytes(),
19048 }
19049 return out, metadata, err
19050 }
19051
19052 err = awsAwsjson11_deserializeOpDocumentStopRelationalDatabaseOutput(&output, shape)
19053 if err != nil {
19054 var snapshot bytes.Buffer
19055 io.Copy(&snapshot, ringBuffer)
19056 err = &smithy.DeserializationError{
19057 Err: fmt.Errorf("failed to decode response body, %w", err),
19058 Snapshot: snapshot.Bytes(),
19059 }
19060 return out, metadata, err
19061 }
19062
19063 return out, metadata, err
19064 }
19065
19066 func awsAwsjson11_deserializeOpErrorStopRelationalDatabase(response *smithyhttp.Response, metadata *middleware.Metadata) error {
19067 var errorBuffer bytes.Buffer
19068 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
19069 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
19070 }
19071 errorBody := bytes.NewReader(errorBuffer.Bytes())
19072
19073 errorCode := "UnknownError"
19074 errorMessage := errorCode
19075
19076 headerCode := response.Header.Get("X-Amzn-ErrorType")
19077
19078 var buff [1024]byte
19079 ringBuffer := smithyio.NewRingBuffer(buff[:])
19080
19081 body := io.TeeReader(errorBody, ringBuffer)
19082 decoder := json.NewDecoder(body)
19083 decoder.UseNumber()
19084 bodyInfo, err := getProtocolErrorInfo(decoder)
19085 if err != nil {
19086 var snapshot bytes.Buffer
19087 io.Copy(&snapshot, ringBuffer)
19088 err = &smithy.DeserializationError{
19089 Err: fmt.Errorf("failed to decode response body, %w", err),
19090 Snapshot: snapshot.Bytes(),
19091 }
19092 return err
19093 }
19094
19095 errorBody.Seek(0, io.SeekStart)
19096 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
19097 errorCode = restjson.SanitizeErrorCode(typ)
19098 }
19099 if len(bodyInfo.Message) != 0 {
19100 errorMessage = bodyInfo.Message
19101 }
19102 switch {
19103 case strings.EqualFold("AccessDeniedException", errorCode):
19104 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
19105
19106 case strings.EqualFold("AccountSetupInProgressException", errorCode):
19107 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
19108
19109 case strings.EqualFold("InvalidInputException", errorCode):
19110 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
19111
19112 case strings.EqualFold("NotFoundException", errorCode):
19113 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
19114
19115 case strings.EqualFold("OperationFailureException", errorCode):
19116 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
19117
19118 case strings.EqualFold("RegionSetupInProgressException", errorCode):
19119 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
19120
19121 case strings.EqualFold("ServiceException", errorCode):
19122 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
19123
19124 case strings.EqualFold("UnauthenticatedException", errorCode):
19125 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
19126
19127 default:
19128 genericError := &smithy.GenericAPIError{
19129 Code: errorCode,
19130 Message: errorMessage,
19131 }
19132 return genericError
19133
19134 }
19135 }
19136
19137 type awsAwsjson11_deserializeOpTagResource struct {
19138 }
19139
19140 func (*awsAwsjson11_deserializeOpTagResource) ID() string {
19141 return "OperationDeserializer"
19142 }
19143
19144 func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
19145 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
19146 ) {
19147 out, metadata, err = next.HandleDeserialize(ctx, in)
19148 if err != nil {
19149 return out, metadata, err
19150 }
19151
19152 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
19153 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
19154 defer endTimer()
19155 defer span.End()
19156 response, ok := out.RawResponse.(*smithyhttp.Response)
19157 if !ok {
19158 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
19159 }
19160
19161 if response.StatusCode < 200 || response.StatusCode >= 300 {
19162 return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata)
19163 }
19164 output := &TagResourceOutput{}
19165 out.Result = output
19166
19167 var buff [1024]byte
19168 ringBuffer := smithyio.NewRingBuffer(buff[:])
19169
19170 body := io.TeeReader(response.Body, ringBuffer)
19171 decoder := json.NewDecoder(body)
19172 decoder.UseNumber()
19173 var shape interface{}
19174 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
19175 var snapshot bytes.Buffer
19176 io.Copy(&snapshot, ringBuffer)
19177 err = &smithy.DeserializationError{
19178 Err: fmt.Errorf("failed to decode response body, %w", err),
19179 Snapshot: snapshot.Bytes(),
19180 }
19181 return out, metadata, err
19182 }
19183
19184 err = awsAwsjson11_deserializeOpDocumentTagResourceOutput(&output, shape)
19185 if err != nil {
19186 var snapshot bytes.Buffer
19187 io.Copy(&snapshot, ringBuffer)
19188 err = &smithy.DeserializationError{
19189 Err: fmt.Errorf("failed to decode response body, %w", err),
19190 Snapshot: snapshot.Bytes(),
19191 }
19192 return out, metadata, err
19193 }
19194
19195 return out, metadata, err
19196 }
19197
19198 func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
19199 var errorBuffer bytes.Buffer
19200 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
19201 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
19202 }
19203 errorBody := bytes.NewReader(errorBuffer.Bytes())
19204
19205 errorCode := "UnknownError"
19206 errorMessage := errorCode
19207
19208 headerCode := response.Header.Get("X-Amzn-ErrorType")
19209
19210 var buff [1024]byte
19211 ringBuffer := smithyio.NewRingBuffer(buff[:])
19212
19213 body := io.TeeReader(errorBody, ringBuffer)
19214 decoder := json.NewDecoder(body)
19215 decoder.UseNumber()
19216 bodyInfo, err := getProtocolErrorInfo(decoder)
19217 if err != nil {
19218 var snapshot bytes.Buffer
19219 io.Copy(&snapshot, ringBuffer)
19220 err = &smithy.DeserializationError{
19221 Err: fmt.Errorf("failed to decode response body, %w", err),
19222 Snapshot: snapshot.Bytes(),
19223 }
19224 return err
19225 }
19226
19227 errorBody.Seek(0, io.SeekStart)
19228 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
19229 errorCode = restjson.SanitizeErrorCode(typ)
19230 }
19231 if len(bodyInfo.Message) != 0 {
19232 errorMessage = bodyInfo.Message
19233 }
19234 switch {
19235 case strings.EqualFold("AccessDeniedException", errorCode):
19236 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
19237
19238 case strings.EqualFold("AccountSetupInProgressException", errorCode):
19239 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
19240
19241 case strings.EqualFold("InvalidInputException", errorCode):
19242 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
19243
19244 case strings.EqualFold("NotFoundException", errorCode):
19245 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
19246
19247 case strings.EqualFold("OperationFailureException", errorCode):
19248 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
19249
19250 case strings.EqualFold("RegionSetupInProgressException", errorCode):
19251 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
19252
19253 case strings.EqualFold("ServiceException", errorCode):
19254 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
19255
19256 case strings.EqualFold("UnauthenticatedException", errorCode):
19257 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
19258
19259 default:
19260 genericError := &smithy.GenericAPIError{
19261 Code: errorCode,
19262 Message: errorMessage,
19263 }
19264 return genericError
19265
19266 }
19267 }
19268
19269 type awsAwsjson11_deserializeOpTestAlarm struct {
19270 }
19271
19272 func (*awsAwsjson11_deserializeOpTestAlarm) ID() string {
19273 return "OperationDeserializer"
19274 }
19275
19276 func (m *awsAwsjson11_deserializeOpTestAlarm) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
19277 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
19278 ) {
19279 out, metadata, err = next.HandleDeserialize(ctx, in)
19280 if err != nil {
19281 return out, metadata, err
19282 }
19283
19284 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
19285 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
19286 defer endTimer()
19287 defer span.End()
19288 response, ok := out.RawResponse.(*smithyhttp.Response)
19289 if !ok {
19290 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
19291 }
19292
19293 if response.StatusCode < 200 || response.StatusCode >= 300 {
19294 return out, metadata, awsAwsjson11_deserializeOpErrorTestAlarm(response, &metadata)
19295 }
19296 output := &TestAlarmOutput{}
19297 out.Result = output
19298
19299 var buff [1024]byte
19300 ringBuffer := smithyio.NewRingBuffer(buff[:])
19301
19302 body := io.TeeReader(response.Body, ringBuffer)
19303 decoder := json.NewDecoder(body)
19304 decoder.UseNumber()
19305 var shape interface{}
19306 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
19307 var snapshot bytes.Buffer
19308 io.Copy(&snapshot, ringBuffer)
19309 err = &smithy.DeserializationError{
19310 Err: fmt.Errorf("failed to decode response body, %w", err),
19311 Snapshot: snapshot.Bytes(),
19312 }
19313 return out, metadata, err
19314 }
19315
19316 err = awsAwsjson11_deserializeOpDocumentTestAlarmOutput(&output, shape)
19317 if err != nil {
19318 var snapshot bytes.Buffer
19319 io.Copy(&snapshot, ringBuffer)
19320 err = &smithy.DeserializationError{
19321 Err: fmt.Errorf("failed to decode response body, %w", err),
19322 Snapshot: snapshot.Bytes(),
19323 }
19324 return out, metadata, err
19325 }
19326
19327 return out, metadata, err
19328 }
19329
19330 func awsAwsjson11_deserializeOpErrorTestAlarm(response *smithyhttp.Response, metadata *middleware.Metadata) error {
19331 var errorBuffer bytes.Buffer
19332 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
19333 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
19334 }
19335 errorBody := bytes.NewReader(errorBuffer.Bytes())
19336
19337 errorCode := "UnknownError"
19338 errorMessage := errorCode
19339
19340 headerCode := response.Header.Get("X-Amzn-ErrorType")
19341
19342 var buff [1024]byte
19343 ringBuffer := smithyio.NewRingBuffer(buff[:])
19344
19345 body := io.TeeReader(errorBody, ringBuffer)
19346 decoder := json.NewDecoder(body)
19347 decoder.UseNumber()
19348 bodyInfo, err := getProtocolErrorInfo(decoder)
19349 if err != nil {
19350 var snapshot bytes.Buffer
19351 io.Copy(&snapshot, ringBuffer)
19352 err = &smithy.DeserializationError{
19353 Err: fmt.Errorf("failed to decode response body, %w", err),
19354 Snapshot: snapshot.Bytes(),
19355 }
19356 return err
19357 }
19358
19359 errorBody.Seek(0, io.SeekStart)
19360 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
19361 errorCode = restjson.SanitizeErrorCode(typ)
19362 }
19363 if len(bodyInfo.Message) != 0 {
19364 errorMessage = bodyInfo.Message
19365 }
19366 switch {
19367 case strings.EqualFold("AccessDeniedException", errorCode):
19368 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
19369
19370 case strings.EqualFold("InvalidInputException", errorCode):
19371 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
19372
19373 case strings.EqualFold("NotFoundException", errorCode):
19374 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
19375
19376 case strings.EqualFold("OperationFailureException", errorCode):
19377 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
19378
19379 case strings.EqualFold("RegionSetupInProgressException", errorCode):
19380 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
19381
19382 case strings.EqualFold("ServiceException", errorCode):
19383 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
19384
19385 case strings.EqualFold("UnauthenticatedException", errorCode):
19386 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
19387
19388 default:
19389 genericError := &smithy.GenericAPIError{
19390 Code: errorCode,
19391 Message: errorMessage,
19392 }
19393 return genericError
19394
19395 }
19396 }
19397
19398 type awsAwsjson11_deserializeOpUnpeerVpc struct {
19399 }
19400
19401 func (*awsAwsjson11_deserializeOpUnpeerVpc) ID() string {
19402 return "OperationDeserializer"
19403 }
19404
19405 func (m *awsAwsjson11_deserializeOpUnpeerVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
19406 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
19407 ) {
19408 out, metadata, err = next.HandleDeserialize(ctx, in)
19409 if err != nil {
19410 return out, metadata, err
19411 }
19412
19413 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
19414 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
19415 defer endTimer()
19416 defer span.End()
19417 response, ok := out.RawResponse.(*smithyhttp.Response)
19418 if !ok {
19419 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
19420 }
19421
19422 if response.StatusCode < 200 || response.StatusCode >= 300 {
19423 return out, metadata, awsAwsjson11_deserializeOpErrorUnpeerVpc(response, &metadata)
19424 }
19425 output := &UnpeerVpcOutput{}
19426 out.Result = output
19427
19428 var buff [1024]byte
19429 ringBuffer := smithyio.NewRingBuffer(buff[:])
19430
19431 body := io.TeeReader(response.Body, ringBuffer)
19432 decoder := json.NewDecoder(body)
19433 decoder.UseNumber()
19434 var shape interface{}
19435 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
19436 var snapshot bytes.Buffer
19437 io.Copy(&snapshot, ringBuffer)
19438 err = &smithy.DeserializationError{
19439 Err: fmt.Errorf("failed to decode response body, %w", err),
19440 Snapshot: snapshot.Bytes(),
19441 }
19442 return out, metadata, err
19443 }
19444
19445 err = awsAwsjson11_deserializeOpDocumentUnpeerVpcOutput(&output, shape)
19446 if err != nil {
19447 var snapshot bytes.Buffer
19448 io.Copy(&snapshot, ringBuffer)
19449 err = &smithy.DeserializationError{
19450 Err: fmt.Errorf("failed to decode response body, %w", err),
19451 Snapshot: snapshot.Bytes(),
19452 }
19453 return out, metadata, err
19454 }
19455
19456 return out, metadata, err
19457 }
19458
19459 func awsAwsjson11_deserializeOpErrorUnpeerVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error {
19460 var errorBuffer bytes.Buffer
19461 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
19462 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
19463 }
19464 errorBody := bytes.NewReader(errorBuffer.Bytes())
19465
19466 errorCode := "UnknownError"
19467 errorMessage := errorCode
19468
19469 headerCode := response.Header.Get("X-Amzn-ErrorType")
19470
19471 var buff [1024]byte
19472 ringBuffer := smithyio.NewRingBuffer(buff[:])
19473
19474 body := io.TeeReader(errorBody, ringBuffer)
19475 decoder := json.NewDecoder(body)
19476 decoder.UseNumber()
19477 bodyInfo, err := getProtocolErrorInfo(decoder)
19478 if err != nil {
19479 var snapshot bytes.Buffer
19480 io.Copy(&snapshot, ringBuffer)
19481 err = &smithy.DeserializationError{
19482 Err: fmt.Errorf("failed to decode response body, %w", err),
19483 Snapshot: snapshot.Bytes(),
19484 }
19485 return err
19486 }
19487
19488 errorBody.Seek(0, io.SeekStart)
19489 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
19490 errorCode = restjson.SanitizeErrorCode(typ)
19491 }
19492 if len(bodyInfo.Message) != 0 {
19493 errorMessage = bodyInfo.Message
19494 }
19495 switch {
19496 case strings.EqualFold("AccessDeniedException", errorCode):
19497 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
19498
19499 case strings.EqualFold("AccountSetupInProgressException", errorCode):
19500 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
19501
19502 case strings.EqualFold("InvalidInputException", errorCode):
19503 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
19504
19505 case strings.EqualFold("NotFoundException", errorCode):
19506 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
19507
19508 case strings.EqualFold("OperationFailureException", errorCode):
19509 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
19510
19511 case strings.EqualFold("RegionSetupInProgressException", errorCode):
19512 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
19513
19514 case strings.EqualFold("ServiceException", errorCode):
19515 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
19516
19517 case strings.EqualFold("UnauthenticatedException", errorCode):
19518 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
19519
19520 default:
19521 genericError := &smithy.GenericAPIError{
19522 Code: errorCode,
19523 Message: errorMessage,
19524 }
19525 return genericError
19526
19527 }
19528 }
19529
19530 type awsAwsjson11_deserializeOpUntagResource struct {
19531 }
19532
19533 func (*awsAwsjson11_deserializeOpUntagResource) ID() string {
19534 return "OperationDeserializer"
19535 }
19536
19537 func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
19538 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
19539 ) {
19540 out, metadata, err = next.HandleDeserialize(ctx, in)
19541 if err != nil {
19542 return out, metadata, err
19543 }
19544
19545 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
19546 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
19547 defer endTimer()
19548 defer span.End()
19549 response, ok := out.RawResponse.(*smithyhttp.Response)
19550 if !ok {
19551 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
19552 }
19553
19554 if response.StatusCode < 200 || response.StatusCode >= 300 {
19555 return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata)
19556 }
19557 output := &UntagResourceOutput{}
19558 out.Result = output
19559
19560 var buff [1024]byte
19561 ringBuffer := smithyio.NewRingBuffer(buff[:])
19562
19563 body := io.TeeReader(response.Body, ringBuffer)
19564 decoder := json.NewDecoder(body)
19565 decoder.UseNumber()
19566 var shape interface{}
19567 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
19568 var snapshot bytes.Buffer
19569 io.Copy(&snapshot, ringBuffer)
19570 err = &smithy.DeserializationError{
19571 Err: fmt.Errorf("failed to decode response body, %w", err),
19572 Snapshot: snapshot.Bytes(),
19573 }
19574 return out, metadata, err
19575 }
19576
19577 err = awsAwsjson11_deserializeOpDocumentUntagResourceOutput(&output, shape)
19578 if err != nil {
19579 var snapshot bytes.Buffer
19580 io.Copy(&snapshot, ringBuffer)
19581 err = &smithy.DeserializationError{
19582 Err: fmt.Errorf("failed to decode response body, %w", err),
19583 Snapshot: snapshot.Bytes(),
19584 }
19585 return out, metadata, err
19586 }
19587
19588 return out, metadata, err
19589 }
19590
19591 func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
19592 var errorBuffer bytes.Buffer
19593 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
19594 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
19595 }
19596 errorBody := bytes.NewReader(errorBuffer.Bytes())
19597
19598 errorCode := "UnknownError"
19599 errorMessage := errorCode
19600
19601 headerCode := response.Header.Get("X-Amzn-ErrorType")
19602
19603 var buff [1024]byte
19604 ringBuffer := smithyio.NewRingBuffer(buff[:])
19605
19606 body := io.TeeReader(errorBody, ringBuffer)
19607 decoder := json.NewDecoder(body)
19608 decoder.UseNumber()
19609 bodyInfo, err := getProtocolErrorInfo(decoder)
19610 if err != nil {
19611 var snapshot bytes.Buffer
19612 io.Copy(&snapshot, ringBuffer)
19613 err = &smithy.DeserializationError{
19614 Err: fmt.Errorf("failed to decode response body, %w", err),
19615 Snapshot: snapshot.Bytes(),
19616 }
19617 return err
19618 }
19619
19620 errorBody.Seek(0, io.SeekStart)
19621 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
19622 errorCode = restjson.SanitizeErrorCode(typ)
19623 }
19624 if len(bodyInfo.Message) != 0 {
19625 errorMessage = bodyInfo.Message
19626 }
19627 switch {
19628 case strings.EqualFold("AccessDeniedException", errorCode):
19629 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
19630
19631 case strings.EqualFold("AccountSetupInProgressException", errorCode):
19632 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
19633
19634 case strings.EqualFold("InvalidInputException", errorCode):
19635 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
19636
19637 case strings.EqualFold("NotFoundException", errorCode):
19638 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
19639
19640 case strings.EqualFold("OperationFailureException", errorCode):
19641 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
19642
19643 case strings.EqualFold("RegionSetupInProgressException", errorCode):
19644 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
19645
19646 case strings.EqualFold("ServiceException", errorCode):
19647 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
19648
19649 case strings.EqualFold("UnauthenticatedException", errorCode):
19650 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
19651
19652 default:
19653 genericError := &smithy.GenericAPIError{
19654 Code: errorCode,
19655 Message: errorMessage,
19656 }
19657 return genericError
19658
19659 }
19660 }
19661
19662 type awsAwsjson11_deserializeOpUpdateBucket struct {
19663 }
19664
19665 func (*awsAwsjson11_deserializeOpUpdateBucket) ID() string {
19666 return "OperationDeserializer"
19667 }
19668
19669 func (m *awsAwsjson11_deserializeOpUpdateBucket) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
19670 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
19671 ) {
19672 out, metadata, err = next.HandleDeserialize(ctx, in)
19673 if err != nil {
19674 return out, metadata, err
19675 }
19676
19677 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
19678 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
19679 defer endTimer()
19680 defer span.End()
19681 response, ok := out.RawResponse.(*smithyhttp.Response)
19682 if !ok {
19683 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
19684 }
19685
19686 if response.StatusCode < 200 || response.StatusCode >= 300 {
19687 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateBucket(response, &metadata)
19688 }
19689 output := &UpdateBucketOutput{}
19690 out.Result = output
19691
19692 var buff [1024]byte
19693 ringBuffer := smithyio.NewRingBuffer(buff[:])
19694
19695 body := io.TeeReader(response.Body, ringBuffer)
19696 decoder := json.NewDecoder(body)
19697 decoder.UseNumber()
19698 var shape interface{}
19699 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
19700 var snapshot bytes.Buffer
19701 io.Copy(&snapshot, ringBuffer)
19702 err = &smithy.DeserializationError{
19703 Err: fmt.Errorf("failed to decode response body, %w", err),
19704 Snapshot: snapshot.Bytes(),
19705 }
19706 return out, metadata, err
19707 }
19708
19709 err = awsAwsjson11_deserializeOpDocumentUpdateBucketOutput(&output, shape)
19710 if err != nil {
19711 var snapshot bytes.Buffer
19712 io.Copy(&snapshot, ringBuffer)
19713 err = &smithy.DeserializationError{
19714 Err: fmt.Errorf("failed to decode response body, %w", err),
19715 Snapshot: snapshot.Bytes(),
19716 }
19717 return out, metadata, err
19718 }
19719
19720 return out, metadata, err
19721 }
19722
19723 func awsAwsjson11_deserializeOpErrorUpdateBucket(response *smithyhttp.Response, metadata *middleware.Metadata) error {
19724 var errorBuffer bytes.Buffer
19725 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
19726 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
19727 }
19728 errorBody := bytes.NewReader(errorBuffer.Bytes())
19729
19730 errorCode := "UnknownError"
19731 errorMessage := errorCode
19732
19733 headerCode := response.Header.Get("X-Amzn-ErrorType")
19734
19735 var buff [1024]byte
19736 ringBuffer := smithyio.NewRingBuffer(buff[:])
19737
19738 body := io.TeeReader(errorBody, ringBuffer)
19739 decoder := json.NewDecoder(body)
19740 decoder.UseNumber()
19741 bodyInfo, err := getProtocolErrorInfo(decoder)
19742 if err != nil {
19743 var snapshot bytes.Buffer
19744 io.Copy(&snapshot, ringBuffer)
19745 err = &smithy.DeserializationError{
19746 Err: fmt.Errorf("failed to decode response body, %w", err),
19747 Snapshot: snapshot.Bytes(),
19748 }
19749 return err
19750 }
19751
19752 errorBody.Seek(0, io.SeekStart)
19753 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
19754 errorCode = restjson.SanitizeErrorCode(typ)
19755 }
19756 if len(bodyInfo.Message) != 0 {
19757 errorMessage = bodyInfo.Message
19758 }
19759 switch {
19760 case strings.EqualFold("AccessDeniedException", errorCode):
19761 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
19762
19763 case strings.EqualFold("InvalidInputException", errorCode):
19764 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
19765
19766 case strings.EqualFold("NotFoundException", errorCode):
19767 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
19768
19769 case strings.EqualFold("RegionSetupInProgressException", errorCode):
19770 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
19771
19772 case strings.EqualFold("ServiceException", errorCode):
19773 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
19774
19775 case strings.EqualFold("UnauthenticatedException", errorCode):
19776 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
19777
19778 default:
19779 genericError := &smithy.GenericAPIError{
19780 Code: errorCode,
19781 Message: errorMessage,
19782 }
19783 return genericError
19784
19785 }
19786 }
19787
19788 type awsAwsjson11_deserializeOpUpdateBucketBundle struct {
19789 }
19790
19791 func (*awsAwsjson11_deserializeOpUpdateBucketBundle) ID() string {
19792 return "OperationDeserializer"
19793 }
19794
19795 func (m *awsAwsjson11_deserializeOpUpdateBucketBundle) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
19796 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
19797 ) {
19798 out, metadata, err = next.HandleDeserialize(ctx, in)
19799 if err != nil {
19800 return out, metadata, err
19801 }
19802
19803 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
19804 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
19805 defer endTimer()
19806 defer span.End()
19807 response, ok := out.RawResponse.(*smithyhttp.Response)
19808 if !ok {
19809 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
19810 }
19811
19812 if response.StatusCode < 200 || response.StatusCode >= 300 {
19813 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateBucketBundle(response, &metadata)
19814 }
19815 output := &UpdateBucketBundleOutput{}
19816 out.Result = output
19817
19818 var buff [1024]byte
19819 ringBuffer := smithyio.NewRingBuffer(buff[:])
19820
19821 body := io.TeeReader(response.Body, ringBuffer)
19822 decoder := json.NewDecoder(body)
19823 decoder.UseNumber()
19824 var shape interface{}
19825 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
19826 var snapshot bytes.Buffer
19827 io.Copy(&snapshot, ringBuffer)
19828 err = &smithy.DeserializationError{
19829 Err: fmt.Errorf("failed to decode response body, %w", err),
19830 Snapshot: snapshot.Bytes(),
19831 }
19832 return out, metadata, err
19833 }
19834
19835 err = awsAwsjson11_deserializeOpDocumentUpdateBucketBundleOutput(&output, shape)
19836 if err != nil {
19837 var snapshot bytes.Buffer
19838 io.Copy(&snapshot, ringBuffer)
19839 err = &smithy.DeserializationError{
19840 Err: fmt.Errorf("failed to decode response body, %w", err),
19841 Snapshot: snapshot.Bytes(),
19842 }
19843 return out, metadata, err
19844 }
19845
19846 return out, metadata, err
19847 }
19848
19849 func awsAwsjson11_deserializeOpErrorUpdateBucketBundle(response *smithyhttp.Response, metadata *middleware.Metadata) error {
19850 var errorBuffer bytes.Buffer
19851 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
19852 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
19853 }
19854 errorBody := bytes.NewReader(errorBuffer.Bytes())
19855
19856 errorCode := "UnknownError"
19857 errorMessage := errorCode
19858
19859 headerCode := response.Header.Get("X-Amzn-ErrorType")
19860
19861 var buff [1024]byte
19862 ringBuffer := smithyio.NewRingBuffer(buff[:])
19863
19864 body := io.TeeReader(errorBody, ringBuffer)
19865 decoder := json.NewDecoder(body)
19866 decoder.UseNumber()
19867 bodyInfo, err := getProtocolErrorInfo(decoder)
19868 if err != nil {
19869 var snapshot bytes.Buffer
19870 io.Copy(&snapshot, ringBuffer)
19871 err = &smithy.DeserializationError{
19872 Err: fmt.Errorf("failed to decode response body, %w", err),
19873 Snapshot: snapshot.Bytes(),
19874 }
19875 return err
19876 }
19877
19878 errorBody.Seek(0, io.SeekStart)
19879 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
19880 errorCode = restjson.SanitizeErrorCode(typ)
19881 }
19882 if len(bodyInfo.Message) != 0 {
19883 errorMessage = bodyInfo.Message
19884 }
19885 switch {
19886 case strings.EqualFold("AccessDeniedException", errorCode):
19887 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
19888
19889 case strings.EqualFold("InvalidInputException", errorCode):
19890 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
19891
19892 case strings.EqualFold("NotFoundException", errorCode):
19893 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
19894
19895 case strings.EqualFold("RegionSetupInProgressException", errorCode):
19896 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
19897
19898 case strings.EqualFold("ServiceException", errorCode):
19899 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
19900
19901 case strings.EqualFold("UnauthenticatedException", errorCode):
19902 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
19903
19904 default:
19905 genericError := &smithy.GenericAPIError{
19906 Code: errorCode,
19907 Message: errorMessage,
19908 }
19909 return genericError
19910
19911 }
19912 }
19913
19914 type awsAwsjson11_deserializeOpUpdateContainerService struct {
19915 }
19916
19917 func (*awsAwsjson11_deserializeOpUpdateContainerService) ID() string {
19918 return "OperationDeserializer"
19919 }
19920
19921 func (m *awsAwsjson11_deserializeOpUpdateContainerService) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
19922 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
19923 ) {
19924 out, metadata, err = next.HandleDeserialize(ctx, in)
19925 if err != nil {
19926 return out, metadata, err
19927 }
19928
19929 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
19930 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
19931 defer endTimer()
19932 defer span.End()
19933 response, ok := out.RawResponse.(*smithyhttp.Response)
19934 if !ok {
19935 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
19936 }
19937
19938 if response.StatusCode < 200 || response.StatusCode >= 300 {
19939 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateContainerService(response, &metadata)
19940 }
19941 output := &UpdateContainerServiceOutput{}
19942 out.Result = output
19943
19944 var buff [1024]byte
19945 ringBuffer := smithyio.NewRingBuffer(buff[:])
19946
19947 body := io.TeeReader(response.Body, ringBuffer)
19948 decoder := json.NewDecoder(body)
19949 decoder.UseNumber()
19950 var shape interface{}
19951 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
19952 var snapshot bytes.Buffer
19953 io.Copy(&snapshot, ringBuffer)
19954 err = &smithy.DeserializationError{
19955 Err: fmt.Errorf("failed to decode response body, %w", err),
19956 Snapshot: snapshot.Bytes(),
19957 }
19958 return out, metadata, err
19959 }
19960
19961 err = awsAwsjson11_deserializeOpDocumentUpdateContainerServiceOutput(&output, shape)
19962 if err != nil {
19963 var snapshot bytes.Buffer
19964 io.Copy(&snapshot, ringBuffer)
19965 err = &smithy.DeserializationError{
19966 Err: fmt.Errorf("failed to decode response body, %w", err),
19967 Snapshot: snapshot.Bytes(),
19968 }
19969 return out, metadata, err
19970 }
19971
19972 return out, metadata, err
19973 }
19974
19975 func awsAwsjson11_deserializeOpErrorUpdateContainerService(response *smithyhttp.Response, metadata *middleware.Metadata) error {
19976 var errorBuffer bytes.Buffer
19977 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
19978 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
19979 }
19980 errorBody := bytes.NewReader(errorBuffer.Bytes())
19981
19982 errorCode := "UnknownError"
19983 errorMessage := errorCode
19984
19985 headerCode := response.Header.Get("X-Amzn-ErrorType")
19986
19987 var buff [1024]byte
19988 ringBuffer := smithyio.NewRingBuffer(buff[:])
19989
19990 body := io.TeeReader(errorBody, ringBuffer)
19991 decoder := json.NewDecoder(body)
19992 decoder.UseNumber()
19993 bodyInfo, err := getProtocolErrorInfo(decoder)
19994 if err != nil {
19995 var snapshot bytes.Buffer
19996 io.Copy(&snapshot, ringBuffer)
19997 err = &smithy.DeserializationError{
19998 Err: fmt.Errorf("failed to decode response body, %w", err),
19999 Snapshot: snapshot.Bytes(),
20000 }
20001 return err
20002 }
20003
20004 errorBody.Seek(0, io.SeekStart)
20005 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
20006 errorCode = restjson.SanitizeErrorCode(typ)
20007 }
20008 if len(bodyInfo.Message) != 0 {
20009 errorMessage = bodyInfo.Message
20010 }
20011 switch {
20012 case strings.EqualFold("AccessDeniedException", errorCode):
20013 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
20014
20015 case strings.EqualFold("InvalidInputException", errorCode):
20016 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
20017
20018 case strings.EqualFold("NotFoundException", errorCode):
20019 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
20020
20021 case strings.EqualFold("RegionSetupInProgressException", errorCode):
20022 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
20023
20024 case strings.EqualFold("ServiceException", errorCode):
20025 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
20026
20027 case strings.EqualFold("UnauthenticatedException", errorCode):
20028 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
20029
20030 default:
20031 genericError := &smithy.GenericAPIError{
20032 Code: errorCode,
20033 Message: errorMessage,
20034 }
20035 return genericError
20036
20037 }
20038 }
20039
20040 type awsAwsjson11_deserializeOpUpdateDistribution struct {
20041 }
20042
20043 func (*awsAwsjson11_deserializeOpUpdateDistribution) ID() string {
20044 return "OperationDeserializer"
20045 }
20046
20047 func (m *awsAwsjson11_deserializeOpUpdateDistribution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
20048 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
20049 ) {
20050 out, metadata, err = next.HandleDeserialize(ctx, in)
20051 if err != nil {
20052 return out, metadata, err
20053 }
20054
20055 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
20056 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
20057 defer endTimer()
20058 defer span.End()
20059 response, ok := out.RawResponse.(*smithyhttp.Response)
20060 if !ok {
20061 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
20062 }
20063
20064 if response.StatusCode < 200 || response.StatusCode >= 300 {
20065 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateDistribution(response, &metadata)
20066 }
20067 output := &UpdateDistributionOutput{}
20068 out.Result = output
20069
20070 var buff [1024]byte
20071 ringBuffer := smithyio.NewRingBuffer(buff[:])
20072
20073 body := io.TeeReader(response.Body, ringBuffer)
20074 decoder := json.NewDecoder(body)
20075 decoder.UseNumber()
20076 var shape interface{}
20077 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
20078 var snapshot bytes.Buffer
20079 io.Copy(&snapshot, ringBuffer)
20080 err = &smithy.DeserializationError{
20081 Err: fmt.Errorf("failed to decode response body, %w", err),
20082 Snapshot: snapshot.Bytes(),
20083 }
20084 return out, metadata, err
20085 }
20086
20087 err = awsAwsjson11_deserializeOpDocumentUpdateDistributionOutput(&output, shape)
20088 if err != nil {
20089 var snapshot bytes.Buffer
20090 io.Copy(&snapshot, ringBuffer)
20091 err = &smithy.DeserializationError{
20092 Err: fmt.Errorf("failed to decode response body, %w", err),
20093 Snapshot: snapshot.Bytes(),
20094 }
20095 return out, metadata, err
20096 }
20097
20098 return out, metadata, err
20099 }
20100
20101 func awsAwsjson11_deserializeOpErrorUpdateDistribution(response *smithyhttp.Response, metadata *middleware.Metadata) error {
20102 var errorBuffer bytes.Buffer
20103 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
20104 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
20105 }
20106 errorBody := bytes.NewReader(errorBuffer.Bytes())
20107
20108 errorCode := "UnknownError"
20109 errorMessage := errorCode
20110
20111 headerCode := response.Header.Get("X-Amzn-ErrorType")
20112
20113 var buff [1024]byte
20114 ringBuffer := smithyio.NewRingBuffer(buff[:])
20115
20116 body := io.TeeReader(errorBody, ringBuffer)
20117 decoder := json.NewDecoder(body)
20118 decoder.UseNumber()
20119 bodyInfo, err := getProtocolErrorInfo(decoder)
20120 if err != nil {
20121 var snapshot bytes.Buffer
20122 io.Copy(&snapshot, ringBuffer)
20123 err = &smithy.DeserializationError{
20124 Err: fmt.Errorf("failed to decode response body, %w", err),
20125 Snapshot: snapshot.Bytes(),
20126 }
20127 return err
20128 }
20129
20130 errorBody.Seek(0, io.SeekStart)
20131 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
20132 errorCode = restjson.SanitizeErrorCode(typ)
20133 }
20134 if len(bodyInfo.Message) != 0 {
20135 errorMessage = bodyInfo.Message
20136 }
20137 switch {
20138 case strings.EqualFold("AccessDeniedException", errorCode):
20139 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
20140
20141 case strings.EqualFold("InvalidInputException", errorCode):
20142 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
20143
20144 case strings.EqualFold("NotFoundException", errorCode):
20145 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
20146
20147 case strings.EqualFold("OperationFailureException", errorCode):
20148 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
20149
20150 case strings.EqualFold("ServiceException", errorCode):
20151 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
20152
20153 case strings.EqualFold("UnauthenticatedException", errorCode):
20154 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
20155
20156 default:
20157 genericError := &smithy.GenericAPIError{
20158 Code: errorCode,
20159 Message: errorMessage,
20160 }
20161 return genericError
20162
20163 }
20164 }
20165
20166 type awsAwsjson11_deserializeOpUpdateDistributionBundle struct {
20167 }
20168
20169 func (*awsAwsjson11_deserializeOpUpdateDistributionBundle) ID() string {
20170 return "OperationDeserializer"
20171 }
20172
20173 func (m *awsAwsjson11_deserializeOpUpdateDistributionBundle) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
20174 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
20175 ) {
20176 out, metadata, err = next.HandleDeserialize(ctx, in)
20177 if err != nil {
20178 return out, metadata, err
20179 }
20180
20181 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
20182 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
20183 defer endTimer()
20184 defer span.End()
20185 response, ok := out.RawResponse.(*smithyhttp.Response)
20186 if !ok {
20187 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
20188 }
20189
20190 if response.StatusCode < 200 || response.StatusCode >= 300 {
20191 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateDistributionBundle(response, &metadata)
20192 }
20193 output := &UpdateDistributionBundleOutput{}
20194 out.Result = output
20195
20196 var buff [1024]byte
20197 ringBuffer := smithyio.NewRingBuffer(buff[:])
20198
20199 body := io.TeeReader(response.Body, ringBuffer)
20200 decoder := json.NewDecoder(body)
20201 decoder.UseNumber()
20202 var shape interface{}
20203 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
20204 var snapshot bytes.Buffer
20205 io.Copy(&snapshot, ringBuffer)
20206 err = &smithy.DeserializationError{
20207 Err: fmt.Errorf("failed to decode response body, %w", err),
20208 Snapshot: snapshot.Bytes(),
20209 }
20210 return out, metadata, err
20211 }
20212
20213 err = awsAwsjson11_deserializeOpDocumentUpdateDistributionBundleOutput(&output, shape)
20214 if err != nil {
20215 var snapshot bytes.Buffer
20216 io.Copy(&snapshot, ringBuffer)
20217 err = &smithy.DeserializationError{
20218 Err: fmt.Errorf("failed to decode response body, %w", err),
20219 Snapshot: snapshot.Bytes(),
20220 }
20221 return out, metadata, err
20222 }
20223
20224 return out, metadata, err
20225 }
20226
20227 func awsAwsjson11_deserializeOpErrorUpdateDistributionBundle(response *smithyhttp.Response, metadata *middleware.Metadata) error {
20228 var errorBuffer bytes.Buffer
20229 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
20230 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
20231 }
20232 errorBody := bytes.NewReader(errorBuffer.Bytes())
20233
20234 errorCode := "UnknownError"
20235 errorMessage := errorCode
20236
20237 headerCode := response.Header.Get("X-Amzn-ErrorType")
20238
20239 var buff [1024]byte
20240 ringBuffer := smithyio.NewRingBuffer(buff[:])
20241
20242 body := io.TeeReader(errorBody, ringBuffer)
20243 decoder := json.NewDecoder(body)
20244 decoder.UseNumber()
20245 bodyInfo, err := getProtocolErrorInfo(decoder)
20246 if err != nil {
20247 var snapshot bytes.Buffer
20248 io.Copy(&snapshot, ringBuffer)
20249 err = &smithy.DeserializationError{
20250 Err: fmt.Errorf("failed to decode response body, %w", err),
20251 Snapshot: snapshot.Bytes(),
20252 }
20253 return err
20254 }
20255
20256 errorBody.Seek(0, io.SeekStart)
20257 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
20258 errorCode = restjson.SanitizeErrorCode(typ)
20259 }
20260 if len(bodyInfo.Message) != 0 {
20261 errorMessage = bodyInfo.Message
20262 }
20263 switch {
20264 case strings.EqualFold("AccessDeniedException", errorCode):
20265 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
20266
20267 case strings.EqualFold("InvalidInputException", errorCode):
20268 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
20269
20270 case strings.EqualFold("NotFoundException", errorCode):
20271 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
20272
20273 case strings.EqualFold("OperationFailureException", errorCode):
20274 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
20275
20276 case strings.EqualFold("ServiceException", errorCode):
20277 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
20278
20279 case strings.EqualFold("UnauthenticatedException", errorCode):
20280 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
20281
20282 default:
20283 genericError := &smithy.GenericAPIError{
20284 Code: errorCode,
20285 Message: errorMessage,
20286 }
20287 return genericError
20288
20289 }
20290 }
20291
20292 type awsAwsjson11_deserializeOpUpdateDomainEntry struct {
20293 }
20294
20295 func (*awsAwsjson11_deserializeOpUpdateDomainEntry) ID() string {
20296 return "OperationDeserializer"
20297 }
20298
20299 func (m *awsAwsjson11_deserializeOpUpdateDomainEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
20300 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
20301 ) {
20302 out, metadata, err = next.HandleDeserialize(ctx, in)
20303 if err != nil {
20304 return out, metadata, err
20305 }
20306
20307 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
20308 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
20309 defer endTimer()
20310 defer span.End()
20311 response, ok := out.RawResponse.(*smithyhttp.Response)
20312 if !ok {
20313 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
20314 }
20315
20316 if response.StatusCode < 200 || response.StatusCode >= 300 {
20317 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateDomainEntry(response, &metadata)
20318 }
20319 output := &UpdateDomainEntryOutput{}
20320 out.Result = output
20321
20322 var buff [1024]byte
20323 ringBuffer := smithyio.NewRingBuffer(buff[:])
20324
20325 body := io.TeeReader(response.Body, ringBuffer)
20326 decoder := json.NewDecoder(body)
20327 decoder.UseNumber()
20328 var shape interface{}
20329 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
20330 var snapshot bytes.Buffer
20331 io.Copy(&snapshot, ringBuffer)
20332 err = &smithy.DeserializationError{
20333 Err: fmt.Errorf("failed to decode response body, %w", err),
20334 Snapshot: snapshot.Bytes(),
20335 }
20336 return out, metadata, err
20337 }
20338
20339 err = awsAwsjson11_deserializeOpDocumentUpdateDomainEntryOutput(&output, shape)
20340 if err != nil {
20341 var snapshot bytes.Buffer
20342 io.Copy(&snapshot, ringBuffer)
20343 err = &smithy.DeserializationError{
20344 Err: fmt.Errorf("failed to decode response body, %w", err),
20345 Snapshot: snapshot.Bytes(),
20346 }
20347 return out, metadata, err
20348 }
20349
20350 return out, metadata, err
20351 }
20352
20353 func awsAwsjson11_deserializeOpErrorUpdateDomainEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error {
20354 var errorBuffer bytes.Buffer
20355 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
20356 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
20357 }
20358 errorBody := bytes.NewReader(errorBuffer.Bytes())
20359
20360 errorCode := "UnknownError"
20361 errorMessage := errorCode
20362
20363 headerCode := response.Header.Get("X-Amzn-ErrorType")
20364
20365 var buff [1024]byte
20366 ringBuffer := smithyio.NewRingBuffer(buff[:])
20367
20368 body := io.TeeReader(errorBody, ringBuffer)
20369 decoder := json.NewDecoder(body)
20370 decoder.UseNumber()
20371 bodyInfo, err := getProtocolErrorInfo(decoder)
20372 if err != nil {
20373 var snapshot bytes.Buffer
20374 io.Copy(&snapshot, ringBuffer)
20375 err = &smithy.DeserializationError{
20376 Err: fmt.Errorf("failed to decode response body, %w", err),
20377 Snapshot: snapshot.Bytes(),
20378 }
20379 return err
20380 }
20381
20382 errorBody.Seek(0, io.SeekStart)
20383 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
20384 errorCode = restjson.SanitizeErrorCode(typ)
20385 }
20386 if len(bodyInfo.Message) != 0 {
20387 errorMessage = bodyInfo.Message
20388 }
20389 switch {
20390 case strings.EqualFold("AccessDeniedException", errorCode):
20391 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
20392
20393 case strings.EqualFold("AccountSetupInProgressException", errorCode):
20394 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
20395
20396 case strings.EqualFold("InvalidInputException", errorCode):
20397 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
20398
20399 case strings.EqualFold("NotFoundException", errorCode):
20400 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
20401
20402 case strings.EqualFold("OperationFailureException", errorCode):
20403 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
20404
20405 case strings.EqualFold("RegionSetupInProgressException", errorCode):
20406 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
20407
20408 case strings.EqualFold("ServiceException", errorCode):
20409 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
20410
20411 case strings.EqualFold("UnauthenticatedException", errorCode):
20412 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
20413
20414 default:
20415 genericError := &smithy.GenericAPIError{
20416 Code: errorCode,
20417 Message: errorMessage,
20418 }
20419 return genericError
20420
20421 }
20422 }
20423
20424 type awsAwsjson11_deserializeOpUpdateInstanceMetadataOptions struct {
20425 }
20426
20427 func (*awsAwsjson11_deserializeOpUpdateInstanceMetadataOptions) ID() string {
20428 return "OperationDeserializer"
20429 }
20430
20431 func (m *awsAwsjson11_deserializeOpUpdateInstanceMetadataOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
20432 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
20433 ) {
20434 out, metadata, err = next.HandleDeserialize(ctx, in)
20435 if err != nil {
20436 return out, metadata, err
20437 }
20438
20439 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
20440 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
20441 defer endTimer()
20442 defer span.End()
20443 response, ok := out.RawResponse.(*smithyhttp.Response)
20444 if !ok {
20445 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
20446 }
20447
20448 if response.StatusCode < 200 || response.StatusCode >= 300 {
20449 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateInstanceMetadataOptions(response, &metadata)
20450 }
20451 output := &UpdateInstanceMetadataOptionsOutput{}
20452 out.Result = output
20453
20454 var buff [1024]byte
20455 ringBuffer := smithyio.NewRingBuffer(buff[:])
20456
20457 body := io.TeeReader(response.Body, ringBuffer)
20458 decoder := json.NewDecoder(body)
20459 decoder.UseNumber()
20460 var shape interface{}
20461 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
20462 var snapshot bytes.Buffer
20463 io.Copy(&snapshot, ringBuffer)
20464 err = &smithy.DeserializationError{
20465 Err: fmt.Errorf("failed to decode response body, %w", err),
20466 Snapshot: snapshot.Bytes(),
20467 }
20468 return out, metadata, err
20469 }
20470
20471 err = awsAwsjson11_deserializeOpDocumentUpdateInstanceMetadataOptionsOutput(&output, shape)
20472 if err != nil {
20473 var snapshot bytes.Buffer
20474 io.Copy(&snapshot, ringBuffer)
20475 err = &smithy.DeserializationError{
20476 Err: fmt.Errorf("failed to decode response body, %w", err),
20477 Snapshot: snapshot.Bytes(),
20478 }
20479 return out, metadata, err
20480 }
20481
20482 return out, metadata, err
20483 }
20484
20485 func awsAwsjson11_deserializeOpErrorUpdateInstanceMetadataOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
20486 var errorBuffer bytes.Buffer
20487 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
20488 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
20489 }
20490 errorBody := bytes.NewReader(errorBuffer.Bytes())
20491
20492 errorCode := "UnknownError"
20493 errorMessage := errorCode
20494
20495 headerCode := response.Header.Get("X-Amzn-ErrorType")
20496
20497 var buff [1024]byte
20498 ringBuffer := smithyio.NewRingBuffer(buff[:])
20499
20500 body := io.TeeReader(errorBody, ringBuffer)
20501 decoder := json.NewDecoder(body)
20502 decoder.UseNumber()
20503 bodyInfo, err := getProtocolErrorInfo(decoder)
20504 if err != nil {
20505 var snapshot bytes.Buffer
20506 io.Copy(&snapshot, ringBuffer)
20507 err = &smithy.DeserializationError{
20508 Err: fmt.Errorf("failed to decode response body, %w", err),
20509 Snapshot: snapshot.Bytes(),
20510 }
20511 return err
20512 }
20513
20514 errorBody.Seek(0, io.SeekStart)
20515 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
20516 errorCode = restjson.SanitizeErrorCode(typ)
20517 }
20518 if len(bodyInfo.Message) != 0 {
20519 errorMessage = bodyInfo.Message
20520 }
20521 switch {
20522 case strings.EqualFold("AccessDeniedException", errorCode):
20523 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
20524
20525 case strings.EqualFold("AccountSetupInProgressException", errorCode):
20526 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
20527
20528 case strings.EqualFold("InvalidInputException", errorCode):
20529 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
20530
20531 case strings.EqualFold("NotFoundException", errorCode):
20532 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
20533
20534 case strings.EqualFold("OperationFailureException", errorCode):
20535 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
20536
20537 case strings.EqualFold("RegionSetupInProgressException", errorCode):
20538 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
20539
20540 case strings.EqualFold("ServiceException", errorCode):
20541 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
20542
20543 case strings.EqualFold("UnauthenticatedException", errorCode):
20544 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
20545
20546 default:
20547 genericError := &smithy.GenericAPIError{
20548 Code: errorCode,
20549 Message: errorMessage,
20550 }
20551 return genericError
20552
20553 }
20554 }
20555
20556 type awsAwsjson11_deserializeOpUpdateLoadBalancerAttribute struct {
20557 }
20558
20559 func (*awsAwsjson11_deserializeOpUpdateLoadBalancerAttribute) ID() string {
20560 return "OperationDeserializer"
20561 }
20562
20563 func (m *awsAwsjson11_deserializeOpUpdateLoadBalancerAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
20564 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
20565 ) {
20566 out, metadata, err = next.HandleDeserialize(ctx, in)
20567 if err != nil {
20568 return out, metadata, err
20569 }
20570
20571 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
20572 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
20573 defer endTimer()
20574 defer span.End()
20575 response, ok := out.RawResponse.(*smithyhttp.Response)
20576 if !ok {
20577 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
20578 }
20579
20580 if response.StatusCode < 200 || response.StatusCode >= 300 {
20581 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateLoadBalancerAttribute(response, &metadata)
20582 }
20583 output := &UpdateLoadBalancerAttributeOutput{}
20584 out.Result = output
20585
20586 var buff [1024]byte
20587 ringBuffer := smithyio.NewRingBuffer(buff[:])
20588
20589 body := io.TeeReader(response.Body, ringBuffer)
20590 decoder := json.NewDecoder(body)
20591 decoder.UseNumber()
20592 var shape interface{}
20593 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
20594 var snapshot bytes.Buffer
20595 io.Copy(&snapshot, ringBuffer)
20596 err = &smithy.DeserializationError{
20597 Err: fmt.Errorf("failed to decode response body, %w", err),
20598 Snapshot: snapshot.Bytes(),
20599 }
20600 return out, metadata, err
20601 }
20602
20603 err = awsAwsjson11_deserializeOpDocumentUpdateLoadBalancerAttributeOutput(&output, shape)
20604 if err != nil {
20605 var snapshot bytes.Buffer
20606 io.Copy(&snapshot, ringBuffer)
20607 err = &smithy.DeserializationError{
20608 Err: fmt.Errorf("failed to decode response body, %w", err),
20609 Snapshot: snapshot.Bytes(),
20610 }
20611 return out, metadata, err
20612 }
20613
20614 return out, metadata, err
20615 }
20616
20617 func awsAwsjson11_deserializeOpErrorUpdateLoadBalancerAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
20618 var errorBuffer bytes.Buffer
20619 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
20620 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
20621 }
20622 errorBody := bytes.NewReader(errorBuffer.Bytes())
20623
20624 errorCode := "UnknownError"
20625 errorMessage := errorCode
20626
20627 headerCode := response.Header.Get("X-Amzn-ErrorType")
20628
20629 var buff [1024]byte
20630 ringBuffer := smithyio.NewRingBuffer(buff[:])
20631
20632 body := io.TeeReader(errorBody, ringBuffer)
20633 decoder := json.NewDecoder(body)
20634 decoder.UseNumber()
20635 bodyInfo, err := getProtocolErrorInfo(decoder)
20636 if err != nil {
20637 var snapshot bytes.Buffer
20638 io.Copy(&snapshot, ringBuffer)
20639 err = &smithy.DeserializationError{
20640 Err: fmt.Errorf("failed to decode response body, %w", err),
20641 Snapshot: snapshot.Bytes(),
20642 }
20643 return err
20644 }
20645
20646 errorBody.Seek(0, io.SeekStart)
20647 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
20648 errorCode = restjson.SanitizeErrorCode(typ)
20649 }
20650 if len(bodyInfo.Message) != 0 {
20651 errorMessage = bodyInfo.Message
20652 }
20653 switch {
20654 case strings.EqualFold("AccessDeniedException", errorCode):
20655 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
20656
20657 case strings.EqualFold("AccountSetupInProgressException", errorCode):
20658 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
20659
20660 case strings.EqualFold("InvalidInputException", errorCode):
20661 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
20662
20663 case strings.EqualFold("NotFoundException", errorCode):
20664 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
20665
20666 case strings.EqualFold("OperationFailureException", errorCode):
20667 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
20668
20669 case strings.EqualFold("RegionSetupInProgressException", errorCode):
20670 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
20671
20672 case strings.EqualFold("ServiceException", errorCode):
20673 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
20674
20675 case strings.EqualFold("UnauthenticatedException", errorCode):
20676 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
20677
20678 default:
20679 genericError := &smithy.GenericAPIError{
20680 Code: errorCode,
20681 Message: errorMessage,
20682 }
20683 return genericError
20684
20685 }
20686 }
20687
20688 type awsAwsjson11_deserializeOpUpdateRelationalDatabase struct {
20689 }
20690
20691 func (*awsAwsjson11_deserializeOpUpdateRelationalDatabase) ID() string {
20692 return "OperationDeserializer"
20693 }
20694
20695 func (m *awsAwsjson11_deserializeOpUpdateRelationalDatabase) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
20696 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
20697 ) {
20698 out, metadata, err = next.HandleDeserialize(ctx, in)
20699 if err != nil {
20700 return out, metadata, err
20701 }
20702
20703 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
20704 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
20705 defer endTimer()
20706 defer span.End()
20707 response, ok := out.RawResponse.(*smithyhttp.Response)
20708 if !ok {
20709 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
20710 }
20711
20712 if response.StatusCode < 200 || response.StatusCode >= 300 {
20713 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateRelationalDatabase(response, &metadata)
20714 }
20715 output := &UpdateRelationalDatabaseOutput{}
20716 out.Result = output
20717
20718 var buff [1024]byte
20719 ringBuffer := smithyio.NewRingBuffer(buff[:])
20720
20721 body := io.TeeReader(response.Body, ringBuffer)
20722 decoder := json.NewDecoder(body)
20723 decoder.UseNumber()
20724 var shape interface{}
20725 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
20726 var snapshot bytes.Buffer
20727 io.Copy(&snapshot, ringBuffer)
20728 err = &smithy.DeserializationError{
20729 Err: fmt.Errorf("failed to decode response body, %w", err),
20730 Snapshot: snapshot.Bytes(),
20731 }
20732 return out, metadata, err
20733 }
20734
20735 err = awsAwsjson11_deserializeOpDocumentUpdateRelationalDatabaseOutput(&output, shape)
20736 if err != nil {
20737 var snapshot bytes.Buffer
20738 io.Copy(&snapshot, ringBuffer)
20739 err = &smithy.DeserializationError{
20740 Err: fmt.Errorf("failed to decode response body, %w", err),
20741 Snapshot: snapshot.Bytes(),
20742 }
20743 return out, metadata, err
20744 }
20745
20746 return out, metadata, err
20747 }
20748
20749 func awsAwsjson11_deserializeOpErrorUpdateRelationalDatabase(response *smithyhttp.Response, metadata *middleware.Metadata) error {
20750 var errorBuffer bytes.Buffer
20751 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
20752 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
20753 }
20754 errorBody := bytes.NewReader(errorBuffer.Bytes())
20755
20756 errorCode := "UnknownError"
20757 errorMessage := errorCode
20758
20759 headerCode := response.Header.Get("X-Amzn-ErrorType")
20760
20761 var buff [1024]byte
20762 ringBuffer := smithyio.NewRingBuffer(buff[:])
20763
20764 body := io.TeeReader(errorBody, ringBuffer)
20765 decoder := json.NewDecoder(body)
20766 decoder.UseNumber()
20767 bodyInfo, err := getProtocolErrorInfo(decoder)
20768 if err != nil {
20769 var snapshot bytes.Buffer
20770 io.Copy(&snapshot, ringBuffer)
20771 err = &smithy.DeserializationError{
20772 Err: fmt.Errorf("failed to decode response body, %w", err),
20773 Snapshot: snapshot.Bytes(),
20774 }
20775 return err
20776 }
20777
20778 errorBody.Seek(0, io.SeekStart)
20779 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
20780 errorCode = restjson.SanitizeErrorCode(typ)
20781 }
20782 if len(bodyInfo.Message) != 0 {
20783 errorMessage = bodyInfo.Message
20784 }
20785 switch {
20786 case strings.EqualFold("AccessDeniedException", errorCode):
20787 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
20788
20789 case strings.EqualFold("AccountSetupInProgressException", errorCode):
20790 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
20791
20792 case strings.EqualFold("InvalidInputException", errorCode):
20793 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
20794
20795 case strings.EqualFold("NotFoundException", errorCode):
20796 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
20797
20798 case strings.EqualFold("OperationFailureException", errorCode):
20799 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
20800
20801 case strings.EqualFold("RegionSetupInProgressException", errorCode):
20802 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
20803
20804 case strings.EqualFold("ServiceException", errorCode):
20805 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
20806
20807 case strings.EqualFold("UnauthenticatedException", errorCode):
20808 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
20809
20810 default:
20811 genericError := &smithy.GenericAPIError{
20812 Code: errorCode,
20813 Message: errorMessage,
20814 }
20815 return genericError
20816
20817 }
20818 }
20819
20820 type awsAwsjson11_deserializeOpUpdateRelationalDatabaseParameters struct {
20821 }
20822
20823 func (*awsAwsjson11_deserializeOpUpdateRelationalDatabaseParameters) ID() string {
20824 return "OperationDeserializer"
20825 }
20826
20827 func (m *awsAwsjson11_deserializeOpUpdateRelationalDatabaseParameters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
20828 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
20829 ) {
20830 out, metadata, err = next.HandleDeserialize(ctx, in)
20831 if err != nil {
20832 return out, metadata, err
20833 }
20834
20835 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
20836 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
20837 defer endTimer()
20838 defer span.End()
20839 response, ok := out.RawResponse.(*smithyhttp.Response)
20840 if !ok {
20841 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
20842 }
20843
20844 if response.StatusCode < 200 || response.StatusCode >= 300 {
20845 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateRelationalDatabaseParameters(response, &metadata)
20846 }
20847 output := &UpdateRelationalDatabaseParametersOutput{}
20848 out.Result = output
20849
20850 var buff [1024]byte
20851 ringBuffer := smithyio.NewRingBuffer(buff[:])
20852
20853 body := io.TeeReader(response.Body, ringBuffer)
20854 decoder := json.NewDecoder(body)
20855 decoder.UseNumber()
20856 var shape interface{}
20857 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
20858 var snapshot bytes.Buffer
20859 io.Copy(&snapshot, ringBuffer)
20860 err = &smithy.DeserializationError{
20861 Err: fmt.Errorf("failed to decode response body, %w", err),
20862 Snapshot: snapshot.Bytes(),
20863 }
20864 return out, metadata, err
20865 }
20866
20867 err = awsAwsjson11_deserializeOpDocumentUpdateRelationalDatabaseParametersOutput(&output, shape)
20868 if err != nil {
20869 var snapshot bytes.Buffer
20870 io.Copy(&snapshot, ringBuffer)
20871 err = &smithy.DeserializationError{
20872 Err: fmt.Errorf("failed to decode response body, %w", err),
20873 Snapshot: snapshot.Bytes(),
20874 }
20875 return out, metadata, err
20876 }
20877
20878 return out, metadata, err
20879 }
20880
20881 func awsAwsjson11_deserializeOpErrorUpdateRelationalDatabaseParameters(response *smithyhttp.Response, metadata *middleware.Metadata) error {
20882 var errorBuffer bytes.Buffer
20883 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
20884 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
20885 }
20886 errorBody := bytes.NewReader(errorBuffer.Bytes())
20887
20888 errorCode := "UnknownError"
20889 errorMessage := errorCode
20890
20891 headerCode := response.Header.Get("X-Amzn-ErrorType")
20892
20893 var buff [1024]byte
20894 ringBuffer := smithyio.NewRingBuffer(buff[:])
20895
20896 body := io.TeeReader(errorBody, ringBuffer)
20897 decoder := json.NewDecoder(body)
20898 decoder.UseNumber()
20899 bodyInfo, err := getProtocolErrorInfo(decoder)
20900 if err != nil {
20901 var snapshot bytes.Buffer
20902 io.Copy(&snapshot, ringBuffer)
20903 err = &smithy.DeserializationError{
20904 Err: fmt.Errorf("failed to decode response body, %w", err),
20905 Snapshot: snapshot.Bytes(),
20906 }
20907 return err
20908 }
20909
20910 errorBody.Seek(0, io.SeekStart)
20911 if typ, ok := resolveProtocolErrorType(headerCode, bodyInfo); ok {
20912 errorCode = restjson.SanitizeErrorCode(typ)
20913 }
20914 if len(bodyInfo.Message) != 0 {
20915 errorMessage = bodyInfo.Message
20916 }
20917 switch {
20918 case strings.EqualFold("AccessDeniedException", errorCode):
20919 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
20920
20921 case strings.EqualFold("AccountSetupInProgressException", errorCode):
20922 return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
20923
20924 case strings.EqualFold("InvalidInputException", errorCode):
20925 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
20926
20927 case strings.EqualFold("NotFoundException", errorCode):
20928 return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
20929
20930 case strings.EqualFold("OperationFailureException", errorCode):
20931 return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
20932
20933 case strings.EqualFold("RegionSetupInProgressException", errorCode):
20934 return awsAwsjson11_deserializeErrorRegionSetupInProgressException(response, errorBody)
20935
20936 case strings.EqualFold("ServiceException", errorCode):
20937 return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
20938
20939 case strings.EqualFold("UnauthenticatedException", errorCode):
20940 return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
20941
20942 default:
20943 genericError := &smithy.GenericAPIError{
20944 Code: errorCode,
20945 Message: errorMessage,
20946 }
20947 return genericError
20948
20949 }
20950 }
20951
20952 func awsAwsjson11_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
20953 var buff [1024]byte
20954 ringBuffer := smithyio.NewRingBuffer(buff[:])
20955
20956 body := io.TeeReader(errorBody, ringBuffer)
20957 decoder := json.NewDecoder(body)
20958 decoder.UseNumber()
20959 var shape interface{}
20960 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
20961 var snapshot bytes.Buffer
20962 io.Copy(&snapshot, ringBuffer)
20963 err = &smithy.DeserializationError{
20964 Err: fmt.Errorf("failed to decode response body, %w", err),
20965 Snapshot: snapshot.Bytes(),
20966 }
20967 return err
20968 }
20969
20970 output := &types.AccessDeniedException{}
20971 err := awsAwsjson11_deserializeDocumentAccessDeniedException(&output, shape)
20972
20973 if err != nil {
20974 var snapshot bytes.Buffer
20975 io.Copy(&snapshot, ringBuffer)
20976 err = &smithy.DeserializationError{
20977 Err: fmt.Errorf("failed to decode response body, %w", err),
20978 Snapshot: snapshot.Bytes(),
20979 }
20980 return err
20981 }
20982
20983 errorBody.Seek(0, io.SeekStart)
20984 return output
20985 }
20986
20987 func awsAwsjson11_deserializeErrorAccountSetupInProgressException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
20988 var buff [1024]byte
20989 ringBuffer := smithyio.NewRingBuffer(buff[:])
20990
20991 body := io.TeeReader(errorBody, ringBuffer)
20992 decoder := json.NewDecoder(body)
20993 decoder.UseNumber()
20994 var shape interface{}
20995 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
20996 var snapshot bytes.Buffer
20997 io.Copy(&snapshot, ringBuffer)
20998 err = &smithy.DeserializationError{
20999 Err: fmt.Errorf("failed to decode response body, %w", err),
21000 Snapshot: snapshot.Bytes(),
21001 }
21002 return err
21003 }
21004
21005 output := &types.AccountSetupInProgressException{}
21006 err := awsAwsjson11_deserializeDocumentAccountSetupInProgressException(&output, shape)
21007
21008 if err != nil {
21009 var snapshot bytes.Buffer
21010 io.Copy(&snapshot, ringBuffer)
21011 err = &smithy.DeserializationError{
21012 Err: fmt.Errorf("failed to decode response body, %w", err),
21013 Snapshot: snapshot.Bytes(),
21014 }
21015 return err
21016 }
21017
21018 errorBody.Seek(0, io.SeekStart)
21019 return output
21020 }
21021
21022 func awsAwsjson11_deserializeErrorInvalidInputException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
21023 var buff [1024]byte
21024 ringBuffer := smithyio.NewRingBuffer(buff[:])
21025
21026 body := io.TeeReader(errorBody, ringBuffer)
21027 decoder := json.NewDecoder(body)
21028 decoder.UseNumber()
21029 var shape interface{}
21030 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
21031 var snapshot bytes.Buffer
21032 io.Copy(&snapshot, ringBuffer)
21033 err = &smithy.DeserializationError{
21034 Err: fmt.Errorf("failed to decode response body, %w", err),
21035 Snapshot: snapshot.Bytes(),
21036 }
21037 return err
21038 }
21039
21040 output := &types.InvalidInputException{}
21041 err := awsAwsjson11_deserializeDocumentInvalidInputException(&output, shape)
21042
21043 if err != nil {
21044 var snapshot bytes.Buffer
21045 io.Copy(&snapshot, ringBuffer)
21046 err = &smithy.DeserializationError{
21047 Err: fmt.Errorf("failed to decode response body, %w", err),
21048 Snapshot: snapshot.Bytes(),
21049 }
21050 return err
21051 }
21052
21053 errorBody.Seek(0, io.SeekStart)
21054 return output
21055 }
21056
21057 func awsAwsjson11_deserializeErrorNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
21058 var buff [1024]byte
21059 ringBuffer := smithyio.NewRingBuffer(buff[:])
21060
21061 body := io.TeeReader(errorBody, ringBuffer)
21062 decoder := json.NewDecoder(body)
21063 decoder.UseNumber()
21064 var shape interface{}
21065 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
21066 var snapshot bytes.Buffer
21067 io.Copy(&snapshot, ringBuffer)
21068 err = &smithy.DeserializationError{
21069 Err: fmt.Errorf("failed to decode response body, %w", err),
21070 Snapshot: snapshot.Bytes(),
21071 }
21072 return err
21073 }
21074
21075 output := &types.NotFoundException{}
21076 err := awsAwsjson11_deserializeDocumentNotFoundException(&output, shape)
21077
21078 if err != nil {
21079 var snapshot bytes.Buffer
21080 io.Copy(&snapshot, ringBuffer)
21081 err = &smithy.DeserializationError{
21082 Err: fmt.Errorf("failed to decode response body, %w", err),
21083 Snapshot: snapshot.Bytes(),
21084 }
21085 return err
21086 }
21087
21088 errorBody.Seek(0, io.SeekStart)
21089 return output
21090 }
21091
21092 func awsAwsjson11_deserializeErrorOperationFailureException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
21093 var buff [1024]byte
21094 ringBuffer := smithyio.NewRingBuffer(buff[:])
21095
21096 body := io.TeeReader(errorBody, ringBuffer)
21097 decoder := json.NewDecoder(body)
21098 decoder.UseNumber()
21099 var shape interface{}
21100 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
21101 var snapshot bytes.Buffer
21102 io.Copy(&snapshot, ringBuffer)
21103 err = &smithy.DeserializationError{
21104 Err: fmt.Errorf("failed to decode response body, %w", err),
21105 Snapshot: snapshot.Bytes(),
21106 }
21107 return err
21108 }
21109
21110 output := &types.OperationFailureException{}
21111 err := awsAwsjson11_deserializeDocumentOperationFailureException(&output, shape)
21112
21113 if err != nil {
21114 var snapshot bytes.Buffer
21115 io.Copy(&snapshot, ringBuffer)
21116 err = &smithy.DeserializationError{
21117 Err: fmt.Errorf("failed to decode response body, %w", err),
21118 Snapshot: snapshot.Bytes(),
21119 }
21120 return err
21121 }
21122
21123 errorBody.Seek(0, io.SeekStart)
21124 return output
21125 }
21126
21127 func awsAwsjson11_deserializeErrorRegionSetupInProgressException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
21128 var buff [1024]byte
21129 ringBuffer := smithyio.NewRingBuffer(buff[:])
21130
21131 body := io.TeeReader(errorBody, ringBuffer)
21132 decoder := json.NewDecoder(body)
21133 decoder.UseNumber()
21134 var shape interface{}
21135 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
21136 var snapshot bytes.Buffer
21137 io.Copy(&snapshot, ringBuffer)
21138 err = &smithy.DeserializationError{
21139 Err: fmt.Errorf("failed to decode response body, %w", err),
21140 Snapshot: snapshot.Bytes(),
21141 }
21142 return err
21143 }
21144
21145 output := &types.RegionSetupInProgressException{}
21146 err := awsAwsjson11_deserializeDocumentRegionSetupInProgressException(&output, shape)
21147
21148 if err != nil {
21149 var snapshot bytes.Buffer
21150 io.Copy(&snapshot, ringBuffer)
21151 err = &smithy.DeserializationError{
21152 Err: fmt.Errorf("failed to decode response body, %w", err),
21153 Snapshot: snapshot.Bytes(),
21154 }
21155 return err
21156 }
21157
21158 errorBody.Seek(0, io.SeekStart)
21159 return output
21160 }
21161
21162 func awsAwsjson11_deserializeErrorServiceException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
21163 var buff [1024]byte
21164 ringBuffer := smithyio.NewRingBuffer(buff[:])
21165
21166 body := io.TeeReader(errorBody, ringBuffer)
21167 decoder := json.NewDecoder(body)
21168 decoder.UseNumber()
21169 var shape interface{}
21170 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
21171 var snapshot bytes.Buffer
21172 io.Copy(&snapshot, ringBuffer)
21173 err = &smithy.DeserializationError{
21174 Err: fmt.Errorf("failed to decode response body, %w", err),
21175 Snapshot: snapshot.Bytes(),
21176 }
21177 return err
21178 }
21179
21180 output := &types.ServiceException{}
21181 err := awsAwsjson11_deserializeDocumentServiceException(&output, shape)
21182
21183 if err != nil {
21184 var snapshot bytes.Buffer
21185 io.Copy(&snapshot, ringBuffer)
21186 err = &smithy.DeserializationError{
21187 Err: fmt.Errorf("failed to decode response body, %w", err),
21188 Snapshot: snapshot.Bytes(),
21189 }
21190 return err
21191 }
21192
21193 errorBody.Seek(0, io.SeekStart)
21194 return output
21195 }
21196
21197 func awsAwsjson11_deserializeErrorUnauthenticatedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
21198 var buff [1024]byte
21199 ringBuffer := smithyio.NewRingBuffer(buff[:])
21200
21201 body := io.TeeReader(errorBody, ringBuffer)
21202 decoder := json.NewDecoder(body)
21203 decoder.UseNumber()
21204 var shape interface{}
21205 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
21206 var snapshot bytes.Buffer
21207 io.Copy(&snapshot, ringBuffer)
21208 err = &smithy.DeserializationError{
21209 Err: fmt.Errorf("failed to decode response body, %w", err),
21210 Snapshot: snapshot.Bytes(),
21211 }
21212 return err
21213 }
21214
21215 output := &types.UnauthenticatedException{}
21216 err := awsAwsjson11_deserializeDocumentUnauthenticatedException(&output, shape)
21217
21218 if err != nil {
21219 var snapshot bytes.Buffer
21220 io.Copy(&snapshot, ringBuffer)
21221 err = &smithy.DeserializationError{
21222 Err: fmt.Errorf("failed to decode response body, %w", err),
21223 Snapshot: snapshot.Bytes(),
21224 }
21225 return err
21226 }
21227
21228 errorBody.Seek(0, io.SeekStart)
21229 return output
21230 }
21231
21232 func awsAwsjson11_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error {
21233 if v == nil {
21234 return fmt.Errorf("unexpected nil of type %T", v)
21235 }
21236 if value == nil {
21237 return nil
21238 }
21239
21240 shape, ok := value.(map[string]interface{})
21241 if !ok {
21242 return fmt.Errorf("unexpected JSON type %v", value)
21243 }
21244
21245 var sv *types.AccessDeniedException
21246 if *v == nil {
21247 sv = &types.AccessDeniedException{}
21248 } else {
21249 sv = *v
21250 }
21251
21252 for key, value := range shape {
21253 switch key {
21254 case "code":
21255 if value != nil {
21256 jtv, ok := value.(string)
21257 if !ok {
21258 return fmt.Errorf("expected string to be of type string, got %T instead", value)
21259 }
21260 sv.Code = ptr.String(jtv)
21261 }
21262
21263 case "docs":
21264 if value != nil {
21265 jtv, ok := value.(string)
21266 if !ok {
21267 return fmt.Errorf("expected string to be of type string, got %T instead", value)
21268 }
21269 sv.Docs = ptr.String(jtv)
21270 }
21271
21272 case "message", "Message":
21273 if value != nil {
21274 jtv, ok := value.(string)
21275 if !ok {
21276 return fmt.Errorf("expected string to be of type string, got %T instead", value)
21277 }
21278 sv.Message = ptr.String(jtv)
21279 }
21280
21281 case "tip":
21282 if value != nil {
21283 jtv, ok := value.(string)
21284 if !ok {
21285 return fmt.Errorf("expected string to be of type string, got %T instead", value)
21286 }
21287 sv.Tip = ptr.String(jtv)
21288 }
21289
21290 default:
21291 _, _ = key, value
21292
21293 }
21294 }
21295 *v = sv
21296 return nil
21297 }
21298
21299 func awsAwsjson11_deserializeDocumentAccessKey(v **types.AccessKey, value interface{}) error {
21300 if v == nil {
21301 return fmt.Errorf("unexpected nil of type %T", v)
21302 }
21303 if value == nil {
21304 return nil
21305 }
21306
21307 shape, ok := value.(map[string]interface{})
21308 if !ok {
21309 return fmt.Errorf("unexpected JSON type %v", value)
21310 }
21311
21312 var sv *types.AccessKey
21313 if *v == nil {
21314 sv = &types.AccessKey{}
21315 } else {
21316 sv = *v
21317 }
21318
21319 for key, value := range shape {
21320 switch key {
21321 case "accessKeyId":
21322 if value != nil {
21323 jtv, ok := value.(string)
21324 if !ok {
21325 return fmt.Errorf("expected IAMAccessKeyId to be of type string, got %T instead", value)
21326 }
21327 sv.AccessKeyId = ptr.String(jtv)
21328 }
21329
21330 case "createdAt":
21331 if value != nil {
21332 switch jtv := value.(type) {
21333 case json.Number:
21334 f64, err := jtv.Float64()
21335 if err != nil {
21336 return err
21337 }
21338 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
21339
21340 default:
21341 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
21342
21343 }
21344 }
21345
21346 case "lastUsed":
21347 if err := awsAwsjson11_deserializeDocumentAccessKeyLastUsed(&sv.LastUsed, value); err != nil {
21348 return err
21349 }
21350
21351 case "secretAccessKey":
21352 if value != nil {
21353 jtv, ok := value.(string)
21354 if !ok {
21355 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
21356 }
21357 sv.SecretAccessKey = ptr.String(jtv)
21358 }
21359
21360 case "status":
21361 if value != nil {
21362 jtv, ok := value.(string)
21363 if !ok {
21364 return fmt.Errorf("expected StatusType to be of type string, got %T instead", value)
21365 }
21366 sv.Status = types.StatusType(jtv)
21367 }
21368
21369 default:
21370 _, _ = key, value
21371
21372 }
21373 }
21374 *v = sv
21375 return nil
21376 }
21377
21378 func awsAwsjson11_deserializeDocumentAccessKeyLastUsed(v **types.AccessKeyLastUsed, value interface{}) error {
21379 if v == nil {
21380 return fmt.Errorf("unexpected nil of type %T", v)
21381 }
21382 if value == nil {
21383 return nil
21384 }
21385
21386 shape, ok := value.(map[string]interface{})
21387 if !ok {
21388 return fmt.Errorf("unexpected JSON type %v", value)
21389 }
21390
21391 var sv *types.AccessKeyLastUsed
21392 if *v == nil {
21393 sv = &types.AccessKeyLastUsed{}
21394 } else {
21395 sv = *v
21396 }
21397
21398 for key, value := range shape {
21399 switch key {
21400 case "lastUsedDate":
21401 if value != nil {
21402 switch jtv := value.(type) {
21403 case json.Number:
21404 f64, err := jtv.Float64()
21405 if err != nil {
21406 return err
21407 }
21408 sv.LastUsedDate = ptr.Time(smithytime.ParseEpochSeconds(f64))
21409
21410 default:
21411 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
21412
21413 }
21414 }
21415
21416 case "region":
21417 if value != nil {
21418 jtv, ok := value.(string)
21419 if !ok {
21420 return fmt.Errorf("expected string to be of type string, got %T instead", value)
21421 }
21422 sv.Region = ptr.String(jtv)
21423 }
21424
21425 case "serviceName":
21426 if value != nil {
21427 jtv, ok := value.(string)
21428 if !ok {
21429 return fmt.Errorf("expected string to be of type string, got %T instead", value)
21430 }
21431 sv.ServiceName = ptr.String(jtv)
21432 }
21433
21434 default:
21435 _, _ = key, value
21436
21437 }
21438 }
21439 *v = sv
21440 return nil
21441 }
21442
21443 func awsAwsjson11_deserializeDocumentAccessKeyList(v *[]types.AccessKey, value interface{}) error {
21444 if v == nil {
21445 return fmt.Errorf("unexpected nil of type %T", v)
21446 }
21447 if value == nil {
21448 return nil
21449 }
21450
21451 shape, ok := value.([]interface{})
21452 if !ok {
21453 return fmt.Errorf("unexpected JSON type %v", value)
21454 }
21455
21456 var cv []types.AccessKey
21457 if *v == nil {
21458 cv = []types.AccessKey{}
21459 } else {
21460 cv = *v
21461 }
21462
21463 for _, value := range shape {
21464 var col types.AccessKey
21465 destAddr := &col
21466 if err := awsAwsjson11_deserializeDocumentAccessKey(&destAddr, value); err != nil {
21467 return err
21468 }
21469 col = *destAddr
21470 cv = append(cv, col)
21471
21472 }
21473 *v = cv
21474 return nil
21475 }
21476
21477 func awsAwsjson11_deserializeDocumentAccessReceiverList(v *[]types.ResourceReceivingAccess, value interface{}) error {
21478 if v == nil {
21479 return fmt.Errorf("unexpected nil of type %T", v)
21480 }
21481 if value == nil {
21482 return nil
21483 }
21484
21485 shape, ok := value.([]interface{})
21486 if !ok {
21487 return fmt.Errorf("unexpected JSON type %v", value)
21488 }
21489
21490 var cv []types.ResourceReceivingAccess
21491 if *v == nil {
21492 cv = []types.ResourceReceivingAccess{}
21493 } else {
21494 cv = *v
21495 }
21496
21497 for _, value := range shape {
21498 var col types.ResourceReceivingAccess
21499 destAddr := &col
21500 if err := awsAwsjson11_deserializeDocumentResourceReceivingAccess(&destAddr, value); err != nil {
21501 return err
21502 }
21503 col = *destAddr
21504 cv = append(cv, col)
21505
21506 }
21507 *v = cv
21508 return nil
21509 }
21510
21511 func awsAwsjson11_deserializeDocumentAccessRules(v **types.AccessRules, value interface{}) error {
21512 if v == nil {
21513 return fmt.Errorf("unexpected nil of type %T", v)
21514 }
21515 if value == nil {
21516 return nil
21517 }
21518
21519 shape, ok := value.(map[string]interface{})
21520 if !ok {
21521 return fmt.Errorf("unexpected JSON type %v", value)
21522 }
21523
21524 var sv *types.AccessRules
21525 if *v == nil {
21526 sv = &types.AccessRules{}
21527 } else {
21528 sv = *v
21529 }
21530
21531 for key, value := range shape {
21532 switch key {
21533 case "allowPublicOverrides":
21534 if value != nil {
21535 jtv, ok := value.(bool)
21536 if !ok {
21537 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
21538 }
21539 sv.AllowPublicOverrides = ptr.Bool(jtv)
21540 }
21541
21542 case "getObject":
21543 if value != nil {
21544 jtv, ok := value.(string)
21545 if !ok {
21546 return fmt.Errorf("expected AccessType to be of type string, got %T instead", value)
21547 }
21548 sv.GetObject = types.AccessType(jtv)
21549 }
21550
21551 default:
21552 _, _ = key, value
21553
21554 }
21555 }
21556 *v = sv
21557 return nil
21558 }
21559
21560 func awsAwsjson11_deserializeDocumentAccountLevelBpaSync(v **types.AccountLevelBpaSync, value interface{}) error {
21561 if v == nil {
21562 return fmt.Errorf("unexpected nil of type %T", v)
21563 }
21564 if value == nil {
21565 return nil
21566 }
21567
21568 shape, ok := value.(map[string]interface{})
21569 if !ok {
21570 return fmt.Errorf("unexpected JSON type %v", value)
21571 }
21572
21573 var sv *types.AccountLevelBpaSync
21574 if *v == nil {
21575 sv = &types.AccountLevelBpaSync{}
21576 } else {
21577 sv = *v
21578 }
21579
21580 for key, value := range shape {
21581 switch key {
21582 case "bpaImpactsLightsail":
21583 if value != nil {
21584 jtv, ok := value.(bool)
21585 if !ok {
21586 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
21587 }
21588 sv.BpaImpactsLightsail = ptr.Bool(jtv)
21589 }
21590
21591 case "lastSyncedAt":
21592 if value != nil {
21593 switch jtv := value.(type) {
21594 case json.Number:
21595 f64, err := jtv.Float64()
21596 if err != nil {
21597 return err
21598 }
21599 sv.LastSyncedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
21600
21601 default:
21602 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
21603
21604 }
21605 }
21606
21607 case "message":
21608 if value != nil {
21609 jtv, ok := value.(string)
21610 if !ok {
21611 return fmt.Errorf("expected BPAStatusMessage to be of type string, got %T instead", value)
21612 }
21613 sv.Message = types.BPAStatusMessage(jtv)
21614 }
21615
21616 case "status":
21617 if value != nil {
21618 jtv, ok := value.(string)
21619 if !ok {
21620 return fmt.Errorf("expected AccountLevelBpaSyncStatus to be of type string, got %T instead", value)
21621 }
21622 sv.Status = types.AccountLevelBpaSyncStatus(jtv)
21623 }
21624
21625 default:
21626 _, _ = key, value
21627
21628 }
21629 }
21630 *v = sv
21631 return nil
21632 }
21633
21634 func awsAwsjson11_deserializeDocumentAccountSetupInProgressException(v **types.AccountSetupInProgressException, value interface{}) error {
21635 if v == nil {
21636 return fmt.Errorf("unexpected nil of type %T", v)
21637 }
21638 if value == nil {
21639 return nil
21640 }
21641
21642 shape, ok := value.(map[string]interface{})
21643 if !ok {
21644 return fmt.Errorf("unexpected JSON type %v", value)
21645 }
21646
21647 var sv *types.AccountSetupInProgressException
21648 if *v == nil {
21649 sv = &types.AccountSetupInProgressException{}
21650 } else {
21651 sv = *v
21652 }
21653
21654 for key, value := range shape {
21655 switch key {
21656 case "code":
21657 if value != nil {
21658 jtv, ok := value.(string)
21659 if !ok {
21660 return fmt.Errorf("expected string to be of type string, got %T instead", value)
21661 }
21662 sv.Code = ptr.String(jtv)
21663 }
21664
21665 case "docs":
21666 if value != nil {
21667 jtv, ok := value.(string)
21668 if !ok {
21669 return fmt.Errorf("expected string to be of type string, got %T instead", value)
21670 }
21671 sv.Docs = ptr.String(jtv)
21672 }
21673
21674 case "message", "Message":
21675 if value != nil {
21676 jtv, ok := value.(string)
21677 if !ok {
21678 return fmt.Errorf("expected string to be of type string, got %T instead", value)
21679 }
21680 sv.Message = ptr.String(jtv)
21681 }
21682
21683 case "tip":
21684 if value != nil {
21685 jtv, ok := value.(string)
21686 if !ok {
21687 return fmt.Errorf("expected string to be of type string, got %T instead", value)
21688 }
21689 sv.Tip = ptr.String(jtv)
21690 }
21691
21692 default:
21693 _, _ = key, value
21694
21695 }
21696 }
21697 *v = sv
21698 return nil
21699 }
21700
21701 func awsAwsjson11_deserializeDocumentAddOn(v **types.AddOn, value interface{}) error {
21702 if v == nil {
21703 return fmt.Errorf("unexpected nil of type %T", v)
21704 }
21705 if value == nil {
21706 return nil
21707 }
21708
21709 shape, ok := value.(map[string]interface{})
21710 if !ok {
21711 return fmt.Errorf("unexpected JSON type %v", value)
21712 }
21713
21714 var sv *types.AddOn
21715 if *v == nil {
21716 sv = &types.AddOn{}
21717 } else {
21718 sv = *v
21719 }
21720
21721 for key, value := range shape {
21722 switch key {
21723 case "duration":
21724 if value != nil {
21725 jtv, ok := value.(string)
21726 if !ok {
21727 return fmt.Errorf("expected string to be of type string, got %T instead", value)
21728 }
21729 sv.Duration = ptr.String(jtv)
21730 }
21731
21732 case "name":
21733 if value != nil {
21734 jtv, ok := value.(string)
21735 if !ok {
21736 return fmt.Errorf("expected string to be of type string, got %T instead", value)
21737 }
21738 sv.Name = ptr.String(jtv)
21739 }
21740
21741 case "nextSnapshotTimeOfDay":
21742 if value != nil {
21743 jtv, ok := value.(string)
21744 if !ok {
21745 return fmt.Errorf("expected TimeOfDay to be of type string, got %T instead", value)
21746 }
21747 sv.NextSnapshotTimeOfDay = ptr.String(jtv)
21748 }
21749
21750 case "snapshotTimeOfDay":
21751 if value != nil {
21752 jtv, ok := value.(string)
21753 if !ok {
21754 return fmt.Errorf("expected TimeOfDay to be of type string, got %T instead", value)
21755 }
21756 sv.SnapshotTimeOfDay = ptr.String(jtv)
21757 }
21758
21759 case "status":
21760 if value != nil {
21761 jtv, ok := value.(string)
21762 if !ok {
21763 return fmt.Errorf("expected string to be of type string, got %T instead", value)
21764 }
21765 sv.Status = ptr.String(jtv)
21766 }
21767
21768 case "threshold":
21769 if value != nil {
21770 jtv, ok := value.(string)
21771 if !ok {
21772 return fmt.Errorf("expected string to be of type string, got %T instead", value)
21773 }
21774 sv.Threshold = ptr.String(jtv)
21775 }
21776
21777 default:
21778 _, _ = key, value
21779
21780 }
21781 }
21782 *v = sv
21783 return nil
21784 }
21785
21786 func awsAwsjson11_deserializeDocumentAddOnList(v *[]types.AddOn, value interface{}) error {
21787 if v == nil {
21788 return fmt.Errorf("unexpected nil of type %T", v)
21789 }
21790 if value == nil {
21791 return nil
21792 }
21793
21794 shape, ok := value.([]interface{})
21795 if !ok {
21796 return fmt.Errorf("unexpected JSON type %v", value)
21797 }
21798
21799 var cv []types.AddOn
21800 if *v == nil {
21801 cv = []types.AddOn{}
21802 } else {
21803 cv = *v
21804 }
21805
21806 for _, value := range shape {
21807 var col types.AddOn
21808 destAddr := &col
21809 if err := awsAwsjson11_deserializeDocumentAddOn(&destAddr, value); err != nil {
21810 return err
21811 }
21812 col = *destAddr
21813 cv = append(cv, col)
21814
21815 }
21816 *v = cv
21817 return nil
21818 }
21819
21820 func awsAwsjson11_deserializeDocumentAlarm(v **types.Alarm, value interface{}) error {
21821 if v == nil {
21822 return fmt.Errorf("unexpected nil of type %T", v)
21823 }
21824 if value == nil {
21825 return nil
21826 }
21827
21828 shape, ok := value.(map[string]interface{})
21829 if !ok {
21830 return fmt.Errorf("unexpected JSON type %v", value)
21831 }
21832
21833 var sv *types.Alarm
21834 if *v == nil {
21835 sv = &types.Alarm{}
21836 } else {
21837 sv = *v
21838 }
21839
21840 for key, value := range shape {
21841 switch key {
21842 case "arn":
21843 if value != nil {
21844 jtv, ok := value.(string)
21845 if !ok {
21846 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
21847 }
21848 sv.Arn = ptr.String(jtv)
21849 }
21850
21851 case "comparisonOperator":
21852 if value != nil {
21853 jtv, ok := value.(string)
21854 if !ok {
21855 return fmt.Errorf("expected ComparisonOperator to be of type string, got %T instead", value)
21856 }
21857 sv.ComparisonOperator = types.ComparisonOperator(jtv)
21858 }
21859
21860 case "contactProtocols":
21861 if err := awsAwsjson11_deserializeDocumentContactProtocolsList(&sv.ContactProtocols, value); err != nil {
21862 return err
21863 }
21864
21865 case "createdAt":
21866 if value != nil {
21867 switch jtv := value.(type) {
21868 case json.Number:
21869 f64, err := jtv.Float64()
21870 if err != nil {
21871 return err
21872 }
21873 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
21874
21875 default:
21876 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
21877
21878 }
21879 }
21880
21881 case "datapointsToAlarm":
21882 if value != nil {
21883 jtv, ok := value.(json.Number)
21884 if !ok {
21885 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
21886 }
21887 i64, err := jtv.Int64()
21888 if err != nil {
21889 return err
21890 }
21891 sv.DatapointsToAlarm = ptr.Int32(int32(i64))
21892 }
21893
21894 case "evaluationPeriods":
21895 if value != nil {
21896 jtv, ok := value.(json.Number)
21897 if !ok {
21898 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
21899 }
21900 i64, err := jtv.Int64()
21901 if err != nil {
21902 return err
21903 }
21904 sv.EvaluationPeriods = ptr.Int32(int32(i64))
21905 }
21906
21907 case "location":
21908 if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
21909 return err
21910 }
21911
21912 case "metricName":
21913 if value != nil {
21914 jtv, ok := value.(string)
21915 if !ok {
21916 return fmt.Errorf("expected MetricName to be of type string, got %T instead", value)
21917 }
21918 sv.MetricName = types.MetricName(jtv)
21919 }
21920
21921 case "monitoredResourceInfo":
21922 if err := awsAwsjson11_deserializeDocumentMonitoredResourceInfo(&sv.MonitoredResourceInfo, value); err != nil {
21923 return err
21924 }
21925
21926 case "name":
21927 if value != nil {
21928 jtv, ok := value.(string)
21929 if !ok {
21930 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
21931 }
21932 sv.Name = ptr.String(jtv)
21933 }
21934
21935 case "notificationEnabled":
21936 if value != nil {
21937 jtv, ok := value.(bool)
21938 if !ok {
21939 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
21940 }
21941 sv.NotificationEnabled = ptr.Bool(jtv)
21942 }
21943
21944 case "notificationTriggers":
21945 if err := awsAwsjson11_deserializeDocumentNotificationTriggerList(&sv.NotificationTriggers, value); err != nil {
21946 return err
21947 }
21948
21949 case "period":
21950 if value != nil {
21951 jtv, ok := value.(json.Number)
21952 if !ok {
21953 return fmt.Errorf("expected MetricPeriod to be json.Number, got %T instead", value)
21954 }
21955 i64, err := jtv.Int64()
21956 if err != nil {
21957 return err
21958 }
21959 sv.Period = ptr.Int32(int32(i64))
21960 }
21961
21962 case "resourceType":
21963 if value != nil {
21964 jtv, ok := value.(string)
21965 if !ok {
21966 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
21967 }
21968 sv.ResourceType = types.ResourceType(jtv)
21969 }
21970
21971 case "state":
21972 if value != nil {
21973 jtv, ok := value.(string)
21974 if !ok {
21975 return fmt.Errorf("expected AlarmState to be of type string, got %T instead", value)
21976 }
21977 sv.State = types.AlarmState(jtv)
21978 }
21979
21980 case "statistic":
21981 if value != nil {
21982 jtv, ok := value.(string)
21983 if !ok {
21984 return fmt.Errorf("expected MetricStatistic to be of type string, got %T instead", value)
21985 }
21986 sv.Statistic = types.MetricStatistic(jtv)
21987 }
21988
21989 case "supportCode":
21990 if value != nil {
21991 jtv, ok := value.(string)
21992 if !ok {
21993 return fmt.Errorf("expected string to be of type string, got %T instead", value)
21994 }
21995 sv.SupportCode = ptr.String(jtv)
21996 }
21997
21998 case "threshold":
21999 if value != nil {
22000 switch jtv := value.(type) {
22001 case json.Number:
22002 f64, err := jtv.Float64()
22003 if err != nil {
22004 return err
22005 }
22006 sv.Threshold = ptr.Float64(f64)
22007
22008 case string:
22009 var f64 float64
22010 switch {
22011 case strings.EqualFold(jtv, "NaN"):
22012 f64 = math.NaN()
22013
22014 case strings.EqualFold(jtv, "Infinity"):
22015 f64 = math.Inf(1)
22016
22017 case strings.EqualFold(jtv, "-Infinity"):
22018 f64 = math.Inf(-1)
22019
22020 default:
22021 return fmt.Errorf("unknown JSON number value: %s", jtv)
22022
22023 }
22024 sv.Threshold = ptr.Float64(f64)
22025
22026 default:
22027 return fmt.Errorf("expected double to be a JSON Number, got %T instead", value)
22028
22029 }
22030 }
22031
22032 case "treatMissingData":
22033 if value != nil {
22034 jtv, ok := value.(string)
22035 if !ok {
22036 return fmt.Errorf("expected TreatMissingData to be of type string, got %T instead", value)
22037 }
22038 sv.TreatMissingData = types.TreatMissingData(jtv)
22039 }
22040
22041 case "unit":
22042 if value != nil {
22043 jtv, ok := value.(string)
22044 if !ok {
22045 return fmt.Errorf("expected MetricUnit to be of type string, got %T instead", value)
22046 }
22047 sv.Unit = types.MetricUnit(jtv)
22048 }
22049
22050 default:
22051 _, _ = key, value
22052
22053 }
22054 }
22055 *v = sv
22056 return nil
22057 }
22058
22059 func awsAwsjson11_deserializeDocumentAlarmsList(v *[]types.Alarm, value interface{}) error {
22060 if v == nil {
22061 return fmt.Errorf("unexpected nil of type %T", v)
22062 }
22063 if value == nil {
22064 return nil
22065 }
22066
22067 shape, ok := value.([]interface{})
22068 if !ok {
22069 return fmt.Errorf("unexpected JSON type %v", value)
22070 }
22071
22072 var cv []types.Alarm
22073 if *v == nil {
22074 cv = []types.Alarm{}
22075 } else {
22076 cv = *v
22077 }
22078
22079 for _, value := range shape {
22080 var col types.Alarm
22081 destAddr := &col
22082 if err := awsAwsjson11_deserializeDocumentAlarm(&destAddr, value); err != nil {
22083 return err
22084 }
22085 col = *destAddr
22086 cv = append(cv, col)
22087
22088 }
22089 *v = cv
22090 return nil
22091 }
22092
22093 func awsAwsjson11_deserializeDocumentAppCategoryList(v *[]types.AppCategory, value interface{}) error {
22094 if v == nil {
22095 return fmt.Errorf("unexpected nil of type %T", v)
22096 }
22097 if value == nil {
22098 return nil
22099 }
22100
22101 shape, ok := value.([]interface{})
22102 if !ok {
22103 return fmt.Errorf("unexpected JSON type %v", value)
22104 }
22105
22106 var cv []types.AppCategory
22107 if *v == nil {
22108 cv = []types.AppCategory{}
22109 } else {
22110 cv = *v
22111 }
22112
22113 for _, value := range shape {
22114 var col types.AppCategory
22115 if value != nil {
22116 jtv, ok := value.(string)
22117 if !ok {
22118 return fmt.Errorf("expected AppCategory to be of type string, got %T instead", value)
22119 }
22120 col = types.AppCategory(jtv)
22121 }
22122 cv = append(cv, col)
22123
22124 }
22125 *v = cv
22126 return nil
22127 }
22128
22129 func awsAwsjson11_deserializeDocumentAttachedDisk(v **types.AttachedDisk, value interface{}) error {
22130 if v == nil {
22131 return fmt.Errorf("unexpected nil of type %T", v)
22132 }
22133 if value == nil {
22134 return nil
22135 }
22136
22137 shape, ok := value.(map[string]interface{})
22138 if !ok {
22139 return fmt.Errorf("unexpected JSON type %v", value)
22140 }
22141
22142 var sv *types.AttachedDisk
22143 if *v == nil {
22144 sv = &types.AttachedDisk{}
22145 } else {
22146 sv = *v
22147 }
22148
22149 for key, value := range shape {
22150 switch key {
22151 case "path":
22152 if value != nil {
22153 jtv, ok := value.(string)
22154 if !ok {
22155 return fmt.Errorf("expected string to be of type string, got %T instead", value)
22156 }
22157 sv.Path = ptr.String(jtv)
22158 }
22159
22160 case "sizeInGb":
22161 if value != nil {
22162 jtv, ok := value.(json.Number)
22163 if !ok {
22164 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
22165 }
22166 i64, err := jtv.Int64()
22167 if err != nil {
22168 return err
22169 }
22170 sv.SizeInGb = ptr.Int32(int32(i64))
22171 }
22172
22173 default:
22174 _, _ = key, value
22175
22176 }
22177 }
22178 *v = sv
22179 return nil
22180 }
22181
22182 func awsAwsjson11_deserializeDocumentAttachedDiskList(v *[]types.AttachedDisk, value interface{}) error {
22183 if v == nil {
22184 return fmt.Errorf("unexpected nil of type %T", v)
22185 }
22186 if value == nil {
22187 return nil
22188 }
22189
22190 shape, ok := value.([]interface{})
22191 if !ok {
22192 return fmt.Errorf("unexpected JSON type %v", value)
22193 }
22194
22195 var cv []types.AttachedDisk
22196 if *v == nil {
22197 cv = []types.AttachedDisk{}
22198 } else {
22199 cv = *v
22200 }
22201
22202 for _, value := range shape {
22203 var col types.AttachedDisk
22204 destAddr := &col
22205 if err := awsAwsjson11_deserializeDocumentAttachedDisk(&destAddr, value); err != nil {
22206 return err
22207 }
22208 col = *destAddr
22209 cv = append(cv, col)
22210
22211 }
22212 *v = cv
22213 return nil
22214 }
22215
22216 func awsAwsjson11_deserializeDocumentAutoSnapshotDetails(v **types.AutoSnapshotDetails, value interface{}) error {
22217 if v == nil {
22218 return fmt.Errorf("unexpected nil of type %T", v)
22219 }
22220 if value == nil {
22221 return nil
22222 }
22223
22224 shape, ok := value.(map[string]interface{})
22225 if !ok {
22226 return fmt.Errorf("unexpected JSON type %v", value)
22227 }
22228
22229 var sv *types.AutoSnapshotDetails
22230 if *v == nil {
22231 sv = &types.AutoSnapshotDetails{}
22232 } else {
22233 sv = *v
22234 }
22235
22236 for key, value := range shape {
22237 switch key {
22238 case "createdAt":
22239 if value != nil {
22240 switch jtv := value.(type) {
22241 case json.Number:
22242 f64, err := jtv.Float64()
22243 if err != nil {
22244 return err
22245 }
22246 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
22247
22248 default:
22249 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
22250
22251 }
22252 }
22253
22254 case "date":
22255 if value != nil {
22256 jtv, ok := value.(string)
22257 if !ok {
22258 return fmt.Errorf("expected string to be of type string, got %T instead", value)
22259 }
22260 sv.Date = ptr.String(jtv)
22261 }
22262
22263 case "fromAttachedDisks":
22264 if err := awsAwsjson11_deserializeDocumentAttachedDiskList(&sv.FromAttachedDisks, value); err != nil {
22265 return err
22266 }
22267
22268 case "status":
22269 if value != nil {
22270 jtv, ok := value.(string)
22271 if !ok {
22272 return fmt.Errorf("expected AutoSnapshotStatus to be of type string, got %T instead", value)
22273 }
22274 sv.Status = types.AutoSnapshotStatus(jtv)
22275 }
22276
22277 default:
22278 _, _ = key, value
22279
22280 }
22281 }
22282 *v = sv
22283 return nil
22284 }
22285
22286 func awsAwsjson11_deserializeDocumentAutoSnapshotDetailsList(v *[]types.AutoSnapshotDetails, value interface{}) error {
22287 if v == nil {
22288 return fmt.Errorf("unexpected nil of type %T", v)
22289 }
22290 if value == nil {
22291 return nil
22292 }
22293
22294 shape, ok := value.([]interface{})
22295 if !ok {
22296 return fmt.Errorf("unexpected JSON type %v", value)
22297 }
22298
22299 var cv []types.AutoSnapshotDetails
22300 if *v == nil {
22301 cv = []types.AutoSnapshotDetails{}
22302 } else {
22303 cv = *v
22304 }
22305
22306 for _, value := range shape {
22307 var col types.AutoSnapshotDetails
22308 destAddr := &col
22309 if err := awsAwsjson11_deserializeDocumentAutoSnapshotDetails(&destAddr, value); err != nil {
22310 return err
22311 }
22312 col = *destAddr
22313 cv = append(cv, col)
22314
22315 }
22316 *v = cv
22317 return nil
22318 }
22319
22320 func awsAwsjson11_deserializeDocumentAvailabilityZone(v **types.AvailabilityZone, value interface{}) error {
22321 if v == nil {
22322 return fmt.Errorf("unexpected nil of type %T", v)
22323 }
22324 if value == nil {
22325 return nil
22326 }
22327
22328 shape, ok := value.(map[string]interface{})
22329 if !ok {
22330 return fmt.Errorf("unexpected JSON type %v", value)
22331 }
22332
22333 var sv *types.AvailabilityZone
22334 if *v == nil {
22335 sv = &types.AvailabilityZone{}
22336 } else {
22337 sv = *v
22338 }
22339
22340 for key, value := range shape {
22341 switch key {
22342 case "state":
22343 if value != nil {
22344 jtv, ok := value.(string)
22345 if !ok {
22346 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
22347 }
22348 sv.State = ptr.String(jtv)
22349 }
22350
22351 case "zoneName":
22352 if value != nil {
22353 jtv, ok := value.(string)
22354 if !ok {
22355 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
22356 }
22357 sv.ZoneName = ptr.String(jtv)
22358 }
22359
22360 default:
22361 _, _ = key, value
22362
22363 }
22364 }
22365 *v = sv
22366 return nil
22367 }
22368
22369 func awsAwsjson11_deserializeDocumentAvailabilityZoneList(v *[]types.AvailabilityZone, value interface{}) error {
22370 if v == nil {
22371 return fmt.Errorf("unexpected nil of type %T", v)
22372 }
22373 if value == nil {
22374 return nil
22375 }
22376
22377 shape, ok := value.([]interface{})
22378 if !ok {
22379 return fmt.Errorf("unexpected JSON type %v", value)
22380 }
22381
22382 var cv []types.AvailabilityZone
22383 if *v == nil {
22384 cv = []types.AvailabilityZone{}
22385 } else {
22386 cv = *v
22387 }
22388
22389 for _, value := range shape {
22390 var col types.AvailabilityZone
22391 destAddr := &col
22392 if err := awsAwsjson11_deserializeDocumentAvailabilityZone(&destAddr, value); err != nil {
22393 return err
22394 }
22395 col = *destAddr
22396 cv = append(cv, col)
22397
22398 }
22399 *v = cv
22400 return nil
22401 }
22402
22403 func awsAwsjson11_deserializeDocumentBlueprint(v **types.Blueprint, value interface{}) error {
22404 if v == nil {
22405 return fmt.Errorf("unexpected nil of type %T", v)
22406 }
22407 if value == nil {
22408 return nil
22409 }
22410
22411 shape, ok := value.(map[string]interface{})
22412 if !ok {
22413 return fmt.Errorf("unexpected JSON type %v", value)
22414 }
22415
22416 var sv *types.Blueprint
22417 if *v == nil {
22418 sv = &types.Blueprint{}
22419 } else {
22420 sv = *v
22421 }
22422
22423 for key, value := range shape {
22424 switch key {
22425 case "appCategory":
22426 if value != nil {
22427 jtv, ok := value.(string)
22428 if !ok {
22429 return fmt.Errorf("expected AppCategory to be of type string, got %T instead", value)
22430 }
22431 sv.AppCategory = types.AppCategory(jtv)
22432 }
22433
22434 case "blueprintId":
22435 if value != nil {
22436 jtv, ok := value.(string)
22437 if !ok {
22438 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
22439 }
22440 sv.BlueprintId = ptr.String(jtv)
22441 }
22442
22443 case "description":
22444 if value != nil {
22445 jtv, ok := value.(string)
22446 if !ok {
22447 return fmt.Errorf("expected string to be of type string, got %T instead", value)
22448 }
22449 sv.Description = ptr.String(jtv)
22450 }
22451
22452 case "group":
22453 if value != nil {
22454 jtv, ok := value.(string)
22455 if !ok {
22456 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
22457 }
22458 sv.Group = ptr.String(jtv)
22459 }
22460
22461 case "isActive":
22462 if value != nil {
22463 jtv, ok := value.(bool)
22464 if !ok {
22465 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
22466 }
22467 sv.IsActive = ptr.Bool(jtv)
22468 }
22469
22470 case "licenseUrl":
22471 if value != nil {
22472 jtv, ok := value.(string)
22473 if !ok {
22474 return fmt.Errorf("expected string to be of type string, got %T instead", value)
22475 }
22476 sv.LicenseUrl = ptr.String(jtv)
22477 }
22478
22479 case "minPower":
22480 if value != nil {
22481 jtv, ok := value.(json.Number)
22482 if !ok {
22483 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
22484 }
22485 i64, err := jtv.Int64()
22486 if err != nil {
22487 return err
22488 }
22489 sv.MinPower = ptr.Int32(int32(i64))
22490 }
22491
22492 case "name":
22493 if value != nil {
22494 jtv, ok := value.(string)
22495 if !ok {
22496 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
22497 }
22498 sv.Name = ptr.String(jtv)
22499 }
22500
22501 case "platform":
22502 if value != nil {
22503 jtv, ok := value.(string)
22504 if !ok {
22505 return fmt.Errorf("expected InstancePlatform to be of type string, got %T instead", value)
22506 }
22507 sv.Platform = types.InstancePlatform(jtv)
22508 }
22509
22510 case "productUrl":
22511 if value != nil {
22512 jtv, ok := value.(string)
22513 if !ok {
22514 return fmt.Errorf("expected string to be of type string, got %T instead", value)
22515 }
22516 sv.ProductUrl = ptr.String(jtv)
22517 }
22518
22519 case "type":
22520 if value != nil {
22521 jtv, ok := value.(string)
22522 if !ok {
22523 return fmt.Errorf("expected BlueprintType to be of type string, got %T instead", value)
22524 }
22525 sv.Type = types.BlueprintType(jtv)
22526 }
22527
22528 case "version":
22529 if value != nil {
22530 jtv, ok := value.(string)
22531 if !ok {
22532 return fmt.Errorf("expected string to be of type string, got %T instead", value)
22533 }
22534 sv.Version = ptr.String(jtv)
22535 }
22536
22537 case "versionCode":
22538 if value != nil {
22539 jtv, ok := value.(string)
22540 if !ok {
22541 return fmt.Errorf("expected string to be of type string, got %T instead", value)
22542 }
22543 sv.VersionCode = ptr.String(jtv)
22544 }
22545
22546 default:
22547 _, _ = key, value
22548
22549 }
22550 }
22551 *v = sv
22552 return nil
22553 }
22554
22555 func awsAwsjson11_deserializeDocumentBlueprintList(v *[]types.Blueprint, value interface{}) error {
22556 if v == nil {
22557 return fmt.Errorf("unexpected nil of type %T", v)
22558 }
22559 if value == nil {
22560 return nil
22561 }
22562
22563 shape, ok := value.([]interface{})
22564 if !ok {
22565 return fmt.Errorf("unexpected JSON type %v", value)
22566 }
22567
22568 var cv []types.Blueprint
22569 if *v == nil {
22570 cv = []types.Blueprint{}
22571 } else {
22572 cv = *v
22573 }
22574
22575 for _, value := range shape {
22576 var col types.Blueprint
22577 destAddr := &col
22578 if err := awsAwsjson11_deserializeDocumentBlueprint(&destAddr, value); err != nil {
22579 return err
22580 }
22581 col = *destAddr
22582 cv = append(cv, col)
22583
22584 }
22585 *v = cv
22586 return nil
22587 }
22588
22589 func awsAwsjson11_deserializeDocumentBucket(v **types.Bucket, value interface{}) error {
22590 if v == nil {
22591 return fmt.Errorf("unexpected nil of type %T", v)
22592 }
22593 if value == nil {
22594 return nil
22595 }
22596
22597 shape, ok := value.(map[string]interface{})
22598 if !ok {
22599 return fmt.Errorf("unexpected JSON type %v", value)
22600 }
22601
22602 var sv *types.Bucket
22603 if *v == nil {
22604 sv = &types.Bucket{}
22605 } else {
22606 sv = *v
22607 }
22608
22609 for key, value := range shape {
22610 switch key {
22611 case "ableToUpdateBundle":
22612 if value != nil {
22613 jtv, ok := value.(bool)
22614 if !ok {
22615 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
22616 }
22617 sv.AbleToUpdateBundle = ptr.Bool(jtv)
22618 }
22619
22620 case "accessLogConfig":
22621 if err := awsAwsjson11_deserializeDocumentBucketAccessLogConfig(&sv.AccessLogConfig, value); err != nil {
22622 return err
22623 }
22624
22625 case "accessRules":
22626 if err := awsAwsjson11_deserializeDocumentAccessRules(&sv.AccessRules, value); err != nil {
22627 return err
22628 }
22629
22630 case "arn":
22631 if value != nil {
22632 jtv, ok := value.(string)
22633 if !ok {
22634 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
22635 }
22636 sv.Arn = ptr.String(jtv)
22637 }
22638
22639 case "bundleId":
22640 if value != nil {
22641 jtv, ok := value.(string)
22642 if !ok {
22643 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
22644 }
22645 sv.BundleId = ptr.String(jtv)
22646 }
22647
22648 case "cors":
22649 if err := awsAwsjson11_deserializeDocumentBucketCorsConfig(&sv.Cors, value); err != nil {
22650 return err
22651 }
22652
22653 case "createdAt":
22654 if value != nil {
22655 switch jtv := value.(type) {
22656 case json.Number:
22657 f64, err := jtv.Float64()
22658 if err != nil {
22659 return err
22660 }
22661 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
22662
22663 default:
22664 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
22665
22666 }
22667 }
22668
22669 case "location":
22670 if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
22671 return err
22672 }
22673
22674 case "name":
22675 if value != nil {
22676 jtv, ok := value.(string)
22677 if !ok {
22678 return fmt.Errorf("expected BucketName to be of type string, got %T instead", value)
22679 }
22680 sv.Name = ptr.String(jtv)
22681 }
22682
22683 case "objectVersioning":
22684 if value != nil {
22685 jtv, ok := value.(string)
22686 if !ok {
22687 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
22688 }
22689 sv.ObjectVersioning = ptr.String(jtv)
22690 }
22691
22692 case "readonlyAccessAccounts":
22693 if err := awsAwsjson11_deserializeDocumentPartnerIdList(&sv.ReadonlyAccessAccounts, value); err != nil {
22694 return err
22695 }
22696
22697 case "resourcesReceivingAccess":
22698 if err := awsAwsjson11_deserializeDocumentAccessReceiverList(&sv.ResourcesReceivingAccess, value); err != nil {
22699 return err
22700 }
22701
22702 case "resourceType":
22703 if value != nil {
22704 jtv, ok := value.(string)
22705 if !ok {
22706 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
22707 }
22708 sv.ResourceType = ptr.String(jtv)
22709 }
22710
22711 case "state":
22712 if err := awsAwsjson11_deserializeDocumentBucketState(&sv.State, value); err != nil {
22713 return err
22714 }
22715
22716 case "supportCode":
22717 if value != nil {
22718 jtv, ok := value.(string)
22719 if !ok {
22720 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
22721 }
22722 sv.SupportCode = ptr.String(jtv)
22723 }
22724
22725 case "tags":
22726 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
22727 return err
22728 }
22729
22730 case "url":
22731 if value != nil {
22732 jtv, ok := value.(string)
22733 if !ok {
22734 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
22735 }
22736 sv.Url = ptr.String(jtv)
22737 }
22738
22739 default:
22740 _, _ = key, value
22741
22742 }
22743 }
22744 *v = sv
22745 return nil
22746 }
22747
22748 func awsAwsjson11_deserializeDocumentBucketAccessLogConfig(v **types.BucketAccessLogConfig, value interface{}) error {
22749 if v == nil {
22750 return fmt.Errorf("unexpected nil of type %T", v)
22751 }
22752 if value == nil {
22753 return nil
22754 }
22755
22756 shape, ok := value.(map[string]interface{})
22757 if !ok {
22758 return fmt.Errorf("unexpected JSON type %v", value)
22759 }
22760
22761 var sv *types.BucketAccessLogConfig
22762 if *v == nil {
22763 sv = &types.BucketAccessLogConfig{}
22764 } else {
22765 sv = *v
22766 }
22767
22768 for key, value := range shape {
22769 switch key {
22770 case "destination":
22771 if value != nil {
22772 jtv, ok := value.(string)
22773 if !ok {
22774 return fmt.Errorf("expected BucketName to be of type string, got %T instead", value)
22775 }
22776 sv.Destination = ptr.String(jtv)
22777 }
22778
22779 case "enabled":
22780 if value != nil {
22781 jtv, ok := value.(bool)
22782 if !ok {
22783 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
22784 }
22785 sv.Enabled = ptr.Bool(jtv)
22786 }
22787
22788 case "prefix":
22789 if value != nil {
22790 jtv, ok := value.(string)
22791 if !ok {
22792 return fmt.Errorf("expected BucketAccessLogPrefix to be of type string, got %T instead", value)
22793 }
22794 sv.Prefix = ptr.String(jtv)
22795 }
22796
22797 default:
22798 _, _ = key, value
22799
22800 }
22801 }
22802 *v = sv
22803 return nil
22804 }
22805
22806 func awsAwsjson11_deserializeDocumentBucketBundle(v **types.BucketBundle, value interface{}) error {
22807 if v == nil {
22808 return fmt.Errorf("unexpected nil of type %T", v)
22809 }
22810 if value == nil {
22811 return nil
22812 }
22813
22814 shape, ok := value.(map[string]interface{})
22815 if !ok {
22816 return fmt.Errorf("unexpected JSON type %v", value)
22817 }
22818
22819 var sv *types.BucketBundle
22820 if *v == nil {
22821 sv = &types.BucketBundle{}
22822 } else {
22823 sv = *v
22824 }
22825
22826 for key, value := range shape {
22827 switch key {
22828 case "bundleId":
22829 if value != nil {
22830 jtv, ok := value.(string)
22831 if !ok {
22832 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
22833 }
22834 sv.BundleId = ptr.String(jtv)
22835 }
22836
22837 case "isActive":
22838 if value != nil {
22839 jtv, ok := value.(bool)
22840 if !ok {
22841 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
22842 }
22843 sv.IsActive = ptr.Bool(jtv)
22844 }
22845
22846 case "name":
22847 if value != nil {
22848 jtv, ok := value.(string)
22849 if !ok {
22850 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
22851 }
22852 sv.Name = ptr.String(jtv)
22853 }
22854
22855 case "price":
22856 if value != nil {
22857 switch jtv := value.(type) {
22858 case json.Number:
22859 f64, err := jtv.Float64()
22860 if err != nil {
22861 return err
22862 }
22863 sv.Price = ptr.Float32(float32(f64))
22864
22865 case string:
22866 var f64 float64
22867 switch {
22868 case strings.EqualFold(jtv, "NaN"):
22869 f64 = math.NaN()
22870
22871 case strings.EqualFold(jtv, "Infinity"):
22872 f64 = math.Inf(1)
22873
22874 case strings.EqualFold(jtv, "-Infinity"):
22875 f64 = math.Inf(-1)
22876
22877 default:
22878 return fmt.Errorf("unknown JSON number value: %s", jtv)
22879
22880 }
22881 sv.Price = ptr.Float32(float32(f64))
22882
22883 default:
22884 return fmt.Errorf("expected float to be a JSON Number, got %T instead", value)
22885
22886 }
22887 }
22888
22889 case "storagePerMonthInGb":
22890 if value != nil {
22891 jtv, ok := value.(json.Number)
22892 if !ok {
22893 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
22894 }
22895 i64, err := jtv.Int64()
22896 if err != nil {
22897 return err
22898 }
22899 sv.StoragePerMonthInGb = ptr.Int32(int32(i64))
22900 }
22901
22902 case "transferPerMonthInGb":
22903 if value != nil {
22904 jtv, ok := value.(json.Number)
22905 if !ok {
22906 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
22907 }
22908 i64, err := jtv.Int64()
22909 if err != nil {
22910 return err
22911 }
22912 sv.TransferPerMonthInGb = ptr.Int32(int32(i64))
22913 }
22914
22915 default:
22916 _, _ = key, value
22917
22918 }
22919 }
22920 *v = sv
22921 return nil
22922 }
22923
22924 func awsAwsjson11_deserializeDocumentBucketBundleList(v *[]types.BucketBundle, value interface{}) error {
22925 if v == nil {
22926 return fmt.Errorf("unexpected nil of type %T", v)
22927 }
22928 if value == nil {
22929 return nil
22930 }
22931
22932 shape, ok := value.([]interface{})
22933 if !ok {
22934 return fmt.Errorf("unexpected JSON type %v", value)
22935 }
22936
22937 var cv []types.BucketBundle
22938 if *v == nil {
22939 cv = []types.BucketBundle{}
22940 } else {
22941 cv = *v
22942 }
22943
22944 for _, value := range shape {
22945 var col types.BucketBundle
22946 destAddr := &col
22947 if err := awsAwsjson11_deserializeDocumentBucketBundle(&destAddr, value); err != nil {
22948 return err
22949 }
22950 col = *destAddr
22951 cv = append(cv, col)
22952
22953 }
22954 *v = cv
22955 return nil
22956 }
22957
22958 func awsAwsjson11_deserializeDocumentBucketCorsAllowedHeaders(v *[]string, value interface{}) error {
22959 if v == nil {
22960 return fmt.Errorf("unexpected nil of type %T", v)
22961 }
22962 if value == nil {
22963 return nil
22964 }
22965
22966 shape, ok := value.([]interface{})
22967 if !ok {
22968 return fmt.Errorf("unexpected JSON type %v", value)
22969 }
22970
22971 var cv []string
22972 if *v == nil {
22973 cv = []string{}
22974 } else {
22975 cv = *v
22976 }
22977
22978 for _, value := range shape {
22979 var col string
22980 if value != nil {
22981 jtv, ok := value.(string)
22982 if !ok {
22983 return fmt.Errorf("expected string to be of type string, got %T instead", value)
22984 }
22985 col = jtv
22986 }
22987 cv = append(cv, col)
22988
22989 }
22990 *v = cv
22991 return nil
22992 }
22993
22994 func awsAwsjson11_deserializeDocumentBucketCorsAllowedMethods(v *[]string, value interface{}) error {
22995 if v == nil {
22996 return fmt.Errorf("unexpected nil of type %T", v)
22997 }
22998 if value == nil {
22999 return nil
23000 }
23001
23002 shape, ok := value.([]interface{})
23003 if !ok {
23004 return fmt.Errorf("unexpected JSON type %v", value)
23005 }
23006
23007 var cv []string
23008 if *v == nil {
23009 cv = []string{}
23010 } else {
23011 cv = *v
23012 }
23013
23014 for _, value := range shape {
23015 var col string
23016 if value != nil {
23017 jtv, ok := value.(string)
23018 if !ok {
23019 return fmt.Errorf("expected BucketCorsAllowedMethod to be of type string, got %T instead", value)
23020 }
23021 col = jtv
23022 }
23023 cv = append(cv, col)
23024
23025 }
23026 *v = cv
23027 return nil
23028 }
23029
23030 func awsAwsjson11_deserializeDocumentBucketCorsAllowedOrigins(v *[]string, value interface{}) error {
23031 if v == nil {
23032 return fmt.Errorf("unexpected nil of type %T", v)
23033 }
23034 if value == nil {
23035 return nil
23036 }
23037
23038 shape, ok := value.([]interface{})
23039 if !ok {
23040 return fmt.Errorf("unexpected JSON type %v", value)
23041 }
23042
23043 var cv []string
23044 if *v == nil {
23045 cv = []string{}
23046 } else {
23047 cv = *v
23048 }
23049
23050 for _, value := range shape {
23051 var col string
23052 if value != nil {
23053 jtv, ok := value.(string)
23054 if !ok {
23055 return fmt.Errorf("expected string to be of type string, got %T instead", value)
23056 }
23057 col = jtv
23058 }
23059 cv = append(cv, col)
23060
23061 }
23062 *v = cv
23063 return nil
23064 }
23065
23066 func awsAwsjson11_deserializeDocumentBucketCorsConfig(v **types.BucketCorsConfig, value interface{}) error {
23067 if v == nil {
23068 return fmt.Errorf("unexpected nil of type %T", v)
23069 }
23070 if value == nil {
23071 return nil
23072 }
23073
23074 shape, ok := value.(map[string]interface{})
23075 if !ok {
23076 return fmt.Errorf("unexpected JSON type %v", value)
23077 }
23078
23079 var sv *types.BucketCorsConfig
23080 if *v == nil {
23081 sv = &types.BucketCorsConfig{}
23082 } else {
23083 sv = *v
23084 }
23085
23086 for key, value := range shape {
23087 switch key {
23088 case "rules":
23089 if err := awsAwsjson11_deserializeDocumentBucketCorsRules(&sv.Rules, value); err != nil {
23090 return err
23091 }
23092
23093 default:
23094 _, _ = key, value
23095
23096 }
23097 }
23098 *v = sv
23099 return nil
23100 }
23101
23102 func awsAwsjson11_deserializeDocumentBucketCorsExposeHeaders(v *[]string, value interface{}) error {
23103 if v == nil {
23104 return fmt.Errorf("unexpected nil of type %T", v)
23105 }
23106 if value == nil {
23107 return nil
23108 }
23109
23110 shape, ok := value.([]interface{})
23111 if !ok {
23112 return fmt.Errorf("unexpected JSON type %v", value)
23113 }
23114
23115 var cv []string
23116 if *v == nil {
23117 cv = []string{}
23118 } else {
23119 cv = *v
23120 }
23121
23122 for _, value := range shape {
23123 var col string
23124 if value != nil {
23125 jtv, ok := value.(string)
23126 if !ok {
23127 return fmt.Errorf("expected string to be of type string, got %T instead", value)
23128 }
23129 col = jtv
23130 }
23131 cv = append(cv, col)
23132
23133 }
23134 *v = cv
23135 return nil
23136 }
23137
23138 func awsAwsjson11_deserializeDocumentBucketCorsRule(v **types.BucketCorsRule, value interface{}) error {
23139 if v == nil {
23140 return fmt.Errorf("unexpected nil of type %T", v)
23141 }
23142 if value == nil {
23143 return nil
23144 }
23145
23146 shape, ok := value.(map[string]interface{})
23147 if !ok {
23148 return fmt.Errorf("unexpected JSON type %v", value)
23149 }
23150
23151 var sv *types.BucketCorsRule
23152 if *v == nil {
23153 sv = &types.BucketCorsRule{}
23154 } else {
23155 sv = *v
23156 }
23157
23158 for key, value := range shape {
23159 switch key {
23160 case "allowedHeaders":
23161 if err := awsAwsjson11_deserializeDocumentBucketCorsAllowedHeaders(&sv.AllowedHeaders, value); err != nil {
23162 return err
23163 }
23164
23165 case "allowedMethods":
23166 if err := awsAwsjson11_deserializeDocumentBucketCorsAllowedMethods(&sv.AllowedMethods, value); err != nil {
23167 return err
23168 }
23169
23170 case "allowedOrigins":
23171 if err := awsAwsjson11_deserializeDocumentBucketCorsAllowedOrigins(&sv.AllowedOrigins, value); err != nil {
23172 return err
23173 }
23174
23175 case "exposeHeaders":
23176 if err := awsAwsjson11_deserializeDocumentBucketCorsExposeHeaders(&sv.ExposeHeaders, value); err != nil {
23177 return err
23178 }
23179
23180 case "id":
23181 if value != nil {
23182 jtv, ok := value.(string)
23183 if !ok {
23184 return fmt.Errorf("expected BucketCorsRuleId to be of type string, got %T instead", value)
23185 }
23186 sv.Id = ptr.String(jtv)
23187 }
23188
23189 case "maxAgeSeconds":
23190 if value != nil {
23191 jtv, ok := value.(json.Number)
23192 if !ok {
23193 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
23194 }
23195 i64, err := jtv.Int64()
23196 if err != nil {
23197 return err
23198 }
23199 sv.MaxAgeSeconds = ptr.Int32(int32(i64))
23200 }
23201
23202 default:
23203 _, _ = key, value
23204
23205 }
23206 }
23207 *v = sv
23208 return nil
23209 }
23210
23211 func awsAwsjson11_deserializeDocumentBucketCorsRules(v *[]types.BucketCorsRule, value interface{}) error {
23212 if v == nil {
23213 return fmt.Errorf("unexpected nil of type %T", v)
23214 }
23215 if value == nil {
23216 return nil
23217 }
23218
23219 shape, ok := value.([]interface{})
23220 if !ok {
23221 return fmt.Errorf("unexpected JSON type %v", value)
23222 }
23223
23224 var cv []types.BucketCorsRule
23225 if *v == nil {
23226 cv = []types.BucketCorsRule{}
23227 } else {
23228 cv = *v
23229 }
23230
23231 for _, value := range shape {
23232 var col types.BucketCorsRule
23233 destAddr := &col
23234 if err := awsAwsjson11_deserializeDocumentBucketCorsRule(&destAddr, value); err != nil {
23235 return err
23236 }
23237 col = *destAddr
23238 cv = append(cv, col)
23239
23240 }
23241 *v = cv
23242 return nil
23243 }
23244
23245 func awsAwsjson11_deserializeDocumentBucketList(v *[]types.Bucket, value interface{}) error {
23246 if v == nil {
23247 return fmt.Errorf("unexpected nil of type %T", v)
23248 }
23249 if value == nil {
23250 return nil
23251 }
23252
23253 shape, ok := value.([]interface{})
23254 if !ok {
23255 return fmt.Errorf("unexpected JSON type %v", value)
23256 }
23257
23258 var cv []types.Bucket
23259 if *v == nil {
23260 cv = []types.Bucket{}
23261 } else {
23262 cv = *v
23263 }
23264
23265 for _, value := range shape {
23266 var col types.Bucket
23267 destAddr := &col
23268 if err := awsAwsjson11_deserializeDocumentBucket(&destAddr, value); err != nil {
23269 return err
23270 }
23271 col = *destAddr
23272 cv = append(cv, col)
23273
23274 }
23275 *v = cv
23276 return nil
23277 }
23278
23279 func awsAwsjson11_deserializeDocumentBucketState(v **types.BucketState, value interface{}) error {
23280 if v == nil {
23281 return fmt.Errorf("unexpected nil of type %T", v)
23282 }
23283 if value == nil {
23284 return nil
23285 }
23286
23287 shape, ok := value.(map[string]interface{})
23288 if !ok {
23289 return fmt.Errorf("unexpected JSON type %v", value)
23290 }
23291
23292 var sv *types.BucketState
23293 if *v == nil {
23294 sv = &types.BucketState{}
23295 } else {
23296 sv = *v
23297 }
23298
23299 for key, value := range shape {
23300 switch key {
23301 case "code":
23302 if value != nil {
23303 jtv, ok := value.(string)
23304 if !ok {
23305 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
23306 }
23307 sv.Code = ptr.String(jtv)
23308 }
23309
23310 case "message":
23311 if value != nil {
23312 jtv, ok := value.(string)
23313 if !ok {
23314 return fmt.Errorf("expected string to be of type string, got %T instead", value)
23315 }
23316 sv.Message = ptr.String(jtv)
23317 }
23318
23319 default:
23320 _, _ = key, value
23321
23322 }
23323 }
23324 *v = sv
23325 return nil
23326 }
23327
23328 func awsAwsjson11_deserializeDocumentBundle(v **types.Bundle, value interface{}) error {
23329 if v == nil {
23330 return fmt.Errorf("unexpected nil of type %T", v)
23331 }
23332 if value == nil {
23333 return nil
23334 }
23335
23336 shape, ok := value.(map[string]interface{})
23337 if !ok {
23338 return fmt.Errorf("unexpected JSON type %v", value)
23339 }
23340
23341 var sv *types.Bundle
23342 if *v == nil {
23343 sv = &types.Bundle{}
23344 } else {
23345 sv = *v
23346 }
23347
23348 for key, value := range shape {
23349 switch key {
23350 case "bundleId":
23351 if value != nil {
23352 jtv, ok := value.(string)
23353 if !ok {
23354 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
23355 }
23356 sv.BundleId = ptr.String(jtv)
23357 }
23358
23359 case "cpuCount":
23360 if value != nil {
23361 jtv, ok := value.(json.Number)
23362 if !ok {
23363 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
23364 }
23365 i64, err := jtv.Int64()
23366 if err != nil {
23367 return err
23368 }
23369 sv.CpuCount = ptr.Int32(int32(i64))
23370 }
23371
23372 case "diskSizeInGb":
23373 if value != nil {
23374 jtv, ok := value.(json.Number)
23375 if !ok {
23376 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
23377 }
23378 i64, err := jtv.Int64()
23379 if err != nil {
23380 return err
23381 }
23382 sv.DiskSizeInGb = ptr.Int32(int32(i64))
23383 }
23384
23385 case "instanceType":
23386 if value != nil {
23387 jtv, ok := value.(string)
23388 if !ok {
23389 return fmt.Errorf("expected string to be of type string, got %T instead", value)
23390 }
23391 sv.InstanceType = ptr.String(jtv)
23392 }
23393
23394 case "isActive":
23395 if value != nil {
23396 jtv, ok := value.(bool)
23397 if !ok {
23398 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
23399 }
23400 sv.IsActive = ptr.Bool(jtv)
23401 }
23402
23403 case "name":
23404 if value != nil {
23405 jtv, ok := value.(string)
23406 if !ok {
23407 return fmt.Errorf("expected string to be of type string, got %T instead", value)
23408 }
23409 sv.Name = ptr.String(jtv)
23410 }
23411
23412 case "power":
23413 if value != nil {
23414 jtv, ok := value.(json.Number)
23415 if !ok {
23416 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
23417 }
23418 i64, err := jtv.Int64()
23419 if err != nil {
23420 return err
23421 }
23422 sv.Power = ptr.Int32(int32(i64))
23423 }
23424
23425 case "price":
23426 if value != nil {
23427 switch jtv := value.(type) {
23428 case json.Number:
23429 f64, err := jtv.Float64()
23430 if err != nil {
23431 return err
23432 }
23433 sv.Price = ptr.Float32(float32(f64))
23434
23435 case string:
23436 var f64 float64
23437 switch {
23438 case strings.EqualFold(jtv, "NaN"):
23439 f64 = math.NaN()
23440
23441 case strings.EqualFold(jtv, "Infinity"):
23442 f64 = math.Inf(1)
23443
23444 case strings.EqualFold(jtv, "-Infinity"):
23445 f64 = math.Inf(-1)
23446
23447 default:
23448 return fmt.Errorf("unknown JSON number value: %s", jtv)
23449
23450 }
23451 sv.Price = ptr.Float32(float32(f64))
23452
23453 default:
23454 return fmt.Errorf("expected float to be a JSON Number, got %T instead", value)
23455
23456 }
23457 }
23458
23459 case "publicIpv4AddressCount":
23460 if value != nil {
23461 jtv, ok := value.(json.Number)
23462 if !ok {
23463 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
23464 }
23465 i64, err := jtv.Int64()
23466 if err != nil {
23467 return err
23468 }
23469 sv.PublicIpv4AddressCount = ptr.Int32(int32(i64))
23470 }
23471
23472 case "ramSizeInGb":
23473 if value != nil {
23474 switch jtv := value.(type) {
23475 case json.Number:
23476 f64, err := jtv.Float64()
23477 if err != nil {
23478 return err
23479 }
23480 sv.RamSizeInGb = ptr.Float32(float32(f64))
23481
23482 case string:
23483 var f64 float64
23484 switch {
23485 case strings.EqualFold(jtv, "NaN"):
23486 f64 = math.NaN()
23487
23488 case strings.EqualFold(jtv, "Infinity"):
23489 f64 = math.Inf(1)
23490
23491 case strings.EqualFold(jtv, "-Infinity"):
23492 f64 = math.Inf(-1)
23493
23494 default:
23495 return fmt.Errorf("unknown JSON number value: %s", jtv)
23496
23497 }
23498 sv.RamSizeInGb = ptr.Float32(float32(f64))
23499
23500 default:
23501 return fmt.Errorf("expected float to be a JSON Number, got %T instead", value)
23502
23503 }
23504 }
23505
23506 case "supportedAppCategories":
23507 if err := awsAwsjson11_deserializeDocumentAppCategoryList(&sv.SupportedAppCategories, value); err != nil {
23508 return err
23509 }
23510
23511 case "supportedPlatforms":
23512 if err := awsAwsjson11_deserializeDocumentInstancePlatformList(&sv.SupportedPlatforms, value); err != nil {
23513 return err
23514 }
23515
23516 case "transferPerMonthInGb":
23517 if value != nil {
23518 jtv, ok := value.(json.Number)
23519 if !ok {
23520 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
23521 }
23522 i64, err := jtv.Int64()
23523 if err != nil {
23524 return err
23525 }
23526 sv.TransferPerMonthInGb = ptr.Int32(int32(i64))
23527 }
23528
23529 default:
23530 _, _ = key, value
23531
23532 }
23533 }
23534 *v = sv
23535 return nil
23536 }
23537
23538 func awsAwsjson11_deserializeDocumentBundleList(v *[]types.Bundle, value interface{}) error {
23539 if v == nil {
23540 return fmt.Errorf("unexpected nil of type %T", v)
23541 }
23542 if value == nil {
23543 return nil
23544 }
23545
23546 shape, ok := value.([]interface{})
23547 if !ok {
23548 return fmt.Errorf("unexpected JSON type %v", value)
23549 }
23550
23551 var cv []types.Bundle
23552 if *v == nil {
23553 cv = []types.Bundle{}
23554 } else {
23555 cv = *v
23556 }
23557
23558 for _, value := range shape {
23559 var col types.Bundle
23560 destAddr := &col
23561 if err := awsAwsjson11_deserializeDocumentBundle(&destAddr, value); err != nil {
23562 return err
23563 }
23564 col = *destAddr
23565 cv = append(cv, col)
23566
23567 }
23568 *v = cv
23569 return nil
23570 }
23571
23572 func awsAwsjson11_deserializeDocumentCacheBehavior(v **types.CacheBehavior, value interface{}) error {
23573 if v == nil {
23574 return fmt.Errorf("unexpected nil of type %T", v)
23575 }
23576 if value == nil {
23577 return nil
23578 }
23579
23580 shape, ok := value.(map[string]interface{})
23581 if !ok {
23582 return fmt.Errorf("unexpected JSON type %v", value)
23583 }
23584
23585 var sv *types.CacheBehavior
23586 if *v == nil {
23587 sv = &types.CacheBehavior{}
23588 } else {
23589 sv = *v
23590 }
23591
23592 for key, value := range shape {
23593 switch key {
23594 case "behavior":
23595 if value != nil {
23596 jtv, ok := value.(string)
23597 if !ok {
23598 return fmt.Errorf("expected BehaviorEnum to be of type string, got %T instead", value)
23599 }
23600 sv.Behavior = types.BehaviorEnum(jtv)
23601 }
23602
23603 default:
23604 _, _ = key, value
23605
23606 }
23607 }
23608 *v = sv
23609 return nil
23610 }
23611
23612 func awsAwsjson11_deserializeDocumentCacheBehaviorList(v *[]types.CacheBehaviorPerPath, value interface{}) error {
23613 if v == nil {
23614 return fmt.Errorf("unexpected nil of type %T", v)
23615 }
23616 if value == nil {
23617 return nil
23618 }
23619
23620 shape, ok := value.([]interface{})
23621 if !ok {
23622 return fmt.Errorf("unexpected JSON type %v", value)
23623 }
23624
23625 var cv []types.CacheBehaviorPerPath
23626 if *v == nil {
23627 cv = []types.CacheBehaviorPerPath{}
23628 } else {
23629 cv = *v
23630 }
23631
23632 for _, value := range shape {
23633 var col types.CacheBehaviorPerPath
23634 destAddr := &col
23635 if err := awsAwsjson11_deserializeDocumentCacheBehaviorPerPath(&destAddr, value); err != nil {
23636 return err
23637 }
23638 col = *destAddr
23639 cv = append(cv, col)
23640
23641 }
23642 *v = cv
23643 return nil
23644 }
23645
23646 func awsAwsjson11_deserializeDocumentCacheBehaviorPerPath(v **types.CacheBehaviorPerPath, value interface{}) error {
23647 if v == nil {
23648 return fmt.Errorf("unexpected nil of type %T", v)
23649 }
23650 if value == nil {
23651 return nil
23652 }
23653
23654 shape, ok := value.(map[string]interface{})
23655 if !ok {
23656 return fmt.Errorf("unexpected JSON type %v", value)
23657 }
23658
23659 var sv *types.CacheBehaviorPerPath
23660 if *v == nil {
23661 sv = &types.CacheBehaviorPerPath{}
23662 } else {
23663 sv = *v
23664 }
23665
23666 for key, value := range shape {
23667 switch key {
23668 case "behavior":
23669 if value != nil {
23670 jtv, ok := value.(string)
23671 if !ok {
23672 return fmt.Errorf("expected BehaviorEnum to be of type string, got %T instead", value)
23673 }
23674 sv.Behavior = types.BehaviorEnum(jtv)
23675 }
23676
23677 case "path":
23678 if value != nil {
23679 jtv, ok := value.(string)
23680 if !ok {
23681 return fmt.Errorf("expected string to be of type string, got %T instead", value)
23682 }
23683 sv.Path = ptr.String(jtv)
23684 }
23685
23686 default:
23687 _, _ = key, value
23688
23689 }
23690 }
23691 *v = sv
23692 return nil
23693 }
23694
23695 func awsAwsjson11_deserializeDocumentCacheSettings(v **types.CacheSettings, value interface{}) error {
23696 if v == nil {
23697 return fmt.Errorf("unexpected nil of type %T", v)
23698 }
23699 if value == nil {
23700 return nil
23701 }
23702
23703 shape, ok := value.(map[string]interface{})
23704 if !ok {
23705 return fmt.Errorf("unexpected JSON type %v", value)
23706 }
23707
23708 var sv *types.CacheSettings
23709 if *v == nil {
23710 sv = &types.CacheSettings{}
23711 } else {
23712 sv = *v
23713 }
23714
23715 for key, value := range shape {
23716 switch key {
23717 case "allowedHTTPMethods":
23718 if value != nil {
23719 jtv, ok := value.(string)
23720 if !ok {
23721 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
23722 }
23723 sv.AllowedHTTPMethods = ptr.String(jtv)
23724 }
23725
23726 case "cachedHTTPMethods":
23727 if value != nil {
23728 jtv, ok := value.(string)
23729 if !ok {
23730 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
23731 }
23732 sv.CachedHTTPMethods = ptr.String(jtv)
23733 }
23734
23735 case "defaultTTL":
23736 if value != nil {
23737 jtv, ok := value.(json.Number)
23738 if !ok {
23739 return fmt.Errorf("expected long to be json.Number, got %T instead", value)
23740 }
23741 i64, err := jtv.Int64()
23742 if err != nil {
23743 return err
23744 }
23745 sv.DefaultTTL = ptr.Int64(i64)
23746 }
23747
23748 case "forwardedCookies":
23749 if err := awsAwsjson11_deserializeDocumentCookieObject(&sv.ForwardedCookies, value); err != nil {
23750 return err
23751 }
23752
23753 case "forwardedHeaders":
23754 if err := awsAwsjson11_deserializeDocumentHeaderObject(&sv.ForwardedHeaders, value); err != nil {
23755 return err
23756 }
23757
23758 case "forwardedQueryStrings":
23759 if err := awsAwsjson11_deserializeDocumentQueryStringObject(&sv.ForwardedQueryStrings, value); err != nil {
23760 return err
23761 }
23762
23763 case "maximumTTL":
23764 if value != nil {
23765 jtv, ok := value.(json.Number)
23766 if !ok {
23767 return fmt.Errorf("expected long to be json.Number, got %T instead", value)
23768 }
23769 i64, err := jtv.Int64()
23770 if err != nil {
23771 return err
23772 }
23773 sv.MaximumTTL = ptr.Int64(i64)
23774 }
23775
23776 case "minimumTTL":
23777 if value != nil {
23778 jtv, ok := value.(json.Number)
23779 if !ok {
23780 return fmt.Errorf("expected long to be json.Number, got %T instead", value)
23781 }
23782 i64, err := jtv.Int64()
23783 if err != nil {
23784 return err
23785 }
23786 sv.MinimumTTL = ptr.Int64(i64)
23787 }
23788
23789 default:
23790 _, _ = key, value
23791
23792 }
23793 }
23794 *v = sv
23795 return nil
23796 }
23797
23798 func awsAwsjson11_deserializeDocumentCertificate(v **types.Certificate, value interface{}) error {
23799 if v == nil {
23800 return fmt.Errorf("unexpected nil of type %T", v)
23801 }
23802 if value == nil {
23803 return nil
23804 }
23805
23806 shape, ok := value.(map[string]interface{})
23807 if !ok {
23808 return fmt.Errorf("unexpected JSON type %v", value)
23809 }
23810
23811 var sv *types.Certificate
23812 if *v == nil {
23813 sv = &types.Certificate{}
23814 } else {
23815 sv = *v
23816 }
23817
23818 for key, value := range shape {
23819 switch key {
23820 case "arn":
23821 if value != nil {
23822 jtv, ok := value.(string)
23823 if !ok {
23824 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
23825 }
23826 sv.Arn = ptr.String(jtv)
23827 }
23828
23829 case "createdAt":
23830 if value != nil {
23831 switch jtv := value.(type) {
23832 case json.Number:
23833 f64, err := jtv.Float64()
23834 if err != nil {
23835 return err
23836 }
23837 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
23838
23839 default:
23840 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
23841
23842 }
23843 }
23844
23845 case "domainName":
23846 if value != nil {
23847 jtv, ok := value.(string)
23848 if !ok {
23849 return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
23850 }
23851 sv.DomainName = ptr.String(jtv)
23852 }
23853
23854 case "domainValidationRecords":
23855 if err := awsAwsjson11_deserializeDocumentDomainValidationRecordList(&sv.DomainValidationRecords, value); err != nil {
23856 return err
23857 }
23858
23859 case "eligibleToRenew":
23860 if value != nil {
23861 jtv, ok := value.(string)
23862 if !ok {
23863 return fmt.Errorf("expected EligibleToRenew to be of type string, got %T instead", value)
23864 }
23865 sv.EligibleToRenew = ptr.String(jtv)
23866 }
23867
23868 case "inUseResourceCount":
23869 if value != nil {
23870 jtv, ok := value.(json.Number)
23871 if !ok {
23872 return fmt.Errorf("expected InUseResourceCount to be json.Number, got %T instead", value)
23873 }
23874 i64, err := jtv.Int64()
23875 if err != nil {
23876 return err
23877 }
23878 sv.InUseResourceCount = int32(i64)
23879 }
23880
23881 case "issuedAt":
23882 if value != nil {
23883 switch jtv := value.(type) {
23884 case json.Number:
23885 f64, err := jtv.Float64()
23886 if err != nil {
23887 return err
23888 }
23889 sv.IssuedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
23890
23891 default:
23892 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
23893
23894 }
23895 }
23896
23897 case "issuerCA":
23898 if value != nil {
23899 jtv, ok := value.(string)
23900 if !ok {
23901 return fmt.Errorf("expected IssuerCA to be of type string, got %T instead", value)
23902 }
23903 sv.IssuerCA = ptr.String(jtv)
23904 }
23905
23906 case "keyAlgorithm":
23907 if value != nil {
23908 jtv, ok := value.(string)
23909 if !ok {
23910 return fmt.Errorf("expected KeyAlgorithm to be of type string, got %T instead", value)
23911 }
23912 sv.KeyAlgorithm = ptr.String(jtv)
23913 }
23914
23915 case "name":
23916 if value != nil {
23917 jtv, ok := value.(string)
23918 if !ok {
23919 return fmt.Errorf("expected CertificateName to be of type string, got %T instead", value)
23920 }
23921 sv.Name = ptr.String(jtv)
23922 }
23923
23924 case "notAfter":
23925 if value != nil {
23926 switch jtv := value.(type) {
23927 case json.Number:
23928 f64, err := jtv.Float64()
23929 if err != nil {
23930 return err
23931 }
23932 sv.NotAfter = ptr.Time(smithytime.ParseEpochSeconds(f64))
23933
23934 default:
23935 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
23936
23937 }
23938 }
23939
23940 case "notBefore":
23941 if value != nil {
23942 switch jtv := value.(type) {
23943 case json.Number:
23944 f64, err := jtv.Float64()
23945 if err != nil {
23946 return err
23947 }
23948 sv.NotBefore = ptr.Time(smithytime.ParseEpochSeconds(f64))
23949
23950 default:
23951 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
23952
23953 }
23954 }
23955
23956 case "renewalSummary":
23957 if err := awsAwsjson11_deserializeDocumentRenewalSummary(&sv.RenewalSummary, value); err != nil {
23958 return err
23959 }
23960
23961 case "requestFailureReason":
23962 if value != nil {
23963 jtv, ok := value.(string)
23964 if !ok {
23965 return fmt.Errorf("expected RequestFailureReason to be of type string, got %T instead", value)
23966 }
23967 sv.RequestFailureReason = ptr.String(jtv)
23968 }
23969
23970 case "revocationReason":
23971 if value != nil {
23972 jtv, ok := value.(string)
23973 if !ok {
23974 return fmt.Errorf("expected RevocationReason to be of type string, got %T instead", value)
23975 }
23976 sv.RevocationReason = ptr.String(jtv)
23977 }
23978
23979 case "revokedAt":
23980 if value != nil {
23981 switch jtv := value.(type) {
23982 case json.Number:
23983 f64, err := jtv.Float64()
23984 if err != nil {
23985 return err
23986 }
23987 sv.RevokedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
23988
23989 default:
23990 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
23991
23992 }
23993 }
23994
23995 case "serialNumber":
23996 if value != nil {
23997 jtv, ok := value.(string)
23998 if !ok {
23999 return fmt.Errorf("expected SerialNumber to be of type string, got %T instead", value)
24000 }
24001 sv.SerialNumber = ptr.String(jtv)
24002 }
24003
24004 case "status":
24005 if value != nil {
24006 jtv, ok := value.(string)
24007 if !ok {
24008 return fmt.Errorf("expected CertificateStatus to be of type string, got %T instead", value)
24009 }
24010 sv.Status = types.CertificateStatus(jtv)
24011 }
24012
24013 case "subjectAlternativeNames":
24014 if err := awsAwsjson11_deserializeDocumentSubjectAlternativeNameList(&sv.SubjectAlternativeNames, value); err != nil {
24015 return err
24016 }
24017
24018 case "supportCode":
24019 if value != nil {
24020 jtv, ok := value.(string)
24021 if !ok {
24022 return fmt.Errorf("expected string to be of type string, got %T instead", value)
24023 }
24024 sv.SupportCode = ptr.String(jtv)
24025 }
24026
24027 case "tags":
24028 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
24029 return err
24030 }
24031
24032 default:
24033 _, _ = key, value
24034
24035 }
24036 }
24037 *v = sv
24038 return nil
24039 }
24040
24041 func awsAwsjson11_deserializeDocumentCertificateSummary(v **types.CertificateSummary, value interface{}) error {
24042 if v == nil {
24043 return fmt.Errorf("unexpected nil of type %T", v)
24044 }
24045 if value == nil {
24046 return nil
24047 }
24048
24049 shape, ok := value.(map[string]interface{})
24050 if !ok {
24051 return fmt.Errorf("unexpected JSON type %v", value)
24052 }
24053
24054 var sv *types.CertificateSummary
24055 if *v == nil {
24056 sv = &types.CertificateSummary{}
24057 } else {
24058 sv = *v
24059 }
24060
24061 for key, value := range shape {
24062 switch key {
24063 case "certificateArn":
24064 if value != nil {
24065 jtv, ok := value.(string)
24066 if !ok {
24067 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
24068 }
24069 sv.CertificateArn = ptr.String(jtv)
24070 }
24071
24072 case "certificateDetail":
24073 if err := awsAwsjson11_deserializeDocumentCertificate(&sv.CertificateDetail, value); err != nil {
24074 return err
24075 }
24076
24077 case "certificateName":
24078 if value != nil {
24079 jtv, ok := value.(string)
24080 if !ok {
24081 return fmt.Errorf("expected CertificateName to be of type string, got %T instead", value)
24082 }
24083 sv.CertificateName = ptr.String(jtv)
24084 }
24085
24086 case "domainName":
24087 if value != nil {
24088 jtv, ok := value.(string)
24089 if !ok {
24090 return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
24091 }
24092 sv.DomainName = ptr.String(jtv)
24093 }
24094
24095 case "tags":
24096 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
24097 return err
24098 }
24099
24100 default:
24101 _, _ = key, value
24102
24103 }
24104 }
24105 *v = sv
24106 return nil
24107 }
24108
24109 func awsAwsjson11_deserializeDocumentCertificateSummaryList(v *[]types.CertificateSummary, value interface{}) error {
24110 if v == nil {
24111 return fmt.Errorf("unexpected nil of type %T", v)
24112 }
24113 if value == nil {
24114 return nil
24115 }
24116
24117 shape, ok := value.([]interface{})
24118 if !ok {
24119 return fmt.Errorf("unexpected JSON type %v", value)
24120 }
24121
24122 var cv []types.CertificateSummary
24123 if *v == nil {
24124 cv = []types.CertificateSummary{}
24125 } else {
24126 cv = *v
24127 }
24128
24129 for _, value := range shape {
24130 var col types.CertificateSummary
24131 destAddr := &col
24132 if err := awsAwsjson11_deserializeDocumentCertificateSummary(&destAddr, value); err != nil {
24133 return err
24134 }
24135 col = *destAddr
24136 cv = append(cv, col)
24137
24138 }
24139 *v = cv
24140 return nil
24141 }
24142
24143 func awsAwsjson11_deserializeDocumentCloudFormationStackRecord(v **types.CloudFormationStackRecord, value interface{}) error {
24144 if v == nil {
24145 return fmt.Errorf("unexpected nil of type %T", v)
24146 }
24147 if value == nil {
24148 return nil
24149 }
24150
24151 shape, ok := value.(map[string]interface{})
24152 if !ok {
24153 return fmt.Errorf("unexpected JSON type %v", value)
24154 }
24155
24156 var sv *types.CloudFormationStackRecord
24157 if *v == nil {
24158 sv = &types.CloudFormationStackRecord{}
24159 } else {
24160 sv = *v
24161 }
24162
24163 for key, value := range shape {
24164 switch key {
24165 case "arn":
24166 if value != nil {
24167 jtv, ok := value.(string)
24168 if !ok {
24169 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
24170 }
24171 sv.Arn = ptr.String(jtv)
24172 }
24173
24174 case "createdAt":
24175 if value != nil {
24176 switch jtv := value.(type) {
24177 case json.Number:
24178 f64, err := jtv.Float64()
24179 if err != nil {
24180 return err
24181 }
24182 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
24183
24184 default:
24185 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
24186
24187 }
24188 }
24189
24190 case "destinationInfo":
24191 if err := awsAwsjson11_deserializeDocumentDestinationInfo(&sv.DestinationInfo, value); err != nil {
24192 return err
24193 }
24194
24195 case "location":
24196 if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
24197 return err
24198 }
24199
24200 case "name":
24201 if value != nil {
24202 jtv, ok := value.(string)
24203 if !ok {
24204 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
24205 }
24206 sv.Name = ptr.String(jtv)
24207 }
24208
24209 case "resourceType":
24210 if value != nil {
24211 jtv, ok := value.(string)
24212 if !ok {
24213 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
24214 }
24215 sv.ResourceType = types.ResourceType(jtv)
24216 }
24217
24218 case "sourceInfo":
24219 if err := awsAwsjson11_deserializeDocumentCloudFormationStackRecordSourceInfoList(&sv.SourceInfo, value); err != nil {
24220 return err
24221 }
24222
24223 case "state":
24224 if value != nil {
24225 jtv, ok := value.(string)
24226 if !ok {
24227 return fmt.Errorf("expected RecordState to be of type string, got %T instead", value)
24228 }
24229 sv.State = types.RecordState(jtv)
24230 }
24231
24232 default:
24233 _, _ = key, value
24234
24235 }
24236 }
24237 *v = sv
24238 return nil
24239 }
24240
24241 func awsAwsjson11_deserializeDocumentCloudFormationStackRecordList(v *[]types.CloudFormationStackRecord, value interface{}) error {
24242 if v == nil {
24243 return fmt.Errorf("unexpected nil of type %T", v)
24244 }
24245 if value == nil {
24246 return nil
24247 }
24248
24249 shape, ok := value.([]interface{})
24250 if !ok {
24251 return fmt.Errorf("unexpected JSON type %v", value)
24252 }
24253
24254 var cv []types.CloudFormationStackRecord
24255 if *v == nil {
24256 cv = []types.CloudFormationStackRecord{}
24257 } else {
24258 cv = *v
24259 }
24260
24261 for _, value := range shape {
24262 var col types.CloudFormationStackRecord
24263 destAddr := &col
24264 if err := awsAwsjson11_deserializeDocumentCloudFormationStackRecord(&destAddr, value); err != nil {
24265 return err
24266 }
24267 col = *destAddr
24268 cv = append(cv, col)
24269
24270 }
24271 *v = cv
24272 return nil
24273 }
24274
24275 func awsAwsjson11_deserializeDocumentCloudFormationStackRecordSourceInfo(v **types.CloudFormationStackRecordSourceInfo, value interface{}) error {
24276 if v == nil {
24277 return fmt.Errorf("unexpected nil of type %T", v)
24278 }
24279 if value == nil {
24280 return nil
24281 }
24282
24283 shape, ok := value.(map[string]interface{})
24284 if !ok {
24285 return fmt.Errorf("unexpected JSON type %v", value)
24286 }
24287
24288 var sv *types.CloudFormationStackRecordSourceInfo
24289 if *v == nil {
24290 sv = &types.CloudFormationStackRecordSourceInfo{}
24291 } else {
24292 sv = *v
24293 }
24294
24295 for key, value := range shape {
24296 switch key {
24297 case "arn":
24298 if value != nil {
24299 jtv, ok := value.(string)
24300 if !ok {
24301 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
24302 }
24303 sv.Arn = ptr.String(jtv)
24304 }
24305
24306 case "name":
24307 if value != nil {
24308 jtv, ok := value.(string)
24309 if !ok {
24310 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
24311 }
24312 sv.Name = ptr.String(jtv)
24313 }
24314
24315 case "resourceType":
24316 if value != nil {
24317 jtv, ok := value.(string)
24318 if !ok {
24319 return fmt.Errorf("expected CloudFormationStackRecordSourceType to be of type string, got %T instead", value)
24320 }
24321 sv.ResourceType = types.CloudFormationStackRecordSourceType(jtv)
24322 }
24323
24324 default:
24325 _, _ = key, value
24326
24327 }
24328 }
24329 *v = sv
24330 return nil
24331 }
24332
24333 func awsAwsjson11_deserializeDocumentCloudFormationStackRecordSourceInfoList(v *[]types.CloudFormationStackRecordSourceInfo, value interface{}) error {
24334 if v == nil {
24335 return fmt.Errorf("unexpected nil of type %T", v)
24336 }
24337 if value == nil {
24338 return nil
24339 }
24340
24341 shape, ok := value.([]interface{})
24342 if !ok {
24343 return fmt.Errorf("unexpected JSON type %v", value)
24344 }
24345
24346 var cv []types.CloudFormationStackRecordSourceInfo
24347 if *v == nil {
24348 cv = []types.CloudFormationStackRecordSourceInfo{}
24349 } else {
24350 cv = *v
24351 }
24352
24353 for _, value := range shape {
24354 var col types.CloudFormationStackRecordSourceInfo
24355 destAddr := &col
24356 if err := awsAwsjson11_deserializeDocumentCloudFormationStackRecordSourceInfo(&destAddr, value); err != nil {
24357 return err
24358 }
24359 col = *destAddr
24360 cv = append(cv, col)
24361
24362 }
24363 *v = cv
24364 return nil
24365 }
24366
24367 func awsAwsjson11_deserializeDocumentContactMethod(v **types.ContactMethod, value interface{}) error {
24368 if v == nil {
24369 return fmt.Errorf("unexpected nil of type %T", v)
24370 }
24371 if value == nil {
24372 return nil
24373 }
24374
24375 shape, ok := value.(map[string]interface{})
24376 if !ok {
24377 return fmt.Errorf("unexpected JSON type %v", value)
24378 }
24379
24380 var sv *types.ContactMethod
24381 if *v == nil {
24382 sv = &types.ContactMethod{}
24383 } else {
24384 sv = *v
24385 }
24386
24387 for key, value := range shape {
24388 switch key {
24389 case "arn":
24390 if value != nil {
24391 jtv, ok := value.(string)
24392 if !ok {
24393 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
24394 }
24395 sv.Arn = ptr.String(jtv)
24396 }
24397
24398 case "contactEndpoint":
24399 if value != nil {
24400 jtv, ok := value.(string)
24401 if !ok {
24402 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
24403 }
24404 sv.ContactEndpoint = ptr.String(jtv)
24405 }
24406
24407 case "createdAt":
24408 if value != nil {
24409 switch jtv := value.(type) {
24410 case json.Number:
24411 f64, err := jtv.Float64()
24412 if err != nil {
24413 return err
24414 }
24415 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
24416
24417 default:
24418 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
24419
24420 }
24421 }
24422
24423 case "location":
24424 if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
24425 return err
24426 }
24427
24428 case "name":
24429 if value != nil {
24430 jtv, ok := value.(string)
24431 if !ok {
24432 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
24433 }
24434 sv.Name = ptr.String(jtv)
24435 }
24436
24437 case "protocol":
24438 if value != nil {
24439 jtv, ok := value.(string)
24440 if !ok {
24441 return fmt.Errorf("expected ContactProtocol to be of type string, got %T instead", value)
24442 }
24443 sv.Protocol = types.ContactProtocol(jtv)
24444 }
24445
24446 case "resourceType":
24447 if value != nil {
24448 jtv, ok := value.(string)
24449 if !ok {
24450 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
24451 }
24452 sv.ResourceType = types.ResourceType(jtv)
24453 }
24454
24455 case "status":
24456 if value != nil {
24457 jtv, ok := value.(string)
24458 if !ok {
24459 return fmt.Errorf("expected ContactMethodStatus to be of type string, got %T instead", value)
24460 }
24461 sv.Status = types.ContactMethodStatus(jtv)
24462 }
24463
24464 case "supportCode":
24465 if value != nil {
24466 jtv, ok := value.(string)
24467 if !ok {
24468 return fmt.Errorf("expected string to be of type string, got %T instead", value)
24469 }
24470 sv.SupportCode = ptr.String(jtv)
24471 }
24472
24473 default:
24474 _, _ = key, value
24475
24476 }
24477 }
24478 *v = sv
24479 return nil
24480 }
24481
24482 func awsAwsjson11_deserializeDocumentContactMethodsList(v *[]types.ContactMethod, value interface{}) error {
24483 if v == nil {
24484 return fmt.Errorf("unexpected nil of type %T", v)
24485 }
24486 if value == nil {
24487 return nil
24488 }
24489
24490 shape, ok := value.([]interface{})
24491 if !ok {
24492 return fmt.Errorf("unexpected JSON type %v", value)
24493 }
24494
24495 var cv []types.ContactMethod
24496 if *v == nil {
24497 cv = []types.ContactMethod{}
24498 } else {
24499 cv = *v
24500 }
24501
24502 for _, value := range shape {
24503 var col types.ContactMethod
24504 destAddr := &col
24505 if err := awsAwsjson11_deserializeDocumentContactMethod(&destAddr, value); err != nil {
24506 return err
24507 }
24508 col = *destAddr
24509 cv = append(cv, col)
24510
24511 }
24512 *v = cv
24513 return nil
24514 }
24515
24516 func awsAwsjson11_deserializeDocumentContactProtocolsList(v *[]types.ContactProtocol, value interface{}) error {
24517 if v == nil {
24518 return fmt.Errorf("unexpected nil of type %T", v)
24519 }
24520 if value == nil {
24521 return nil
24522 }
24523
24524 shape, ok := value.([]interface{})
24525 if !ok {
24526 return fmt.Errorf("unexpected JSON type %v", value)
24527 }
24528
24529 var cv []types.ContactProtocol
24530 if *v == nil {
24531 cv = []types.ContactProtocol{}
24532 } else {
24533 cv = *v
24534 }
24535
24536 for _, value := range shape {
24537 var col types.ContactProtocol
24538 if value != nil {
24539 jtv, ok := value.(string)
24540 if !ok {
24541 return fmt.Errorf("expected ContactProtocol to be of type string, got %T instead", value)
24542 }
24543 col = types.ContactProtocol(jtv)
24544 }
24545 cv = append(cv, col)
24546
24547 }
24548 *v = cv
24549 return nil
24550 }
24551
24552 func awsAwsjson11_deserializeDocumentContainer(v **types.Container, value interface{}) error {
24553 if v == nil {
24554 return fmt.Errorf("unexpected nil of type %T", v)
24555 }
24556 if value == nil {
24557 return nil
24558 }
24559
24560 shape, ok := value.(map[string]interface{})
24561 if !ok {
24562 return fmt.Errorf("unexpected JSON type %v", value)
24563 }
24564
24565 var sv *types.Container
24566 if *v == nil {
24567 sv = &types.Container{}
24568 } else {
24569 sv = *v
24570 }
24571
24572 for key, value := range shape {
24573 switch key {
24574 case "command":
24575 if err := awsAwsjson11_deserializeDocumentStringList(&sv.Command, value); err != nil {
24576 return err
24577 }
24578
24579 case "environment":
24580 if err := awsAwsjson11_deserializeDocumentEnvironment(&sv.Environment, value); err != nil {
24581 return err
24582 }
24583
24584 case "image":
24585 if value != nil {
24586 jtv, ok := value.(string)
24587 if !ok {
24588 return fmt.Errorf("expected string to be of type string, got %T instead", value)
24589 }
24590 sv.Image = ptr.String(jtv)
24591 }
24592
24593 case "ports":
24594 if err := awsAwsjson11_deserializeDocumentPortMap(&sv.Ports, value); err != nil {
24595 return err
24596 }
24597
24598 default:
24599 _, _ = key, value
24600
24601 }
24602 }
24603 *v = sv
24604 return nil
24605 }
24606
24607 func awsAwsjson11_deserializeDocumentContainerImage(v **types.ContainerImage, value interface{}) error {
24608 if v == nil {
24609 return fmt.Errorf("unexpected nil of type %T", v)
24610 }
24611 if value == nil {
24612 return nil
24613 }
24614
24615 shape, ok := value.(map[string]interface{})
24616 if !ok {
24617 return fmt.Errorf("unexpected JSON type %v", value)
24618 }
24619
24620 var sv *types.ContainerImage
24621 if *v == nil {
24622 sv = &types.ContainerImage{}
24623 } else {
24624 sv = *v
24625 }
24626
24627 for key, value := range shape {
24628 switch key {
24629 case "createdAt":
24630 if value != nil {
24631 switch jtv := value.(type) {
24632 case json.Number:
24633 f64, err := jtv.Float64()
24634 if err != nil {
24635 return err
24636 }
24637 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
24638
24639 default:
24640 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
24641
24642 }
24643 }
24644
24645 case "digest":
24646 if value != nil {
24647 jtv, ok := value.(string)
24648 if !ok {
24649 return fmt.Errorf("expected string to be of type string, got %T instead", value)
24650 }
24651 sv.Digest = ptr.String(jtv)
24652 }
24653
24654 case "image":
24655 if value != nil {
24656 jtv, ok := value.(string)
24657 if !ok {
24658 return fmt.Errorf("expected string to be of type string, got %T instead", value)
24659 }
24660 sv.Image = ptr.String(jtv)
24661 }
24662
24663 default:
24664 _, _ = key, value
24665
24666 }
24667 }
24668 *v = sv
24669 return nil
24670 }
24671
24672 func awsAwsjson11_deserializeDocumentContainerImageList(v *[]types.ContainerImage, value interface{}) error {
24673 if v == nil {
24674 return fmt.Errorf("unexpected nil of type %T", v)
24675 }
24676 if value == nil {
24677 return nil
24678 }
24679
24680 shape, ok := value.([]interface{})
24681 if !ok {
24682 return fmt.Errorf("unexpected JSON type %v", value)
24683 }
24684
24685 var cv []types.ContainerImage
24686 if *v == nil {
24687 cv = []types.ContainerImage{}
24688 } else {
24689 cv = *v
24690 }
24691
24692 for _, value := range shape {
24693 var col types.ContainerImage
24694 destAddr := &col
24695 if err := awsAwsjson11_deserializeDocumentContainerImage(&destAddr, value); err != nil {
24696 return err
24697 }
24698 col = *destAddr
24699 cv = append(cv, col)
24700
24701 }
24702 *v = cv
24703 return nil
24704 }
24705
24706 func awsAwsjson11_deserializeDocumentContainerMap(v *map[string]types.Container, value interface{}) error {
24707 if v == nil {
24708 return fmt.Errorf("unexpected nil of type %T", v)
24709 }
24710 if value == nil {
24711 return nil
24712 }
24713
24714 shape, ok := value.(map[string]interface{})
24715 if !ok {
24716 return fmt.Errorf("unexpected JSON type %v", value)
24717 }
24718
24719 var mv map[string]types.Container
24720 if *v == nil {
24721 mv = map[string]types.Container{}
24722 } else {
24723 mv = *v
24724 }
24725
24726 for key, value := range shape {
24727 var parsedVal types.Container
24728 mapVar := parsedVal
24729 destAddr := &mapVar
24730 if err := awsAwsjson11_deserializeDocumentContainer(&destAddr, value); err != nil {
24731 return err
24732 }
24733 parsedVal = *destAddr
24734 mv[key] = parsedVal
24735
24736 }
24737 *v = mv
24738 return nil
24739 }
24740
24741 func awsAwsjson11_deserializeDocumentContainerService(v **types.ContainerService, value interface{}) error {
24742 if v == nil {
24743 return fmt.Errorf("unexpected nil of type %T", v)
24744 }
24745 if value == nil {
24746 return nil
24747 }
24748
24749 shape, ok := value.(map[string]interface{})
24750 if !ok {
24751 return fmt.Errorf("unexpected JSON type %v", value)
24752 }
24753
24754 var sv *types.ContainerService
24755 if *v == nil {
24756 sv = &types.ContainerService{}
24757 } else {
24758 sv = *v
24759 }
24760
24761 for key, value := range shape {
24762 switch key {
24763 case "arn":
24764 if value != nil {
24765 jtv, ok := value.(string)
24766 if !ok {
24767 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
24768 }
24769 sv.Arn = ptr.String(jtv)
24770 }
24771
24772 case "containerServiceName":
24773 if value != nil {
24774 jtv, ok := value.(string)
24775 if !ok {
24776 return fmt.Errorf("expected ContainerServiceName to be of type string, got %T instead", value)
24777 }
24778 sv.ContainerServiceName = ptr.String(jtv)
24779 }
24780
24781 case "createdAt":
24782 if value != nil {
24783 switch jtv := value.(type) {
24784 case json.Number:
24785 f64, err := jtv.Float64()
24786 if err != nil {
24787 return err
24788 }
24789 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
24790
24791 default:
24792 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
24793
24794 }
24795 }
24796
24797 case "currentDeployment":
24798 if err := awsAwsjson11_deserializeDocumentContainerServiceDeployment(&sv.CurrentDeployment, value); err != nil {
24799 return err
24800 }
24801
24802 case "isDisabled":
24803 if value != nil {
24804 jtv, ok := value.(bool)
24805 if !ok {
24806 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
24807 }
24808 sv.IsDisabled = ptr.Bool(jtv)
24809 }
24810
24811 case "location":
24812 if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
24813 return err
24814 }
24815
24816 case "nextDeployment":
24817 if err := awsAwsjson11_deserializeDocumentContainerServiceDeployment(&sv.NextDeployment, value); err != nil {
24818 return err
24819 }
24820
24821 case "power":
24822 if value != nil {
24823 jtv, ok := value.(string)
24824 if !ok {
24825 return fmt.Errorf("expected ContainerServicePowerName to be of type string, got %T instead", value)
24826 }
24827 sv.Power = types.ContainerServicePowerName(jtv)
24828 }
24829
24830 case "powerId":
24831 if value != nil {
24832 jtv, ok := value.(string)
24833 if !ok {
24834 return fmt.Errorf("expected string to be of type string, got %T instead", value)
24835 }
24836 sv.PowerId = ptr.String(jtv)
24837 }
24838
24839 case "principalArn":
24840 if value != nil {
24841 jtv, ok := value.(string)
24842 if !ok {
24843 return fmt.Errorf("expected string to be of type string, got %T instead", value)
24844 }
24845 sv.PrincipalArn = ptr.String(jtv)
24846 }
24847
24848 case "privateDomainName":
24849 if value != nil {
24850 jtv, ok := value.(string)
24851 if !ok {
24852 return fmt.Errorf("expected string to be of type string, got %T instead", value)
24853 }
24854 sv.PrivateDomainName = ptr.String(jtv)
24855 }
24856
24857 case "privateRegistryAccess":
24858 if err := awsAwsjson11_deserializeDocumentPrivateRegistryAccess(&sv.PrivateRegistryAccess, value); err != nil {
24859 return err
24860 }
24861
24862 case "publicDomainNames":
24863 if err := awsAwsjson11_deserializeDocumentContainerServicePublicDomains(&sv.PublicDomainNames, value); err != nil {
24864 return err
24865 }
24866
24867 case "resourceType":
24868 if value != nil {
24869 jtv, ok := value.(string)
24870 if !ok {
24871 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
24872 }
24873 sv.ResourceType = types.ResourceType(jtv)
24874 }
24875
24876 case "scale":
24877 if value != nil {
24878 jtv, ok := value.(json.Number)
24879 if !ok {
24880 return fmt.Errorf("expected ContainerServiceScale to be json.Number, got %T instead", value)
24881 }
24882 i64, err := jtv.Int64()
24883 if err != nil {
24884 return err
24885 }
24886 sv.Scale = ptr.Int32(int32(i64))
24887 }
24888
24889 case "state":
24890 if value != nil {
24891 jtv, ok := value.(string)
24892 if !ok {
24893 return fmt.Errorf("expected ContainerServiceState to be of type string, got %T instead", value)
24894 }
24895 sv.State = types.ContainerServiceState(jtv)
24896 }
24897
24898 case "stateDetail":
24899 if err := awsAwsjson11_deserializeDocumentContainerServiceStateDetail(&sv.StateDetail, value); err != nil {
24900 return err
24901 }
24902
24903 case "tags":
24904 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
24905 return err
24906 }
24907
24908 case "url":
24909 if value != nil {
24910 jtv, ok := value.(string)
24911 if !ok {
24912 return fmt.Errorf("expected string to be of type string, got %T instead", value)
24913 }
24914 sv.Url = ptr.String(jtv)
24915 }
24916
24917 default:
24918 _, _ = key, value
24919
24920 }
24921 }
24922 *v = sv
24923 return nil
24924 }
24925
24926 func awsAwsjson11_deserializeDocumentContainerServiceDeployment(v **types.ContainerServiceDeployment, value interface{}) error {
24927 if v == nil {
24928 return fmt.Errorf("unexpected nil of type %T", v)
24929 }
24930 if value == nil {
24931 return nil
24932 }
24933
24934 shape, ok := value.(map[string]interface{})
24935 if !ok {
24936 return fmt.Errorf("unexpected JSON type %v", value)
24937 }
24938
24939 var sv *types.ContainerServiceDeployment
24940 if *v == nil {
24941 sv = &types.ContainerServiceDeployment{}
24942 } else {
24943 sv = *v
24944 }
24945
24946 for key, value := range shape {
24947 switch key {
24948 case "containers":
24949 if err := awsAwsjson11_deserializeDocumentContainerMap(&sv.Containers, value); err != nil {
24950 return err
24951 }
24952
24953 case "createdAt":
24954 if value != nil {
24955 switch jtv := value.(type) {
24956 case json.Number:
24957 f64, err := jtv.Float64()
24958 if err != nil {
24959 return err
24960 }
24961 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
24962
24963 default:
24964 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
24965
24966 }
24967 }
24968
24969 case "publicEndpoint":
24970 if err := awsAwsjson11_deserializeDocumentContainerServiceEndpoint(&sv.PublicEndpoint, value); err != nil {
24971 return err
24972 }
24973
24974 case "state":
24975 if value != nil {
24976 jtv, ok := value.(string)
24977 if !ok {
24978 return fmt.Errorf("expected ContainerServiceDeploymentState to be of type string, got %T instead", value)
24979 }
24980 sv.State = types.ContainerServiceDeploymentState(jtv)
24981 }
24982
24983 case "version":
24984 if value != nil {
24985 jtv, ok := value.(json.Number)
24986 if !ok {
24987 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
24988 }
24989 i64, err := jtv.Int64()
24990 if err != nil {
24991 return err
24992 }
24993 sv.Version = ptr.Int32(int32(i64))
24994 }
24995
24996 default:
24997 _, _ = key, value
24998
24999 }
25000 }
25001 *v = sv
25002 return nil
25003 }
25004
25005 func awsAwsjson11_deserializeDocumentContainerServiceDeploymentList(v *[]types.ContainerServiceDeployment, value interface{}) error {
25006 if v == nil {
25007 return fmt.Errorf("unexpected nil of type %T", v)
25008 }
25009 if value == nil {
25010 return nil
25011 }
25012
25013 shape, ok := value.([]interface{})
25014 if !ok {
25015 return fmt.Errorf("unexpected JSON type %v", value)
25016 }
25017
25018 var cv []types.ContainerServiceDeployment
25019 if *v == nil {
25020 cv = []types.ContainerServiceDeployment{}
25021 } else {
25022 cv = *v
25023 }
25024
25025 for _, value := range shape {
25026 var col types.ContainerServiceDeployment
25027 destAddr := &col
25028 if err := awsAwsjson11_deserializeDocumentContainerServiceDeployment(&destAddr, value); err != nil {
25029 return err
25030 }
25031 col = *destAddr
25032 cv = append(cv, col)
25033
25034 }
25035 *v = cv
25036 return nil
25037 }
25038
25039 func awsAwsjson11_deserializeDocumentContainerServiceECRImagePullerRole(v **types.ContainerServiceECRImagePullerRole, value interface{}) error {
25040 if v == nil {
25041 return fmt.Errorf("unexpected nil of type %T", v)
25042 }
25043 if value == nil {
25044 return nil
25045 }
25046
25047 shape, ok := value.(map[string]interface{})
25048 if !ok {
25049 return fmt.Errorf("unexpected JSON type %v", value)
25050 }
25051
25052 var sv *types.ContainerServiceECRImagePullerRole
25053 if *v == nil {
25054 sv = &types.ContainerServiceECRImagePullerRole{}
25055 } else {
25056 sv = *v
25057 }
25058
25059 for key, value := range shape {
25060 switch key {
25061 case "isActive":
25062 if value != nil {
25063 jtv, ok := value.(bool)
25064 if !ok {
25065 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
25066 }
25067 sv.IsActive = ptr.Bool(jtv)
25068 }
25069
25070 case "principalArn":
25071 if value != nil {
25072 jtv, ok := value.(string)
25073 if !ok {
25074 return fmt.Errorf("expected string to be of type string, got %T instead", value)
25075 }
25076 sv.PrincipalArn = ptr.String(jtv)
25077 }
25078
25079 default:
25080 _, _ = key, value
25081
25082 }
25083 }
25084 *v = sv
25085 return nil
25086 }
25087
25088 func awsAwsjson11_deserializeDocumentContainerServiceEndpoint(v **types.ContainerServiceEndpoint, value interface{}) error {
25089 if v == nil {
25090 return fmt.Errorf("unexpected nil of type %T", v)
25091 }
25092 if value == nil {
25093 return nil
25094 }
25095
25096 shape, ok := value.(map[string]interface{})
25097 if !ok {
25098 return fmt.Errorf("unexpected JSON type %v", value)
25099 }
25100
25101 var sv *types.ContainerServiceEndpoint
25102 if *v == nil {
25103 sv = &types.ContainerServiceEndpoint{}
25104 } else {
25105 sv = *v
25106 }
25107
25108 for key, value := range shape {
25109 switch key {
25110 case "containerName":
25111 if value != nil {
25112 jtv, ok := value.(string)
25113 if !ok {
25114 return fmt.Errorf("expected string to be of type string, got %T instead", value)
25115 }
25116 sv.ContainerName = ptr.String(jtv)
25117 }
25118
25119 case "containerPort":
25120 if value != nil {
25121 jtv, ok := value.(json.Number)
25122 if !ok {
25123 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
25124 }
25125 i64, err := jtv.Int64()
25126 if err != nil {
25127 return err
25128 }
25129 sv.ContainerPort = ptr.Int32(int32(i64))
25130 }
25131
25132 case "healthCheck":
25133 if err := awsAwsjson11_deserializeDocumentContainerServiceHealthCheckConfig(&sv.HealthCheck, value); err != nil {
25134 return err
25135 }
25136
25137 default:
25138 _, _ = key, value
25139
25140 }
25141 }
25142 *v = sv
25143 return nil
25144 }
25145
25146 func awsAwsjson11_deserializeDocumentContainerServiceHealthCheckConfig(v **types.ContainerServiceHealthCheckConfig, value interface{}) error {
25147 if v == nil {
25148 return fmt.Errorf("unexpected nil of type %T", v)
25149 }
25150 if value == nil {
25151 return nil
25152 }
25153
25154 shape, ok := value.(map[string]interface{})
25155 if !ok {
25156 return fmt.Errorf("unexpected JSON type %v", value)
25157 }
25158
25159 var sv *types.ContainerServiceHealthCheckConfig
25160 if *v == nil {
25161 sv = &types.ContainerServiceHealthCheckConfig{}
25162 } else {
25163 sv = *v
25164 }
25165
25166 for key, value := range shape {
25167 switch key {
25168 case "healthyThreshold":
25169 if value != nil {
25170 jtv, ok := value.(json.Number)
25171 if !ok {
25172 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
25173 }
25174 i64, err := jtv.Int64()
25175 if err != nil {
25176 return err
25177 }
25178 sv.HealthyThreshold = ptr.Int32(int32(i64))
25179 }
25180
25181 case "intervalSeconds":
25182 if value != nil {
25183 jtv, ok := value.(json.Number)
25184 if !ok {
25185 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
25186 }
25187 i64, err := jtv.Int64()
25188 if err != nil {
25189 return err
25190 }
25191 sv.IntervalSeconds = ptr.Int32(int32(i64))
25192 }
25193
25194 case "path":
25195 if value != nil {
25196 jtv, ok := value.(string)
25197 if !ok {
25198 return fmt.Errorf("expected string to be of type string, got %T instead", value)
25199 }
25200 sv.Path = ptr.String(jtv)
25201 }
25202
25203 case "successCodes":
25204 if value != nil {
25205 jtv, ok := value.(string)
25206 if !ok {
25207 return fmt.Errorf("expected string to be of type string, got %T instead", value)
25208 }
25209 sv.SuccessCodes = ptr.String(jtv)
25210 }
25211
25212 case "timeoutSeconds":
25213 if value != nil {
25214 jtv, ok := value.(json.Number)
25215 if !ok {
25216 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
25217 }
25218 i64, err := jtv.Int64()
25219 if err != nil {
25220 return err
25221 }
25222 sv.TimeoutSeconds = ptr.Int32(int32(i64))
25223 }
25224
25225 case "unhealthyThreshold":
25226 if value != nil {
25227 jtv, ok := value.(json.Number)
25228 if !ok {
25229 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
25230 }
25231 i64, err := jtv.Int64()
25232 if err != nil {
25233 return err
25234 }
25235 sv.UnhealthyThreshold = ptr.Int32(int32(i64))
25236 }
25237
25238 default:
25239 _, _ = key, value
25240
25241 }
25242 }
25243 *v = sv
25244 return nil
25245 }
25246
25247 func awsAwsjson11_deserializeDocumentContainerServiceList(v *[]types.ContainerService, value interface{}) error {
25248 if v == nil {
25249 return fmt.Errorf("unexpected nil of type %T", v)
25250 }
25251 if value == nil {
25252 return nil
25253 }
25254
25255 shape, ok := value.([]interface{})
25256 if !ok {
25257 return fmt.Errorf("unexpected JSON type %v", value)
25258 }
25259
25260 var cv []types.ContainerService
25261 if *v == nil {
25262 cv = []types.ContainerService{}
25263 } else {
25264 cv = *v
25265 }
25266
25267 for _, value := range shape {
25268 var col types.ContainerService
25269 destAddr := &col
25270 if err := awsAwsjson11_deserializeDocumentContainerService(&destAddr, value); err != nil {
25271 return err
25272 }
25273 col = *destAddr
25274 cv = append(cv, col)
25275
25276 }
25277 *v = cv
25278 return nil
25279 }
25280
25281 func awsAwsjson11_deserializeDocumentContainerServiceLogEvent(v **types.ContainerServiceLogEvent, value interface{}) error {
25282 if v == nil {
25283 return fmt.Errorf("unexpected nil of type %T", v)
25284 }
25285 if value == nil {
25286 return nil
25287 }
25288
25289 shape, ok := value.(map[string]interface{})
25290 if !ok {
25291 return fmt.Errorf("unexpected JSON type %v", value)
25292 }
25293
25294 var sv *types.ContainerServiceLogEvent
25295 if *v == nil {
25296 sv = &types.ContainerServiceLogEvent{}
25297 } else {
25298 sv = *v
25299 }
25300
25301 for key, value := range shape {
25302 switch key {
25303 case "createdAt":
25304 if value != nil {
25305 switch jtv := value.(type) {
25306 case json.Number:
25307 f64, err := jtv.Float64()
25308 if err != nil {
25309 return err
25310 }
25311 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
25312
25313 default:
25314 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
25315
25316 }
25317 }
25318
25319 case "message":
25320 if value != nil {
25321 jtv, ok := value.(string)
25322 if !ok {
25323 return fmt.Errorf("expected string to be of type string, got %T instead", value)
25324 }
25325 sv.Message = ptr.String(jtv)
25326 }
25327
25328 default:
25329 _, _ = key, value
25330
25331 }
25332 }
25333 *v = sv
25334 return nil
25335 }
25336
25337 func awsAwsjson11_deserializeDocumentContainerServiceLogEventList(v *[]types.ContainerServiceLogEvent, value interface{}) error {
25338 if v == nil {
25339 return fmt.Errorf("unexpected nil of type %T", v)
25340 }
25341 if value == nil {
25342 return nil
25343 }
25344
25345 shape, ok := value.([]interface{})
25346 if !ok {
25347 return fmt.Errorf("unexpected JSON type %v", value)
25348 }
25349
25350 var cv []types.ContainerServiceLogEvent
25351 if *v == nil {
25352 cv = []types.ContainerServiceLogEvent{}
25353 } else {
25354 cv = *v
25355 }
25356
25357 for _, value := range shape {
25358 var col types.ContainerServiceLogEvent
25359 destAddr := &col
25360 if err := awsAwsjson11_deserializeDocumentContainerServiceLogEvent(&destAddr, value); err != nil {
25361 return err
25362 }
25363 col = *destAddr
25364 cv = append(cv, col)
25365
25366 }
25367 *v = cv
25368 return nil
25369 }
25370
25371 func awsAwsjson11_deserializeDocumentContainerServiceMetadataEntry(v *map[string]string, value interface{}) error {
25372 if v == nil {
25373 return fmt.Errorf("unexpected nil of type %T", v)
25374 }
25375 if value == nil {
25376 return nil
25377 }
25378
25379 shape, ok := value.(map[string]interface{})
25380 if !ok {
25381 return fmt.Errorf("unexpected JSON type %v", value)
25382 }
25383
25384 var mv map[string]string
25385 if *v == nil {
25386 mv = map[string]string{}
25387 } else {
25388 mv = *v
25389 }
25390
25391 for key, value := range shape {
25392 var parsedVal string
25393 if value != nil {
25394 jtv, ok := value.(string)
25395 if !ok {
25396 return fmt.Errorf("expected string to be of type string, got %T instead", value)
25397 }
25398 parsedVal = jtv
25399 }
25400 mv[key] = parsedVal
25401
25402 }
25403 *v = mv
25404 return nil
25405 }
25406
25407 func awsAwsjson11_deserializeDocumentContainerServiceMetadataEntryList(v *[]map[string]string, value interface{}) error {
25408 if v == nil {
25409 return fmt.Errorf("unexpected nil of type %T", v)
25410 }
25411 if value == nil {
25412 return nil
25413 }
25414
25415 shape, ok := value.([]interface{})
25416 if !ok {
25417 return fmt.Errorf("unexpected JSON type %v", value)
25418 }
25419
25420 var cv []map[string]string
25421 if *v == nil {
25422 cv = []map[string]string{}
25423 } else {
25424 cv = *v
25425 }
25426
25427 for _, value := range shape {
25428 var col map[string]string
25429 if err := awsAwsjson11_deserializeDocumentContainerServiceMetadataEntry(&col, value); err != nil {
25430 return err
25431 }
25432 cv = append(cv, col)
25433
25434 }
25435 *v = cv
25436 return nil
25437 }
25438
25439 func awsAwsjson11_deserializeDocumentContainerServicePower(v **types.ContainerServicePower, value interface{}) error {
25440 if v == nil {
25441 return fmt.Errorf("unexpected nil of type %T", v)
25442 }
25443 if value == nil {
25444 return nil
25445 }
25446
25447 shape, ok := value.(map[string]interface{})
25448 if !ok {
25449 return fmt.Errorf("unexpected JSON type %v", value)
25450 }
25451
25452 var sv *types.ContainerServicePower
25453 if *v == nil {
25454 sv = &types.ContainerServicePower{}
25455 } else {
25456 sv = *v
25457 }
25458
25459 for key, value := range shape {
25460 switch key {
25461 case "cpuCount":
25462 if value != nil {
25463 switch jtv := value.(type) {
25464 case json.Number:
25465 f64, err := jtv.Float64()
25466 if err != nil {
25467 return err
25468 }
25469 sv.CpuCount = ptr.Float32(float32(f64))
25470
25471 case string:
25472 var f64 float64
25473 switch {
25474 case strings.EqualFold(jtv, "NaN"):
25475 f64 = math.NaN()
25476
25477 case strings.EqualFold(jtv, "Infinity"):
25478 f64 = math.Inf(1)
25479
25480 case strings.EqualFold(jtv, "-Infinity"):
25481 f64 = math.Inf(-1)
25482
25483 default:
25484 return fmt.Errorf("unknown JSON number value: %s", jtv)
25485
25486 }
25487 sv.CpuCount = ptr.Float32(float32(f64))
25488
25489 default:
25490 return fmt.Errorf("expected float to be a JSON Number, got %T instead", value)
25491
25492 }
25493 }
25494
25495 case "isActive":
25496 if value != nil {
25497 jtv, ok := value.(bool)
25498 if !ok {
25499 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
25500 }
25501 sv.IsActive = ptr.Bool(jtv)
25502 }
25503
25504 case "name":
25505 if value != nil {
25506 jtv, ok := value.(string)
25507 if !ok {
25508 return fmt.Errorf("expected string to be of type string, got %T instead", value)
25509 }
25510 sv.Name = ptr.String(jtv)
25511 }
25512
25513 case "powerId":
25514 if value != nil {
25515 jtv, ok := value.(string)
25516 if !ok {
25517 return fmt.Errorf("expected string to be of type string, got %T instead", value)
25518 }
25519 sv.PowerId = ptr.String(jtv)
25520 }
25521
25522 case "price":
25523 if value != nil {
25524 switch jtv := value.(type) {
25525 case json.Number:
25526 f64, err := jtv.Float64()
25527 if err != nil {
25528 return err
25529 }
25530 sv.Price = ptr.Float32(float32(f64))
25531
25532 case string:
25533 var f64 float64
25534 switch {
25535 case strings.EqualFold(jtv, "NaN"):
25536 f64 = math.NaN()
25537
25538 case strings.EqualFold(jtv, "Infinity"):
25539 f64 = math.Inf(1)
25540
25541 case strings.EqualFold(jtv, "-Infinity"):
25542 f64 = math.Inf(-1)
25543
25544 default:
25545 return fmt.Errorf("unknown JSON number value: %s", jtv)
25546
25547 }
25548 sv.Price = ptr.Float32(float32(f64))
25549
25550 default:
25551 return fmt.Errorf("expected float to be a JSON Number, got %T instead", value)
25552
25553 }
25554 }
25555
25556 case "ramSizeInGb":
25557 if value != nil {
25558 switch jtv := value.(type) {
25559 case json.Number:
25560 f64, err := jtv.Float64()
25561 if err != nil {
25562 return err
25563 }
25564 sv.RamSizeInGb = ptr.Float32(float32(f64))
25565
25566 case string:
25567 var f64 float64
25568 switch {
25569 case strings.EqualFold(jtv, "NaN"):
25570 f64 = math.NaN()
25571
25572 case strings.EqualFold(jtv, "Infinity"):
25573 f64 = math.Inf(1)
25574
25575 case strings.EqualFold(jtv, "-Infinity"):
25576 f64 = math.Inf(-1)
25577
25578 default:
25579 return fmt.Errorf("unknown JSON number value: %s", jtv)
25580
25581 }
25582 sv.RamSizeInGb = ptr.Float32(float32(f64))
25583
25584 default:
25585 return fmt.Errorf("expected float to be a JSON Number, got %T instead", value)
25586
25587 }
25588 }
25589
25590 default:
25591 _, _ = key, value
25592
25593 }
25594 }
25595 *v = sv
25596 return nil
25597 }
25598
25599 func awsAwsjson11_deserializeDocumentContainerServicePowerList(v *[]types.ContainerServicePower, value interface{}) error {
25600 if v == nil {
25601 return fmt.Errorf("unexpected nil of type %T", v)
25602 }
25603 if value == nil {
25604 return nil
25605 }
25606
25607 shape, ok := value.([]interface{})
25608 if !ok {
25609 return fmt.Errorf("unexpected JSON type %v", value)
25610 }
25611
25612 var cv []types.ContainerServicePower
25613 if *v == nil {
25614 cv = []types.ContainerServicePower{}
25615 } else {
25616 cv = *v
25617 }
25618
25619 for _, value := range shape {
25620 var col types.ContainerServicePower
25621 destAddr := &col
25622 if err := awsAwsjson11_deserializeDocumentContainerServicePower(&destAddr, value); err != nil {
25623 return err
25624 }
25625 col = *destAddr
25626 cv = append(cv, col)
25627
25628 }
25629 *v = cv
25630 return nil
25631 }
25632
25633 func awsAwsjson11_deserializeDocumentContainerServicePublicDomains(v *map[string][]string, value interface{}) error {
25634 if v == nil {
25635 return fmt.Errorf("unexpected nil of type %T", v)
25636 }
25637 if value == nil {
25638 return nil
25639 }
25640
25641 shape, ok := value.(map[string]interface{})
25642 if !ok {
25643 return fmt.Errorf("unexpected JSON type %v", value)
25644 }
25645
25646 var mv map[string][]string
25647 if *v == nil {
25648 mv = map[string][]string{}
25649 } else {
25650 mv = *v
25651 }
25652
25653 for key, value := range shape {
25654 var parsedVal []string
25655 mapVar := parsedVal
25656 if err := awsAwsjson11_deserializeDocumentContainerServicePublicDomainsList(&mapVar, value); err != nil {
25657 return err
25658 }
25659 parsedVal = mapVar
25660 mv[key] = parsedVal
25661
25662 }
25663 *v = mv
25664 return nil
25665 }
25666
25667 func awsAwsjson11_deserializeDocumentContainerServicePublicDomainsList(v *[]string, value interface{}) error {
25668 if v == nil {
25669 return fmt.Errorf("unexpected nil of type %T", v)
25670 }
25671 if value == nil {
25672 return nil
25673 }
25674
25675 shape, ok := value.([]interface{})
25676 if !ok {
25677 return fmt.Errorf("unexpected JSON type %v", value)
25678 }
25679
25680 var cv []string
25681 if *v == nil {
25682 cv = []string{}
25683 } else {
25684 cv = *v
25685 }
25686
25687 for _, value := range shape {
25688 var col string
25689 if value != nil {
25690 jtv, ok := value.(string)
25691 if !ok {
25692 return fmt.Errorf("expected string to be of type string, got %T instead", value)
25693 }
25694 col = jtv
25695 }
25696 cv = append(cv, col)
25697
25698 }
25699 *v = cv
25700 return nil
25701 }
25702
25703 func awsAwsjson11_deserializeDocumentContainerServiceRegistryLogin(v **types.ContainerServiceRegistryLogin, value interface{}) error {
25704 if v == nil {
25705 return fmt.Errorf("unexpected nil of type %T", v)
25706 }
25707 if value == nil {
25708 return nil
25709 }
25710
25711 shape, ok := value.(map[string]interface{})
25712 if !ok {
25713 return fmt.Errorf("unexpected JSON type %v", value)
25714 }
25715
25716 var sv *types.ContainerServiceRegistryLogin
25717 if *v == nil {
25718 sv = &types.ContainerServiceRegistryLogin{}
25719 } else {
25720 sv = *v
25721 }
25722
25723 for key, value := range shape {
25724 switch key {
25725 case "expiresAt":
25726 if value != nil {
25727 switch jtv := value.(type) {
25728 case json.Number:
25729 f64, err := jtv.Float64()
25730 if err != nil {
25731 return err
25732 }
25733 sv.ExpiresAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
25734
25735 default:
25736 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
25737
25738 }
25739 }
25740
25741 case "password":
25742 if value != nil {
25743 jtv, ok := value.(string)
25744 if !ok {
25745 return fmt.Errorf("expected string to be of type string, got %T instead", value)
25746 }
25747 sv.Password = ptr.String(jtv)
25748 }
25749
25750 case "registry":
25751 if value != nil {
25752 jtv, ok := value.(string)
25753 if !ok {
25754 return fmt.Errorf("expected string to be of type string, got %T instead", value)
25755 }
25756 sv.Registry = ptr.String(jtv)
25757 }
25758
25759 case "username":
25760 if value != nil {
25761 jtv, ok := value.(string)
25762 if !ok {
25763 return fmt.Errorf("expected string to be of type string, got %T instead", value)
25764 }
25765 sv.Username = ptr.String(jtv)
25766 }
25767
25768 default:
25769 _, _ = key, value
25770
25771 }
25772 }
25773 *v = sv
25774 return nil
25775 }
25776
25777 func awsAwsjson11_deserializeDocumentContainerServiceStateDetail(v **types.ContainerServiceStateDetail, value interface{}) error {
25778 if v == nil {
25779 return fmt.Errorf("unexpected nil of type %T", v)
25780 }
25781 if value == nil {
25782 return nil
25783 }
25784
25785 shape, ok := value.(map[string]interface{})
25786 if !ok {
25787 return fmt.Errorf("unexpected JSON type %v", value)
25788 }
25789
25790 var sv *types.ContainerServiceStateDetail
25791 if *v == nil {
25792 sv = &types.ContainerServiceStateDetail{}
25793 } else {
25794 sv = *v
25795 }
25796
25797 for key, value := range shape {
25798 switch key {
25799 case "code":
25800 if value != nil {
25801 jtv, ok := value.(string)
25802 if !ok {
25803 return fmt.Errorf("expected ContainerServiceStateDetailCode to be of type string, got %T instead", value)
25804 }
25805 sv.Code = types.ContainerServiceStateDetailCode(jtv)
25806 }
25807
25808 case "message":
25809 if value != nil {
25810 jtv, ok := value.(string)
25811 if !ok {
25812 return fmt.Errorf("expected string to be of type string, got %T instead", value)
25813 }
25814 sv.Message = ptr.String(jtv)
25815 }
25816
25817 default:
25818 _, _ = key, value
25819
25820 }
25821 }
25822 *v = sv
25823 return nil
25824 }
25825
25826 func awsAwsjson11_deserializeDocumentCookieObject(v **types.CookieObject, value interface{}) error {
25827 if v == nil {
25828 return fmt.Errorf("unexpected nil of type %T", v)
25829 }
25830 if value == nil {
25831 return nil
25832 }
25833
25834 shape, ok := value.(map[string]interface{})
25835 if !ok {
25836 return fmt.Errorf("unexpected JSON type %v", value)
25837 }
25838
25839 var sv *types.CookieObject
25840 if *v == nil {
25841 sv = &types.CookieObject{}
25842 } else {
25843 sv = *v
25844 }
25845
25846 for key, value := range shape {
25847 switch key {
25848 case "cookiesAllowList":
25849 if err := awsAwsjson11_deserializeDocumentStringList(&sv.CookiesAllowList, value); err != nil {
25850 return err
25851 }
25852
25853 case "option":
25854 if value != nil {
25855 jtv, ok := value.(string)
25856 if !ok {
25857 return fmt.Errorf("expected ForwardValues to be of type string, got %T instead", value)
25858 }
25859 sv.Option = types.ForwardValues(jtv)
25860 }
25861
25862 default:
25863 _, _ = key, value
25864
25865 }
25866 }
25867 *v = sv
25868 return nil
25869 }
25870
25871 func awsAwsjson11_deserializeDocumentCostEstimate(v **types.CostEstimate, value interface{}) error {
25872 if v == nil {
25873 return fmt.Errorf("unexpected nil of type %T", v)
25874 }
25875 if value == nil {
25876 return nil
25877 }
25878
25879 shape, ok := value.(map[string]interface{})
25880 if !ok {
25881 return fmt.Errorf("unexpected JSON type %v", value)
25882 }
25883
25884 var sv *types.CostEstimate
25885 if *v == nil {
25886 sv = &types.CostEstimate{}
25887 } else {
25888 sv = *v
25889 }
25890
25891 for key, value := range shape {
25892 switch key {
25893 case "resultsByTime":
25894 if err := awsAwsjson11_deserializeDocumentEstimatesByTime(&sv.ResultsByTime, value); err != nil {
25895 return err
25896 }
25897
25898 case "usageType":
25899 if value != nil {
25900 jtv, ok := value.(string)
25901 if !ok {
25902 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
25903 }
25904 sv.UsageType = ptr.String(jtv)
25905 }
25906
25907 default:
25908 _, _ = key, value
25909
25910 }
25911 }
25912 *v = sv
25913 return nil
25914 }
25915
25916 func awsAwsjson11_deserializeDocumentCostEstimates(v *[]types.CostEstimate, value interface{}) error {
25917 if v == nil {
25918 return fmt.Errorf("unexpected nil of type %T", v)
25919 }
25920 if value == nil {
25921 return nil
25922 }
25923
25924 shape, ok := value.([]interface{})
25925 if !ok {
25926 return fmt.Errorf("unexpected JSON type %v", value)
25927 }
25928
25929 var cv []types.CostEstimate
25930 if *v == nil {
25931 cv = []types.CostEstimate{}
25932 } else {
25933 cv = *v
25934 }
25935
25936 for _, value := range shape {
25937 var col types.CostEstimate
25938 destAddr := &col
25939 if err := awsAwsjson11_deserializeDocumentCostEstimate(&destAddr, value); err != nil {
25940 return err
25941 }
25942 col = *destAddr
25943 cv = append(cv, col)
25944
25945 }
25946 *v = cv
25947 return nil
25948 }
25949
25950 func awsAwsjson11_deserializeDocumentDestinationInfo(v **types.DestinationInfo, value interface{}) error {
25951 if v == nil {
25952 return fmt.Errorf("unexpected nil of type %T", v)
25953 }
25954 if value == nil {
25955 return nil
25956 }
25957
25958 shape, ok := value.(map[string]interface{})
25959 if !ok {
25960 return fmt.Errorf("unexpected JSON type %v", value)
25961 }
25962
25963 var sv *types.DestinationInfo
25964 if *v == nil {
25965 sv = &types.DestinationInfo{}
25966 } else {
25967 sv = *v
25968 }
25969
25970 for key, value := range shape {
25971 switch key {
25972 case "id":
25973 if value != nil {
25974 jtv, ok := value.(string)
25975 if !ok {
25976 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
25977 }
25978 sv.Id = ptr.String(jtv)
25979 }
25980
25981 case "service":
25982 if value != nil {
25983 jtv, ok := value.(string)
25984 if !ok {
25985 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
25986 }
25987 sv.Service = ptr.String(jtv)
25988 }
25989
25990 default:
25991 _, _ = key, value
25992
25993 }
25994 }
25995 *v = sv
25996 return nil
25997 }
25998
25999 func awsAwsjson11_deserializeDocumentDisk(v **types.Disk, value interface{}) error {
26000 if v == nil {
26001 return fmt.Errorf("unexpected nil of type %T", v)
26002 }
26003 if value == nil {
26004 return nil
26005 }
26006
26007 shape, ok := value.(map[string]interface{})
26008 if !ok {
26009 return fmt.Errorf("unexpected JSON type %v", value)
26010 }
26011
26012 var sv *types.Disk
26013 if *v == nil {
26014 sv = &types.Disk{}
26015 } else {
26016 sv = *v
26017 }
26018
26019 for key, value := range shape {
26020 switch key {
26021 case "addOns":
26022 if err := awsAwsjson11_deserializeDocumentAddOnList(&sv.AddOns, value); err != nil {
26023 return err
26024 }
26025
26026 case "arn":
26027 if value != nil {
26028 jtv, ok := value.(string)
26029 if !ok {
26030 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
26031 }
26032 sv.Arn = ptr.String(jtv)
26033 }
26034
26035 case "attachedTo":
26036 if value != nil {
26037 jtv, ok := value.(string)
26038 if !ok {
26039 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
26040 }
26041 sv.AttachedTo = ptr.String(jtv)
26042 }
26043
26044 case "attachmentState":
26045 if value != nil {
26046 jtv, ok := value.(string)
26047 if !ok {
26048 return fmt.Errorf("expected string to be of type string, got %T instead", value)
26049 }
26050 sv.AttachmentState = ptr.String(jtv)
26051 }
26052
26053 case "autoMountStatus":
26054 if value != nil {
26055 jtv, ok := value.(string)
26056 if !ok {
26057 return fmt.Errorf("expected AutoMountStatus to be of type string, got %T instead", value)
26058 }
26059 sv.AutoMountStatus = types.AutoMountStatus(jtv)
26060 }
26061
26062 case "createdAt":
26063 if value != nil {
26064 switch jtv := value.(type) {
26065 case json.Number:
26066 f64, err := jtv.Float64()
26067 if err != nil {
26068 return err
26069 }
26070 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
26071
26072 default:
26073 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
26074
26075 }
26076 }
26077
26078 case "gbInUse":
26079 if value != nil {
26080 jtv, ok := value.(json.Number)
26081 if !ok {
26082 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
26083 }
26084 i64, err := jtv.Int64()
26085 if err != nil {
26086 return err
26087 }
26088 sv.GbInUse = ptr.Int32(int32(i64))
26089 }
26090
26091 case "iops":
26092 if value != nil {
26093 jtv, ok := value.(json.Number)
26094 if !ok {
26095 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
26096 }
26097 i64, err := jtv.Int64()
26098 if err != nil {
26099 return err
26100 }
26101 sv.Iops = ptr.Int32(int32(i64))
26102 }
26103
26104 case "isAttached":
26105 if value != nil {
26106 jtv, ok := value.(bool)
26107 if !ok {
26108 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
26109 }
26110 sv.IsAttached = ptr.Bool(jtv)
26111 }
26112
26113 case "isSystemDisk":
26114 if value != nil {
26115 jtv, ok := value.(bool)
26116 if !ok {
26117 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
26118 }
26119 sv.IsSystemDisk = ptr.Bool(jtv)
26120 }
26121
26122 case "location":
26123 if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
26124 return err
26125 }
26126
26127 case "name":
26128 if value != nil {
26129 jtv, ok := value.(string)
26130 if !ok {
26131 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
26132 }
26133 sv.Name = ptr.String(jtv)
26134 }
26135
26136 case "path":
26137 if value != nil {
26138 jtv, ok := value.(string)
26139 if !ok {
26140 return fmt.Errorf("expected string to be of type string, got %T instead", value)
26141 }
26142 sv.Path = ptr.String(jtv)
26143 }
26144
26145 case "resourceType":
26146 if value != nil {
26147 jtv, ok := value.(string)
26148 if !ok {
26149 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
26150 }
26151 sv.ResourceType = types.ResourceType(jtv)
26152 }
26153
26154 case "sizeInGb":
26155 if value != nil {
26156 jtv, ok := value.(json.Number)
26157 if !ok {
26158 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
26159 }
26160 i64, err := jtv.Int64()
26161 if err != nil {
26162 return err
26163 }
26164 sv.SizeInGb = ptr.Int32(int32(i64))
26165 }
26166
26167 case "state":
26168 if value != nil {
26169 jtv, ok := value.(string)
26170 if !ok {
26171 return fmt.Errorf("expected DiskState to be of type string, got %T instead", value)
26172 }
26173 sv.State = types.DiskState(jtv)
26174 }
26175
26176 case "supportCode":
26177 if value != nil {
26178 jtv, ok := value.(string)
26179 if !ok {
26180 return fmt.Errorf("expected string to be of type string, got %T instead", value)
26181 }
26182 sv.SupportCode = ptr.String(jtv)
26183 }
26184
26185 case "tags":
26186 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
26187 return err
26188 }
26189
26190 default:
26191 _, _ = key, value
26192
26193 }
26194 }
26195 *v = sv
26196 return nil
26197 }
26198
26199 func awsAwsjson11_deserializeDocumentDiskInfo(v **types.DiskInfo, value interface{}) error {
26200 if v == nil {
26201 return fmt.Errorf("unexpected nil of type %T", v)
26202 }
26203 if value == nil {
26204 return nil
26205 }
26206
26207 shape, ok := value.(map[string]interface{})
26208 if !ok {
26209 return fmt.Errorf("unexpected JSON type %v", value)
26210 }
26211
26212 var sv *types.DiskInfo
26213 if *v == nil {
26214 sv = &types.DiskInfo{}
26215 } else {
26216 sv = *v
26217 }
26218
26219 for key, value := range shape {
26220 switch key {
26221 case "isSystemDisk":
26222 if value != nil {
26223 jtv, ok := value.(bool)
26224 if !ok {
26225 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
26226 }
26227 sv.IsSystemDisk = ptr.Bool(jtv)
26228 }
26229
26230 case "name":
26231 if value != nil {
26232 jtv, ok := value.(string)
26233 if !ok {
26234 return fmt.Errorf("expected string to be of type string, got %T instead", value)
26235 }
26236 sv.Name = ptr.String(jtv)
26237 }
26238
26239 case "path":
26240 if value != nil {
26241 jtv, ok := value.(string)
26242 if !ok {
26243 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
26244 }
26245 sv.Path = ptr.String(jtv)
26246 }
26247
26248 case "sizeInGb":
26249 if value != nil {
26250 jtv, ok := value.(json.Number)
26251 if !ok {
26252 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
26253 }
26254 i64, err := jtv.Int64()
26255 if err != nil {
26256 return err
26257 }
26258 sv.SizeInGb = ptr.Int32(int32(i64))
26259 }
26260
26261 default:
26262 _, _ = key, value
26263
26264 }
26265 }
26266 *v = sv
26267 return nil
26268 }
26269
26270 func awsAwsjson11_deserializeDocumentDiskInfoList(v *[]types.DiskInfo, value interface{}) error {
26271 if v == nil {
26272 return fmt.Errorf("unexpected nil of type %T", v)
26273 }
26274 if value == nil {
26275 return nil
26276 }
26277
26278 shape, ok := value.([]interface{})
26279 if !ok {
26280 return fmt.Errorf("unexpected JSON type %v", value)
26281 }
26282
26283 var cv []types.DiskInfo
26284 if *v == nil {
26285 cv = []types.DiskInfo{}
26286 } else {
26287 cv = *v
26288 }
26289
26290 for _, value := range shape {
26291 var col types.DiskInfo
26292 destAddr := &col
26293 if err := awsAwsjson11_deserializeDocumentDiskInfo(&destAddr, value); err != nil {
26294 return err
26295 }
26296 col = *destAddr
26297 cv = append(cv, col)
26298
26299 }
26300 *v = cv
26301 return nil
26302 }
26303
26304 func awsAwsjson11_deserializeDocumentDiskList(v *[]types.Disk, value interface{}) error {
26305 if v == nil {
26306 return fmt.Errorf("unexpected nil of type %T", v)
26307 }
26308 if value == nil {
26309 return nil
26310 }
26311
26312 shape, ok := value.([]interface{})
26313 if !ok {
26314 return fmt.Errorf("unexpected JSON type %v", value)
26315 }
26316
26317 var cv []types.Disk
26318 if *v == nil {
26319 cv = []types.Disk{}
26320 } else {
26321 cv = *v
26322 }
26323
26324 for _, value := range shape {
26325 var col types.Disk
26326 destAddr := &col
26327 if err := awsAwsjson11_deserializeDocumentDisk(&destAddr, value); err != nil {
26328 return err
26329 }
26330 col = *destAddr
26331 cv = append(cv, col)
26332
26333 }
26334 *v = cv
26335 return nil
26336 }
26337
26338 func awsAwsjson11_deserializeDocumentDiskSnapshot(v **types.DiskSnapshot, value interface{}) error {
26339 if v == nil {
26340 return fmt.Errorf("unexpected nil of type %T", v)
26341 }
26342 if value == nil {
26343 return nil
26344 }
26345
26346 shape, ok := value.(map[string]interface{})
26347 if !ok {
26348 return fmt.Errorf("unexpected JSON type %v", value)
26349 }
26350
26351 var sv *types.DiskSnapshot
26352 if *v == nil {
26353 sv = &types.DiskSnapshot{}
26354 } else {
26355 sv = *v
26356 }
26357
26358 for key, value := range shape {
26359 switch key {
26360 case "arn":
26361 if value != nil {
26362 jtv, ok := value.(string)
26363 if !ok {
26364 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
26365 }
26366 sv.Arn = ptr.String(jtv)
26367 }
26368
26369 case "createdAt":
26370 if value != nil {
26371 switch jtv := value.(type) {
26372 case json.Number:
26373 f64, err := jtv.Float64()
26374 if err != nil {
26375 return err
26376 }
26377 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
26378
26379 default:
26380 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
26381
26382 }
26383 }
26384
26385 case "fromDiskArn":
26386 if value != nil {
26387 jtv, ok := value.(string)
26388 if !ok {
26389 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
26390 }
26391 sv.FromDiskArn = ptr.String(jtv)
26392 }
26393
26394 case "fromDiskName":
26395 if value != nil {
26396 jtv, ok := value.(string)
26397 if !ok {
26398 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
26399 }
26400 sv.FromDiskName = ptr.String(jtv)
26401 }
26402
26403 case "fromInstanceArn":
26404 if value != nil {
26405 jtv, ok := value.(string)
26406 if !ok {
26407 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
26408 }
26409 sv.FromInstanceArn = ptr.String(jtv)
26410 }
26411
26412 case "fromInstanceName":
26413 if value != nil {
26414 jtv, ok := value.(string)
26415 if !ok {
26416 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
26417 }
26418 sv.FromInstanceName = ptr.String(jtv)
26419 }
26420
26421 case "isFromAutoSnapshot":
26422 if value != nil {
26423 jtv, ok := value.(bool)
26424 if !ok {
26425 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
26426 }
26427 sv.IsFromAutoSnapshot = ptr.Bool(jtv)
26428 }
26429
26430 case "location":
26431 if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
26432 return err
26433 }
26434
26435 case "name":
26436 if value != nil {
26437 jtv, ok := value.(string)
26438 if !ok {
26439 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
26440 }
26441 sv.Name = ptr.String(jtv)
26442 }
26443
26444 case "progress":
26445 if value != nil {
26446 jtv, ok := value.(string)
26447 if !ok {
26448 return fmt.Errorf("expected string to be of type string, got %T instead", value)
26449 }
26450 sv.Progress = ptr.String(jtv)
26451 }
26452
26453 case "resourceType":
26454 if value != nil {
26455 jtv, ok := value.(string)
26456 if !ok {
26457 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
26458 }
26459 sv.ResourceType = types.ResourceType(jtv)
26460 }
26461
26462 case "sizeInGb":
26463 if value != nil {
26464 jtv, ok := value.(json.Number)
26465 if !ok {
26466 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
26467 }
26468 i64, err := jtv.Int64()
26469 if err != nil {
26470 return err
26471 }
26472 sv.SizeInGb = ptr.Int32(int32(i64))
26473 }
26474
26475 case "state":
26476 if value != nil {
26477 jtv, ok := value.(string)
26478 if !ok {
26479 return fmt.Errorf("expected DiskSnapshotState to be of type string, got %T instead", value)
26480 }
26481 sv.State = types.DiskSnapshotState(jtv)
26482 }
26483
26484 case "supportCode":
26485 if value != nil {
26486 jtv, ok := value.(string)
26487 if !ok {
26488 return fmt.Errorf("expected string to be of type string, got %T instead", value)
26489 }
26490 sv.SupportCode = ptr.String(jtv)
26491 }
26492
26493 case "tags":
26494 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
26495 return err
26496 }
26497
26498 default:
26499 _, _ = key, value
26500
26501 }
26502 }
26503 *v = sv
26504 return nil
26505 }
26506
26507 func awsAwsjson11_deserializeDocumentDiskSnapshotInfo(v **types.DiskSnapshotInfo, value interface{}) error {
26508 if v == nil {
26509 return fmt.Errorf("unexpected nil of type %T", v)
26510 }
26511 if value == nil {
26512 return nil
26513 }
26514
26515 shape, ok := value.(map[string]interface{})
26516 if !ok {
26517 return fmt.Errorf("unexpected JSON type %v", value)
26518 }
26519
26520 var sv *types.DiskSnapshotInfo
26521 if *v == nil {
26522 sv = &types.DiskSnapshotInfo{}
26523 } else {
26524 sv = *v
26525 }
26526
26527 for key, value := range shape {
26528 switch key {
26529 case "sizeInGb":
26530 if value != nil {
26531 jtv, ok := value.(json.Number)
26532 if !ok {
26533 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
26534 }
26535 i64, err := jtv.Int64()
26536 if err != nil {
26537 return err
26538 }
26539 sv.SizeInGb = ptr.Int32(int32(i64))
26540 }
26541
26542 default:
26543 _, _ = key, value
26544
26545 }
26546 }
26547 *v = sv
26548 return nil
26549 }
26550
26551 func awsAwsjson11_deserializeDocumentDiskSnapshotList(v *[]types.DiskSnapshot, value interface{}) error {
26552 if v == nil {
26553 return fmt.Errorf("unexpected nil of type %T", v)
26554 }
26555 if value == nil {
26556 return nil
26557 }
26558
26559 shape, ok := value.([]interface{})
26560 if !ok {
26561 return fmt.Errorf("unexpected JSON type %v", value)
26562 }
26563
26564 var cv []types.DiskSnapshot
26565 if *v == nil {
26566 cv = []types.DiskSnapshot{}
26567 } else {
26568 cv = *v
26569 }
26570
26571 for _, value := range shape {
26572 var col types.DiskSnapshot
26573 destAddr := &col
26574 if err := awsAwsjson11_deserializeDocumentDiskSnapshot(&destAddr, value); err != nil {
26575 return err
26576 }
26577 col = *destAddr
26578 cv = append(cv, col)
26579
26580 }
26581 *v = cv
26582 return nil
26583 }
26584
26585 func awsAwsjson11_deserializeDocumentDistributionBundle(v **types.DistributionBundle, value interface{}) error {
26586 if v == nil {
26587 return fmt.Errorf("unexpected nil of type %T", v)
26588 }
26589 if value == nil {
26590 return nil
26591 }
26592
26593 shape, ok := value.(map[string]interface{})
26594 if !ok {
26595 return fmt.Errorf("unexpected JSON type %v", value)
26596 }
26597
26598 var sv *types.DistributionBundle
26599 if *v == nil {
26600 sv = &types.DistributionBundle{}
26601 } else {
26602 sv = *v
26603 }
26604
26605 for key, value := range shape {
26606 switch key {
26607 case "bundleId":
26608 if value != nil {
26609 jtv, ok := value.(string)
26610 if !ok {
26611 return fmt.Errorf("expected string to be of type string, got %T instead", value)
26612 }
26613 sv.BundleId = ptr.String(jtv)
26614 }
26615
26616 case "isActive":
26617 if value != nil {
26618 jtv, ok := value.(bool)
26619 if !ok {
26620 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
26621 }
26622 sv.IsActive = ptr.Bool(jtv)
26623 }
26624
26625 case "name":
26626 if value != nil {
26627 jtv, ok := value.(string)
26628 if !ok {
26629 return fmt.Errorf("expected string to be of type string, got %T instead", value)
26630 }
26631 sv.Name = ptr.String(jtv)
26632 }
26633
26634 case "price":
26635 if value != nil {
26636 switch jtv := value.(type) {
26637 case json.Number:
26638 f64, err := jtv.Float64()
26639 if err != nil {
26640 return err
26641 }
26642 sv.Price = ptr.Float32(float32(f64))
26643
26644 case string:
26645 var f64 float64
26646 switch {
26647 case strings.EqualFold(jtv, "NaN"):
26648 f64 = math.NaN()
26649
26650 case strings.EqualFold(jtv, "Infinity"):
26651 f64 = math.Inf(1)
26652
26653 case strings.EqualFold(jtv, "-Infinity"):
26654 f64 = math.Inf(-1)
26655
26656 default:
26657 return fmt.Errorf("unknown JSON number value: %s", jtv)
26658
26659 }
26660 sv.Price = ptr.Float32(float32(f64))
26661
26662 default:
26663 return fmt.Errorf("expected float to be a JSON Number, got %T instead", value)
26664
26665 }
26666 }
26667
26668 case "transferPerMonthInGb":
26669 if value != nil {
26670 jtv, ok := value.(json.Number)
26671 if !ok {
26672 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
26673 }
26674 i64, err := jtv.Int64()
26675 if err != nil {
26676 return err
26677 }
26678 sv.TransferPerMonthInGb = ptr.Int32(int32(i64))
26679 }
26680
26681 default:
26682 _, _ = key, value
26683
26684 }
26685 }
26686 *v = sv
26687 return nil
26688 }
26689
26690 func awsAwsjson11_deserializeDocumentDistributionBundleList(v *[]types.DistributionBundle, value interface{}) error {
26691 if v == nil {
26692 return fmt.Errorf("unexpected nil of type %T", v)
26693 }
26694 if value == nil {
26695 return nil
26696 }
26697
26698 shape, ok := value.([]interface{})
26699 if !ok {
26700 return fmt.Errorf("unexpected JSON type %v", value)
26701 }
26702
26703 var cv []types.DistributionBundle
26704 if *v == nil {
26705 cv = []types.DistributionBundle{}
26706 } else {
26707 cv = *v
26708 }
26709
26710 for _, value := range shape {
26711 var col types.DistributionBundle
26712 destAddr := &col
26713 if err := awsAwsjson11_deserializeDocumentDistributionBundle(&destAddr, value); err != nil {
26714 return err
26715 }
26716 col = *destAddr
26717 cv = append(cv, col)
26718
26719 }
26720 *v = cv
26721 return nil
26722 }
26723
26724 func awsAwsjson11_deserializeDocumentDistributionList(v *[]types.LightsailDistribution, value interface{}) error {
26725 if v == nil {
26726 return fmt.Errorf("unexpected nil of type %T", v)
26727 }
26728 if value == nil {
26729 return nil
26730 }
26731
26732 shape, ok := value.([]interface{})
26733 if !ok {
26734 return fmt.Errorf("unexpected JSON type %v", value)
26735 }
26736
26737 var cv []types.LightsailDistribution
26738 if *v == nil {
26739 cv = []types.LightsailDistribution{}
26740 } else {
26741 cv = *v
26742 }
26743
26744 for _, value := range shape {
26745 var col types.LightsailDistribution
26746 destAddr := &col
26747 if err := awsAwsjson11_deserializeDocumentLightsailDistribution(&destAddr, value); err != nil {
26748 return err
26749 }
26750 col = *destAddr
26751 cv = append(cv, col)
26752
26753 }
26754 *v = cv
26755 return nil
26756 }
26757
26758 func awsAwsjson11_deserializeDocumentDnsRecordCreationState(v **types.DnsRecordCreationState, value interface{}) error {
26759 if v == nil {
26760 return fmt.Errorf("unexpected nil of type %T", v)
26761 }
26762 if value == nil {
26763 return nil
26764 }
26765
26766 shape, ok := value.(map[string]interface{})
26767 if !ok {
26768 return fmt.Errorf("unexpected JSON type %v", value)
26769 }
26770
26771 var sv *types.DnsRecordCreationState
26772 if *v == nil {
26773 sv = &types.DnsRecordCreationState{}
26774 } else {
26775 sv = *v
26776 }
26777
26778 for key, value := range shape {
26779 switch key {
26780 case "code":
26781 if value != nil {
26782 jtv, ok := value.(string)
26783 if !ok {
26784 return fmt.Errorf("expected DnsRecordCreationStateCode to be of type string, got %T instead", value)
26785 }
26786 sv.Code = types.DnsRecordCreationStateCode(jtv)
26787 }
26788
26789 case "message":
26790 if value != nil {
26791 jtv, ok := value.(string)
26792 if !ok {
26793 return fmt.Errorf("expected string to be of type string, got %T instead", value)
26794 }
26795 sv.Message = ptr.String(jtv)
26796 }
26797
26798 default:
26799 _, _ = key, value
26800
26801 }
26802 }
26803 *v = sv
26804 return nil
26805 }
26806
26807 func awsAwsjson11_deserializeDocumentDomain(v **types.Domain, value interface{}) error {
26808 if v == nil {
26809 return fmt.Errorf("unexpected nil of type %T", v)
26810 }
26811 if value == nil {
26812 return nil
26813 }
26814
26815 shape, ok := value.(map[string]interface{})
26816 if !ok {
26817 return fmt.Errorf("unexpected JSON type %v", value)
26818 }
26819
26820 var sv *types.Domain
26821 if *v == nil {
26822 sv = &types.Domain{}
26823 } else {
26824 sv = *v
26825 }
26826
26827 for key, value := range shape {
26828 switch key {
26829 case "arn":
26830 if value != nil {
26831 jtv, ok := value.(string)
26832 if !ok {
26833 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
26834 }
26835 sv.Arn = ptr.String(jtv)
26836 }
26837
26838 case "createdAt":
26839 if value != nil {
26840 switch jtv := value.(type) {
26841 case json.Number:
26842 f64, err := jtv.Float64()
26843 if err != nil {
26844 return err
26845 }
26846 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
26847
26848 default:
26849 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
26850
26851 }
26852 }
26853
26854 case "domainEntries":
26855 if err := awsAwsjson11_deserializeDocumentDomainEntryList(&sv.DomainEntries, value); err != nil {
26856 return err
26857 }
26858
26859 case "location":
26860 if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
26861 return err
26862 }
26863
26864 case "name":
26865 if value != nil {
26866 jtv, ok := value.(string)
26867 if !ok {
26868 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
26869 }
26870 sv.Name = ptr.String(jtv)
26871 }
26872
26873 case "registeredDomainDelegationInfo":
26874 if err := awsAwsjson11_deserializeDocumentRegisteredDomainDelegationInfo(&sv.RegisteredDomainDelegationInfo, value); err != nil {
26875 return err
26876 }
26877
26878 case "resourceType":
26879 if value != nil {
26880 jtv, ok := value.(string)
26881 if !ok {
26882 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
26883 }
26884 sv.ResourceType = types.ResourceType(jtv)
26885 }
26886
26887 case "supportCode":
26888 if value != nil {
26889 jtv, ok := value.(string)
26890 if !ok {
26891 return fmt.Errorf("expected string to be of type string, got %T instead", value)
26892 }
26893 sv.SupportCode = ptr.String(jtv)
26894 }
26895
26896 case "tags":
26897 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
26898 return err
26899 }
26900
26901 default:
26902 _, _ = key, value
26903
26904 }
26905 }
26906 *v = sv
26907 return nil
26908 }
26909
26910 func awsAwsjson11_deserializeDocumentDomainEntry(v **types.DomainEntry, value interface{}) error {
26911 if v == nil {
26912 return fmt.Errorf("unexpected nil of type %T", v)
26913 }
26914 if value == nil {
26915 return nil
26916 }
26917
26918 shape, ok := value.(map[string]interface{})
26919 if !ok {
26920 return fmt.Errorf("unexpected JSON type %v", value)
26921 }
26922
26923 var sv *types.DomainEntry
26924 if *v == nil {
26925 sv = &types.DomainEntry{}
26926 } else {
26927 sv = *v
26928 }
26929
26930 for key, value := range shape {
26931 switch key {
26932 case "id":
26933 if value != nil {
26934 jtv, ok := value.(string)
26935 if !ok {
26936 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
26937 }
26938 sv.Id = ptr.String(jtv)
26939 }
26940
26941 case "isAlias":
26942 if value != nil {
26943 jtv, ok := value.(bool)
26944 if !ok {
26945 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
26946 }
26947 sv.IsAlias = ptr.Bool(jtv)
26948 }
26949
26950 case "name":
26951 if value != nil {
26952 jtv, ok := value.(string)
26953 if !ok {
26954 return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
26955 }
26956 sv.Name = ptr.String(jtv)
26957 }
26958
26959 case "options":
26960 if err := awsAwsjson11_deserializeDocumentDomainEntryOptions(&sv.Options, value); err != nil {
26961 return err
26962 }
26963
26964 case "target":
26965 if value != nil {
26966 jtv, ok := value.(string)
26967 if !ok {
26968 return fmt.Errorf("expected string to be of type string, got %T instead", value)
26969 }
26970 sv.Target = ptr.String(jtv)
26971 }
26972
26973 case "type":
26974 if value != nil {
26975 jtv, ok := value.(string)
26976 if !ok {
26977 return fmt.Errorf("expected DomainEntryType to be of type string, got %T instead", value)
26978 }
26979 sv.Type = ptr.String(jtv)
26980 }
26981
26982 default:
26983 _, _ = key, value
26984
26985 }
26986 }
26987 *v = sv
26988 return nil
26989 }
26990
26991 func awsAwsjson11_deserializeDocumentDomainEntryList(v *[]types.DomainEntry, value interface{}) error {
26992 if v == nil {
26993 return fmt.Errorf("unexpected nil of type %T", v)
26994 }
26995 if value == nil {
26996 return nil
26997 }
26998
26999 shape, ok := value.([]interface{})
27000 if !ok {
27001 return fmt.Errorf("unexpected JSON type %v", value)
27002 }
27003
27004 var cv []types.DomainEntry
27005 if *v == nil {
27006 cv = []types.DomainEntry{}
27007 } else {
27008 cv = *v
27009 }
27010
27011 for _, value := range shape {
27012 var col types.DomainEntry
27013 destAddr := &col
27014 if err := awsAwsjson11_deserializeDocumentDomainEntry(&destAddr, value); err != nil {
27015 return err
27016 }
27017 col = *destAddr
27018 cv = append(cv, col)
27019
27020 }
27021 *v = cv
27022 return nil
27023 }
27024
27025 func awsAwsjson11_deserializeDocumentDomainEntryOptions(v *map[string]string, value interface{}) error {
27026 if v == nil {
27027 return fmt.Errorf("unexpected nil of type %T", v)
27028 }
27029 if value == nil {
27030 return nil
27031 }
27032
27033 shape, ok := value.(map[string]interface{})
27034 if !ok {
27035 return fmt.Errorf("unexpected JSON type %v", value)
27036 }
27037
27038 var mv map[string]string
27039 if *v == nil {
27040 mv = map[string]string{}
27041 } else {
27042 mv = *v
27043 }
27044
27045 for key, value := range shape {
27046 var parsedVal string
27047 if value != nil {
27048 jtv, ok := value.(string)
27049 if !ok {
27050 return fmt.Errorf("expected string to be of type string, got %T instead", value)
27051 }
27052 parsedVal = jtv
27053 }
27054 mv[key] = parsedVal
27055
27056 }
27057 *v = mv
27058 return nil
27059 }
27060
27061 func awsAwsjson11_deserializeDocumentDomainList(v *[]types.Domain, value interface{}) error {
27062 if v == nil {
27063 return fmt.Errorf("unexpected nil of type %T", v)
27064 }
27065 if value == nil {
27066 return nil
27067 }
27068
27069 shape, ok := value.([]interface{})
27070 if !ok {
27071 return fmt.Errorf("unexpected JSON type %v", value)
27072 }
27073
27074 var cv []types.Domain
27075 if *v == nil {
27076 cv = []types.Domain{}
27077 } else {
27078 cv = *v
27079 }
27080
27081 for _, value := range shape {
27082 var col types.Domain
27083 destAddr := &col
27084 if err := awsAwsjson11_deserializeDocumentDomain(&destAddr, value); err != nil {
27085 return err
27086 }
27087 col = *destAddr
27088 cv = append(cv, col)
27089
27090 }
27091 *v = cv
27092 return nil
27093 }
27094
27095 func awsAwsjson11_deserializeDocumentDomainValidationRecord(v **types.DomainValidationRecord, value interface{}) error {
27096 if v == nil {
27097 return fmt.Errorf("unexpected nil of type %T", v)
27098 }
27099 if value == nil {
27100 return nil
27101 }
27102
27103 shape, ok := value.(map[string]interface{})
27104 if !ok {
27105 return fmt.Errorf("unexpected JSON type %v", value)
27106 }
27107
27108 var sv *types.DomainValidationRecord
27109 if *v == nil {
27110 sv = &types.DomainValidationRecord{}
27111 } else {
27112 sv = *v
27113 }
27114
27115 for key, value := range shape {
27116 switch key {
27117 case "dnsRecordCreationState":
27118 if err := awsAwsjson11_deserializeDocumentDnsRecordCreationState(&sv.DnsRecordCreationState, value); err != nil {
27119 return err
27120 }
27121
27122 case "domainName":
27123 if value != nil {
27124 jtv, ok := value.(string)
27125 if !ok {
27126 return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
27127 }
27128 sv.DomainName = ptr.String(jtv)
27129 }
27130
27131 case "resourceRecord":
27132 if err := awsAwsjson11_deserializeDocumentResourceRecord(&sv.ResourceRecord, value); err != nil {
27133 return err
27134 }
27135
27136 case "validationStatus":
27137 if value != nil {
27138 jtv, ok := value.(string)
27139 if !ok {
27140 return fmt.Errorf("expected CertificateDomainValidationStatus to be of type string, got %T instead", value)
27141 }
27142 sv.ValidationStatus = types.CertificateDomainValidationStatus(jtv)
27143 }
27144
27145 default:
27146 _, _ = key, value
27147
27148 }
27149 }
27150 *v = sv
27151 return nil
27152 }
27153
27154 func awsAwsjson11_deserializeDocumentDomainValidationRecordList(v *[]types.DomainValidationRecord, value interface{}) error {
27155 if v == nil {
27156 return fmt.Errorf("unexpected nil of type %T", v)
27157 }
27158 if value == nil {
27159 return nil
27160 }
27161
27162 shape, ok := value.([]interface{})
27163 if !ok {
27164 return fmt.Errorf("unexpected JSON type %v", value)
27165 }
27166
27167 var cv []types.DomainValidationRecord
27168 if *v == nil {
27169 cv = []types.DomainValidationRecord{}
27170 } else {
27171 cv = *v
27172 }
27173
27174 for _, value := range shape {
27175 var col types.DomainValidationRecord
27176 destAddr := &col
27177 if err := awsAwsjson11_deserializeDocumentDomainValidationRecord(&destAddr, value); err != nil {
27178 return err
27179 }
27180 col = *destAddr
27181 cv = append(cv, col)
27182
27183 }
27184 *v = cv
27185 return nil
27186 }
27187
27188 func awsAwsjson11_deserializeDocumentEnvironment(v *map[string]string, value interface{}) error {
27189 if v == nil {
27190 return fmt.Errorf("unexpected nil of type %T", v)
27191 }
27192 if value == nil {
27193 return nil
27194 }
27195
27196 shape, ok := value.(map[string]interface{})
27197 if !ok {
27198 return fmt.Errorf("unexpected JSON type %v", value)
27199 }
27200
27201 var mv map[string]string
27202 if *v == nil {
27203 mv = map[string]string{}
27204 } else {
27205 mv = *v
27206 }
27207
27208 for key, value := range shape {
27209 var parsedVal string
27210 if value != nil {
27211 jtv, ok := value.(string)
27212 if !ok {
27213 return fmt.Errorf("expected string to be of type string, got %T instead", value)
27214 }
27215 parsedVal = jtv
27216 }
27217 mv[key] = parsedVal
27218
27219 }
27220 *v = mv
27221 return nil
27222 }
27223
27224 func awsAwsjson11_deserializeDocumentEstimateByTime(v **types.EstimateByTime, value interface{}) error {
27225 if v == nil {
27226 return fmt.Errorf("unexpected nil of type %T", v)
27227 }
27228 if value == nil {
27229 return nil
27230 }
27231
27232 shape, ok := value.(map[string]interface{})
27233 if !ok {
27234 return fmt.Errorf("unexpected JSON type %v", value)
27235 }
27236
27237 var sv *types.EstimateByTime
27238 if *v == nil {
27239 sv = &types.EstimateByTime{}
27240 } else {
27241 sv = *v
27242 }
27243
27244 for key, value := range shape {
27245 switch key {
27246 case "currency":
27247 if value != nil {
27248 jtv, ok := value.(string)
27249 if !ok {
27250 return fmt.Errorf("expected Currency to be of type string, got %T instead", value)
27251 }
27252 sv.Currency = types.Currency(jtv)
27253 }
27254
27255 case "pricingUnit":
27256 if value != nil {
27257 jtv, ok := value.(string)
27258 if !ok {
27259 return fmt.Errorf("expected PricingUnit to be of type string, got %T instead", value)
27260 }
27261 sv.PricingUnit = types.PricingUnit(jtv)
27262 }
27263
27264 case "timePeriod":
27265 if err := awsAwsjson11_deserializeDocumentTimePeriod(&sv.TimePeriod, value); err != nil {
27266 return err
27267 }
27268
27269 case "unit":
27270 if value != nil {
27271 switch jtv := value.(type) {
27272 case json.Number:
27273 f64, err := jtv.Float64()
27274 if err != nil {
27275 return err
27276 }
27277 sv.Unit = ptr.Float64(f64)
27278
27279 case string:
27280 var f64 float64
27281 switch {
27282 case strings.EqualFold(jtv, "NaN"):
27283 f64 = math.NaN()
27284
27285 case strings.EqualFold(jtv, "Infinity"):
27286 f64 = math.Inf(1)
27287
27288 case strings.EqualFold(jtv, "-Infinity"):
27289 f64 = math.Inf(-1)
27290
27291 default:
27292 return fmt.Errorf("unknown JSON number value: %s", jtv)
27293
27294 }
27295 sv.Unit = ptr.Float64(f64)
27296
27297 default:
27298 return fmt.Errorf("expected double to be a JSON Number, got %T instead", value)
27299
27300 }
27301 }
27302
27303 case "usageCost":
27304 if value != nil {
27305 switch jtv := value.(type) {
27306 case json.Number:
27307 f64, err := jtv.Float64()
27308 if err != nil {
27309 return err
27310 }
27311 sv.UsageCost = ptr.Float64(f64)
27312
27313 case string:
27314 var f64 float64
27315 switch {
27316 case strings.EqualFold(jtv, "NaN"):
27317 f64 = math.NaN()
27318
27319 case strings.EqualFold(jtv, "Infinity"):
27320 f64 = math.Inf(1)
27321
27322 case strings.EqualFold(jtv, "-Infinity"):
27323 f64 = math.Inf(-1)
27324
27325 default:
27326 return fmt.Errorf("unknown JSON number value: %s", jtv)
27327
27328 }
27329 sv.UsageCost = ptr.Float64(f64)
27330
27331 default:
27332 return fmt.Errorf("expected double to be a JSON Number, got %T instead", value)
27333
27334 }
27335 }
27336
27337 default:
27338 _, _ = key, value
27339
27340 }
27341 }
27342 *v = sv
27343 return nil
27344 }
27345
27346 func awsAwsjson11_deserializeDocumentEstimatesByTime(v *[]types.EstimateByTime, value interface{}) error {
27347 if v == nil {
27348 return fmt.Errorf("unexpected nil of type %T", v)
27349 }
27350 if value == nil {
27351 return nil
27352 }
27353
27354 shape, ok := value.([]interface{})
27355 if !ok {
27356 return fmt.Errorf("unexpected JSON type %v", value)
27357 }
27358
27359 var cv []types.EstimateByTime
27360 if *v == nil {
27361 cv = []types.EstimateByTime{}
27362 } else {
27363 cv = *v
27364 }
27365
27366 for _, value := range shape {
27367 var col types.EstimateByTime
27368 destAddr := &col
27369 if err := awsAwsjson11_deserializeDocumentEstimateByTime(&destAddr, value); err != nil {
27370 return err
27371 }
27372 col = *destAddr
27373 cv = append(cv, col)
27374
27375 }
27376 *v = cv
27377 return nil
27378 }
27379
27380 func awsAwsjson11_deserializeDocumentExportSnapshotRecord(v **types.ExportSnapshotRecord, value interface{}) error {
27381 if v == nil {
27382 return fmt.Errorf("unexpected nil of type %T", v)
27383 }
27384 if value == nil {
27385 return nil
27386 }
27387
27388 shape, ok := value.(map[string]interface{})
27389 if !ok {
27390 return fmt.Errorf("unexpected JSON type %v", value)
27391 }
27392
27393 var sv *types.ExportSnapshotRecord
27394 if *v == nil {
27395 sv = &types.ExportSnapshotRecord{}
27396 } else {
27397 sv = *v
27398 }
27399
27400 for key, value := range shape {
27401 switch key {
27402 case "arn":
27403 if value != nil {
27404 jtv, ok := value.(string)
27405 if !ok {
27406 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27407 }
27408 sv.Arn = ptr.String(jtv)
27409 }
27410
27411 case "createdAt":
27412 if value != nil {
27413 switch jtv := value.(type) {
27414 case json.Number:
27415 f64, err := jtv.Float64()
27416 if err != nil {
27417 return err
27418 }
27419 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
27420
27421 default:
27422 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
27423
27424 }
27425 }
27426
27427 case "destinationInfo":
27428 if err := awsAwsjson11_deserializeDocumentDestinationInfo(&sv.DestinationInfo, value); err != nil {
27429 return err
27430 }
27431
27432 case "location":
27433 if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
27434 return err
27435 }
27436
27437 case "name":
27438 if value != nil {
27439 jtv, ok := value.(string)
27440 if !ok {
27441 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
27442 }
27443 sv.Name = ptr.String(jtv)
27444 }
27445
27446 case "resourceType":
27447 if value != nil {
27448 jtv, ok := value.(string)
27449 if !ok {
27450 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
27451 }
27452 sv.ResourceType = types.ResourceType(jtv)
27453 }
27454
27455 case "sourceInfo":
27456 if err := awsAwsjson11_deserializeDocumentExportSnapshotRecordSourceInfo(&sv.SourceInfo, value); err != nil {
27457 return err
27458 }
27459
27460 case "state":
27461 if value != nil {
27462 jtv, ok := value.(string)
27463 if !ok {
27464 return fmt.Errorf("expected RecordState to be of type string, got %T instead", value)
27465 }
27466 sv.State = types.RecordState(jtv)
27467 }
27468
27469 default:
27470 _, _ = key, value
27471
27472 }
27473 }
27474 *v = sv
27475 return nil
27476 }
27477
27478 func awsAwsjson11_deserializeDocumentExportSnapshotRecordList(v *[]types.ExportSnapshotRecord, value interface{}) error {
27479 if v == nil {
27480 return fmt.Errorf("unexpected nil of type %T", v)
27481 }
27482 if value == nil {
27483 return nil
27484 }
27485
27486 shape, ok := value.([]interface{})
27487 if !ok {
27488 return fmt.Errorf("unexpected JSON type %v", value)
27489 }
27490
27491 var cv []types.ExportSnapshotRecord
27492 if *v == nil {
27493 cv = []types.ExportSnapshotRecord{}
27494 } else {
27495 cv = *v
27496 }
27497
27498 for _, value := range shape {
27499 var col types.ExportSnapshotRecord
27500 destAddr := &col
27501 if err := awsAwsjson11_deserializeDocumentExportSnapshotRecord(&destAddr, value); err != nil {
27502 return err
27503 }
27504 col = *destAddr
27505 cv = append(cv, col)
27506
27507 }
27508 *v = cv
27509 return nil
27510 }
27511
27512 func awsAwsjson11_deserializeDocumentExportSnapshotRecordSourceInfo(v **types.ExportSnapshotRecordSourceInfo, value interface{}) error {
27513 if v == nil {
27514 return fmt.Errorf("unexpected nil of type %T", v)
27515 }
27516 if value == nil {
27517 return nil
27518 }
27519
27520 shape, ok := value.(map[string]interface{})
27521 if !ok {
27522 return fmt.Errorf("unexpected JSON type %v", value)
27523 }
27524
27525 var sv *types.ExportSnapshotRecordSourceInfo
27526 if *v == nil {
27527 sv = &types.ExportSnapshotRecordSourceInfo{}
27528 } else {
27529 sv = *v
27530 }
27531
27532 for key, value := range shape {
27533 switch key {
27534 case "arn":
27535 if value != nil {
27536 jtv, ok := value.(string)
27537 if !ok {
27538 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27539 }
27540 sv.Arn = ptr.String(jtv)
27541 }
27542
27543 case "createdAt":
27544 if value != nil {
27545 switch jtv := value.(type) {
27546 case json.Number:
27547 f64, err := jtv.Float64()
27548 if err != nil {
27549 return err
27550 }
27551 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
27552
27553 default:
27554 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
27555
27556 }
27557 }
27558
27559 case "diskSnapshotInfo":
27560 if err := awsAwsjson11_deserializeDocumentDiskSnapshotInfo(&sv.DiskSnapshotInfo, value); err != nil {
27561 return err
27562 }
27563
27564 case "fromResourceArn":
27565 if value != nil {
27566 jtv, ok := value.(string)
27567 if !ok {
27568 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27569 }
27570 sv.FromResourceArn = ptr.String(jtv)
27571 }
27572
27573 case "fromResourceName":
27574 if value != nil {
27575 jtv, ok := value.(string)
27576 if !ok {
27577 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27578 }
27579 sv.FromResourceName = ptr.String(jtv)
27580 }
27581
27582 case "instanceSnapshotInfo":
27583 if err := awsAwsjson11_deserializeDocumentInstanceSnapshotInfo(&sv.InstanceSnapshotInfo, value); err != nil {
27584 return err
27585 }
27586
27587 case "name":
27588 if value != nil {
27589 jtv, ok := value.(string)
27590 if !ok {
27591 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27592 }
27593 sv.Name = ptr.String(jtv)
27594 }
27595
27596 case "resourceType":
27597 if value != nil {
27598 jtv, ok := value.(string)
27599 if !ok {
27600 return fmt.Errorf("expected ExportSnapshotRecordSourceType to be of type string, got %T instead", value)
27601 }
27602 sv.ResourceType = types.ExportSnapshotRecordSourceType(jtv)
27603 }
27604
27605 default:
27606 _, _ = key, value
27607
27608 }
27609 }
27610 *v = sv
27611 return nil
27612 }
27613
27614 func awsAwsjson11_deserializeDocumentHeaderForwardList(v *[]types.HeaderEnum, value interface{}) error {
27615 if v == nil {
27616 return fmt.Errorf("unexpected nil of type %T", v)
27617 }
27618 if value == nil {
27619 return nil
27620 }
27621
27622 shape, ok := value.([]interface{})
27623 if !ok {
27624 return fmt.Errorf("unexpected JSON type %v", value)
27625 }
27626
27627 var cv []types.HeaderEnum
27628 if *v == nil {
27629 cv = []types.HeaderEnum{}
27630 } else {
27631 cv = *v
27632 }
27633
27634 for _, value := range shape {
27635 var col types.HeaderEnum
27636 if value != nil {
27637 jtv, ok := value.(string)
27638 if !ok {
27639 return fmt.Errorf("expected HeaderEnum to be of type string, got %T instead", value)
27640 }
27641 col = types.HeaderEnum(jtv)
27642 }
27643 cv = append(cv, col)
27644
27645 }
27646 *v = cv
27647 return nil
27648 }
27649
27650 func awsAwsjson11_deserializeDocumentHeaderObject(v **types.HeaderObject, value interface{}) error {
27651 if v == nil {
27652 return fmt.Errorf("unexpected nil of type %T", v)
27653 }
27654 if value == nil {
27655 return nil
27656 }
27657
27658 shape, ok := value.(map[string]interface{})
27659 if !ok {
27660 return fmt.Errorf("unexpected JSON type %v", value)
27661 }
27662
27663 var sv *types.HeaderObject
27664 if *v == nil {
27665 sv = &types.HeaderObject{}
27666 } else {
27667 sv = *v
27668 }
27669
27670 for key, value := range shape {
27671 switch key {
27672 case "headersAllowList":
27673 if err := awsAwsjson11_deserializeDocumentHeaderForwardList(&sv.HeadersAllowList, value); err != nil {
27674 return err
27675 }
27676
27677 case "option":
27678 if value != nil {
27679 jtv, ok := value.(string)
27680 if !ok {
27681 return fmt.Errorf("expected ForwardValues to be of type string, got %T instead", value)
27682 }
27683 sv.Option = types.ForwardValues(jtv)
27684 }
27685
27686 default:
27687 _, _ = key, value
27688
27689 }
27690 }
27691 *v = sv
27692 return nil
27693 }
27694
27695 func awsAwsjson11_deserializeDocumentHostKeyAttributes(v **types.HostKeyAttributes, value interface{}) error {
27696 if v == nil {
27697 return fmt.Errorf("unexpected nil of type %T", v)
27698 }
27699 if value == nil {
27700 return nil
27701 }
27702
27703 shape, ok := value.(map[string]interface{})
27704 if !ok {
27705 return fmt.Errorf("unexpected JSON type %v", value)
27706 }
27707
27708 var sv *types.HostKeyAttributes
27709 if *v == nil {
27710 sv = &types.HostKeyAttributes{}
27711 } else {
27712 sv = *v
27713 }
27714
27715 for key, value := range shape {
27716 switch key {
27717 case "algorithm":
27718 if value != nil {
27719 jtv, ok := value.(string)
27720 if !ok {
27721 return fmt.Errorf("expected string to be of type string, got %T instead", value)
27722 }
27723 sv.Algorithm = ptr.String(jtv)
27724 }
27725
27726 case "fingerprintSHA1":
27727 if value != nil {
27728 jtv, ok := value.(string)
27729 if !ok {
27730 return fmt.Errorf("expected string to be of type string, got %T instead", value)
27731 }
27732 sv.FingerprintSHA1 = ptr.String(jtv)
27733 }
27734
27735 case "fingerprintSHA256":
27736 if value != nil {
27737 jtv, ok := value.(string)
27738 if !ok {
27739 return fmt.Errorf("expected string to be of type string, got %T instead", value)
27740 }
27741 sv.FingerprintSHA256 = ptr.String(jtv)
27742 }
27743
27744 case "notValidAfter":
27745 if value != nil {
27746 switch jtv := value.(type) {
27747 case json.Number:
27748 f64, err := jtv.Float64()
27749 if err != nil {
27750 return err
27751 }
27752 sv.NotValidAfter = ptr.Time(smithytime.ParseEpochSeconds(f64))
27753
27754 default:
27755 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
27756
27757 }
27758 }
27759
27760 case "notValidBefore":
27761 if value != nil {
27762 switch jtv := value.(type) {
27763 case json.Number:
27764 f64, err := jtv.Float64()
27765 if err != nil {
27766 return err
27767 }
27768 sv.NotValidBefore = ptr.Time(smithytime.ParseEpochSeconds(f64))
27769
27770 default:
27771 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
27772
27773 }
27774 }
27775
27776 case "publicKey":
27777 if value != nil {
27778 jtv, ok := value.(string)
27779 if !ok {
27780 return fmt.Errorf("expected string to be of type string, got %T instead", value)
27781 }
27782 sv.PublicKey = ptr.String(jtv)
27783 }
27784
27785 case "witnessedAt":
27786 if value != nil {
27787 switch jtv := value.(type) {
27788 case json.Number:
27789 f64, err := jtv.Float64()
27790 if err != nil {
27791 return err
27792 }
27793 sv.WitnessedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
27794
27795 default:
27796 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
27797
27798 }
27799 }
27800
27801 default:
27802 _, _ = key, value
27803
27804 }
27805 }
27806 *v = sv
27807 return nil
27808 }
27809
27810 func awsAwsjson11_deserializeDocumentHostKeysList(v *[]types.HostKeyAttributes, value interface{}) error {
27811 if v == nil {
27812 return fmt.Errorf("unexpected nil of type %T", v)
27813 }
27814 if value == nil {
27815 return nil
27816 }
27817
27818 shape, ok := value.([]interface{})
27819 if !ok {
27820 return fmt.Errorf("unexpected JSON type %v", value)
27821 }
27822
27823 var cv []types.HostKeyAttributes
27824 if *v == nil {
27825 cv = []types.HostKeyAttributes{}
27826 } else {
27827 cv = *v
27828 }
27829
27830 for _, value := range shape {
27831 var col types.HostKeyAttributes
27832 destAddr := &col
27833 if err := awsAwsjson11_deserializeDocumentHostKeyAttributes(&destAddr, value); err != nil {
27834 return err
27835 }
27836 col = *destAddr
27837 cv = append(cv, col)
27838
27839 }
27840 *v = cv
27841 return nil
27842 }
27843
27844 func awsAwsjson11_deserializeDocumentInstance(v **types.Instance, value interface{}) error {
27845 if v == nil {
27846 return fmt.Errorf("unexpected nil of type %T", v)
27847 }
27848 if value == nil {
27849 return nil
27850 }
27851
27852 shape, ok := value.(map[string]interface{})
27853 if !ok {
27854 return fmt.Errorf("unexpected JSON type %v", value)
27855 }
27856
27857 var sv *types.Instance
27858 if *v == nil {
27859 sv = &types.Instance{}
27860 } else {
27861 sv = *v
27862 }
27863
27864 for key, value := range shape {
27865 switch key {
27866 case "addOns":
27867 if err := awsAwsjson11_deserializeDocumentAddOnList(&sv.AddOns, value); err != nil {
27868 return err
27869 }
27870
27871 case "arn":
27872 if value != nil {
27873 jtv, ok := value.(string)
27874 if !ok {
27875 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27876 }
27877 sv.Arn = ptr.String(jtv)
27878 }
27879
27880 case "blueprintId":
27881 if value != nil {
27882 jtv, ok := value.(string)
27883 if !ok {
27884 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27885 }
27886 sv.BlueprintId = ptr.String(jtv)
27887 }
27888
27889 case "blueprintName":
27890 if value != nil {
27891 jtv, ok := value.(string)
27892 if !ok {
27893 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27894 }
27895 sv.BlueprintName = ptr.String(jtv)
27896 }
27897
27898 case "bundleId":
27899 if value != nil {
27900 jtv, ok := value.(string)
27901 if !ok {
27902 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27903 }
27904 sv.BundleId = ptr.String(jtv)
27905 }
27906
27907 case "createdAt":
27908 if value != nil {
27909 switch jtv := value.(type) {
27910 case json.Number:
27911 f64, err := jtv.Float64()
27912 if err != nil {
27913 return err
27914 }
27915 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
27916
27917 default:
27918 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
27919
27920 }
27921 }
27922
27923 case "hardware":
27924 if err := awsAwsjson11_deserializeDocumentInstanceHardware(&sv.Hardware, value); err != nil {
27925 return err
27926 }
27927
27928 case "ipAddressType":
27929 if value != nil {
27930 jtv, ok := value.(string)
27931 if !ok {
27932 return fmt.Errorf("expected IpAddressType to be of type string, got %T instead", value)
27933 }
27934 sv.IpAddressType = types.IpAddressType(jtv)
27935 }
27936
27937 case "ipv6Addresses":
27938 if err := awsAwsjson11_deserializeDocumentIpv6AddressList(&sv.Ipv6Addresses, value); err != nil {
27939 return err
27940 }
27941
27942 case "isStaticIp":
27943 if value != nil {
27944 jtv, ok := value.(bool)
27945 if !ok {
27946 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
27947 }
27948 sv.IsStaticIp = ptr.Bool(jtv)
27949 }
27950
27951 case "location":
27952 if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
27953 return err
27954 }
27955
27956 case "metadataOptions":
27957 if err := awsAwsjson11_deserializeDocumentInstanceMetadataOptions(&sv.MetadataOptions, value); err != nil {
27958 return err
27959 }
27960
27961 case "name":
27962 if value != nil {
27963 jtv, ok := value.(string)
27964 if !ok {
27965 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
27966 }
27967 sv.Name = ptr.String(jtv)
27968 }
27969
27970 case "networking":
27971 if err := awsAwsjson11_deserializeDocumentInstanceNetworking(&sv.Networking, value); err != nil {
27972 return err
27973 }
27974
27975 case "privateIpAddress":
27976 if value != nil {
27977 jtv, ok := value.(string)
27978 if !ok {
27979 return fmt.Errorf("expected IpAddress to be of type string, got %T instead", value)
27980 }
27981 sv.PrivateIpAddress = ptr.String(jtv)
27982 }
27983
27984 case "publicIpAddress":
27985 if value != nil {
27986 jtv, ok := value.(string)
27987 if !ok {
27988 return fmt.Errorf("expected IpAddress to be of type string, got %T instead", value)
27989 }
27990 sv.PublicIpAddress = ptr.String(jtv)
27991 }
27992
27993 case "resourceType":
27994 if value != nil {
27995 jtv, ok := value.(string)
27996 if !ok {
27997 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
27998 }
27999 sv.ResourceType = types.ResourceType(jtv)
28000 }
28001
28002 case "sshKeyName":
28003 if value != nil {
28004 jtv, ok := value.(string)
28005 if !ok {
28006 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
28007 }
28008 sv.SshKeyName = ptr.String(jtv)
28009 }
28010
28011 case "state":
28012 if err := awsAwsjson11_deserializeDocumentInstanceState(&sv.State, value); err != nil {
28013 return err
28014 }
28015
28016 case "supportCode":
28017 if value != nil {
28018 jtv, ok := value.(string)
28019 if !ok {
28020 return fmt.Errorf("expected string to be of type string, got %T instead", value)
28021 }
28022 sv.SupportCode = ptr.String(jtv)
28023 }
28024
28025 case "tags":
28026 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
28027 return err
28028 }
28029
28030 case "username":
28031 if value != nil {
28032 jtv, ok := value.(string)
28033 if !ok {
28034 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
28035 }
28036 sv.Username = ptr.String(jtv)
28037 }
28038
28039 default:
28040 _, _ = key, value
28041
28042 }
28043 }
28044 *v = sv
28045 return nil
28046 }
28047
28048 func awsAwsjson11_deserializeDocumentInstanceAccessDetails(v **types.InstanceAccessDetails, value interface{}) error {
28049 if v == nil {
28050 return fmt.Errorf("unexpected nil of type %T", v)
28051 }
28052 if value == nil {
28053 return nil
28054 }
28055
28056 shape, ok := value.(map[string]interface{})
28057 if !ok {
28058 return fmt.Errorf("unexpected JSON type %v", value)
28059 }
28060
28061 var sv *types.InstanceAccessDetails
28062 if *v == nil {
28063 sv = &types.InstanceAccessDetails{}
28064 } else {
28065 sv = *v
28066 }
28067
28068 for key, value := range shape {
28069 switch key {
28070 case "certKey":
28071 if value != nil {
28072 jtv, ok := value.(string)
28073 if !ok {
28074 return fmt.Errorf("expected string to be of type string, got %T instead", value)
28075 }
28076 sv.CertKey = ptr.String(jtv)
28077 }
28078
28079 case "expiresAt":
28080 if value != nil {
28081 switch jtv := value.(type) {
28082 case json.Number:
28083 f64, err := jtv.Float64()
28084 if err != nil {
28085 return err
28086 }
28087 sv.ExpiresAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
28088
28089 default:
28090 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
28091
28092 }
28093 }
28094
28095 case "hostKeys":
28096 if err := awsAwsjson11_deserializeDocumentHostKeysList(&sv.HostKeys, value); err != nil {
28097 return err
28098 }
28099
28100 case "instanceName":
28101 if value != nil {
28102 jtv, ok := value.(string)
28103 if !ok {
28104 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
28105 }
28106 sv.InstanceName = ptr.String(jtv)
28107 }
28108
28109 case "ipAddress":
28110 if value != nil {
28111 jtv, ok := value.(string)
28112 if !ok {
28113 return fmt.Errorf("expected IpAddress to be of type string, got %T instead", value)
28114 }
28115 sv.IpAddress = ptr.String(jtv)
28116 }
28117
28118 case "ipv6Addresses":
28119 if err := awsAwsjson11_deserializeDocumentIpv6AddressList(&sv.Ipv6Addresses, value); err != nil {
28120 return err
28121 }
28122
28123 case "password":
28124 if value != nil {
28125 jtv, ok := value.(string)
28126 if !ok {
28127 return fmt.Errorf("expected string to be of type string, got %T instead", value)
28128 }
28129 sv.Password = ptr.String(jtv)
28130 }
28131
28132 case "passwordData":
28133 if err := awsAwsjson11_deserializeDocumentPasswordData(&sv.PasswordData, value); err != nil {
28134 return err
28135 }
28136
28137 case "privateKey":
28138 if value != nil {
28139 jtv, ok := value.(string)
28140 if !ok {
28141 return fmt.Errorf("expected string to be of type string, got %T instead", value)
28142 }
28143 sv.PrivateKey = ptr.String(jtv)
28144 }
28145
28146 case "protocol":
28147 if value != nil {
28148 jtv, ok := value.(string)
28149 if !ok {
28150 return fmt.Errorf("expected InstanceAccessProtocol to be of type string, got %T instead", value)
28151 }
28152 sv.Protocol = types.InstanceAccessProtocol(jtv)
28153 }
28154
28155 case "username":
28156 if value != nil {
28157 jtv, ok := value.(string)
28158 if !ok {
28159 return fmt.Errorf("expected string to be of type string, got %T instead", value)
28160 }
28161 sv.Username = ptr.String(jtv)
28162 }
28163
28164 default:
28165 _, _ = key, value
28166
28167 }
28168 }
28169 *v = sv
28170 return nil
28171 }
28172
28173 func awsAwsjson11_deserializeDocumentInstanceHardware(v **types.InstanceHardware, value interface{}) error {
28174 if v == nil {
28175 return fmt.Errorf("unexpected nil of type %T", v)
28176 }
28177 if value == nil {
28178 return nil
28179 }
28180
28181 shape, ok := value.(map[string]interface{})
28182 if !ok {
28183 return fmt.Errorf("unexpected JSON type %v", value)
28184 }
28185
28186 var sv *types.InstanceHardware
28187 if *v == nil {
28188 sv = &types.InstanceHardware{}
28189 } else {
28190 sv = *v
28191 }
28192
28193 for key, value := range shape {
28194 switch key {
28195 case "cpuCount":
28196 if value != nil {
28197 jtv, ok := value.(json.Number)
28198 if !ok {
28199 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
28200 }
28201 i64, err := jtv.Int64()
28202 if err != nil {
28203 return err
28204 }
28205 sv.CpuCount = ptr.Int32(int32(i64))
28206 }
28207
28208 case "disks":
28209 if err := awsAwsjson11_deserializeDocumentDiskList(&sv.Disks, value); err != nil {
28210 return err
28211 }
28212
28213 case "ramSizeInGb":
28214 if value != nil {
28215 switch jtv := value.(type) {
28216 case json.Number:
28217 f64, err := jtv.Float64()
28218 if err != nil {
28219 return err
28220 }
28221 sv.RamSizeInGb = ptr.Float32(float32(f64))
28222
28223 case string:
28224 var f64 float64
28225 switch {
28226 case strings.EqualFold(jtv, "NaN"):
28227 f64 = math.NaN()
28228
28229 case strings.EqualFold(jtv, "Infinity"):
28230 f64 = math.Inf(1)
28231
28232 case strings.EqualFold(jtv, "-Infinity"):
28233 f64 = math.Inf(-1)
28234
28235 default:
28236 return fmt.Errorf("unknown JSON number value: %s", jtv)
28237
28238 }
28239 sv.RamSizeInGb = ptr.Float32(float32(f64))
28240
28241 default:
28242 return fmt.Errorf("expected float to be a JSON Number, got %T instead", value)
28243
28244 }
28245 }
28246
28247 default:
28248 _, _ = key, value
28249
28250 }
28251 }
28252 *v = sv
28253 return nil
28254 }
28255
28256 func awsAwsjson11_deserializeDocumentInstanceHealthSummary(v **types.InstanceHealthSummary, value interface{}) error {
28257 if v == nil {
28258 return fmt.Errorf("unexpected nil of type %T", v)
28259 }
28260 if value == nil {
28261 return nil
28262 }
28263
28264 shape, ok := value.(map[string]interface{})
28265 if !ok {
28266 return fmt.Errorf("unexpected JSON type %v", value)
28267 }
28268
28269 var sv *types.InstanceHealthSummary
28270 if *v == nil {
28271 sv = &types.InstanceHealthSummary{}
28272 } else {
28273 sv = *v
28274 }
28275
28276 for key, value := range shape {
28277 switch key {
28278 case "instanceHealth":
28279 if value != nil {
28280 jtv, ok := value.(string)
28281 if !ok {
28282 return fmt.Errorf("expected InstanceHealthState to be of type string, got %T instead", value)
28283 }
28284 sv.InstanceHealth = types.InstanceHealthState(jtv)
28285 }
28286
28287 case "instanceHealthReason":
28288 if value != nil {
28289 jtv, ok := value.(string)
28290 if !ok {
28291 return fmt.Errorf("expected InstanceHealthReason to be of type string, got %T instead", value)
28292 }
28293 sv.InstanceHealthReason = types.InstanceHealthReason(jtv)
28294 }
28295
28296 case "instanceName":
28297 if value != nil {
28298 jtv, ok := value.(string)
28299 if !ok {
28300 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
28301 }
28302 sv.InstanceName = ptr.String(jtv)
28303 }
28304
28305 default:
28306 _, _ = key, value
28307
28308 }
28309 }
28310 *v = sv
28311 return nil
28312 }
28313
28314 func awsAwsjson11_deserializeDocumentInstanceHealthSummaryList(v *[]types.InstanceHealthSummary, value interface{}) error {
28315 if v == nil {
28316 return fmt.Errorf("unexpected nil of type %T", v)
28317 }
28318 if value == nil {
28319 return nil
28320 }
28321
28322 shape, ok := value.([]interface{})
28323 if !ok {
28324 return fmt.Errorf("unexpected JSON type %v", value)
28325 }
28326
28327 var cv []types.InstanceHealthSummary
28328 if *v == nil {
28329 cv = []types.InstanceHealthSummary{}
28330 } else {
28331 cv = *v
28332 }
28333
28334 for _, value := range shape {
28335 var col types.InstanceHealthSummary
28336 destAddr := &col
28337 if err := awsAwsjson11_deserializeDocumentInstanceHealthSummary(&destAddr, value); err != nil {
28338 return err
28339 }
28340 col = *destAddr
28341 cv = append(cv, col)
28342
28343 }
28344 *v = cv
28345 return nil
28346 }
28347
28348 func awsAwsjson11_deserializeDocumentInstanceList(v *[]types.Instance, value interface{}) error {
28349 if v == nil {
28350 return fmt.Errorf("unexpected nil of type %T", v)
28351 }
28352 if value == nil {
28353 return nil
28354 }
28355
28356 shape, ok := value.([]interface{})
28357 if !ok {
28358 return fmt.Errorf("unexpected JSON type %v", value)
28359 }
28360
28361 var cv []types.Instance
28362 if *v == nil {
28363 cv = []types.Instance{}
28364 } else {
28365 cv = *v
28366 }
28367
28368 for _, value := range shape {
28369 var col types.Instance
28370 destAddr := &col
28371 if err := awsAwsjson11_deserializeDocumentInstance(&destAddr, value); err != nil {
28372 return err
28373 }
28374 col = *destAddr
28375 cv = append(cv, col)
28376
28377 }
28378 *v = cv
28379 return nil
28380 }
28381
28382 func awsAwsjson11_deserializeDocumentInstanceMetadataOptions(v **types.InstanceMetadataOptions, value interface{}) error {
28383 if v == nil {
28384 return fmt.Errorf("unexpected nil of type %T", v)
28385 }
28386 if value == nil {
28387 return nil
28388 }
28389
28390 shape, ok := value.(map[string]interface{})
28391 if !ok {
28392 return fmt.Errorf("unexpected JSON type %v", value)
28393 }
28394
28395 var sv *types.InstanceMetadataOptions
28396 if *v == nil {
28397 sv = &types.InstanceMetadataOptions{}
28398 } else {
28399 sv = *v
28400 }
28401
28402 for key, value := range shape {
28403 switch key {
28404 case "httpEndpoint":
28405 if value != nil {
28406 jtv, ok := value.(string)
28407 if !ok {
28408 return fmt.Errorf("expected HttpEndpoint to be of type string, got %T instead", value)
28409 }
28410 sv.HttpEndpoint = types.HttpEndpoint(jtv)
28411 }
28412
28413 case "httpProtocolIpv6":
28414 if value != nil {
28415 jtv, ok := value.(string)
28416 if !ok {
28417 return fmt.Errorf("expected HttpProtocolIpv6 to be of type string, got %T instead", value)
28418 }
28419 sv.HttpProtocolIpv6 = types.HttpProtocolIpv6(jtv)
28420 }
28421
28422 case "httpPutResponseHopLimit":
28423 if value != nil {
28424 jtv, ok := value.(json.Number)
28425 if !ok {
28426 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
28427 }
28428 i64, err := jtv.Int64()
28429 if err != nil {
28430 return err
28431 }
28432 sv.HttpPutResponseHopLimit = ptr.Int32(int32(i64))
28433 }
28434
28435 case "httpTokens":
28436 if value != nil {
28437 jtv, ok := value.(string)
28438 if !ok {
28439 return fmt.Errorf("expected HttpTokens to be of type string, got %T instead", value)
28440 }
28441 sv.HttpTokens = types.HttpTokens(jtv)
28442 }
28443
28444 case "state":
28445 if value != nil {
28446 jtv, ok := value.(string)
28447 if !ok {
28448 return fmt.Errorf("expected InstanceMetadataState to be of type string, got %T instead", value)
28449 }
28450 sv.State = types.InstanceMetadataState(jtv)
28451 }
28452
28453 default:
28454 _, _ = key, value
28455
28456 }
28457 }
28458 *v = sv
28459 return nil
28460 }
28461
28462 func awsAwsjson11_deserializeDocumentInstanceNetworking(v **types.InstanceNetworking, value interface{}) error {
28463 if v == nil {
28464 return fmt.Errorf("unexpected nil of type %T", v)
28465 }
28466 if value == nil {
28467 return nil
28468 }
28469
28470 shape, ok := value.(map[string]interface{})
28471 if !ok {
28472 return fmt.Errorf("unexpected JSON type %v", value)
28473 }
28474
28475 var sv *types.InstanceNetworking
28476 if *v == nil {
28477 sv = &types.InstanceNetworking{}
28478 } else {
28479 sv = *v
28480 }
28481
28482 for key, value := range shape {
28483 switch key {
28484 case "monthlyTransfer":
28485 if err := awsAwsjson11_deserializeDocumentMonthlyTransfer(&sv.MonthlyTransfer, value); err != nil {
28486 return err
28487 }
28488
28489 case "ports":
28490 if err := awsAwsjson11_deserializeDocumentInstancePortInfoList(&sv.Ports, value); err != nil {
28491 return err
28492 }
28493
28494 default:
28495 _, _ = key, value
28496
28497 }
28498 }
28499 *v = sv
28500 return nil
28501 }
28502
28503 func awsAwsjson11_deserializeDocumentInstancePlatformList(v *[]types.InstancePlatform, value interface{}) error {
28504 if v == nil {
28505 return fmt.Errorf("unexpected nil of type %T", v)
28506 }
28507 if value == nil {
28508 return nil
28509 }
28510
28511 shape, ok := value.([]interface{})
28512 if !ok {
28513 return fmt.Errorf("unexpected JSON type %v", value)
28514 }
28515
28516 var cv []types.InstancePlatform
28517 if *v == nil {
28518 cv = []types.InstancePlatform{}
28519 } else {
28520 cv = *v
28521 }
28522
28523 for _, value := range shape {
28524 var col types.InstancePlatform
28525 if value != nil {
28526 jtv, ok := value.(string)
28527 if !ok {
28528 return fmt.Errorf("expected InstancePlatform to be of type string, got %T instead", value)
28529 }
28530 col = types.InstancePlatform(jtv)
28531 }
28532 cv = append(cv, col)
28533
28534 }
28535 *v = cv
28536 return nil
28537 }
28538
28539 func awsAwsjson11_deserializeDocumentInstancePortInfo(v **types.InstancePortInfo, value interface{}) error {
28540 if v == nil {
28541 return fmt.Errorf("unexpected nil of type %T", v)
28542 }
28543 if value == nil {
28544 return nil
28545 }
28546
28547 shape, ok := value.(map[string]interface{})
28548 if !ok {
28549 return fmt.Errorf("unexpected JSON type %v", value)
28550 }
28551
28552 var sv *types.InstancePortInfo
28553 if *v == nil {
28554 sv = &types.InstancePortInfo{}
28555 } else {
28556 sv = *v
28557 }
28558
28559 for key, value := range shape {
28560 switch key {
28561 case "accessDirection":
28562 if value != nil {
28563 jtv, ok := value.(string)
28564 if !ok {
28565 return fmt.Errorf("expected AccessDirection to be of type string, got %T instead", value)
28566 }
28567 sv.AccessDirection = types.AccessDirection(jtv)
28568 }
28569
28570 case "accessFrom":
28571 if value != nil {
28572 jtv, ok := value.(string)
28573 if !ok {
28574 return fmt.Errorf("expected string to be of type string, got %T instead", value)
28575 }
28576 sv.AccessFrom = ptr.String(jtv)
28577 }
28578
28579 case "accessType":
28580 if value != nil {
28581 jtv, ok := value.(string)
28582 if !ok {
28583 return fmt.Errorf("expected PortAccessType to be of type string, got %T instead", value)
28584 }
28585 sv.AccessType = types.PortAccessType(jtv)
28586 }
28587
28588 case "cidrListAliases":
28589 if err := awsAwsjson11_deserializeDocumentStringList(&sv.CidrListAliases, value); err != nil {
28590 return err
28591 }
28592
28593 case "cidrs":
28594 if err := awsAwsjson11_deserializeDocumentStringList(&sv.Cidrs, value); err != nil {
28595 return err
28596 }
28597
28598 case "commonName":
28599 if value != nil {
28600 jtv, ok := value.(string)
28601 if !ok {
28602 return fmt.Errorf("expected string to be of type string, got %T instead", value)
28603 }
28604 sv.CommonName = ptr.String(jtv)
28605 }
28606
28607 case "fromPort":
28608 if value != nil {
28609 jtv, ok := value.(json.Number)
28610 if !ok {
28611 return fmt.Errorf("expected Port to be json.Number, got %T instead", value)
28612 }
28613 i64, err := jtv.Int64()
28614 if err != nil {
28615 return err
28616 }
28617 sv.FromPort = int32(i64)
28618 }
28619
28620 case "ipv6Cidrs":
28621 if err := awsAwsjson11_deserializeDocumentStringList(&sv.Ipv6Cidrs, value); err != nil {
28622 return err
28623 }
28624
28625 case "protocol":
28626 if value != nil {
28627 jtv, ok := value.(string)
28628 if !ok {
28629 return fmt.Errorf("expected NetworkProtocol to be of type string, got %T instead", value)
28630 }
28631 sv.Protocol = types.NetworkProtocol(jtv)
28632 }
28633
28634 case "toPort":
28635 if value != nil {
28636 jtv, ok := value.(json.Number)
28637 if !ok {
28638 return fmt.Errorf("expected Port to be json.Number, got %T instead", value)
28639 }
28640 i64, err := jtv.Int64()
28641 if err != nil {
28642 return err
28643 }
28644 sv.ToPort = int32(i64)
28645 }
28646
28647 default:
28648 _, _ = key, value
28649
28650 }
28651 }
28652 *v = sv
28653 return nil
28654 }
28655
28656 func awsAwsjson11_deserializeDocumentInstancePortInfoList(v *[]types.InstancePortInfo, value interface{}) error {
28657 if v == nil {
28658 return fmt.Errorf("unexpected nil of type %T", v)
28659 }
28660 if value == nil {
28661 return nil
28662 }
28663
28664 shape, ok := value.([]interface{})
28665 if !ok {
28666 return fmt.Errorf("unexpected JSON type %v", value)
28667 }
28668
28669 var cv []types.InstancePortInfo
28670 if *v == nil {
28671 cv = []types.InstancePortInfo{}
28672 } else {
28673 cv = *v
28674 }
28675
28676 for _, value := range shape {
28677 var col types.InstancePortInfo
28678 destAddr := &col
28679 if err := awsAwsjson11_deserializeDocumentInstancePortInfo(&destAddr, value); err != nil {
28680 return err
28681 }
28682 col = *destAddr
28683 cv = append(cv, col)
28684
28685 }
28686 *v = cv
28687 return nil
28688 }
28689
28690 func awsAwsjson11_deserializeDocumentInstancePortState(v **types.InstancePortState, value interface{}) error {
28691 if v == nil {
28692 return fmt.Errorf("unexpected nil of type %T", v)
28693 }
28694 if value == nil {
28695 return nil
28696 }
28697
28698 shape, ok := value.(map[string]interface{})
28699 if !ok {
28700 return fmt.Errorf("unexpected JSON type %v", value)
28701 }
28702
28703 var sv *types.InstancePortState
28704 if *v == nil {
28705 sv = &types.InstancePortState{}
28706 } else {
28707 sv = *v
28708 }
28709
28710 for key, value := range shape {
28711 switch key {
28712 case "cidrListAliases":
28713 if err := awsAwsjson11_deserializeDocumentStringList(&sv.CidrListAliases, value); err != nil {
28714 return err
28715 }
28716
28717 case "cidrs":
28718 if err := awsAwsjson11_deserializeDocumentStringList(&sv.Cidrs, value); err != nil {
28719 return err
28720 }
28721
28722 case "fromPort":
28723 if value != nil {
28724 jtv, ok := value.(json.Number)
28725 if !ok {
28726 return fmt.Errorf("expected Port to be json.Number, got %T instead", value)
28727 }
28728 i64, err := jtv.Int64()
28729 if err != nil {
28730 return err
28731 }
28732 sv.FromPort = int32(i64)
28733 }
28734
28735 case "ipv6Cidrs":
28736 if err := awsAwsjson11_deserializeDocumentStringList(&sv.Ipv6Cidrs, value); err != nil {
28737 return err
28738 }
28739
28740 case "protocol":
28741 if value != nil {
28742 jtv, ok := value.(string)
28743 if !ok {
28744 return fmt.Errorf("expected NetworkProtocol to be of type string, got %T instead", value)
28745 }
28746 sv.Protocol = types.NetworkProtocol(jtv)
28747 }
28748
28749 case "state":
28750 if value != nil {
28751 jtv, ok := value.(string)
28752 if !ok {
28753 return fmt.Errorf("expected PortState to be of type string, got %T instead", value)
28754 }
28755 sv.State = types.PortState(jtv)
28756 }
28757
28758 case "toPort":
28759 if value != nil {
28760 jtv, ok := value.(json.Number)
28761 if !ok {
28762 return fmt.Errorf("expected Port to be json.Number, got %T instead", value)
28763 }
28764 i64, err := jtv.Int64()
28765 if err != nil {
28766 return err
28767 }
28768 sv.ToPort = int32(i64)
28769 }
28770
28771 default:
28772 _, _ = key, value
28773
28774 }
28775 }
28776 *v = sv
28777 return nil
28778 }
28779
28780 func awsAwsjson11_deserializeDocumentInstancePortStateList(v *[]types.InstancePortState, value interface{}) error {
28781 if v == nil {
28782 return fmt.Errorf("unexpected nil of type %T", v)
28783 }
28784 if value == nil {
28785 return nil
28786 }
28787
28788 shape, ok := value.([]interface{})
28789 if !ok {
28790 return fmt.Errorf("unexpected JSON type %v", value)
28791 }
28792
28793 var cv []types.InstancePortState
28794 if *v == nil {
28795 cv = []types.InstancePortState{}
28796 } else {
28797 cv = *v
28798 }
28799
28800 for _, value := range shape {
28801 var col types.InstancePortState
28802 destAddr := &col
28803 if err := awsAwsjson11_deserializeDocumentInstancePortState(&destAddr, value); err != nil {
28804 return err
28805 }
28806 col = *destAddr
28807 cv = append(cv, col)
28808
28809 }
28810 *v = cv
28811 return nil
28812 }
28813
28814 func awsAwsjson11_deserializeDocumentInstanceSnapshot(v **types.InstanceSnapshot, value interface{}) error {
28815 if v == nil {
28816 return fmt.Errorf("unexpected nil of type %T", v)
28817 }
28818 if value == nil {
28819 return nil
28820 }
28821
28822 shape, ok := value.(map[string]interface{})
28823 if !ok {
28824 return fmt.Errorf("unexpected JSON type %v", value)
28825 }
28826
28827 var sv *types.InstanceSnapshot
28828 if *v == nil {
28829 sv = &types.InstanceSnapshot{}
28830 } else {
28831 sv = *v
28832 }
28833
28834 for key, value := range shape {
28835 switch key {
28836 case "arn":
28837 if value != nil {
28838 jtv, ok := value.(string)
28839 if !ok {
28840 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
28841 }
28842 sv.Arn = ptr.String(jtv)
28843 }
28844
28845 case "createdAt":
28846 if value != nil {
28847 switch jtv := value.(type) {
28848 case json.Number:
28849 f64, err := jtv.Float64()
28850 if err != nil {
28851 return err
28852 }
28853 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
28854
28855 default:
28856 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
28857
28858 }
28859 }
28860
28861 case "fromAttachedDisks":
28862 if err := awsAwsjson11_deserializeDocumentDiskList(&sv.FromAttachedDisks, value); err != nil {
28863 return err
28864 }
28865
28866 case "fromBlueprintId":
28867 if value != nil {
28868 jtv, ok := value.(string)
28869 if !ok {
28870 return fmt.Errorf("expected string to be of type string, got %T instead", value)
28871 }
28872 sv.FromBlueprintId = ptr.String(jtv)
28873 }
28874
28875 case "fromBundleId":
28876 if value != nil {
28877 jtv, ok := value.(string)
28878 if !ok {
28879 return fmt.Errorf("expected string to be of type string, got %T instead", value)
28880 }
28881 sv.FromBundleId = ptr.String(jtv)
28882 }
28883
28884 case "fromInstanceArn":
28885 if value != nil {
28886 jtv, ok := value.(string)
28887 if !ok {
28888 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
28889 }
28890 sv.FromInstanceArn = ptr.String(jtv)
28891 }
28892
28893 case "fromInstanceName":
28894 if value != nil {
28895 jtv, ok := value.(string)
28896 if !ok {
28897 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
28898 }
28899 sv.FromInstanceName = ptr.String(jtv)
28900 }
28901
28902 case "isFromAutoSnapshot":
28903 if value != nil {
28904 jtv, ok := value.(bool)
28905 if !ok {
28906 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
28907 }
28908 sv.IsFromAutoSnapshot = ptr.Bool(jtv)
28909 }
28910
28911 case "location":
28912 if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
28913 return err
28914 }
28915
28916 case "name":
28917 if value != nil {
28918 jtv, ok := value.(string)
28919 if !ok {
28920 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
28921 }
28922 sv.Name = ptr.String(jtv)
28923 }
28924
28925 case "progress":
28926 if value != nil {
28927 jtv, ok := value.(string)
28928 if !ok {
28929 return fmt.Errorf("expected string to be of type string, got %T instead", value)
28930 }
28931 sv.Progress = ptr.String(jtv)
28932 }
28933
28934 case "resourceType":
28935 if value != nil {
28936 jtv, ok := value.(string)
28937 if !ok {
28938 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
28939 }
28940 sv.ResourceType = types.ResourceType(jtv)
28941 }
28942
28943 case "sizeInGb":
28944 if value != nil {
28945 jtv, ok := value.(json.Number)
28946 if !ok {
28947 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
28948 }
28949 i64, err := jtv.Int64()
28950 if err != nil {
28951 return err
28952 }
28953 sv.SizeInGb = ptr.Int32(int32(i64))
28954 }
28955
28956 case "state":
28957 if value != nil {
28958 jtv, ok := value.(string)
28959 if !ok {
28960 return fmt.Errorf("expected InstanceSnapshotState to be of type string, got %T instead", value)
28961 }
28962 sv.State = types.InstanceSnapshotState(jtv)
28963 }
28964
28965 case "supportCode":
28966 if value != nil {
28967 jtv, ok := value.(string)
28968 if !ok {
28969 return fmt.Errorf("expected string to be of type string, got %T instead", value)
28970 }
28971 sv.SupportCode = ptr.String(jtv)
28972 }
28973
28974 case "tags":
28975 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
28976 return err
28977 }
28978
28979 default:
28980 _, _ = key, value
28981
28982 }
28983 }
28984 *v = sv
28985 return nil
28986 }
28987
28988 func awsAwsjson11_deserializeDocumentInstanceSnapshotInfo(v **types.InstanceSnapshotInfo, value interface{}) error {
28989 if v == nil {
28990 return fmt.Errorf("unexpected nil of type %T", v)
28991 }
28992 if value == nil {
28993 return nil
28994 }
28995
28996 shape, ok := value.(map[string]interface{})
28997 if !ok {
28998 return fmt.Errorf("unexpected JSON type %v", value)
28999 }
29000
29001 var sv *types.InstanceSnapshotInfo
29002 if *v == nil {
29003 sv = &types.InstanceSnapshotInfo{}
29004 } else {
29005 sv = *v
29006 }
29007
29008 for key, value := range shape {
29009 switch key {
29010 case "fromBlueprintId":
29011 if value != nil {
29012 jtv, ok := value.(string)
29013 if !ok {
29014 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
29015 }
29016 sv.FromBlueprintId = ptr.String(jtv)
29017 }
29018
29019 case "fromBundleId":
29020 if value != nil {
29021 jtv, ok := value.(string)
29022 if !ok {
29023 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
29024 }
29025 sv.FromBundleId = ptr.String(jtv)
29026 }
29027
29028 case "fromDiskInfo":
29029 if err := awsAwsjson11_deserializeDocumentDiskInfoList(&sv.FromDiskInfo, value); err != nil {
29030 return err
29031 }
29032
29033 default:
29034 _, _ = key, value
29035
29036 }
29037 }
29038 *v = sv
29039 return nil
29040 }
29041
29042 func awsAwsjson11_deserializeDocumentInstanceSnapshotList(v *[]types.InstanceSnapshot, value interface{}) error {
29043 if v == nil {
29044 return fmt.Errorf("unexpected nil of type %T", v)
29045 }
29046 if value == nil {
29047 return nil
29048 }
29049
29050 shape, ok := value.([]interface{})
29051 if !ok {
29052 return fmt.Errorf("unexpected JSON type %v", value)
29053 }
29054
29055 var cv []types.InstanceSnapshot
29056 if *v == nil {
29057 cv = []types.InstanceSnapshot{}
29058 } else {
29059 cv = *v
29060 }
29061
29062 for _, value := range shape {
29063 var col types.InstanceSnapshot
29064 destAddr := &col
29065 if err := awsAwsjson11_deserializeDocumentInstanceSnapshot(&destAddr, value); err != nil {
29066 return err
29067 }
29068 col = *destAddr
29069 cv = append(cv, col)
29070
29071 }
29072 *v = cv
29073 return nil
29074 }
29075
29076 func awsAwsjson11_deserializeDocumentInstanceState(v **types.InstanceState, value interface{}) error {
29077 if v == nil {
29078 return fmt.Errorf("unexpected nil of type %T", v)
29079 }
29080 if value == nil {
29081 return nil
29082 }
29083
29084 shape, ok := value.(map[string]interface{})
29085 if !ok {
29086 return fmt.Errorf("unexpected JSON type %v", value)
29087 }
29088
29089 var sv *types.InstanceState
29090 if *v == nil {
29091 sv = &types.InstanceState{}
29092 } else {
29093 sv = *v
29094 }
29095
29096 for key, value := range shape {
29097 switch key {
29098 case "code":
29099 if value != nil {
29100 jtv, ok := value.(json.Number)
29101 if !ok {
29102 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
29103 }
29104 i64, err := jtv.Int64()
29105 if err != nil {
29106 return err
29107 }
29108 sv.Code = ptr.Int32(int32(i64))
29109 }
29110
29111 case "name":
29112 if value != nil {
29113 jtv, ok := value.(string)
29114 if !ok {
29115 return fmt.Errorf("expected string to be of type string, got %T instead", value)
29116 }
29117 sv.Name = ptr.String(jtv)
29118 }
29119
29120 default:
29121 _, _ = key, value
29122
29123 }
29124 }
29125 *v = sv
29126 return nil
29127 }
29128
29129 func awsAwsjson11_deserializeDocumentInvalidInputException(v **types.InvalidInputException, value interface{}) error {
29130 if v == nil {
29131 return fmt.Errorf("unexpected nil of type %T", v)
29132 }
29133 if value == nil {
29134 return nil
29135 }
29136
29137 shape, ok := value.(map[string]interface{})
29138 if !ok {
29139 return fmt.Errorf("unexpected JSON type %v", value)
29140 }
29141
29142 var sv *types.InvalidInputException
29143 if *v == nil {
29144 sv = &types.InvalidInputException{}
29145 } else {
29146 sv = *v
29147 }
29148
29149 for key, value := range shape {
29150 switch key {
29151 case "code":
29152 if value != nil {
29153 jtv, ok := value.(string)
29154 if !ok {
29155 return fmt.Errorf("expected string to be of type string, got %T instead", value)
29156 }
29157 sv.Code = ptr.String(jtv)
29158 }
29159
29160 case "docs":
29161 if value != nil {
29162 jtv, ok := value.(string)
29163 if !ok {
29164 return fmt.Errorf("expected string to be of type string, got %T instead", value)
29165 }
29166 sv.Docs = ptr.String(jtv)
29167 }
29168
29169 case "message", "Message":
29170 if value != nil {
29171 jtv, ok := value.(string)
29172 if !ok {
29173 return fmt.Errorf("expected string to be of type string, got %T instead", value)
29174 }
29175 sv.Message = ptr.String(jtv)
29176 }
29177
29178 case "tip":
29179 if value != nil {
29180 jtv, ok := value.(string)
29181 if !ok {
29182 return fmt.Errorf("expected string to be of type string, got %T instead", value)
29183 }
29184 sv.Tip = ptr.String(jtv)
29185 }
29186
29187 default:
29188 _, _ = key, value
29189
29190 }
29191 }
29192 *v = sv
29193 return nil
29194 }
29195
29196 func awsAwsjson11_deserializeDocumentIpv6AddressList(v *[]string, value interface{}) error {
29197 if v == nil {
29198 return fmt.Errorf("unexpected nil of type %T", v)
29199 }
29200 if value == nil {
29201 return nil
29202 }
29203
29204 shape, ok := value.([]interface{})
29205 if !ok {
29206 return fmt.Errorf("unexpected JSON type %v", value)
29207 }
29208
29209 var cv []string
29210 if *v == nil {
29211 cv = []string{}
29212 } else {
29213 cv = *v
29214 }
29215
29216 for _, value := range shape {
29217 var col string
29218 if value != nil {
29219 jtv, ok := value.(string)
29220 if !ok {
29221 return fmt.Errorf("expected Ipv6Address to be of type string, got %T instead", value)
29222 }
29223 col = jtv
29224 }
29225 cv = append(cv, col)
29226
29227 }
29228 *v = cv
29229 return nil
29230 }
29231
29232 func awsAwsjson11_deserializeDocumentKeyPair(v **types.KeyPair, value interface{}) error {
29233 if v == nil {
29234 return fmt.Errorf("unexpected nil of type %T", v)
29235 }
29236 if value == nil {
29237 return nil
29238 }
29239
29240 shape, ok := value.(map[string]interface{})
29241 if !ok {
29242 return fmt.Errorf("unexpected JSON type %v", value)
29243 }
29244
29245 var sv *types.KeyPair
29246 if *v == nil {
29247 sv = &types.KeyPair{}
29248 } else {
29249 sv = *v
29250 }
29251
29252 for key, value := range shape {
29253 switch key {
29254 case "arn":
29255 if value != nil {
29256 jtv, ok := value.(string)
29257 if !ok {
29258 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
29259 }
29260 sv.Arn = ptr.String(jtv)
29261 }
29262
29263 case "createdAt":
29264 if value != nil {
29265 switch jtv := value.(type) {
29266 case json.Number:
29267 f64, err := jtv.Float64()
29268 if err != nil {
29269 return err
29270 }
29271 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
29272
29273 default:
29274 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
29275
29276 }
29277 }
29278
29279 case "fingerprint":
29280 if value != nil {
29281 jtv, ok := value.(string)
29282 if !ok {
29283 return fmt.Errorf("expected Base64 to be of type string, got %T instead", value)
29284 }
29285 sv.Fingerprint = ptr.String(jtv)
29286 }
29287
29288 case "location":
29289 if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
29290 return err
29291 }
29292
29293 case "name":
29294 if value != nil {
29295 jtv, ok := value.(string)
29296 if !ok {
29297 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
29298 }
29299 sv.Name = ptr.String(jtv)
29300 }
29301
29302 case "resourceType":
29303 if value != nil {
29304 jtv, ok := value.(string)
29305 if !ok {
29306 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
29307 }
29308 sv.ResourceType = types.ResourceType(jtv)
29309 }
29310
29311 case "supportCode":
29312 if value != nil {
29313 jtv, ok := value.(string)
29314 if !ok {
29315 return fmt.Errorf("expected string to be of type string, got %T instead", value)
29316 }
29317 sv.SupportCode = ptr.String(jtv)
29318 }
29319
29320 case "tags":
29321 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
29322 return err
29323 }
29324
29325 default:
29326 _, _ = key, value
29327
29328 }
29329 }
29330 *v = sv
29331 return nil
29332 }
29333
29334 func awsAwsjson11_deserializeDocumentKeyPairList(v *[]types.KeyPair, value interface{}) error {
29335 if v == nil {
29336 return fmt.Errorf("unexpected nil of type %T", v)
29337 }
29338 if value == nil {
29339 return nil
29340 }
29341
29342 shape, ok := value.([]interface{})
29343 if !ok {
29344 return fmt.Errorf("unexpected JSON type %v", value)
29345 }
29346
29347 var cv []types.KeyPair
29348 if *v == nil {
29349 cv = []types.KeyPair{}
29350 } else {
29351 cv = *v
29352 }
29353
29354 for _, value := range shape {
29355 var col types.KeyPair
29356 destAddr := &col
29357 if err := awsAwsjson11_deserializeDocumentKeyPair(&destAddr, value); err != nil {
29358 return err
29359 }
29360 col = *destAddr
29361 cv = append(cv, col)
29362
29363 }
29364 *v = cv
29365 return nil
29366 }
29367
29368 func awsAwsjson11_deserializeDocumentLightsailDistribution(v **types.LightsailDistribution, value interface{}) error {
29369 if v == nil {
29370 return fmt.Errorf("unexpected nil of type %T", v)
29371 }
29372 if value == nil {
29373 return nil
29374 }
29375
29376 shape, ok := value.(map[string]interface{})
29377 if !ok {
29378 return fmt.Errorf("unexpected JSON type %v", value)
29379 }
29380
29381 var sv *types.LightsailDistribution
29382 if *v == nil {
29383 sv = &types.LightsailDistribution{}
29384 } else {
29385 sv = *v
29386 }
29387
29388 for key, value := range shape {
29389 switch key {
29390 case "ableToUpdateBundle":
29391 if value != nil {
29392 jtv, ok := value.(bool)
29393 if !ok {
29394 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
29395 }
29396 sv.AbleToUpdateBundle = ptr.Bool(jtv)
29397 }
29398
29399 case "alternativeDomainNames":
29400 if err := awsAwsjson11_deserializeDocumentStringList(&sv.AlternativeDomainNames, value); err != nil {
29401 return err
29402 }
29403
29404 case "arn":
29405 if value != nil {
29406 jtv, ok := value.(string)
29407 if !ok {
29408 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
29409 }
29410 sv.Arn = ptr.String(jtv)
29411 }
29412
29413 case "bundleId":
29414 if value != nil {
29415 jtv, ok := value.(string)
29416 if !ok {
29417 return fmt.Errorf("expected string to be of type string, got %T instead", value)
29418 }
29419 sv.BundleId = ptr.String(jtv)
29420 }
29421
29422 case "cacheBehaviors":
29423 if err := awsAwsjson11_deserializeDocumentCacheBehaviorList(&sv.CacheBehaviors, value); err != nil {
29424 return err
29425 }
29426
29427 case "cacheBehaviorSettings":
29428 if err := awsAwsjson11_deserializeDocumentCacheSettings(&sv.CacheBehaviorSettings, value); err != nil {
29429 return err
29430 }
29431
29432 case "certificateName":
29433 if value != nil {
29434 jtv, ok := value.(string)
29435 if !ok {
29436 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
29437 }
29438 sv.CertificateName = ptr.String(jtv)
29439 }
29440
29441 case "createdAt":
29442 if value != nil {
29443 switch jtv := value.(type) {
29444 case json.Number:
29445 f64, err := jtv.Float64()
29446 if err != nil {
29447 return err
29448 }
29449 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
29450
29451 default:
29452 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
29453
29454 }
29455 }
29456
29457 case "defaultCacheBehavior":
29458 if err := awsAwsjson11_deserializeDocumentCacheBehavior(&sv.DefaultCacheBehavior, value); err != nil {
29459 return err
29460 }
29461
29462 case "domainName":
29463 if value != nil {
29464 jtv, ok := value.(string)
29465 if !ok {
29466 return fmt.Errorf("expected string to be of type string, got %T instead", value)
29467 }
29468 sv.DomainName = ptr.String(jtv)
29469 }
29470
29471 case "ipAddressType":
29472 if value != nil {
29473 jtv, ok := value.(string)
29474 if !ok {
29475 return fmt.Errorf("expected IpAddressType to be of type string, got %T instead", value)
29476 }
29477 sv.IpAddressType = types.IpAddressType(jtv)
29478 }
29479
29480 case "isEnabled":
29481 if value != nil {
29482 jtv, ok := value.(bool)
29483 if !ok {
29484 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
29485 }
29486 sv.IsEnabled = ptr.Bool(jtv)
29487 }
29488
29489 case "location":
29490 if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
29491 return err
29492 }
29493
29494 case "name":
29495 if value != nil {
29496 jtv, ok := value.(string)
29497 if !ok {
29498 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
29499 }
29500 sv.Name = ptr.String(jtv)
29501 }
29502
29503 case "origin":
29504 if err := awsAwsjson11_deserializeDocumentOrigin(&sv.Origin, value); err != nil {
29505 return err
29506 }
29507
29508 case "originPublicDNS":
29509 if value != nil {
29510 jtv, ok := value.(string)
29511 if !ok {
29512 return fmt.Errorf("expected string to be of type string, got %T instead", value)
29513 }
29514 sv.OriginPublicDNS = ptr.String(jtv)
29515 }
29516
29517 case "resourceType":
29518 if value != nil {
29519 jtv, ok := value.(string)
29520 if !ok {
29521 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
29522 }
29523 sv.ResourceType = types.ResourceType(jtv)
29524 }
29525
29526 case "status":
29527 if value != nil {
29528 jtv, ok := value.(string)
29529 if !ok {
29530 return fmt.Errorf("expected string to be of type string, got %T instead", value)
29531 }
29532 sv.Status = ptr.String(jtv)
29533 }
29534
29535 case "supportCode":
29536 if value != nil {
29537 jtv, ok := value.(string)
29538 if !ok {
29539 return fmt.Errorf("expected string to be of type string, got %T instead", value)
29540 }
29541 sv.SupportCode = ptr.String(jtv)
29542 }
29543
29544 case "tags":
29545 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
29546 return err
29547 }
29548
29549 case "viewerMinimumTlsProtocolVersion":
29550 if value != nil {
29551 jtv, ok := value.(string)
29552 if !ok {
29553 return fmt.Errorf("expected string to be of type string, got %T instead", value)
29554 }
29555 sv.ViewerMinimumTlsProtocolVersion = ptr.String(jtv)
29556 }
29557
29558 default:
29559 _, _ = key, value
29560
29561 }
29562 }
29563 *v = sv
29564 return nil
29565 }
29566
29567 func awsAwsjson11_deserializeDocumentLoadBalancer(v **types.LoadBalancer, value interface{}) error {
29568 if v == nil {
29569 return fmt.Errorf("unexpected nil of type %T", v)
29570 }
29571 if value == nil {
29572 return nil
29573 }
29574
29575 shape, ok := value.(map[string]interface{})
29576 if !ok {
29577 return fmt.Errorf("unexpected JSON type %v", value)
29578 }
29579
29580 var sv *types.LoadBalancer
29581 if *v == nil {
29582 sv = &types.LoadBalancer{}
29583 } else {
29584 sv = *v
29585 }
29586
29587 for key, value := range shape {
29588 switch key {
29589 case "arn":
29590 if value != nil {
29591 jtv, ok := value.(string)
29592 if !ok {
29593 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
29594 }
29595 sv.Arn = ptr.String(jtv)
29596 }
29597
29598 case "configurationOptions":
29599 if err := awsAwsjson11_deserializeDocumentLoadBalancerConfigurationOptions(&sv.ConfigurationOptions, value); err != nil {
29600 return err
29601 }
29602
29603 case "createdAt":
29604 if value != nil {
29605 switch jtv := value.(type) {
29606 case json.Number:
29607 f64, err := jtv.Float64()
29608 if err != nil {
29609 return err
29610 }
29611 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
29612
29613 default:
29614 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
29615
29616 }
29617 }
29618
29619 case "dnsName":
29620 if value != nil {
29621 jtv, ok := value.(string)
29622 if !ok {
29623 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
29624 }
29625 sv.DnsName = ptr.String(jtv)
29626 }
29627
29628 case "healthCheckPath":
29629 if value != nil {
29630 jtv, ok := value.(string)
29631 if !ok {
29632 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
29633 }
29634 sv.HealthCheckPath = ptr.String(jtv)
29635 }
29636
29637 case "httpsRedirectionEnabled":
29638 if value != nil {
29639 jtv, ok := value.(bool)
29640 if !ok {
29641 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
29642 }
29643 sv.HttpsRedirectionEnabled = ptr.Bool(jtv)
29644 }
29645
29646 case "instanceHealthSummary":
29647 if err := awsAwsjson11_deserializeDocumentInstanceHealthSummaryList(&sv.InstanceHealthSummary, value); err != nil {
29648 return err
29649 }
29650
29651 case "instancePort":
29652 if value != nil {
29653 jtv, ok := value.(json.Number)
29654 if !ok {
29655 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
29656 }
29657 i64, err := jtv.Int64()
29658 if err != nil {
29659 return err
29660 }
29661 sv.InstancePort = ptr.Int32(int32(i64))
29662 }
29663
29664 case "ipAddressType":
29665 if value != nil {
29666 jtv, ok := value.(string)
29667 if !ok {
29668 return fmt.Errorf("expected IpAddressType to be of type string, got %T instead", value)
29669 }
29670 sv.IpAddressType = types.IpAddressType(jtv)
29671 }
29672
29673 case "location":
29674 if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
29675 return err
29676 }
29677
29678 case "name":
29679 if value != nil {
29680 jtv, ok := value.(string)
29681 if !ok {
29682 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
29683 }
29684 sv.Name = ptr.String(jtv)
29685 }
29686
29687 case "protocol":
29688 if value != nil {
29689 jtv, ok := value.(string)
29690 if !ok {
29691 return fmt.Errorf("expected LoadBalancerProtocol to be of type string, got %T instead", value)
29692 }
29693 sv.Protocol = types.LoadBalancerProtocol(jtv)
29694 }
29695
29696 case "publicPorts":
29697 if err := awsAwsjson11_deserializeDocumentPortList(&sv.PublicPorts, value); err != nil {
29698 return err
29699 }
29700
29701 case "resourceType":
29702 if value != nil {
29703 jtv, ok := value.(string)
29704 if !ok {
29705 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
29706 }
29707 sv.ResourceType = types.ResourceType(jtv)
29708 }
29709
29710 case "state":
29711 if value != nil {
29712 jtv, ok := value.(string)
29713 if !ok {
29714 return fmt.Errorf("expected LoadBalancerState to be of type string, got %T instead", value)
29715 }
29716 sv.State = types.LoadBalancerState(jtv)
29717 }
29718
29719 case "supportCode":
29720 if value != nil {
29721 jtv, ok := value.(string)
29722 if !ok {
29723 return fmt.Errorf("expected string to be of type string, got %T instead", value)
29724 }
29725 sv.SupportCode = ptr.String(jtv)
29726 }
29727
29728 case "tags":
29729 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
29730 return err
29731 }
29732
29733 case "tlsCertificateSummaries":
29734 if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateSummaryList(&sv.TlsCertificateSummaries, value); err != nil {
29735 return err
29736 }
29737
29738 case "tlsPolicyName":
29739 if value != nil {
29740 jtv, ok := value.(string)
29741 if !ok {
29742 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
29743 }
29744 sv.TlsPolicyName = ptr.String(jtv)
29745 }
29746
29747 default:
29748 _, _ = key, value
29749
29750 }
29751 }
29752 *v = sv
29753 return nil
29754 }
29755
29756 func awsAwsjson11_deserializeDocumentLoadBalancerConfigurationOptions(v *map[string]string, value interface{}) error {
29757 if v == nil {
29758 return fmt.Errorf("unexpected nil of type %T", v)
29759 }
29760 if value == nil {
29761 return nil
29762 }
29763
29764 shape, ok := value.(map[string]interface{})
29765 if !ok {
29766 return fmt.Errorf("unexpected JSON type %v", value)
29767 }
29768
29769 var mv map[string]string
29770 if *v == nil {
29771 mv = map[string]string{}
29772 } else {
29773 mv = *v
29774 }
29775
29776 for key, value := range shape {
29777 var parsedVal string
29778 if value != nil {
29779 jtv, ok := value.(string)
29780 if !ok {
29781 return fmt.Errorf("expected string to be of type string, got %T instead", value)
29782 }
29783 parsedVal = jtv
29784 }
29785 mv[key] = parsedVal
29786
29787 }
29788 *v = mv
29789 return nil
29790 }
29791
29792 func awsAwsjson11_deserializeDocumentLoadBalancerList(v *[]types.LoadBalancer, value interface{}) error {
29793 if v == nil {
29794 return fmt.Errorf("unexpected nil of type %T", v)
29795 }
29796 if value == nil {
29797 return nil
29798 }
29799
29800 shape, ok := value.([]interface{})
29801 if !ok {
29802 return fmt.Errorf("unexpected JSON type %v", value)
29803 }
29804
29805 var cv []types.LoadBalancer
29806 if *v == nil {
29807 cv = []types.LoadBalancer{}
29808 } else {
29809 cv = *v
29810 }
29811
29812 for _, value := range shape {
29813 var col types.LoadBalancer
29814 destAddr := &col
29815 if err := awsAwsjson11_deserializeDocumentLoadBalancer(&destAddr, value); err != nil {
29816 return err
29817 }
29818 col = *destAddr
29819 cv = append(cv, col)
29820
29821 }
29822 *v = cv
29823 return nil
29824 }
29825
29826 func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificate(v **types.LoadBalancerTlsCertificate, value interface{}) error {
29827 if v == nil {
29828 return fmt.Errorf("unexpected nil of type %T", v)
29829 }
29830 if value == nil {
29831 return nil
29832 }
29833
29834 shape, ok := value.(map[string]interface{})
29835 if !ok {
29836 return fmt.Errorf("unexpected JSON type %v", value)
29837 }
29838
29839 var sv *types.LoadBalancerTlsCertificate
29840 if *v == nil {
29841 sv = &types.LoadBalancerTlsCertificate{}
29842 } else {
29843 sv = *v
29844 }
29845
29846 for key, value := range shape {
29847 switch key {
29848 case "arn":
29849 if value != nil {
29850 jtv, ok := value.(string)
29851 if !ok {
29852 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
29853 }
29854 sv.Arn = ptr.String(jtv)
29855 }
29856
29857 case "createdAt":
29858 if value != nil {
29859 switch jtv := value.(type) {
29860 case json.Number:
29861 f64, err := jtv.Float64()
29862 if err != nil {
29863 return err
29864 }
29865 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
29866
29867 default:
29868 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
29869
29870 }
29871 }
29872
29873 case "domainName":
29874 if value != nil {
29875 jtv, ok := value.(string)
29876 if !ok {
29877 return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
29878 }
29879 sv.DomainName = ptr.String(jtv)
29880 }
29881
29882 case "domainValidationRecords":
29883 if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateDomainValidationRecordList(&sv.DomainValidationRecords, value); err != nil {
29884 return err
29885 }
29886
29887 case "failureReason":
29888 if value != nil {
29889 jtv, ok := value.(string)
29890 if !ok {
29891 return fmt.Errorf("expected LoadBalancerTlsCertificateFailureReason to be of type string, got %T instead", value)
29892 }
29893 sv.FailureReason = types.LoadBalancerTlsCertificateFailureReason(jtv)
29894 }
29895
29896 case "isAttached":
29897 if value != nil {
29898 jtv, ok := value.(bool)
29899 if !ok {
29900 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
29901 }
29902 sv.IsAttached = ptr.Bool(jtv)
29903 }
29904
29905 case "issuedAt":
29906 if value != nil {
29907 switch jtv := value.(type) {
29908 case json.Number:
29909 f64, err := jtv.Float64()
29910 if err != nil {
29911 return err
29912 }
29913 sv.IssuedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
29914
29915 default:
29916 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
29917
29918 }
29919 }
29920
29921 case "issuer":
29922 if value != nil {
29923 jtv, ok := value.(string)
29924 if !ok {
29925 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
29926 }
29927 sv.Issuer = ptr.String(jtv)
29928 }
29929
29930 case "keyAlgorithm":
29931 if value != nil {
29932 jtv, ok := value.(string)
29933 if !ok {
29934 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
29935 }
29936 sv.KeyAlgorithm = ptr.String(jtv)
29937 }
29938
29939 case "loadBalancerName":
29940 if value != nil {
29941 jtv, ok := value.(string)
29942 if !ok {
29943 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
29944 }
29945 sv.LoadBalancerName = ptr.String(jtv)
29946 }
29947
29948 case "location":
29949 if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
29950 return err
29951 }
29952
29953 case "name":
29954 if value != nil {
29955 jtv, ok := value.(string)
29956 if !ok {
29957 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
29958 }
29959 sv.Name = ptr.String(jtv)
29960 }
29961
29962 case "notAfter":
29963 if value != nil {
29964 switch jtv := value.(type) {
29965 case json.Number:
29966 f64, err := jtv.Float64()
29967 if err != nil {
29968 return err
29969 }
29970 sv.NotAfter = ptr.Time(smithytime.ParseEpochSeconds(f64))
29971
29972 default:
29973 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
29974
29975 }
29976 }
29977
29978 case "notBefore":
29979 if value != nil {
29980 switch jtv := value.(type) {
29981 case json.Number:
29982 f64, err := jtv.Float64()
29983 if err != nil {
29984 return err
29985 }
29986 sv.NotBefore = ptr.Time(smithytime.ParseEpochSeconds(f64))
29987
29988 default:
29989 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
29990
29991 }
29992 }
29993
29994 case "renewalSummary":
29995 if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateRenewalSummary(&sv.RenewalSummary, value); err != nil {
29996 return err
29997 }
29998
29999 case "resourceType":
30000 if value != nil {
30001 jtv, ok := value.(string)
30002 if !ok {
30003 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
30004 }
30005 sv.ResourceType = types.ResourceType(jtv)
30006 }
30007
30008 case "revocationReason":
30009 if value != nil {
30010 jtv, ok := value.(string)
30011 if !ok {
30012 return fmt.Errorf("expected LoadBalancerTlsCertificateRevocationReason to be of type string, got %T instead", value)
30013 }
30014 sv.RevocationReason = types.LoadBalancerTlsCertificateRevocationReason(jtv)
30015 }
30016
30017 case "revokedAt":
30018 if value != nil {
30019 switch jtv := value.(type) {
30020 case json.Number:
30021 f64, err := jtv.Float64()
30022 if err != nil {
30023 return err
30024 }
30025 sv.RevokedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
30026
30027 default:
30028 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
30029
30030 }
30031 }
30032
30033 case "serial":
30034 if value != nil {
30035 jtv, ok := value.(string)
30036 if !ok {
30037 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
30038 }
30039 sv.Serial = ptr.String(jtv)
30040 }
30041
30042 case "signatureAlgorithm":
30043 if value != nil {
30044 jtv, ok := value.(string)
30045 if !ok {
30046 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
30047 }
30048 sv.SignatureAlgorithm = ptr.String(jtv)
30049 }
30050
30051 case "status":
30052 if value != nil {
30053 jtv, ok := value.(string)
30054 if !ok {
30055 return fmt.Errorf("expected LoadBalancerTlsCertificateStatus to be of type string, got %T instead", value)
30056 }
30057 sv.Status = types.LoadBalancerTlsCertificateStatus(jtv)
30058 }
30059
30060 case "subject":
30061 if value != nil {
30062 jtv, ok := value.(string)
30063 if !ok {
30064 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
30065 }
30066 sv.Subject = ptr.String(jtv)
30067 }
30068
30069 case "subjectAlternativeNames":
30070 if err := awsAwsjson11_deserializeDocumentStringList(&sv.SubjectAlternativeNames, value); err != nil {
30071 return err
30072 }
30073
30074 case "supportCode":
30075 if value != nil {
30076 jtv, ok := value.(string)
30077 if !ok {
30078 return fmt.Errorf("expected string to be of type string, got %T instead", value)
30079 }
30080 sv.SupportCode = ptr.String(jtv)
30081 }
30082
30083 case "tags":
30084 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
30085 return err
30086 }
30087
30088 default:
30089 _, _ = key, value
30090
30091 }
30092 }
30093 *v = sv
30094 return nil
30095 }
30096
30097 func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateDnsRecordCreationState(v **types.LoadBalancerTlsCertificateDnsRecordCreationState, value interface{}) error {
30098 if v == nil {
30099 return fmt.Errorf("unexpected nil of type %T", v)
30100 }
30101 if value == nil {
30102 return nil
30103 }
30104
30105 shape, ok := value.(map[string]interface{})
30106 if !ok {
30107 return fmt.Errorf("unexpected JSON type %v", value)
30108 }
30109
30110 var sv *types.LoadBalancerTlsCertificateDnsRecordCreationState
30111 if *v == nil {
30112 sv = &types.LoadBalancerTlsCertificateDnsRecordCreationState{}
30113 } else {
30114 sv = *v
30115 }
30116
30117 for key, value := range shape {
30118 switch key {
30119 case "code":
30120 if value != nil {
30121 jtv, ok := value.(string)
30122 if !ok {
30123 return fmt.Errorf("expected LoadBalancerTlsCertificateDnsRecordCreationStateCode to be of type string, got %T instead", value)
30124 }
30125 sv.Code = types.LoadBalancerTlsCertificateDnsRecordCreationStateCode(jtv)
30126 }
30127
30128 case "message":
30129 if value != nil {
30130 jtv, ok := value.(string)
30131 if !ok {
30132 return fmt.Errorf("expected string to be of type string, got %T instead", value)
30133 }
30134 sv.Message = ptr.String(jtv)
30135 }
30136
30137 default:
30138 _, _ = key, value
30139
30140 }
30141 }
30142 *v = sv
30143 return nil
30144 }
30145
30146 func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateDomainValidationOption(v **types.LoadBalancerTlsCertificateDomainValidationOption, value interface{}) error {
30147 if v == nil {
30148 return fmt.Errorf("unexpected nil of type %T", v)
30149 }
30150 if value == nil {
30151 return nil
30152 }
30153
30154 shape, ok := value.(map[string]interface{})
30155 if !ok {
30156 return fmt.Errorf("unexpected JSON type %v", value)
30157 }
30158
30159 var sv *types.LoadBalancerTlsCertificateDomainValidationOption
30160 if *v == nil {
30161 sv = &types.LoadBalancerTlsCertificateDomainValidationOption{}
30162 } else {
30163 sv = *v
30164 }
30165
30166 for key, value := range shape {
30167 switch key {
30168 case "domainName":
30169 if value != nil {
30170 jtv, ok := value.(string)
30171 if !ok {
30172 return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
30173 }
30174 sv.DomainName = ptr.String(jtv)
30175 }
30176
30177 case "validationStatus":
30178 if value != nil {
30179 jtv, ok := value.(string)
30180 if !ok {
30181 return fmt.Errorf("expected LoadBalancerTlsCertificateDomainStatus to be of type string, got %T instead", value)
30182 }
30183 sv.ValidationStatus = types.LoadBalancerTlsCertificateDomainStatus(jtv)
30184 }
30185
30186 default:
30187 _, _ = key, value
30188
30189 }
30190 }
30191 *v = sv
30192 return nil
30193 }
30194
30195 func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateDomainValidationOptionList(v *[]types.LoadBalancerTlsCertificateDomainValidationOption, value interface{}) error {
30196 if v == nil {
30197 return fmt.Errorf("unexpected nil of type %T", v)
30198 }
30199 if value == nil {
30200 return nil
30201 }
30202
30203 shape, ok := value.([]interface{})
30204 if !ok {
30205 return fmt.Errorf("unexpected JSON type %v", value)
30206 }
30207
30208 var cv []types.LoadBalancerTlsCertificateDomainValidationOption
30209 if *v == nil {
30210 cv = []types.LoadBalancerTlsCertificateDomainValidationOption{}
30211 } else {
30212 cv = *v
30213 }
30214
30215 for _, value := range shape {
30216 var col types.LoadBalancerTlsCertificateDomainValidationOption
30217 destAddr := &col
30218 if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateDomainValidationOption(&destAddr, value); err != nil {
30219 return err
30220 }
30221 col = *destAddr
30222 cv = append(cv, col)
30223
30224 }
30225 *v = cv
30226 return nil
30227 }
30228
30229 func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateDomainValidationRecord(v **types.LoadBalancerTlsCertificateDomainValidationRecord, value interface{}) error {
30230 if v == nil {
30231 return fmt.Errorf("unexpected nil of type %T", v)
30232 }
30233 if value == nil {
30234 return nil
30235 }
30236
30237 shape, ok := value.(map[string]interface{})
30238 if !ok {
30239 return fmt.Errorf("unexpected JSON type %v", value)
30240 }
30241
30242 var sv *types.LoadBalancerTlsCertificateDomainValidationRecord
30243 if *v == nil {
30244 sv = &types.LoadBalancerTlsCertificateDomainValidationRecord{}
30245 } else {
30246 sv = *v
30247 }
30248
30249 for key, value := range shape {
30250 switch key {
30251 case "dnsRecordCreationState":
30252 if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateDnsRecordCreationState(&sv.DnsRecordCreationState, value); err != nil {
30253 return err
30254 }
30255
30256 case "domainName":
30257 if value != nil {
30258 jtv, ok := value.(string)
30259 if !ok {
30260 return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
30261 }
30262 sv.DomainName = ptr.String(jtv)
30263 }
30264
30265 case "name":
30266 if value != nil {
30267 jtv, ok := value.(string)
30268 if !ok {
30269 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
30270 }
30271 sv.Name = ptr.String(jtv)
30272 }
30273
30274 case "type":
30275 if value != nil {
30276 jtv, ok := value.(string)
30277 if !ok {
30278 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
30279 }
30280 sv.Type = ptr.String(jtv)
30281 }
30282
30283 case "validationStatus":
30284 if value != nil {
30285 jtv, ok := value.(string)
30286 if !ok {
30287 return fmt.Errorf("expected LoadBalancerTlsCertificateDomainStatus to be of type string, got %T instead", value)
30288 }
30289 sv.ValidationStatus = types.LoadBalancerTlsCertificateDomainStatus(jtv)
30290 }
30291
30292 case "value":
30293 if value != nil {
30294 jtv, ok := value.(string)
30295 if !ok {
30296 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
30297 }
30298 sv.Value = ptr.String(jtv)
30299 }
30300
30301 default:
30302 _, _ = key, value
30303
30304 }
30305 }
30306 *v = sv
30307 return nil
30308 }
30309
30310 func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateDomainValidationRecordList(v *[]types.LoadBalancerTlsCertificateDomainValidationRecord, value interface{}) error {
30311 if v == nil {
30312 return fmt.Errorf("unexpected nil of type %T", v)
30313 }
30314 if value == nil {
30315 return nil
30316 }
30317
30318 shape, ok := value.([]interface{})
30319 if !ok {
30320 return fmt.Errorf("unexpected JSON type %v", value)
30321 }
30322
30323 var cv []types.LoadBalancerTlsCertificateDomainValidationRecord
30324 if *v == nil {
30325 cv = []types.LoadBalancerTlsCertificateDomainValidationRecord{}
30326 } else {
30327 cv = *v
30328 }
30329
30330 for _, value := range shape {
30331 var col types.LoadBalancerTlsCertificateDomainValidationRecord
30332 destAddr := &col
30333 if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateDomainValidationRecord(&destAddr, value); err != nil {
30334 return err
30335 }
30336 col = *destAddr
30337 cv = append(cv, col)
30338
30339 }
30340 *v = cv
30341 return nil
30342 }
30343
30344 func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateList(v *[]types.LoadBalancerTlsCertificate, value interface{}) error {
30345 if v == nil {
30346 return fmt.Errorf("unexpected nil of type %T", v)
30347 }
30348 if value == nil {
30349 return nil
30350 }
30351
30352 shape, ok := value.([]interface{})
30353 if !ok {
30354 return fmt.Errorf("unexpected JSON type %v", value)
30355 }
30356
30357 var cv []types.LoadBalancerTlsCertificate
30358 if *v == nil {
30359 cv = []types.LoadBalancerTlsCertificate{}
30360 } else {
30361 cv = *v
30362 }
30363
30364 for _, value := range shape {
30365 var col types.LoadBalancerTlsCertificate
30366 destAddr := &col
30367 if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificate(&destAddr, value); err != nil {
30368 return err
30369 }
30370 col = *destAddr
30371 cv = append(cv, col)
30372
30373 }
30374 *v = cv
30375 return nil
30376 }
30377
30378 func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateRenewalSummary(v **types.LoadBalancerTlsCertificateRenewalSummary, value interface{}) error {
30379 if v == nil {
30380 return fmt.Errorf("unexpected nil of type %T", v)
30381 }
30382 if value == nil {
30383 return nil
30384 }
30385
30386 shape, ok := value.(map[string]interface{})
30387 if !ok {
30388 return fmt.Errorf("unexpected JSON type %v", value)
30389 }
30390
30391 var sv *types.LoadBalancerTlsCertificateRenewalSummary
30392 if *v == nil {
30393 sv = &types.LoadBalancerTlsCertificateRenewalSummary{}
30394 } else {
30395 sv = *v
30396 }
30397
30398 for key, value := range shape {
30399 switch key {
30400 case "domainValidationOptions":
30401 if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateDomainValidationOptionList(&sv.DomainValidationOptions, value); err != nil {
30402 return err
30403 }
30404
30405 case "renewalStatus":
30406 if value != nil {
30407 jtv, ok := value.(string)
30408 if !ok {
30409 return fmt.Errorf("expected LoadBalancerTlsCertificateRenewalStatus to be of type string, got %T instead", value)
30410 }
30411 sv.RenewalStatus = types.LoadBalancerTlsCertificateRenewalStatus(jtv)
30412 }
30413
30414 default:
30415 _, _ = key, value
30416
30417 }
30418 }
30419 *v = sv
30420 return nil
30421 }
30422
30423 func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateSummary(v **types.LoadBalancerTlsCertificateSummary, value interface{}) error {
30424 if v == nil {
30425 return fmt.Errorf("unexpected nil of type %T", v)
30426 }
30427 if value == nil {
30428 return nil
30429 }
30430
30431 shape, ok := value.(map[string]interface{})
30432 if !ok {
30433 return fmt.Errorf("unexpected JSON type %v", value)
30434 }
30435
30436 var sv *types.LoadBalancerTlsCertificateSummary
30437 if *v == nil {
30438 sv = &types.LoadBalancerTlsCertificateSummary{}
30439 } else {
30440 sv = *v
30441 }
30442
30443 for key, value := range shape {
30444 switch key {
30445 case "isAttached":
30446 if value != nil {
30447 jtv, ok := value.(bool)
30448 if !ok {
30449 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
30450 }
30451 sv.IsAttached = ptr.Bool(jtv)
30452 }
30453
30454 case "name":
30455 if value != nil {
30456 jtv, ok := value.(string)
30457 if !ok {
30458 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
30459 }
30460 sv.Name = ptr.String(jtv)
30461 }
30462
30463 default:
30464 _, _ = key, value
30465
30466 }
30467 }
30468 *v = sv
30469 return nil
30470 }
30471
30472 func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateSummaryList(v *[]types.LoadBalancerTlsCertificateSummary, value interface{}) error {
30473 if v == nil {
30474 return fmt.Errorf("unexpected nil of type %T", v)
30475 }
30476 if value == nil {
30477 return nil
30478 }
30479
30480 shape, ok := value.([]interface{})
30481 if !ok {
30482 return fmt.Errorf("unexpected JSON type %v", value)
30483 }
30484
30485 var cv []types.LoadBalancerTlsCertificateSummary
30486 if *v == nil {
30487 cv = []types.LoadBalancerTlsCertificateSummary{}
30488 } else {
30489 cv = *v
30490 }
30491
30492 for _, value := range shape {
30493 var col types.LoadBalancerTlsCertificateSummary
30494 destAddr := &col
30495 if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateSummary(&destAddr, value); err != nil {
30496 return err
30497 }
30498 col = *destAddr
30499 cv = append(cv, col)
30500
30501 }
30502 *v = cv
30503 return nil
30504 }
30505
30506 func awsAwsjson11_deserializeDocumentLoadBalancerTlsPolicy(v **types.LoadBalancerTlsPolicy, value interface{}) error {
30507 if v == nil {
30508 return fmt.Errorf("unexpected nil of type %T", v)
30509 }
30510 if value == nil {
30511 return nil
30512 }
30513
30514 shape, ok := value.(map[string]interface{})
30515 if !ok {
30516 return fmt.Errorf("unexpected JSON type %v", value)
30517 }
30518
30519 var sv *types.LoadBalancerTlsPolicy
30520 if *v == nil {
30521 sv = &types.LoadBalancerTlsPolicy{}
30522 } else {
30523 sv = *v
30524 }
30525
30526 for key, value := range shape {
30527 switch key {
30528 case "ciphers":
30529 if err := awsAwsjson11_deserializeDocumentStringList(&sv.Ciphers, value); err != nil {
30530 return err
30531 }
30532
30533 case "description":
30534 if value != nil {
30535 jtv, ok := value.(string)
30536 if !ok {
30537 return fmt.Errorf("expected string to be of type string, got %T instead", value)
30538 }
30539 sv.Description = ptr.String(jtv)
30540 }
30541
30542 case "isDefault":
30543 if value != nil {
30544 jtv, ok := value.(bool)
30545 if !ok {
30546 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
30547 }
30548 sv.IsDefault = ptr.Bool(jtv)
30549 }
30550
30551 case "name":
30552 if value != nil {
30553 jtv, ok := value.(string)
30554 if !ok {
30555 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
30556 }
30557 sv.Name = ptr.String(jtv)
30558 }
30559
30560 case "protocols":
30561 if err := awsAwsjson11_deserializeDocumentStringList(&sv.Protocols, value); err != nil {
30562 return err
30563 }
30564
30565 default:
30566 _, _ = key, value
30567
30568 }
30569 }
30570 *v = sv
30571 return nil
30572 }
30573
30574 func awsAwsjson11_deserializeDocumentLoadBalancerTlsPolicyList(v *[]types.LoadBalancerTlsPolicy, value interface{}) error {
30575 if v == nil {
30576 return fmt.Errorf("unexpected nil of type %T", v)
30577 }
30578 if value == nil {
30579 return nil
30580 }
30581
30582 shape, ok := value.([]interface{})
30583 if !ok {
30584 return fmt.Errorf("unexpected JSON type %v", value)
30585 }
30586
30587 var cv []types.LoadBalancerTlsPolicy
30588 if *v == nil {
30589 cv = []types.LoadBalancerTlsPolicy{}
30590 } else {
30591 cv = *v
30592 }
30593
30594 for _, value := range shape {
30595 var col types.LoadBalancerTlsPolicy
30596 destAddr := &col
30597 if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsPolicy(&destAddr, value); err != nil {
30598 return err
30599 }
30600 col = *destAddr
30601 cv = append(cv, col)
30602
30603 }
30604 *v = cv
30605 return nil
30606 }
30607
30608 func awsAwsjson11_deserializeDocumentLogEvent(v **types.LogEvent, value interface{}) error {
30609 if v == nil {
30610 return fmt.Errorf("unexpected nil of type %T", v)
30611 }
30612 if value == nil {
30613 return nil
30614 }
30615
30616 shape, ok := value.(map[string]interface{})
30617 if !ok {
30618 return fmt.Errorf("unexpected JSON type %v", value)
30619 }
30620
30621 var sv *types.LogEvent
30622 if *v == nil {
30623 sv = &types.LogEvent{}
30624 } else {
30625 sv = *v
30626 }
30627
30628 for key, value := range shape {
30629 switch key {
30630 case "createdAt":
30631 if value != nil {
30632 switch jtv := value.(type) {
30633 case json.Number:
30634 f64, err := jtv.Float64()
30635 if err != nil {
30636 return err
30637 }
30638 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
30639
30640 default:
30641 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
30642
30643 }
30644 }
30645
30646 case "message":
30647 if value != nil {
30648 jtv, ok := value.(string)
30649 if !ok {
30650 return fmt.Errorf("expected string to be of type string, got %T instead", value)
30651 }
30652 sv.Message = ptr.String(jtv)
30653 }
30654
30655 default:
30656 _, _ = key, value
30657
30658 }
30659 }
30660 *v = sv
30661 return nil
30662 }
30663
30664 func awsAwsjson11_deserializeDocumentLogEventList(v *[]types.LogEvent, value interface{}) error {
30665 if v == nil {
30666 return fmt.Errorf("unexpected nil of type %T", v)
30667 }
30668 if value == nil {
30669 return nil
30670 }
30671
30672 shape, ok := value.([]interface{})
30673 if !ok {
30674 return fmt.Errorf("unexpected JSON type %v", value)
30675 }
30676
30677 var cv []types.LogEvent
30678 if *v == nil {
30679 cv = []types.LogEvent{}
30680 } else {
30681 cv = *v
30682 }
30683
30684 for _, value := range shape {
30685 var col types.LogEvent
30686 destAddr := &col
30687 if err := awsAwsjson11_deserializeDocumentLogEvent(&destAddr, value); err != nil {
30688 return err
30689 }
30690 col = *destAddr
30691 cv = append(cv, col)
30692
30693 }
30694 *v = cv
30695 return nil
30696 }
30697
30698 func awsAwsjson11_deserializeDocumentMetricDatapoint(v **types.MetricDatapoint, value interface{}) error {
30699 if v == nil {
30700 return fmt.Errorf("unexpected nil of type %T", v)
30701 }
30702 if value == nil {
30703 return nil
30704 }
30705
30706 shape, ok := value.(map[string]interface{})
30707 if !ok {
30708 return fmt.Errorf("unexpected JSON type %v", value)
30709 }
30710
30711 var sv *types.MetricDatapoint
30712 if *v == nil {
30713 sv = &types.MetricDatapoint{}
30714 } else {
30715 sv = *v
30716 }
30717
30718 for key, value := range shape {
30719 switch key {
30720 case "average":
30721 if value != nil {
30722 switch jtv := value.(type) {
30723 case json.Number:
30724 f64, err := jtv.Float64()
30725 if err != nil {
30726 return err
30727 }
30728 sv.Average = ptr.Float64(f64)
30729
30730 case string:
30731 var f64 float64
30732 switch {
30733 case strings.EqualFold(jtv, "NaN"):
30734 f64 = math.NaN()
30735
30736 case strings.EqualFold(jtv, "Infinity"):
30737 f64 = math.Inf(1)
30738
30739 case strings.EqualFold(jtv, "-Infinity"):
30740 f64 = math.Inf(-1)
30741
30742 default:
30743 return fmt.Errorf("unknown JSON number value: %s", jtv)
30744
30745 }
30746 sv.Average = ptr.Float64(f64)
30747
30748 default:
30749 return fmt.Errorf("expected double to be a JSON Number, got %T instead", value)
30750
30751 }
30752 }
30753
30754 case "maximum":
30755 if value != nil {
30756 switch jtv := value.(type) {
30757 case json.Number:
30758 f64, err := jtv.Float64()
30759 if err != nil {
30760 return err
30761 }
30762 sv.Maximum = ptr.Float64(f64)
30763
30764 case string:
30765 var f64 float64
30766 switch {
30767 case strings.EqualFold(jtv, "NaN"):
30768 f64 = math.NaN()
30769
30770 case strings.EqualFold(jtv, "Infinity"):
30771 f64 = math.Inf(1)
30772
30773 case strings.EqualFold(jtv, "-Infinity"):
30774 f64 = math.Inf(-1)
30775
30776 default:
30777 return fmt.Errorf("unknown JSON number value: %s", jtv)
30778
30779 }
30780 sv.Maximum = ptr.Float64(f64)
30781
30782 default:
30783 return fmt.Errorf("expected double to be a JSON Number, got %T instead", value)
30784
30785 }
30786 }
30787
30788 case "minimum":
30789 if value != nil {
30790 switch jtv := value.(type) {
30791 case json.Number:
30792 f64, err := jtv.Float64()
30793 if err != nil {
30794 return err
30795 }
30796 sv.Minimum = ptr.Float64(f64)
30797
30798 case string:
30799 var f64 float64
30800 switch {
30801 case strings.EqualFold(jtv, "NaN"):
30802 f64 = math.NaN()
30803
30804 case strings.EqualFold(jtv, "Infinity"):
30805 f64 = math.Inf(1)
30806
30807 case strings.EqualFold(jtv, "-Infinity"):
30808 f64 = math.Inf(-1)
30809
30810 default:
30811 return fmt.Errorf("unknown JSON number value: %s", jtv)
30812
30813 }
30814 sv.Minimum = ptr.Float64(f64)
30815
30816 default:
30817 return fmt.Errorf("expected double to be a JSON Number, got %T instead", value)
30818
30819 }
30820 }
30821
30822 case "sampleCount":
30823 if value != nil {
30824 switch jtv := value.(type) {
30825 case json.Number:
30826 f64, err := jtv.Float64()
30827 if err != nil {
30828 return err
30829 }
30830 sv.SampleCount = ptr.Float64(f64)
30831
30832 case string:
30833 var f64 float64
30834 switch {
30835 case strings.EqualFold(jtv, "NaN"):
30836 f64 = math.NaN()
30837
30838 case strings.EqualFold(jtv, "Infinity"):
30839 f64 = math.Inf(1)
30840
30841 case strings.EqualFold(jtv, "-Infinity"):
30842 f64 = math.Inf(-1)
30843
30844 default:
30845 return fmt.Errorf("unknown JSON number value: %s", jtv)
30846
30847 }
30848 sv.SampleCount = ptr.Float64(f64)
30849
30850 default:
30851 return fmt.Errorf("expected double to be a JSON Number, got %T instead", value)
30852
30853 }
30854 }
30855
30856 case "sum":
30857 if value != nil {
30858 switch jtv := value.(type) {
30859 case json.Number:
30860 f64, err := jtv.Float64()
30861 if err != nil {
30862 return err
30863 }
30864 sv.Sum = ptr.Float64(f64)
30865
30866 case string:
30867 var f64 float64
30868 switch {
30869 case strings.EqualFold(jtv, "NaN"):
30870 f64 = math.NaN()
30871
30872 case strings.EqualFold(jtv, "Infinity"):
30873 f64 = math.Inf(1)
30874
30875 case strings.EqualFold(jtv, "-Infinity"):
30876 f64 = math.Inf(-1)
30877
30878 default:
30879 return fmt.Errorf("unknown JSON number value: %s", jtv)
30880
30881 }
30882 sv.Sum = ptr.Float64(f64)
30883
30884 default:
30885 return fmt.Errorf("expected double to be a JSON Number, got %T instead", value)
30886
30887 }
30888 }
30889
30890 case "timestamp":
30891 if value != nil {
30892 switch jtv := value.(type) {
30893 case json.Number:
30894 f64, err := jtv.Float64()
30895 if err != nil {
30896 return err
30897 }
30898 sv.Timestamp = ptr.Time(smithytime.ParseEpochSeconds(f64))
30899
30900 default:
30901 return fmt.Errorf("expected timestamp to be a JSON Number, got %T instead", value)
30902
30903 }
30904 }
30905
30906 case "unit":
30907 if value != nil {
30908 jtv, ok := value.(string)
30909 if !ok {
30910 return fmt.Errorf("expected MetricUnit to be of type string, got %T instead", value)
30911 }
30912 sv.Unit = types.MetricUnit(jtv)
30913 }
30914
30915 default:
30916 _, _ = key, value
30917
30918 }
30919 }
30920 *v = sv
30921 return nil
30922 }
30923
30924 func awsAwsjson11_deserializeDocumentMetricDatapointList(v *[]types.MetricDatapoint, value interface{}) error {
30925 if v == nil {
30926 return fmt.Errorf("unexpected nil of type %T", v)
30927 }
30928 if value == nil {
30929 return nil
30930 }
30931
30932 shape, ok := value.([]interface{})
30933 if !ok {
30934 return fmt.Errorf("unexpected JSON type %v", value)
30935 }
30936
30937 var cv []types.MetricDatapoint
30938 if *v == nil {
30939 cv = []types.MetricDatapoint{}
30940 } else {
30941 cv = *v
30942 }
30943
30944 for _, value := range shape {
30945 var col types.MetricDatapoint
30946 destAddr := &col
30947 if err := awsAwsjson11_deserializeDocumentMetricDatapoint(&destAddr, value); err != nil {
30948 return err
30949 }
30950 col = *destAddr
30951 cv = append(cv, col)
30952
30953 }
30954 *v = cv
30955 return nil
30956 }
30957
30958 func awsAwsjson11_deserializeDocumentMonitoredResourceInfo(v **types.MonitoredResourceInfo, value interface{}) error {
30959 if v == nil {
30960 return fmt.Errorf("unexpected nil of type %T", v)
30961 }
30962 if value == nil {
30963 return nil
30964 }
30965
30966 shape, ok := value.(map[string]interface{})
30967 if !ok {
30968 return fmt.Errorf("unexpected JSON type %v", value)
30969 }
30970
30971 var sv *types.MonitoredResourceInfo
30972 if *v == nil {
30973 sv = &types.MonitoredResourceInfo{}
30974 } else {
30975 sv = *v
30976 }
30977
30978 for key, value := range shape {
30979 switch key {
30980 case "arn":
30981 if value != nil {
30982 jtv, ok := value.(string)
30983 if !ok {
30984 return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value)
30985 }
30986 sv.Arn = ptr.String(jtv)
30987 }
30988
30989 case "name":
30990 if value != nil {
30991 jtv, ok := value.(string)
30992 if !ok {
30993 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
30994 }
30995 sv.Name = ptr.String(jtv)
30996 }
30997
30998 case "resourceType":
30999 if value != nil {
31000 jtv, ok := value.(string)
31001 if !ok {
31002 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
31003 }
31004 sv.ResourceType = types.ResourceType(jtv)
31005 }
31006
31007 default:
31008 _, _ = key, value
31009
31010 }
31011 }
31012 *v = sv
31013 return nil
31014 }
31015
31016 func awsAwsjson11_deserializeDocumentMonthlyTransfer(v **types.MonthlyTransfer, value interface{}) error {
31017 if v == nil {
31018 return fmt.Errorf("unexpected nil of type %T", v)
31019 }
31020 if value == nil {
31021 return nil
31022 }
31023
31024 shape, ok := value.(map[string]interface{})
31025 if !ok {
31026 return fmt.Errorf("unexpected JSON type %v", value)
31027 }
31028
31029 var sv *types.MonthlyTransfer
31030 if *v == nil {
31031 sv = &types.MonthlyTransfer{}
31032 } else {
31033 sv = *v
31034 }
31035
31036 for key, value := range shape {
31037 switch key {
31038 case "gbPerMonthAllocated":
31039 if value != nil {
31040 jtv, ok := value.(json.Number)
31041 if !ok {
31042 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
31043 }
31044 i64, err := jtv.Int64()
31045 if err != nil {
31046 return err
31047 }
31048 sv.GbPerMonthAllocated = ptr.Int32(int32(i64))
31049 }
31050
31051 default:
31052 _, _ = key, value
31053
31054 }
31055 }
31056 *v = sv
31057 return nil
31058 }
31059
31060 func awsAwsjson11_deserializeDocumentNameServersUpdateState(v **types.NameServersUpdateState, value interface{}) error {
31061 if v == nil {
31062 return fmt.Errorf("unexpected nil of type %T", v)
31063 }
31064 if value == nil {
31065 return nil
31066 }
31067
31068 shape, ok := value.(map[string]interface{})
31069 if !ok {
31070 return fmt.Errorf("unexpected JSON type %v", value)
31071 }
31072
31073 var sv *types.NameServersUpdateState
31074 if *v == nil {
31075 sv = &types.NameServersUpdateState{}
31076 } else {
31077 sv = *v
31078 }
31079
31080 for key, value := range shape {
31081 switch key {
31082 case "code":
31083 if value != nil {
31084 jtv, ok := value.(string)
31085 if !ok {
31086 return fmt.Errorf("expected NameServersUpdateStateCode to be of type string, got %T instead", value)
31087 }
31088 sv.Code = types.NameServersUpdateStateCode(jtv)
31089 }
31090
31091 case "message":
31092 if value != nil {
31093 jtv, ok := value.(string)
31094 if !ok {
31095 return fmt.Errorf("expected string to be of type string, got %T instead", value)
31096 }
31097 sv.Message = ptr.String(jtv)
31098 }
31099
31100 default:
31101 _, _ = key, value
31102
31103 }
31104 }
31105 *v = sv
31106 return nil
31107 }
31108
31109 func awsAwsjson11_deserializeDocumentNotFoundException(v **types.NotFoundException, value interface{}) error {
31110 if v == nil {
31111 return fmt.Errorf("unexpected nil of type %T", v)
31112 }
31113 if value == nil {
31114 return nil
31115 }
31116
31117 shape, ok := value.(map[string]interface{})
31118 if !ok {
31119 return fmt.Errorf("unexpected JSON type %v", value)
31120 }
31121
31122 var sv *types.NotFoundException
31123 if *v == nil {
31124 sv = &types.NotFoundException{}
31125 } else {
31126 sv = *v
31127 }
31128
31129 for key, value := range shape {
31130 switch key {
31131 case "code":
31132 if value != nil {
31133 jtv, ok := value.(string)
31134 if !ok {
31135 return fmt.Errorf("expected string to be of type string, got %T instead", value)
31136 }
31137 sv.Code = ptr.String(jtv)
31138 }
31139
31140 case "docs":
31141 if value != nil {
31142 jtv, ok := value.(string)
31143 if !ok {
31144 return fmt.Errorf("expected string to be of type string, got %T instead", value)
31145 }
31146 sv.Docs = ptr.String(jtv)
31147 }
31148
31149 case "message", "Message":
31150 if value != nil {
31151 jtv, ok := value.(string)
31152 if !ok {
31153 return fmt.Errorf("expected string to be of type string, got %T instead", value)
31154 }
31155 sv.Message = ptr.String(jtv)
31156 }
31157
31158 case "tip":
31159 if value != nil {
31160 jtv, ok := value.(string)
31161 if !ok {
31162 return fmt.Errorf("expected string to be of type string, got %T instead", value)
31163 }
31164 sv.Tip = ptr.String(jtv)
31165 }
31166
31167 default:
31168 _, _ = key, value
31169
31170 }
31171 }
31172 *v = sv
31173 return nil
31174 }
31175
31176 func awsAwsjson11_deserializeDocumentNotificationTriggerList(v *[]types.AlarmState, value interface{}) error {
31177 if v == nil {
31178 return fmt.Errorf("unexpected nil of type %T", v)
31179 }
31180 if value == nil {
31181 return nil
31182 }
31183
31184 shape, ok := value.([]interface{})
31185 if !ok {
31186 return fmt.Errorf("unexpected JSON type %v", value)
31187 }
31188
31189 var cv []types.AlarmState
31190 if *v == nil {
31191 cv = []types.AlarmState{}
31192 } else {
31193 cv = *v
31194 }
31195
31196 for _, value := range shape {
31197 var col types.AlarmState
31198 if value != nil {
31199 jtv, ok := value.(string)
31200 if !ok {
31201 return fmt.Errorf("expected AlarmState to be of type string, got %T instead", value)
31202 }
31203 col = types.AlarmState(jtv)
31204 }
31205 cv = append(cv, col)
31206
31207 }
31208 *v = cv
31209 return nil
31210 }
31211
31212 func awsAwsjson11_deserializeDocumentOperation(v **types.Operation, value interface{}) error {
31213 if v == nil {
31214 return fmt.Errorf("unexpected nil of type %T", v)
31215 }
31216 if value == nil {
31217 return nil
31218 }
31219
31220 shape, ok := value.(map[string]interface{})
31221 if !ok {
31222 return fmt.Errorf("unexpected JSON type %v", value)
31223 }
31224
31225 var sv *types.Operation
31226 if *v == nil {
31227 sv = &types.Operation{}
31228 } else {
31229 sv = *v
31230 }
31231
31232 for key, value := range shape {
31233 switch key {
31234 case "createdAt":
31235 if value != nil {
31236 switch jtv := value.(type) {
31237 case json.Number:
31238 f64, err := jtv.Float64()
31239 if err != nil {
31240 return err
31241 }
31242 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
31243
31244 default:
31245 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
31246
31247 }
31248 }
31249
31250 case "errorCode":
31251 if value != nil {
31252 jtv, ok := value.(string)
31253 if !ok {
31254 return fmt.Errorf("expected string to be of type string, got %T instead", value)
31255 }
31256 sv.ErrorCode = ptr.String(jtv)
31257 }
31258
31259 case "errorDetails":
31260 if value != nil {
31261 jtv, ok := value.(string)
31262 if !ok {
31263 return fmt.Errorf("expected string to be of type string, got %T instead", value)
31264 }
31265 sv.ErrorDetails = ptr.String(jtv)
31266 }
31267
31268 case "id":
31269 if value != nil {
31270 jtv, ok := value.(string)
31271 if !ok {
31272 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
31273 }
31274 sv.Id = ptr.String(jtv)
31275 }
31276
31277 case "isTerminal":
31278 if value != nil {
31279 jtv, ok := value.(bool)
31280 if !ok {
31281 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
31282 }
31283 sv.IsTerminal = ptr.Bool(jtv)
31284 }
31285
31286 case "location":
31287 if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
31288 return err
31289 }
31290
31291 case "operationDetails":
31292 if value != nil {
31293 jtv, ok := value.(string)
31294 if !ok {
31295 return fmt.Errorf("expected string to be of type string, got %T instead", value)
31296 }
31297 sv.OperationDetails = ptr.String(jtv)
31298 }
31299
31300 case "operationType":
31301 if value != nil {
31302 jtv, ok := value.(string)
31303 if !ok {
31304 return fmt.Errorf("expected OperationType to be of type string, got %T instead", value)
31305 }
31306 sv.OperationType = types.OperationType(jtv)
31307 }
31308
31309 case "resourceName":
31310 if value != nil {
31311 jtv, ok := value.(string)
31312 if !ok {
31313 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
31314 }
31315 sv.ResourceName = ptr.String(jtv)
31316 }
31317
31318 case "resourceType":
31319 if value != nil {
31320 jtv, ok := value.(string)
31321 if !ok {
31322 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
31323 }
31324 sv.ResourceType = types.ResourceType(jtv)
31325 }
31326
31327 case "status":
31328 if value != nil {
31329 jtv, ok := value.(string)
31330 if !ok {
31331 return fmt.Errorf("expected OperationStatus to be of type string, got %T instead", value)
31332 }
31333 sv.Status = types.OperationStatus(jtv)
31334 }
31335
31336 case "statusChangedAt":
31337 if value != nil {
31338 switch jtv := value.(type) {
31339 case json.Number:
31340 f64, err := jtv.Float64()
31341 if err != nil {
31342 return err
31343 }
31344 sv.StatusChangedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
31345
31346 default:
31347 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
31348
31349 }
31350 }
31351
31352 default:
31353 _, _ = key, value
31354
31355 }
31356 }
31357 *v = sv
31358 return nil
31359 }
31360
31361 func awsAwsjson11_deserializeDocumentOperationFailureException(v **types.OperationFailureException, value interface{}) error {
31362 if v == nil {
31363 return fmt.Errorf("unexpected nil of type %T", v)
31364 }
31365 if value == nil {
31366 return nil
31367 }
31368
31369 shape, ok := value.(map[string]interface{})
31370 if !ok {
31371 return fmt.Errorf("unexpected JSON type %v", value)
31372 }
31373
31374 var sv *types.OperationFailureException
31375 if *v == nil {
31376 sv = &types.OperationFailureException{}
31377 } else {
31378 sv = *v
31379 }
31380
31381 for key, value := range shape {
31382 switch key {
31383 case "code":
31384 if value != nil {
31385 jtv, ok := value.(string)
31386 if !ok {
31387 return fmt.Errorf("expected string to be of type string, got %T instead", value)
31388 }
31389 sv.Code = ptr.String(jtv)
31390 }
31391
31392 case "docs":
31393 if value != nil {
31394 jtv, ok := value.(string)
31395 if !ok {
31396 return fmt.Errorf("expected string to be of type string, got %T instead", value)
31397 }
31398 sv.Docs = ptr.String(jtv)
31399 }
31400
31401 case "message", "Message":
31402 if value != nil {
31403 jtv, ok := value.(string)
31404 if !ok {
31405 return fmt.Errorf("expected string to be of type string, got %T instead", value)
31406 }
31407 sv.Message = ptr.String(jtv)
31408 }
31409
31410 case "tip":
31411 if value != nil {
31412 jtv, ok := value.(string)
31413 if !ok {
31414 return fmt.Errorf("expected string to be of type string, got %T instead", value)
31415 }
31416 sv.Tip = ptr.String(jtv)
31417 }
31418
31419 default:
31420 _, _ = key, value
31421
31422 }
31423 }
31424 *v = sv
31425 return nil
31426 }
31427
31428 func awsAwsjson11_deserializeDocumentOperationList(v *[]types.Operation, value interface{}) error {
31429 if v == nil {
31430 return fmt.Errorf("unexpected nil of type %T", v)
31431 }
31432 if value == nil {
31433 return nil
31434 }
31435
31436 shape, ok := value.([]interface{})
31437 if !ok {
31438 return fmt.Errorf("unexpected JSON type %v", value)
31439 }
31440
31441 var cv []types.Operation
31442 if *v == nil {
31443 cv = []types.Operation{}
31444 } else {
31445 cv = *v
31446 }
31447
31448 for _, value := range shape {
31449 var col types.Operation
31450 destAddr := &col
31451 if err := awsAwsjson11_deserializeDocumentOperation(&destAddr, value); err != nil {
31452 return err
31453 }
31454 col = *destAddr
31455 cv = append(cv, col)
31456
31457 }
31458 *v = cv
31459 return nil
31460 }
31461
31462 func awsAwsjson11_deserializeDocumentOrigin(v **types.Origin, value interface{}) error {
31463 if v == nil {
31464 return fmt.Errorf("unexpected nil of type %T", v)
31465 }
31466 if value == nil {
31467 return nil
31468 }
31469
31470 shape, ok := value.(map[string]interface{})
31471 if !ok {
31472 return fmt.Errorf("unexpected JSON type %v", value)
31473 }
31474
31475 var sv *types.Origin
31476 if *v == nil {
31477 sv = &types.Origin{}
31478 } else {
31479 sv = *v
31480 }
31481
31482 for key, value := range shape {
31483 switch key {
31484 case "name":
31485 if value != nil {
31486 jtv, ok := value.(string)
31487 if !ok {
31488 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
31489 }
31490 sv.Name = ptr.String(jtv)
31491 }
31492
31493 case "protocolPolicy":
31494 if value != nil {
31495 jtv, ok := value.(string)
31496 if !ok {
31497 return fmt.Errorf("expected OriginProtocolPolicyEnum to be of type string, got %T instead", value)
31498 }
31499 sv.ProtocolPolicy = types.OriginProtocolPolicyEnum(jtv)
31500 }
31501
31502 case "regionName":
31503 if value != nil {
31504 jtv, ok := value.(string)
31505 if !ok {
31506 return fmt.Errorf("expected RegionName to be of type string, got %T instead", value)
31507 }
31508 sv.RegionName = types.RegionName(jtv)
31509 }
31510
31511 case "resourceType":
31512 if value != nil {
31513 jtv, ok := value.(string)
31514 if !ok {
31515 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
31516 }
31517 sv.ResourceType = types.ResourceType(jtv)
31518 }
31519
31520 case "responseTimeout":
31521 if value != nil {
31522 jtv, ok := value.(json.Number)
31523 if !ok {
31524 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
31525 }
31526 i64, err := jtv.Int64()
31527 if err != nil {
31528 return err
31529 }
31530 sv.ResponseTimeout = ptr.Int32(int32(i64))
31531 }
31532
31533 default:
31534 _, _ = key, value
31535
31536 }
31537 }
31538 *v = sv
31539 return nil
31540 }
31541
31542 func awsAwsjson11_deserializeDocumentPartnerIdList(v *[]string, value interface{}) error {
31543 if v == nil {
31544 return fmt.Errorf("unexpected nil of type %T", v)
31545 }
31546 if value == nil {
31547 return nil
31548 }
31549
31550 shape, ok := value.([]interface{})
31551 if !ok {
31552 return fmt.Errorf("unexpected JSON type %v", value)
31553 }
31554
31555 var cv []string
31556 if *v == nil {
31557 cv = []string{}
31558 } else {
31559 cv = *v
31560 }
31561
31562 for _, value := range shape {
31563 var col string
31564 if value != nil {
31565 jtv, ok := value.(string)
31566 if !ok {
31567 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
31568 }
31569 col = jtv
31570 }
31571 cv = append(cv, col)
31572
31573 }
31574 *v = cv
31575 return nil
31576 }
31577
31578 func awsAwsjson11_deserializeDocumentPasswordData(v **types.PasswordData, value interface{}) error {
31579 if v == nil {
31580 return fmt.Errorf("unexpected nil of type %T", v)
31581 }
31582 if value == nil {
31583 return nil
31584 }
31585
31586 shape, ok := value.(map[string]interface{})
31587 if !ok {
31588 return fmt.Errorf("unexpected JSON type %v", value)
31589 }
31590
31591 var sv *types.PasswordData
31592 if *v == nil {
31593 sv = &types.PasswordData{}
31594 } else {
31595 sv = *v
31596 }
31597
31598 for key, value := range shape {
31599 switch key {
31600 case "ciphertext":
31601 if value != nil {
31602 jtv, ok := value.(string)
31603 if !ok {
31604 return fmt.Errorf("expected string to be of type string, got %T instead", value)
31605 }
31606 sv.Ciphertext = ptr.String(jtv)
31607 }
31608
31609 case "keyPairName":
31610 if value != nil {
31611 jtv, ok := value.(string)
31612 if !ok {
31613 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
31614 }
31615 sv.KeyPairName = ptr.String(jtv)
31616 }
31617
31618 default:
31619 _, _ = key, value
31620
31621 }
31622 }
31623 *v = sv
31624 return nil
31625 }
31626
31627 func awsAwsjson11_deserializeDocumentPendingMaintenanceAction(v **types.PendingMaintenanceAction, value interface{}) error {
31628 if v == nil {
31629 return fmt.Errorf("unexpected nil of type %T", v)
31630 }
31631 if value == nil {
31632 return nil
31633 }
31634
31635 shape, ok := value.(map[string]interface{})
31636 if !ok {
31637 return fmt.Errorf("unexpected JSON type %v", value)
31638 }
31639
31640 var sv *types.PendingMaintenanceAction
31641 if *v == nil {
31642 sv = &types.PendingMaintenanceAction{}
31643 } else {
31644 sv = *v
31645 }
31646
31647 for key, value := range shape {
31648 switch key {
31649 case "action":
31650 if value != nil {
31651 jtv, ok := value.(string)
31652 if !ok {
31653 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
31654 }
31655 sv.Action = ptr.String(jtv)
31656 }
31657
31658 case "currentApplyDate":
31659 if value != nil {
31660 switch jtv := value.(type) {
31661 case json.Number:
31662 f64, err := jtv.Float64()
31663 if err != nil {
31664 return err
31665 }
31666 sv.CurrentApplyDate = ptr.Time(smithytime.ParseEpochSeconds(f64))
31667
31668 default:
31669 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
31670
31671 }
31672 }
31673
31674 case "description":
31675 if value != nil {
31676 jtv, ok := value.(string)
31677 if !ok {
31678 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
31679 }
31680 sv.Description = ptr.String(jtv)
31681 }
31682
31683 default:
31684 _, _ = key, value
31685
31686 }
31687 }
31688 *v = sv
31689 return nil
31690 }
31691
31692 func awsAwsjson11_deserializeDocumentPendingMaintenanceActionList(v *[]types.PendingMaintenanceAction, value interface{}) error {
31693 if v == nil {
31694 return fmt.Errorf("unexpected nil of type %T", v)
31695 }
31696 if value == nil {
31697 return nil
31698 }
31699
31700 shape, ok := value.([]interface{})
31701 if !ok {
31702 return fmt.Errorf("unexpected JSON type %v", value)
31703 }
31704
31705 var cv []types.PendingMaintenanceAction
31706 if *v == nil {
31707 cv = []types.PendingMaintenanceAction{}
31708 } else {
31709 cv = *v
31710 }
31711
31712 for _, value := range shape {
31713 var col types.PendingMaintenanceAction
31714 destAddr := &col
31715 if err := awsAwsjson11_deserializeDocumentPendingMaintenanceAction(&destAddr, value); err != nil {
31716 return err
31717 }
31718 col = *destAddr
31719 cv = append(cv, col)
31720
31721 }
31722 *v = cv
31723 return nil
31724 }
31725
31726 func awsAwsjson11_deserializeDocumentPendingModifiedRelationalDatabaseValues(v **types.PendingModifiedRelationalDatabaseValues, value interface{}) error {
31727 if v == nil {
31728 return fmt.Errorf("unexpected nil of type %T", v)
31729 }
31730 if value == nil {
31731 return nil
31732 }
31733
31734 shape, ok := value.(map[string]interface{})
31735 if !ok {
31736 return fmt.Errorf("unexpected JSON type %v", value)
31737 }
31738
31739 var sv *types.PendingModifiedRelationalDatabaseValues
31740 if *v == nil {
31741 sv = &types.PendingModifiedRelationalDatabaseValues{}
31742 } else {
31743 sv = *v
31744 }
31745
31746 for key, value := range shape {
31747 switch key {
31748 case "backupRetentionEnabled":
31749 if value != nil {
31750 jtv, ok := value.(bool)
31751 if !ok {
31752 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
31753 }
31754 sv.BackupRetentionEnabled = ptr.Bool(jtv)
31755 }
31756
31757 case "engineVersion":
31758 if value != nil {
31759 jtv, ok := value.(string)
31760 if !ok {
31761 return fmt.Errorf("expected string to be of type string, got %T instead", value)
31762 }
31763 sv.EngineVersion = ptr.String(jtv)
31764 }
31765
31766 case "masterUserPassword":
31767 if value != nil {
31768 jtv, ok := value.(string)
31769 if !ok {
31770 return fmt.Errorf("expected string to be of type string, got %T instead", value)
31771 }
31772 sv.MasterUserPassword = ptr.String(jtv)
31773 }
31774
31775 default:
31776 _, _ = key, value
31777
31778 }
31779 }
31780 *v = sv
31781 return nil
31782 }
31783
31784 func awsAwsjson11_deserializeDocumentPortList(v *[]int32, value interface{}) error {
31785 if v == nil {
31786 return fmt.Errorf("unexpected nil of type %T", v)
31787 }
31788 if value == nil {
31789 return nil
31790 }
31791
31792 shape, ok := value.([]interface{})
31793 if !ok {
31794 return fmt.Errorf("unexpected JSON type %v", value)
31795 }
31796
31797 var cv []int32
31798 if *v == nil {
31799 cv = []int32{}
31800 } else {
31801 cv = *v
31802 }
31803
31804 for _, value := range shape {
31805 var col int32
31806 if value != nil {
31807 jtv, ok := value.(json.Number)
31808 if !ok {
31809 return fmt.Errorf("expected Port to be json.Number, got %T instead", value)
31810 }
31811 i64, err := jtv.Int64()
31812 if err != nil {
31813 return err
31814 }
31815 col = int32(i64)
31816 }
31817 cv = append(cv, col)
31818
31819 }
31820 *v = cv
31821 return nil
31822 }
31823
31824 func awsAwsjson11_deserializeDocumentPortMap(v *map[string]types.ContainerServiceProtocol, value interface{}) error {
31825 if v == nil {
31826 return fmt.Errorf("unexpected nil of type %T", v)
31827 }
31828 if value == nil {
31829 return nil
31830 }
31831
31832 shape, ok := value.(map[string]interface{})
31833 if !ok {
31834 return fmt.Errorf("unexpected JSON type %v", value)
31835 }
31836
31837 var mv map[string]types.ContainerServiceProtocol
31838 if *v == nil {
31839 mv = map[string]types.ContainerServiceProtocol{}
31840 } else {
31841 mv = *v
31842 }
31843
31844 for key, value := range shape {
31845 var parsedVal types.ContainerServiceProtocol
31846 if value != nil {
31847 jtv, ok := value.(string)
31848 if !ok {
31849 return fmt.Errorf("expected ContainerServiceProtocol to be of type string, got %T instead", value)
31850 }
31851 parsedVal = types.ContainerServiceProtocol(jtv)
31852 }
31853 mv[key] = parsedVal
31854
31855 }
31856 *v = mv
31857 return nil
31858 }
31859
31860 func awsAwsjson11_deserializeDocumentPrivateRegistryAccess(v **types.PrivateRegistryAccess, value interface{}) error {
31861 if v == nil {
31862 return fmt.Errorf("unexpected nil of type %T", v)
31863 }
31864 if value == nil {
31865 return nil
31866 }
31867
31868 shape, ok := value.(map[string]interface{})
31869 if !ok {
31870 return fmt.Errorf("unexpected JSON type %v", value)
31871 }
31872
31873 var sv *types.PrivateRegistryAccess
31874 if *v == nil {
31875 sv = &types.PrivateRegistryAccess{}
31876 } else {
31877 sv = *v
31878 }
31879
31880 for key, value := range shape {
31881 switch key {
31882 case "ecrImagePullerRole":
31883 if err := awsAwsjson11_deserializeDocumentContainerServiceECRImagePullerRole(&sv.EcrImagePullerRole, value); err != nil {
31884 return err
31885 }
31886
31887 default:
31888 _, _ = key, value
31889
31890 }
31891 }
31892 *v = sv
31893 return nil
31894 }
31895
31896 func awsAwsjson11_deserializeDocumentQueryStringObject(v **types.QueryStringObject, value interface{}) error {
31897 if v == nil {
31898 return fmt.Errorf("unexpected nil of type %T", v)
31899 }
31900 if value == nil {
31901 return nil
31902 }
31903
31904 shape, ok := value.(map[string]interface{})
31905 if !ok {
31906 return fmt.Errorf("unexpected JSON type %v", value)
31907 }
31908
31909 var sv *types.QueryStringObject
31910 if *v == nil {
31911 sv = &types.QueryStringObject{}
31912 } else {
31913 sv = *v
31914 }
31915
31916 for key, value := range shape {
31917 switch key {
31918 case "option":
31919 if value != nil {
31920 jtv, ok := value.(bool)
31921 if !ok {
31922 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
31923 }
31924 sv.Option = ptr.Bool(jtv)
31925 }
31926
31927 case "queryStringsAllowList":
31928 if err := awsAwsjson11_deserializeDocumentStringList(&sv.QueryStringsAllowList, value); err != nil {
31929 return err
31930 }
31931
31932 default:
31933 _, _ = key, value
31934
31935 }
31936 }
31937 *v = sv
31938 return nil
31939 }
31940
31941 func awsAwsjson11_deserializeDocumentR53HostedZoneDeletionState(v **types.R53HostedZoneDeletionState, value interface{}) error {
31942 if v == nil {
31943 return fmt.Errorf("unexpected nil of type %T", v)
31944 }
31945 if value == nil {
31946 return nil
31947 }
31948
31949 shape, ok := value.(map[string]interface{})
31950 if !ok {
31951 return fmt.Errorf("unexpected JSON type %v", value)
31952 }
31953
31954 var sv *types.R53HostedZoneDeletionState
31955 if *v == nil {
31956 sv = &types.R53HostedZoneDeletionState{}
31957 } else {
31958 sv = *v
31959 }
31960
31961 for key, value := range shape {
31962 switch key {
31963 case "code":
31964 if value != nil {
31965 jtv, ok := value.(string)
31966 if !ok {
31967 return fmt.Errorf("expected R53HostedZoneDeletionStateCode to be of type string, got %T instead", value)
31968 }
31969 sv.Code = types.R53HostedZoneDeletionStateCode(jtv)
31970 }
31971
31972 case "message":
31973 if value != nil {
31974 jtv, ok := value.(string)
31975 if !ok {
31976 return fmt.Errorf("expected string to be of type string, got %T instead", value)
31977 }
31978 sv.Message = ptr.String(jtv)
31979 }
31980
31981 default:
31982 _, _ = key, value
31983
31984 }
31985 }
31986 *v = sv
31987 return nil
31988 }
31989
31990 func awsAwsjson11_deserializeDocumentRegion(v **types.Region, value interface{}) error {
31991 if v == nil {
31992 return fmt.Errorf("unexpected nil of type %T", v)
31993 }
31994 if value == nil {
31995 return nil
31996 }
31997
31998 shape, ok := value.(map[string]interface{})
31999 if !ok {
32000 return fmt.Errorf("unexpected JSON type %v", value)
32001 }
32002
32003 var sv *types.Region
32004 if *v == nil {
32005 sv = &types.Region{}
32006 } else {
32007 sv = *v
32008 }
32009
32010 for key, value := range shape {
32011 switch key {
32012 case "availabilityZones":
32013 if err := awsAwsjson11_deserializeDocumentAvailabilityZoneList(&sv.AvailabilityZones, value); err != nil {
32014 return err
32015 }
32016
32017 case "continentCode":
32018 if value != nil {
32019 jtv, ok := value.(string)
32020 if !ok {
32021 return fmt.Errorf("expected string to be of type string, got %T instead", value)
32022 }
32023 sv.ContinentCode = ptr.String(jtv)
32024 }
32025
32026 case "description":
32027 if value != nil {
32028 jtv, ok := value.(string)
32029 if !ok {
32030 return fmt.Errorf("expected string to be of type string, got %T instead", value)
32031 }
32032 sv.Description = ptr.String(jtv)
32033 }
32034
32035 case "displayName":
32036 if value != nil {
32037 jtv, ok := value.(string)
32038 if !ok {
32039 return fmt.Errorf("expected string to be of type string, got %T instead", value)
32040 }
32041 sv.DisplayName = ptr.String(jtv)
32042 }
32043
32044 case "name":
32045 if value != nil {
32046 jtv, ok := value.(string)
32047 if !ok {
32048 return fmt.Errorf("expected RegionName to be of type string, got %T instead", value)
32049 }
32050 sv.Name = types.RegionName(jtv)
32051 }
32052
32053 case "relationalDatabaseAvailabilityZones":
32054 if err := awsAwsjson11_deserializeDocumentAvailabilityZoneList(&sv.RelationalDatabaseAvailabilityZones, value); err != nil {
32055 return err
32056 }
32057
32058 default:
32059 _, _ = key, value
32060
32061 }
32062 }
32063 *v = sv
32064 return nil
32065 }
32066
32067 func awsAwsjson11_deserializeDocumentRegionList(v *[]types.Region, value interface{}) error {
32068 if v == nil {
32069 return fmt.Errorf("unexpected nil of type %T", v)
32070 }
32071 if value == nil {
32072 return nil
32073 }
32074
32075 shape, ok := value.([]interface{})
32076 if !ok {
32077 return fmt.Errorf("unexpected JSON type %v", value)
32078 }
32079
32080 var cv []types.Region
32081 if *v == nil {
32082 cv = []types.Region{}
32083 } else {
32084 cv = *v
32085 }
32086
32087 for _, value := range shape {
32088 var col types.Region
32089 destAddr := &col
32090 if err := awsAwsjson11_deserializeDocumentRegion(&destAddr, value); err != nil {
32091 return err
32092 }
32093 col = *destAddr
32094 cv = append(cv, col)
32095
32096 }
32097 *v = cv
32098 return nil
32099 }
32100
32101 func awsAwsjson11_deserializeDocumentRegionSetupInProgressException(v **types.RegionSetupInProgressException, value interface{}) error {
32102 if v == nil {
32103 return fmt.Errorf("unexpected nil of type %T", v)
32104 }
32105 if value == nil {
32106 return nil
32107 }
32108
32109 shape, ok := value.(map[string]interface{})
32110 if !ok {
32111 return fmt.Errorf("unexpected JSON type %v", value)
32112 }
32113
32114 var sv *types.RegionSetupInProgressException
32115 if *v == nil {
32116 sv = &types.RegionSetupInProgressException{}
32117 } else {
32118 sv = *v
32119 }
32120
32121 for key, value := range shape {
32122 switch key {
32123 case "code":
32124 if value != nil {
32125 jtv, ok := value.(string)
32126 if !ok {
32127 return fmt.Errorf("expected string to be of type string, got %T instead", value)
32128 }
32129 sv.Code = ptr.String(jtv)
32130 }
32131
32132 case "docs":
32133 if value != nil {
32134 jtv, ok := value.(string)
32135 if !ok {
32136 return fmt.Errorf("expected string to be of type string, got %T instead", value)
32137 }
32138 sv.Docs = ptr.String(jtv)
32139 }
32140
32141 case "message", "Message":
32142 if value != nil {
32143 jtv, ok := value.(string)
32144 if !ok {
32145 return fmt.Errorf("expected string to be of type string, got %T instead", value)
32146 }
32147 sv.Message = ptr.String(jtv)
32148 }
32149
32150 case "tip":
32151 if value != nil {
32152 jtv, ok := value.(string)
32153 if !ok {
32154 return fmt.Errorf("expected string to be of type string, got %T instead", value)
32155 }
32156 sv.Tip = ptr.String(jtv)
32157 }
32158
32159 default:
32160 _, _ = key, value
32161
32162 }
32163 }
32164 *v = sv
32165 return nil
32166 }
32167
32168 func awsAwsjson11_deserializeDocumentRegisteredDomainDelegationInfo(v **types.RegisteredDomainDelegationInfo, value interface{}) error {
32169 if v == nil {
32170 return fmt.Errorf("unexpected nil of type %T", v)
32171 }
32172 if value == nil {
32173 return nil
32174 }
32175
32176 shape, ok := value.(map[string]interface{})
32177 if !ok {
32178 return fmt.Errorf("unexpected JSON type %v", value)
32179 }
32180
32181 var sv *types.RegisteredDomainDelegationInfo
32182 if *v == nil {
32183 sv = &types.RegisteredDomainDelegationInfo{}
32184 } else {
32185 sv = *v
32186 }
32187
32188 for key, value := range shape {
32189 switch key {
32190 case "nameServersUpdateState":
32191 if err := awsAwsjson11_deserializeDocumentNameServersUpdateState(&sv.NameServersUpdateState, value); err != nil {
32192 return err
32193 }
32194
32195 case "r53HostedZoneDeletionState":
32196 if err := awsAwsjson11_deserializeDocumentR53HostedZoneDeletionState(&sv.R53HostedZoneDeletionState, value); err != nil {
32197 return err
32198 }
32199
32200 default:
32201 _, _ = key, value
32202
32203 }
32204 }
32205 *v = sv
32206 return nil
32207 }
32208
32209 func awsAwsjson11_deserializeDocumentRelationalDatabase(v **types.RelationalDatabase, value interface{}) error {
32210 if v == nil {
32211 return fmt.Errorf("unexpected nil of type %T", v)
32212 }
32213 if value == nil {
32214 return nil
32215 }
32216
32217 shape, ok := value.(map[string]interface{})
32218 if !ok {
32219 return fmt.Errorf("unexpected JSON type %v", value)
32220 }
32221
32222 var sv *types.RelationalDatabase
32223 if *v == nil {
32224 sv = &types.RelationalDatabase{}
32225 } else {
32226 sv = *v
32227 }
32228
32229 for key, value := range shape {
32230 switch key {
32231 case "arn":
32232 if value != nil {
32233 jtv, ok := value.(string)
32234 if !ok {
32235 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
32236 }
32237 sv.Arn = ptr.String(jtv)
32238 }
32239
32240 case "backupRetentionEnabled":
32241 if value != nil {
32242 jtv, ok := value.(bool)
32243 if !ok {
32244 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
32245 }
32246 sv.BackupRetentionEnabled = ptr.Bool(jtv)
32247 }
32248
32249 case "caCertificateIdentifier":
32250 if value != nil {
32251 jtv, ok := value.(string)
32252 if !ok {
32253 return fmt.Errorf("expected string to be of type string, got %T instead", value)
32254 }
32255 sv.CaCertificateIdentifier = ptr.String(jtv)
32256 }
32257
32258 case "createdAt":
32259 if value != nil {
32260 switch jtv := value.(type) {
32261 case json.Number:
32262 f64, err := jtv.Float64()
32263 if err != nil {
32264 return err
32265 }
32266 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
32267
32268 default:
32269 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
32270
32271 }
32272 }
32273
32274 case "engine":
32275 if value != nil {
32276 jtv, ok := value.(string)
32277 if !ok {
32278 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
32279 }
32280 sv.Engine = ptr.String(jtv)
32281 }
32282
32283 case "engineVersion":
32284 if value != nil {
32285 jtv, ok := value.(string)
32286 if !ok {
32287 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
32288 }
32289 sv.EngineVersion = ptr.String(jtv)
32290 }
32291
32292 case "hardware":
32293 if err := awsAwsjson11_deserializeDocumentRelationalDatabaseHardware(&sv.Hardware, value); err != nil {
32294 return err
32295 }
32296
32297 case "latestRestorableTime":
32298 if value != nil {
32299 switch jtv := value.(type) {
32300 case json.Number:
32301 f64, err := jtv.Float64()
32302 if err != nil {
32303 return err
32304 }
32305 sv.LatestRestorableTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
32306
32307 default:
32308 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
32309
32310 }
32311 }
32312
32313 case "location":
32314 if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
32315 return err
32316 }
32317
32318 case "masterDatabaseName":
32319 if value != nil {
32320 jtv, ok := value.(string)
32321 if !ok {
32322 return fmt.Errorf("expected string to be of type string, got %T instead", value)
32323 }
32324 sv.MasterDatabaseName = ptr.String(jtv)
32325 }
32326
32327 case "masterEndpoint":
32328 if err := awsAwsjson11_deserializeDocumentRelationalDatabaseEndpoint(&sv.MasterEndpoint, value); err != nil {
32329 return err
32330 }
32331
32332 case "masterUsername":
32333 if value != nil {
32334 jtv, ok := value.(string)
32335 if !ok {
32336 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
32337 }
32338 sv.MasterUsername = ptr.String(jtv)
32339 }
32340
32341 case "name":
32342 if value != nil {
32343 jtv, ok := value.(string)
32344 if !ok {
32345 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
32346 }
32347 sv.Name = ptr.String(jtv)
32348 }
32349
32350 case "parameterApplyStatus":
32351 if value != nil {
32352 jtv, ok := value.(string)
32353 if !ok {
32354 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
32355 }
32356 sv.ParameterApplyStatus = ptr.String(jtv)
32357 }
32358
32359 case "pendingMaintenanceActions":
32360 if err := awsAwsjson11_deserializeDocumentPendingMaintenanceActionList(&sv.PendingMaintenanceActions, value); err != nil {
32361 return err
32362 }
32363
32364 case "pendingModifiedValues":
32365 if err := awsAwsjson11_deserializeDocumentPendingModifiedRelationalDatabaseValues(&sv.PendingModifiedValues, value); err != nil {
32366 return err
32367 }
32368
32369 case "preferredBackupWindow":
32370 if value != nil {
32371 jtv, ok := value.(string)
32372 if !ok {
32373 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
32374 }
32375 sv.PreferredBackupWindow = ptr.String(jtv)
32376 }
32377
32378 case "preferredMaintenanceWindow":
32379 if value != nil {
32380 jtv, ok := value.(string)
32381 if !ok {
32382 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
32383 }
32384 sv.PreferredMaintenanceWindow = ptr.String(jtv)
32385 }
32386
32387 case "publiclyAccessible":
32388 if value != nil {
32389 jtv, ok := value.(bool)
32390 if !ok {
32391 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
32392 }
32393 sv.PubliclyAccessible = ptr.Bool(jtv)
32394 }
32395
32396 case "relationalDatabaseBlueprintId":
32397 if value != nil {
32398 jtv, ok := value.(string)
32399 if !ok {
32400 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
32401 }
32402 sv.RelationalDatabaseBlueprintId = ptr.String(jtv)
32403 }
32404
32405 case "relationalDatabaseBundleId":
32406 if value != nil {
32407 jtv, ok := value.(string)
32408 if !ok {
32409 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
32410 }
32411 sv.RelationalDatabaseBundleId = ptr.String(jtv)
32412 }
32413
32414 case "resourceType":
32415 if value != nil {
32416 jtv, ok := value.(string)
32417 if !ok {
32418 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
32419 }
32420 sv.ResourceType = types.ResourceType(jtv)
32421 }
32422
32423 case "secondaryAvailabilityZone":
32424 if value != nil {
32425 jtv, ok := value.(string)
32426 if !ok {
32427 return fmt.Errorf("expected string to be of type string, got %T instead", value)
32428 }
32429 sv.SecondaryAvailabilityZone = ptr.String(jtv)
32430 }
32431
32432 case "state":
32433 if value != nil {
32434 jtv, ok := value.(string)
32435 if !ok {
32436 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
32437 }
32438 sv.State = ptr.String(jtv)
32439 }
32440
32441 case "supportCode":
32442 if value != nil {
32443 jtv, ok := value.(string)
32444 if !ok {
32445 return fmt.Errorf("expected string to be of type string, got %T instead", value)
32446 }
32447 sv.SupportCode = ptr.String(jtv)
32448 }
32449
32450 case "tags":
32451 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
32452 return err
32453 }
32454
32455 default:
32456 _, _ = key, value
32457
32458 }
32459 }
32460 *v = sv
32461 return nil
32462 }
32463
32464 func awsAwsjson11_deserializeDocumentRelationalDatabaseBlueprint(v **types.RelationalDatabaseBlueprint, value interface{}) error {
32465 if v == nil {
32466 return fmt.Errorf("unexpected nil of type %T", v)
32467 }
32468 if value == nil {
32469 return nil
32470 }
32471
32472 shape, ok := value.(map[string]interface{})
32473 if !ok {
32474 return fmt.Errorf("unexpected JSON type %v", value)
32475 }
32476
32477 var sv *types.RelationalDatabaseBlueprint
32478 if *v == nil {
32479 sv = &types.RelationalDatabaseBlueprint{}
32480 } else {
32481 sv = *v
32482 }
32483
32484 for key, value := range shape {
32485 switch key {
32486 case "blueprintId":
32487 if value != nil {
32488 jtv, ok := value.(string)
32489 if !ok {
32490 return fmt.Errorf("expected string to be of type string, got %T instead", value)
32491 }
32492 sv.BlueprintId = ptr.String(jtv)
32493 }
32494
32495 case "engine":
32496 if value != nil {
32497 jtv, ok := value.(string)
32498 if !ok {
32499 return fmt.Errorf("expected RelationalDatabaseEngine to be of type string, got %T instead", value)
32500 }
32501 sv.Engine = types.RelationalDatabaseEngine(jtv)
32502 }
32503
32504 case "engineDescription":
32505 if value != nil {
32506 jtv, ok := value.(string)
32507 if !ok {
32508 return fmt.Errorf("expected string to be of type string, got %T instead", value)
32509 }
32510 sv.EngineDescription = ptr.String(jtv)
32511 }
32512
32513 case "engineVersion":
32514 if value != nil {
32515 jtv, ok := value.(string)
32516 if !ok {
32517 return fmt.Errorf("expected string to be of type string, got %T instead", value)
32518 }
32519 sv.EngineVersion = ptr.String(jtv)
32520 }
32521
32522 case "engineVersionDescription":
32523 if value != nil {
32524 jtv, ok := value.(string)
32525 if !ok {
32526 return fmt.Errorf("expected string to be of type string, got %T instead", value)
32527 }
32528 sv.EngineVersionDescription = ptr.String(jtv)
32529 }
32530
32531 case "isEngineDefault":
32532 if value != nil {
32533 jtv, ok := value.(bool)
32534 if !ok {
32535 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
32536 }
32537 sv.IsEngineDefault = ptr.Bool(jtv)
32538 }
32539
32540 default:
32541 _, _ = key, value
32542
32543 }
32544 }
32545 *v = sv
32546 return nil
32547 }
32548
32549 func awsAwsjson11_deserializeDocumentRelationalDatabaseBlueprintList(v *[]types.RelationalDatabaseBlueprint, value interface{}) error {
32550 if v == nil {
32551 return fmt.Errorf("unexpected nil of type %T", v)
32552 }
32553 if value == nil {
32554 return nil
32555 }
32556
32557 shape, ok := value.([]interface{})
32558 if !ok {
32559 return fmt.Errorf("unexpected JSON type %v", value)
32560 }
32561
32562 var cv []types.RelationalDatabaseBlueprint
32563 if *v == nil {
32564 cv = []types.RelationalDatabaseBlueprint{}
32565 } else {
32566 cv = *v
32567 }
32568
32569 for _, value := range shape {
32570 var col types.RelationalDatabaseBlueprint
32571 destAddr := &col
32572 if err := awsAwsjson11_deserializeDocumentRelationalDatabaseBlueprint(&destAddr, value); err != nil {
32573 return err
32574 }
32575 col = *destAddr
32576 cv = append(cv, col)
32577
32578 }
32579 *v = cv
32580 return nil
32581 }
32582
32583 func awsAwsjson11_deserializeDocumentRelationalDatabaseBundle(v **types.RelationalDatabaseBundle, value interface{}) error {
32584 if v == nil {
32585 return fmt.Errorf("unexpected nil of type %T", v)
32586 }
32587 if value == nil {
32588 return nil
32589 }
32590
32591 shape, ok := value.(map[string]interface{})
32592 if !ok {
32593 return fmt.Errorf("unexpected JSON type %v", value)
32594 }
32595
32596 var sv *types.RelationalDatabaseBundle
32597 if *v == nil {
32598 sv = &types.RelationalDatabaseBundle{}
32599 } else {
32600 sv = *v
32601 }
32602
32603 for key, value := range shape {
32604 switch key {
32605 case "bundleId":
32606 if value != nil {
32607 jtv, ok := value.(string)
32608 if !ok {
32609 return fmt.Errorf("expected string to be of type string, got %T instead", value)
32610 }
32611 sv.BundleId = ptr.String(jtv)
32612 }
32613
32614 case "cpuCount":
32615 if value != nil {
32616 jtv, ok := value.(json.Number)
32617 if !ok {
32618 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
32619 }
32620 i64, err := jtv.Int64()
32621 if err != nil {
32622 return err
32623 }
32624 sv.CpuCount = ptr.Int32(int32(i64))
32625 }
32626
32627 case "diskSizeInGb":
32628 if value != nil {
32629 jtv, ok := value.(json.Number)
32630 if !ok {
32631 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
32632 }
32633 i64, err := jtv.Int64()
32634 if err != nil {
32635 return err
32636 }
32637 sv.DiskSizeInGb = ptr.Int32(int32(i64))
32638 }
32639
32640 case "isActive":
32641 if value != nil {
32642 jtv, ok := value.(bool)
32643 if !ok {
32644 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
32645 }
32646 sv.IsActive = ptr.Bool(jtv)
32647 }
32648
32649 case "isEncrypted":
32650 if value != nil {
32651 jtv, ok := value.(bool)
32652 if !ok {
32653 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
32654 }
32655 sv.IsEncrypted = ptr.Bool(jtv)
32656 }
32657
32658 case "name":
32659 if value != nil {
32660 jtv, ok := value.(string)
32661 if !ok {
32662 return fmt.Errorf("expected string to be of type string, got %T instead", value)
32663 }
32664 sv.Name = ptr.String(jtv)
32665 }
32666
32667 case "price":
32668 if value != nil {
32669 switch jtv := value.(type) {
32670 case json.Number:
32671 f64, err := jtv.Float64()
32672 if err != nil {
32673 return err
32674 }
32675 sv.Price = ptr.Float32(float32(f64))
32676
32677 case string:
32678 var f64 float64
32679 switch {
32680 case strings.EqualFold(jtv, "NaN"):
32681 f64 = math.NaN()
32682
32683 case strings.EqualFold(jtv, "Infinity"):
32684 f64 = math.Inf(1)
32685
32686 case strings.EqualFold(jtv, "-Infinity"):
32687 f64 = math.Inf(-1)
32688
32689 default:
32690 return fmt.Errorf("unknown JSON number value: %s", jtv)
32691
32692 }
32693 sv.Price = ptr.Float32(float32(f64))
32694
32695 default:
32696 return fmt.Errorf("expected float to be a JSON Number, got %T instead", value)
32697
32698 }
32699 }
32700
32701 case "ramSizeInGb":
32702 if value != nil {
32703 switch jtv := value.(type) {
32704 case json.Number:
32705 f64, err := jtv.Float64()
32706 if err != nil {
32707 return err
32708 }
32709 sv.RamSizeInGb = ptr.Float32(float32(f64))
32710
32711 case string:
32712 var f64 float64
32713 switch {
32714 case strings.EqualFold(jtv, "NaN"):
32715 f64 = math.NaN()
32716
32717 case strings.EqualFold(jtv, "Infinity"):
32718 f64 = math.Inf(1)
32719
32720 case strings.EqualFold(jtv, "-Infinity"):
32721 f64 = math.Inf(-1)
32722
32723 default:
32724 return fmt.Errorf("unknown JSON number value: %s", jtv)
32725
32726 }
32727 sv.RamSizeInGb = ptr.Float32(float32(f64))
32728
32729 default:
32730 return fmt.Errorf("expected float to be a JSON Number, got %T instead", value)
32731
32732 }
32733 }
32734
32735 case "transferPerMonthInGb":
32736 if value != nil {
32737 jtv, ok := value.(json.Number)
32738 if !ok {
32739 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
32740 }
32741 i64, err := jtv.Int64()
32742 if err != nil {
32743 return err
32744 }
32745 sv.TransferPerMonthInGb = ptr.Int32(int32(i64))
32746 }
32747
32748 default:
32749 _, _ = key, value
32750
32751 }
32752 }
32753 *v = sv
32754 return nil
32755 }
32756
32757 func awsAwsjson11_deserializeDocumentRelationalDatabaseBundleList(v *[]types.RelationalDatabaseBundle, value interface{}) error {
32758 if v == nil {
32759 return fmt.Errorf("unexpected nil of type %T", v)
32760 }
32761 if value == nil {
32762 return nil
32763 }
32764
32765 shape, ok := value.([]interface{})
32766 if !ok {
32767 return fmt.Errorf("unexpected JSON type %v", value)
32768 }
32769
32770 var cv []types.RelationalDatabaseBundle
32771 if *v == nil {
32772 cv = []types.RelationalDatabaseBundle{}
32773 } else {
32774 cv = *v
32775 }
32776
32777 for _, value := range shape {
32778 var col types.RelationalDatabaseBundle
32779 destAddr := &col
32780 if err := awsAwsjson11_deserializeDocumentRelationalDatabaseBundle(&destAddr, value); err != nil {
32781 return err
32782 }
32783 col = *destAddr
32784 cv = append(cv, col)
32785
32786 }
32787 *v = cv
32788 return nil
32789 }
32790
32791 func awsAwsjson11_deserializeDocumentRelationalDatabaseEndpoint(v **types.RelationalDatabaseEndpoint, value interface{}) error {
32792 if v == nil {
32793 return fmt.Errorf("unexpected nil of type %T", v)
32794 }
32795 if value == nil {
32796 return nil
32797 }
32798
32799 shape, ok := value.(map[string]interface{})
32800 if !ok {
32801 return fmt.Errorf("unexpected JSON type %v", value)
32802 }
32803
32804 var sv *types.RelationalDatabaseEndpoint
32805 if *v == nil {
32806 sv = &types.RelationalDatabaseEndpoint{}
32807 } else {
32808 sv = *v
32809 }
32810
32811 for key, value := range shape {
32812 switch key {
32813 case "address":
32814 if value != nil {
32815 jtv, ok := value.(string)
32816 if !ok {
32817 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
32818 }
32819 sv.Address = ptr.String(jtv)
32820 }
32821
32822 case "port":
32823 if value != nil {
32824 jtv, ok := value.(json.Number)
32825 if !ok {
32826 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
32827 }
32828 i64, err := jtv.Int64()
32829 if err != nil {
32830 return err
32831 }
32832 sv.Port = ptr.Int32(int32(i64))
32833 }
32834
32835 default:
32836 _, _ = key, value
32837
32838 }
32839 }
32840 *v = sv
32841 return nil
32842 }
32843
32844 func awsAwsjson11_deserializeDocumentRelationalDatabaseEvent(v **types.RelationalDatabaseEvent, value interface{}) error {
32845 if v == nil {
32846 return fmt.Errorf("unexpected nil of type %T", v)
32847 }
32848 if value == nil {
32849 return nil
32850 }
32851
32852 shape, ok := value.(map[string]interface{})
32853 if !ok {
32854 return fmt.Errorf("unexpected JSON type %v", value)
32855 }
32856
32857 var sv *types.RelationalDatabaseEvent
32858 if *v == nil {
32859 sv = &types.RelationalDatabaseEvent{}
32860 } else {
32861 sv = *v
32862 }
32863
32864 for key, value := range shape {
32865 switch key {
32866 case "createdAt":
32867 if value != nil {
32868 switch jtv := value.(type) {
32869 case json.Number:
32870 f64, err := jtv.Float64()
32871 if err != nil {
32872 return err
32873 }
32874 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
32875
32876 default:
32877 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
32878
32879 }
32880 }
32881
32882 case "eventCategories":
32883 if err := awsAwsjson11_deserializeDocumentStringList(&sv.EventCategories, value); err != nil {
32884 return err
32885 }
32886
32887 case "message":
32888 if value != nil {
32889 jtv, ok := value.(string)
32890 if !ok {
32891 return fmt.Errorf("expected string to be of type string, got %T instead", value)
32892 }
32893 sv.Message = ptr.String(jtv)
32894 }
32895
32896 case "resource":
32897 if value != nil {
32898 jtv, ok := value.(string)
32899 if !ok {
32900 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
32901 }
32902 sv.Resource = ptr.String(jtv)
32903 }
32904
32905 default:
32906 _, _ = key, value
32907
32908 }
32909 }
32910 *v = sv
32911 return nil
32912 }
32913
32914 func awsAwsjson11_deserializeDocumentRelationalDatabaseEventList(v *[]types.RelationalDatabaseEvent, value interface{}) error {
32915 if v == nil {
32916 return fmt.Errorf("unexpected nil of type %T", v)
32917 }
32918 if value == nil {
32919 return nil
32920 }
32921
32922 shape, ok := value.([]interface{})
32923 if !ok {
32924 return fmt.Errorf("unexpected JSON type %v", value)
32925 }
32926
32927 var cv []types.RelationalDatabaseEvent
32928 if *v == nil {
32929 cv = []types.RelationalDatabaseEvent{}
32930 } else {
32931 cv = *v
32932 }
32933
32934 for _, value := range shape {
32935 var col types.RelationalDatabaseEvent
32936 destAddr := &col
32937 if err := awsAwsjson11_deserializeDocumentRelationalDatabaseEvent(&destAddr, value); err != nil {
32938 return err
32939 }
32940 col = *destAddr
32941 cv = append(cv, col)
32942
32943 }
32944 *v = cv
32945 return nil
32946 }
32947
32948 func awsAwsjson11_deserializeDocumentRelationalDatabaseHardware(v **types.RelationalDatabaseHardware, value interface{}) error {
32949 if v == nil {
32950 return fmt.Errorf("unexpected nil of type %T", v)
32951 }
32952 if value == nil {
32953 return nil
32954 }
32955
32956 shape, ok := value.(map[string]interface{})
32957 if !ok {
32958 return fmt.Errorf("unexpected JSON type %v", value)
32959 }
32960
32961 var sv *types.RelationalDatabaseHardware
32962 if *v == nil {
32963 sv = &types.RelationalDatabaseHardware{}
32964 } else {
32965 sv = *v
32966 }
32967
32968 for key, value := range shape {
32969 switch key {
32970 case "cpuCount":
32971 if value != nil {
32972 jtv, ok := value.(json.Number)
32973 if !ok {
32974 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
32975 }
32976 i64, err := jtv.Int64()
32977 if err != nil {
32978 return err
32979 }
32980 sv.CpuCount = ptr.Int32(int32(i64))
32981 }
32982
32983 case "diskSizeInGb":
32984 if value != nil {
32985 jtv, ok := value.(json.Number)
32986 if !ok {
32987 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
32988 }
32989 i64, err := jtv.Int64()
32990 if err != nil {
32991 return err
32992 }
32993 sv.DiskSizeInGb = ptr.Int32(int32(i64))
32994 }
32995
32996 case "ramSizeInGb":
32997 if value != nil {
32998 switch jtv := value.(type) {
32999 case json.Number:
33000 f64, err := jtv.Float64()
33001 if err != nil {
33002 return err
33003 }
33004 sv.RamSizeInGb = ptr.Float32(float32(f64))
33005
33006 case string:
33007 var f64 float64
33008 switch {
33009 case strings.EqualFold(jtv, "NaN"):
33010 f64 = math.NaN()
33011
33012 case strings.EqualFold(jtv, "Infinity"):
33013 f64 = math.Inf(1)
33014
33015 case strings.EqualFold(jtv, "-Infinity"):
33016 f64 = math.Inf(-1)
33017
33018 default:
33019 return fmt.Errorf("unknown JSON number value: %s", jtv)
33020
33021 }
33022 sv.RamSizeInGb = ptr.Float32(float32(f64))
33023
33024 default:
33025 return fmt.Errorf("expected float to be a JSON Number, got %T instead", value)
33026
33027 }
33028 }
33029
33030 default:
33031 _, _ = key, value
33032
33033 }
33034 }
33035 *v = sv
33036 return nil
33037 }
33038
33039 func awsAwsjson11_deserializeDocumentRelationalDatabaseList(v *[]types.RelationalDatabase, value interface{}) error {
33040 if v == nil {
33041 return fmt.Errorf("unexpected nil of type %T", v)
33042 }
33043 if value == nil {
33044 return nil
33045 }
33046
33047 shape, ok := value.([]interface{})
33048 if !ok {
33049 return fmt.Errorf("unexpected JSON type %v", value)
33050 }
33051
33052 var cv []types.RelationalDatabase
33053 if *v == nil {
33054 cv = []types.RelationalDatabase{}
33055 } else {
33056 cv = *v
33057 }
33058
33059 for _, value := range shape {
33060 var col types.RelationalDatabase
33061 destAddr := &col
33062 if err := awsAwsjson11_deserializeDocumentRelationalDatabase(&destAddr, value); err != nil {
33063 return err
33064 }
33065 col = *destAddr
33066 cv = append(cv, col)
33067
33068 }
33069 *v = cv
33070 return nil
33071 }
33072
33073 func awsAwsjson11_deserializeDocumentRelationalDatabaseParameter(v **types.RelationalDatabaseParameter, value interface{}) error {
33074 if v == nil {
33075 return fmt.Errorf("unexpected nil of type %T", v)
33076 }
33077 if value == nil {
33078 return nil
33079 }
33080
33081 shape, ok := value.(map[string]interface{})
33082 if !ok {
33083 return fmt.Errorf("unexpected JSON type %v", value)
33084 }
33085
33086 var sv *types.RelationalDatabaseParameter
33087 if *v == nil {
33088 sv = &types.RelationalDatabaseParameter{}
33089 } else {
33090 sv = *v
33091 }
33092
33093 for key, value := range shape {
33094 switch key {
33095 case "allowedValues":
33096 if value != nil {
33097 jtv, ok := value.(string)
33098 if !ok {
33099 return fmt.Errorf("expected string to be of type string, got %T instead", value)
33100 }
33101 sv.AllowedValues = ptr.String(jtv)
33102 }
33103
33104 case "applyMethod":
33105 if value != nil {
33106 jtv, ok := value.(string)
33107 if !ok {
33108 return fmt.Errorf("expected string to be of type string, got %T instead", value)
33109 }
33110 sv.ApplyMethod = ptr.String(jtv)
33111 }
33112
33113 case "applyType":
33114 if value != nil {
33115 jtv, ok := value.(string)
33116 if !ok {
33117 return fmt.Errorf("expected string to be of type string, got %T instead", value)
33118 }
33119 sv.ApplyType = ptr.String(jtv)
33120 }
33121
33122 case "dataType":
33123 if value != nil {
33124 jtv, ok := value.(string)
33125 if !ok {
33126 return fmt.Errorf("expected string to be of type string, got %T instead", value)
33127 }
33128 sv.DataType = ptr.String(jtv)
33129 }
33130
33131 case "description":
33132 if value != nil {
33133 jtv, ok := value.(string)
33134 if !ok {
33135 return fmt.Errorf("expected string to be of type string, got %T instead", value)
33136 }
33137 sv.Description = ptr.String(jtv)
33138 }
33139
33140 case "isModifiable":
33141 if value != nil {
33142 jtv, ok := value.(bool)
33143 if !ok {
33144 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
33145 }
33146 sv.IsModifiable = ptr.Bool(jtv)
33147 }
33148
33149 case "parameterName":
33150 if value != nil {
33151 jtv, ok := value.(string)
33152 if !ok {
33153 return fmt.Errorf("expected string to be of type string, got %T instead", value)
33154 }
33155 sv.ParameterName = ptr.String(jtv)
33156 }
33157
33158 case "parameterValue":
33159 if value != nil {
33160 jtv, ok := value.(string)
33161 if !ok {
33162 return fmt.Errorf("expected string to be of type string, got %T instead", value)
33163 }
33164 sv.ParameterValue = ptr.String(jtv)
33165 }
33166
33167 default:
33168 _, _ = key, value
33169
33170 }
33171 }
33172 *v = sv
33173 return nil
33174 }
33175
33176 func awsAwsjson11_deserializeDocumentRelationalDatabaseParameterList(v *[]types.RelationalDatabaseParameter, value interface{}) error {
33177 if v == nil {
33178 return fmt.Errorf("unexpected nil of type %T", v)
33179 }
33180 if value == nil {
33181 return nil
33182 }
33183
33184 shape, ok := value.([]interface{})
33185 if !ok {
33186 return fmt.Errorf("unexpected JSON type %v", value)
33187 }
33188
33189 var cv []types.RelationalDatabaseParameter
33190 if *v == nil {
33191 cv = []types.RelationalDatabaseParameter{}
33192 } else {
33193 cv = *v
33194 }
33195
33196 for _, value := range shape {
33197 var col types.RelationalDatabaseParameter
33198 destAddr := &col
33199 if err := awsAwsjson11_deserializeDocumentRelationalDatabaseParameter(&destAddr, value); err != nil {
33200 return err
33201 }
33202 col = *destAddr
33203 cv = append(cv, col)
33204
33205 }
33206 *v = cv
33207 return nil
33208 }
33209
33210 func awsAwsjson11_deserializeDocumentRelationalDatabaseSnapshot(v **types.RelationalDatabaseSnapshot, value interface{}) error {
33211 if v == nil {
33212 return fmt.Errorf("unexpected nil of type %T", v)
33213 }
33214 if value == nil {
33215 return nil
33216 }
33217
33218 shape, ok := value.(map[string]interface{})
33219 if !ok {
33220 return fmt.Errorf("unexpected JSON type %v", value)
33221 }
33222
33223 var sv *types.RelationalDatabaseSnapshot
33224 if *v == nil {
33225 sv = &types.RelationalDatabaseSnapshot{}
33226 } else {
33227 sv = *v
33228 }
33229
33230 for key, value := range shape {
33231 switch key {
33232 case "arn":
33233 if value != nil {
33234 jtv, ok := value.(string)
33235 if !ok {
33236 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
33237 }
33238 sv.Arn = ptr.String(jtv)
33239 }
33240
33241 case "createdAt":
33242 if value != nil {
33243 switch jtv := value.(type) {
33244 case json.Number:
33245 f64, err := jtv.Float64()
33246 if err != nil {
33247 return err
33248 }
33249 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
33250
33251 default:
33252 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
33253
33254 }
33255 }
33256
33257 case "engine":
33258 if value != nil {
33259 jtv, ok := value.(string)
33260 if !ok {
33261 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
33262 }
33263 sv.Engine = ptr.String(jtv)
33264 }
33265
33266 case "engineVersion":
33267 if value != nil {
33268 jtv, ok := value.(string)
33269 if !ok {
33270 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
33271 }
33272 sv.EngineVersion = ptr.String(jtv)
33273 }
33274
33275 case "fromRelationalDatabaseArn":
33276 if value != nil {
33277 jtv, ok := value.(string)
33278 if !ok {
33279 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
33280 }
33281 sv.FromRelationalDatabaseArn = ptr.String(jtv)
33282 }
33283
33284 case "fromRelationalDatabaseBlueprintId":
33285 if value != nil {
33286 jtv, ok := value.(string)
33287 if !ok {
33288 return fmt.Errorf("expected string to be of type string, got %T instead", value)
33289 }
33290 sv.FromRelationalDatabaseBlueprintId = ptr.String(jtv)
33291 }
33292
33293 case "fromRelationalDatabaseBundleId":
33294 if value != nil {
33295 jtv, ok := value.(string)
33296 if !ok {
33297 return fmt.Errorf("expected string to be of type string, got %T instead", value)
33298 }
33299 sv.FromRelationalDatabaseBundleId = ptr.String(jtv)
33300 }
33301
33302 case "fromRelationalDatabaseName":
33303 if value != nil {
33304 jtv, ok := value.(string)
33305 if !ok {
33306 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
33307 }
33308 sv.FromRelationalDatabaseName = ptr.String(jtv)
33309 }
33310
33311 case "location":
33312 if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
33313 return err
33314 }
33315
33316 case "name":
33317 if value != nil {
33318 jtv, ok := value.(string)
33319 if !ok {
33320 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
33321 }
33322 sv.Name = ptr.String(jtv)
33323 }
33324
33325 case "resourceType":
33326 if value != nil {
33327 jtv, ok := value.(string)
33328 if !ok {
33329 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
33330 }
33331 sv.ResourceType = types.ResourceType(jtv)
33332 }
33333
33334 case "sizeInGb":
33335 if value != nil {
33336 jtv, ok := value.(json.Number)
33337 if !ok {
33338 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
33339 }
33340 i64, err := jtv.Int64()
33341 if err != nil {
33342 return err
33343 }
33344 sv.SizeInGb = ptr.Int32(int32(i64))
33345 }
33346
33347 case "state":
33348 if value != nil {
33349 jtv, ok := value.(string)
33350 if !ok {
33351 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
33352 }
33353 sv.State = ptr.String(jtv)
33354 }
33355
33356 case "supportCode":
33357 if value != nil {
33358 jtv, ok := value.(string)
33359 if !ok {
33360 return fmt.Errorf("expected string to be of type string, got %T instead", value)
33361 }
33362 sv.SupportCode = ptr.String(jtv)
33363 }
33364
33365 case "tags":
33366 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
33367 return err
33368 }
33369
33370 default:
33371 _, _ = key, value
33372
33373 }
33374 }
33375 *v = sv
33376 return nil
33377 }
33378
33379 func awsAwsjson11_deserializeDocumentRelationalDatabaseSnapshotList(v *[]types.RelationalDatabaseSnapshot, value interface{}) error {
33380 if v == nil {
33381 return fmt.Errorf("unexpected nil of type %T", v)
33382 }
33383 if value == nil {
33384 return nil
33385 }
33386
33387 shape, ok := value.([]interface{})
33388 if !ok {
33389 return fmt.Errorf("unexpected JSON type %v", value)
33390 }
33391
33392 var cv []types.RelationalDatabaseSnapshot
33393 if *v == nil {
33394 cv = []types.RelationalDatabaseSnapshot{}
33395 } else {
33396 cv = *v
33397 }
33398
33399 for _, value := range shape {
33400 var col types.RelationalDatabaseSnapshot
33401 destAddr := &col
33402 if err := awsAwsjson11_deserializeDocumentRelationalDatabaseSnapshot(&destAddr, value); err != nil {
33403 return err
33404 }
33405 col = *destAddr
33406 cv = append(cv, col)
33407
33408 }
33409 *v = cv
33410 return nil
33411 }
33412
33413 func awsAwsjson11_deserializeDocumentRenewalSummary(v **types.RenewalSummary, value interface{}) error {
33414 if v == nil {
33415 return fmt.Errorf("unexpected nil of type %T", v)
33416 }
33417 if value == nil {
33418 return nil
33419 }
33420
33421 shape, ok := value.(map[string]interface{})
33422 if !ok {
33423 return fmt.Errorf("unexpected JSON type %v", value)
33424 }
33425
33426 var sv *types.RenewalSummary
33427 if *v == nil {
33428 sv = &types.RenewalSummary{}
33429 } else {
33430 sv = *v
33431 }
33432
33433 for key, value := range shape {
33434 switch key {
33435 case "domainValidationRecords":
33436 if err := awsAwsjson11_deserializeDocumentDomainValidationRecordList(&sv.DomainValidationRecords, value); err != nil {
33437 return err
33438 }
33439
33440 case "renewalStatus":
33441 if value != nil {
33442 jtv, ok := value.(string)
33443 if !ok {
33444 return fmt.Errorf("expected RenewalStatus to be of type string, got %T instead", value)
33445 }
33446 sv.RenewalStatus = types.RenewalStatus(jtv)
33447 }
33448
33449 case "renewalStatusReason":
33450 if value != nil {
33451 jtv, ok := value.(string)
33452 if !ok {
33453 return fmt.Errorf("expected RenewalStatusReason to be of type string, got %T instead", value)
33454 }
33455 sv.RenewalStatusReason = ptr.String(jtv)
33456 }
33457
33458 case "updatedAt":
33459 if value != nil {
33460 switch jtv := value.(type) {
33461 case json.Number:
33462 f64, err := jtv.Float64()
33463 if err != nil {
33464 return err
33465 }
33466 sv.UpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
33467
33468 default:
33469 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
33470
33471 }
33472 }
33473
33474 default:
33475 _, _ = key, value
33476
33477 }
33478 }
33479 *v = sv
33480 return nil
33481 }
33482
33483 func awsAwsjson11_deserializeDocumentResourceBudgetEstimate(v **types.ResourceBudgetEstimate, value interface{}) error {
33484 if v == nil {
33485 return fmt.Errorf("unexpected nil of type %T", v)
33486 }
33487 if value == nil {
33488 return nil
33489 }
33490
33491 shape, ok := value.(map[string]interface{})
33492 if !ok {
33493 return fmt.Errorf("unexpected JSON type %v", value)
33494 }
33495
33496 var sv *types.ResourceBudgetEstimate
33497 if *v == nil {
33498 sv = &types.ResourceBudgetEstimate{}
33499 } else {
33500 sv = *v
33501 }
33502
33503 for key, value := range shape {
33504 switch key {
33505 case "costEstimates":
33506 if err := awsAwsjson11_deserializeDocumentCostEstimates(&sv.CostEstimates, value); err != nil {
33507 return err
33508 }
33509
33510 case "endTime":
33511 if value != nil {
33512 switch jtv := value.(type) {
33513 case json.Number:
33514 f64, err := jtv.Float64()
33515 if err != nil {
33516 return err
33517 }
33518 sv.EndTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
33519
33520 default:
33521 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
33522
33523 }
33524 }
33525
33526 case "resourceName":
33527 if value != nil {
33528 jtv, ok := value.(string)
33529 if !ok {
33530 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
33531 }
33532 sv.ResourceName = ptr.String(jtv)
33533 }
33534
33535 case "resourceType":
33536 if value != nil {
33537 jtv, ok := value.(string)
33538 if !ok {
33539 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
33540 }
33541 sv.ResourceType = types.ResourceType(jtv)
33542 }
33543
33544 case "startTime":
33545 if value != nil {
33546 switch jtv := value.(type) {
33547 case json.Number:
33548 f64, err := jtv.Float64()
33549 if err != nil {
33550 return err
33551 }
33552 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
33553
33554 default:
33555 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
33556
33557 }
33558 }
33559
33560 default:
33561 _, _ = key, value
33562
33563 }
33564 }
33565 *v = sv
33566 return nil
33567 }
33568
33569 func awsAwsjson11_deserializeDocumentResourceLocation(v **types.ResourceLocation, value interface{}) error {
33570 if v == nil {
33571 return fmt.Errorf("unexpected nil of type %T", v)
33572 }
33573 if value == nil {
33574 return nil
33575 }
33576
33577 shape, ok := value.(map[string]interface{})
33578 if !ok {
33579 return fmt.Errorf("unexpected JSON type %v", value)
33580 }
33581
33582 var sv *types.ResourceLocation
33583 if *v == nil {
33584 sv = &types.ResourceLocation{}
33585 } else {
33586 sv = *v
33587 }
33588
33589 for key, value := range shape {
33590 switch key {
33591 case "availabilityZone":
33592 if value != nil {
33593 jtv, ok := value.(string)
33594 if !ok {
33595 return fmt.Errorf("expected string to be of type string, got %T instead", value)
33596 }
33597 sv.AvailabilityZone = ptr.String(jtv)
33598 }
33599
33600 case "regionName":
33601 if value != nil {
33602 jtv, ok := value.(string)
33603 if !ok {
33604 return fmt.Errorf("expected RegionName to be of type string, got %T instead", value)
33605 }
33606 sv.RegionName = types.RegionName(jtv)
33607 }
33608
33609 default:
33610 _, _ = key, value
33611
33612 }
33613 }
33614 *v = sv
33615 return nil
33616 }
33617
33618 func awsAwsjson11_deserializeDocumentResourceReceivingAccess(v **types.ResourceReceivingAccess, value interface{}) error {
33619 if v == nil {
33620 return fmt.Errorf("unexpected nil of type %T", v)
33621 }
33622 if value == nil {
33623 return nil
33624 }
33625
33626 shape, ok := value.(map[string]interface{})
33627 if !ok {
33628 return fmt.Errorf("unexpected JSON type %v", value)
33629 }
33630
33631 var sv *types.ResourceReceivingAccess
33632 if *v == nil {
33633 sv = &types.ResourceReceivingAccess{}
33634 } else {
33635 sv = *v
33636 }
33637
33638 for key, value := range shape {
33639 switch key {
33640 case "name":
33641 if value != nil {
33642 jtv, ok := value.(string)
33643 if !ok {
33644 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
33645 }
33646 sv.Name = ptr.String(jtv)
33647 }
33648
33649 case "resourceType":
33650 if value != nil {
33651 jtv, ok := value.(string)
33652 if !ok {
33653 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
33654 }
33655 sv.ResourceType = ptr.String(jtv)
33656 }
33657
33658 default:
33659 _, _ = key, value
33660
33661 }
33662 }
33663 *v = sv
33664 return nil
33665 }
33666
33667 func awsAwsjson11_deserializeDocumentResourceRecord(v **types.ResourceRecord, value interface{}) error {
33668 if v == nil {
33669 return fmt.Errorf("unexpected nil of type %T", v)
33670 }
33671 if value == nil {
33672 return nil
33673 }
33674
33675 shape, ok := value.(map[string]interface{})
33676 if !ok {
33677 return fmt.Errorf("unexpected JSON type %v", value)
33678 }
33679
33680 var sv *types.ResourceRecord
33681 if *v == nil {
33682 sv = &types.ResourceRecord{}
33683 } else {
33684 sv = *v
33685 }
33686
33687 for key, value := range shape {
33688 switch key {
33689 case "name":
33690 if value != nil {
33691 jtv, ok := value.(string)
33692 if !ok {
33693 return fmt.Errorf("expected string to be of type string, got %T instead", value)
33694 }
33695 sv.Name = ptr.String(jtv)
33696 }
33697
33698 case "type":
33699 if value != nil {
33700 jtv, ok := value.(string)
33701 if !ok {
33702 return fmt.Errorf("expected string to be of type string, got %T instead", value)
33703 }
33704 sv.Type = ptr.String(jtv)
33705 }
33706
33707 case "value":
33708 if value != nil {
33709 jtv, ok := value.(string)
33710 if !ok {
33711 return fmt.Errorf("expected string to be of type string, got %T instead", value)
33712 }
33713 sv.Value = ptr.String(jtv)
33714 }
33715
33716 default:
33717 _, _ = key, value
33718
33719 }
33720 }
33721 *v = sv
33722 return nil
33723 }
33724
33725 func awsAwsjson11_deserializeDocumentResourcesBudgetEstimate(v *[]types.ResourceBudgetEstimate, value interface{}) error {
33726 if v == nil {
33727 return fmt.Errorf("unexpected nil of type %T", v)
33728 }
33729 if value == nil {
33730 return nil
33731 }
33732
33733 shape, ok := value.([]interface{})
33734 if !ok {
33735 return fmt.Errorf("unexpected JSON type %v", value)
33736 }
33737
33738 var cv []types.ResourceBudgetEstimate
33739 if *v == nil {
33740 cv = []types.ResourceBudgetEstimate{}
33741 } else {
33742 cv = *v
33743 }
33744
33745 for _, value := range shape {
33746 var col types.ResourceBudgetEstimate
33747 destAddr := &col
33748 if err := awsAwsjson11_deserializeDocumentResourceBudgetEstimate(&destAddr, value); err != nil {
33749 return err
33750 }
33751 col = *destAddr
33752 cv = append(cv, col)
33753
33754 }
33755 *v = cv
33756 return nil
33757 }
33758
33759 func awsAwsjson11_deserializeDocumentServiceException(v **types.ServiceException, value interface{}) error {
33760 if v == nil {
33761 return fmt.Errorf("unexpected nil of type %T", v)
33762 }
33763 if value == nil {
33764 return nil
33765 }
33766
33767 shape, ok := value.(map[string]interface{})
33768 if !ok {
33769 return fmt.Errorf("unexpected JSON type %v", value)
33770 }
33771
33772 var sv *types.ServiceException
33773 if *v == nil {
33774 sv = &types.ServiceException{}
33775 } else {
33776 sv = *v
33777 }
33778
33779 for key, value := range shape {
33780 switch key {
33781 case "code":
33782 if value != nil {
33783 jtv, ok := value.(string)
33784 if !ok {
33785 return fmt.Errorf("expected string to be of type string, got %T instead", value)
33786 }
33787 sv.Code = ptr.String(jtv)
33788 }
33789
33790 case "docs":
33791 if value != nil {
33792 jtv, ok := value.(string)
33793 if !ok {
33794 return fmt.Errorf("expected string to be of type string, got %T instead", value)
33795 }
33796 sv.Docs = ptr.String(jtv)
33797 }
33798
33799 case "message", "Message":
33800 if value != nil {
33801 jtv, ok := value.(string)
33802 if !ok {
33803 return fmt.Errorf("expected string to be of type string, got %T instead", value)
33804 }
33805 sv.Message = ptr.String(jtv)
33806 }
33807
33808 case "tip":
33809 if value != nil {
33810 jtv, ok := value.(string)
33811 if !ok {
33812 return fmt.Errorf("expected string to be of type string, got %T instead", value)
33813 }
33814 sv.Tip = ptr.String(jtv)
33815 }
33816
33817 default:
33818 _, _ = key, value
33819
33820 }
33821 }
33822 *v = sv
33823 return nil
33824 }
33825
33826 func awsAwsjson11_deserializeDocumentSession(v **types.Session, value interface{}) error {
33827 if v == nil {
33828 return fmt.Errorf("unexpected nil of type %T", v)
33829 }
33830 if value == nil {
33831 return nil
33832 }
33833
33834 shape, ok := value.(map[string]interface{})
33835 if !ok {
33836 return fmt.Errorf("unexpected JSON type %v", value)
33837 }
33838
33839 var sv *types.Session
33840 if *v == nil {
33841 sv = &types.Session{}
33842 } else {
33843 sv = *v
33844 }
33845
33846 for key, value := range shape {
33847 switch key {
33848 case "isPrimary":
33849 if value != nil {
33850 jtv, ok := value.(bool)
33851 if !ok {
33852 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
33853 }
33854 sv.IsPrimary = ptr.Bool(jtv)
33855 }
33856
33857 case "name":
33858 if value != nil {
33859 jtv, ok := value.(string)
33860 if !ok {
33861 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
33862 }
33863 sv.Name = ptr.String(jtv)
33864 }
33865
33866 case "url":
33867 if value != nil {
33868 jtv, ok := value.(string)
33869 if !ok {
33870 return fmt.Errorf("expected SensitiveNonEmptyString to be of type string, got %T instead", value)
33871 }
33872 sv.Url = ptr.String(jtv)
33873 }
33874
33875 default:
33876 _, _ = key, value
33877
33878 }
33879 }
33880 *v = sv
33881 return nil
33882 }
33883
33884 func awsAwsjson11_deserializeDocumentSessions(v *[]types.Session, value interface{}) error {
33885 if v == nil {
33886 return fmt.Errorf("unexpected nil of type %T", v)
33887 }
33888 if value == nil {
33889 return nil
33890 }
33891
33892 shape, ok := value.([]interface{})
33893 if !ok {
33894 return fmt.Errorf("unexpected JSON type %v", value)
33895 }
33896
33897 var cv []types.Session
33898 if *v == nil {
33899 cv = []types.Session{}
33900 } else {
33901 cv = *v
33902 }
33903
33904 for _, value := range shape {
33905 var col types.Session
33906 destAddr := &col
33907 if err := awsAwsjson11_deserializeDocumentSession(&destAddr, value); err != nil {
33908 return err
33909 }
33910 col = *destAddr
33911 cv = append(cv, col)
33912
33913 }
33914 *v = cv
33915 return nil
33916 }
33917
33918 func awsAwsjson11_deserializeDocumentSetupDomainNameList(v *[]string, value interface{}) error {
33919 if v == nil {
33920 return fmt.Errorf("unexpected nil of type %T", v)
33921 }
33922 if value == nil {
33923 return nil
33924 }
33925
33926 shape, ok := value.([]interface{})
33927 if !ok {
33928 return fmt.Errorf("unexpected JSON type %v", value)
33929 }
33930
33931 var cv []string
33932 if *v == nil {
33933 cv = []string{}
33934 } else {
33935 cv = *v
33936 }
33937
33938 for _, value := range shape {
33939 var col string
33940 if value != nil {
33941 jtv, ok := value.(string)
33942 if !ok {
33943 return fmt.Errorf("expected SetupDomainName to be of type string, got %T instead", value)
33944 }
33945 col = jtv
33946 }
33947 cv = append(cv, col)
33948
33949 }
33950 *v = cv
33951 return nil
33952 }
33953
33954 func awsAwsjson11_deserializeDocumentSetupExecutionDetails(v **types.SetupExecutionDetails, value interface{}) error {
33955 if v == nil {
33956 return fmt.Errorf("unexpected nil of type %T", v)
33957 }
33958 if value == nil {
33959 return nil
33960 }
33961
33962 shape, ok := value.(map[string]interface{})
33963 if !ok {
33964 return fmt.Errorf("unexpected JSON type %v", value)
33965 }
33966
33967 var sv *types.SetupExecutionDetails
33968 if *v == nil {
33969 sv = &types.SetupExecutionDetails{}
33970 } else {
33971 sv = *v
33972 }
33973
33974 for key, value := range shape {
33975 switch key {
33976 case "command":
33977 if value != nil {
33978 jtv, ok := value.(string)
33979 if !ok {
33980 return fmt.Errorf("expected string to be of type string, got %T instead", value)
33981 }
33982 sv.Command = ptr.String(jtv)
33983 }
33984
33985 case "dateTime":
33986 if value != nil {
33987 switch jtv := value.(type) {
33988 case json.Number:
33989 f64, err := jtv.Float64()
33990 if err != nil {
33991 return err
33992 }
33993 sv.DateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
33994
33995 default:
33996 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
33997
33998 }
33999 }
34000
34001 case "name":
34002 if value != nil {
34003 jtv, ok := value.(string)
34004 if !ok {
34005 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
34006 }
34007 sv.Name = ptr.String(jtv)
34008 }
34009
34010 case "standardError":
34011 if value != nil {
34012 jtv, ok := value.(string)
34013 if !ok {
34014 return fmt.Errorf("expected string to be of type string, got %T instead", value)
34015 }
34016 sv.StandardError = ptr.String(jtv)
34017 }
34018
34019 case "standardOutput":
34020 if value != nil {
34021 jtv, ok := value.(string)
34022 if !ok {
34023 return fmt.Errorf("expected string to be of type string, got %T instead", value)
34024 }
34025 sv.StandardOutput = ptr.String(jtv)
34026 }
34027
34028 case "status":
34029 if value != nil {
34030 jtv, ok := value.(string)
34031 if !ok {
34032 return fmt.Errorf("expected SetupStatus to be of type string, got %T instead", value)
34033 }
34034 sv.Status = types.SetupStatus(jtv)
34035 }
34036
34037 case "version":
34038 if value != nil {
34039 jtv, ok := value.(string)
34040 if !ok {
34041 return fmt.Errorf("expected string to be of type string, got %T instead", value)
34042 }
34043 sv.Version = ptr.String(jtv)
34044 }
34045
34046 default:
34047 _, _ = key, value
34048
34049 }
34050 }
34051 *v = sv
34052 return nil
34053 }
34054
34055 func awsAwsjson11_deserializeDocumentSetupExecutionDetailsList(v *[]types.SetupExecutionDetails, value interface{}) error {
34056 if v == nil {
34057 return fmt.Errorf("unexpected nil of type %T", v)
34058 }
34059 if value == nil {
34060 return nil
34061 }
34062
34063 shape, ok := value.([]interface{})
34064 if !ok {
34065 return fmt.Errorf("unexpected JSON type %v", value)
34066 }
34067
34068 var cv []types.SetupExecutionDetails
34069 if *v == nil {
34070 cv = []types.SetupExecutionDetails{}
34071 } else {
34072 cv = *v
34073 }
34074
34075 for _, value := range shape {
34076 var col types.SetupExecutionDetails
34077 destAddr := &col
34078 if err := awsAwsjson11_deserializeDocumentSetupExecutionDetails(&destAddr, value); err != nil {
34079 return err
34080 }
34081 col = *destAddr
34082 cv = append(cv, col)
34083
34084 }
34085 *v = cv
34086 return nil
34087 }
34088
34089 func awsAwsjson11_deserializeDocumentSetupHistory(v **types.SetupHistory, value interface{}) error {
34090 if v == nil {
34091 return fmt.Errorf("unexpected nil of type %T", v)
34092 }
34093 if value == nil {
34094 return nil
34095 }
34096
34097 shape, ok := value.(map[string]interface{})
34098 if !ok {
34099 return fmt.Errorf("unexpected JSON type %v", value)
34100 }
34101
34102 var sv *types.SetupHistory
34103 if *v == nil {
34104 sv = &types.SetupHistory{}
34105 } else {
34106 sv = *v
34107 }
34108
34109 for key, value := range shape {
34110 switch key {
34111 case "executionDetails":
34112 if err := awsAwsjson11_deserializeDocumentSetupExecutionDetailsList(&sv.ExecutionDetails, value); err != nil {
34113 return err
34114 }
34115
34116 case "operationId":
34117 if value != nil {
34118 jtv, ok := value.(string)
34119 if !ok {
34120 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
34121 }
34122 sv.OperationId = ptr.String(jtv)
34123 }
34124
34125 case "request":
34126 if err := awsAwsjson11_deserializeDocumentSetupRequest(&sv.Request, value); err != nil {
34127 return err
34128 }
34129
34130 case "resource":
34131 if err := awsAwsjson11_deserializeDocumentSetupHistoryResource(&sv.Resource, value); err != nil {
34132 return err
34133 }
34134
34135 case "status":
34136 if value != nil {
34137 jtv, ok := value.(string)
34138 if !ok {
34139 return fmt.Errorf("expected SetupStatus to be of type string, got %T instead", value)
34140 }
34141 sv.Status = types.SetupStatus(jtv)
34142 }
34143
34144 default:
34145 _, _ = key, value
34146
34147 }
34148 }
34149 *v = sv
34150 return nil
34151 }
34152
34153 func awsAwsjson11_deserializeDocumentSetupHistoryList(v *[]types.SetupHistory, value interface{}) error {
34154 if v == nil {
34155 return fmt.Errorf("unexpected nil of type %T", v)
34156 }
34157 if value == nil {
34158 return nil
34159 }
34160
34161 shape, ok := value.([]interface{})
34162 if !ok {
34163 return fmt.Errorf("unexpected JSON type %v", value)
34164 }
34165
34166 var cv []types.SetupHistory
34167 if *v == nil {
34168 cv = []types.SetupHistory{}
34169 } else {
34170 cv = *v
34171 }
34172
34173 for _, value := range shape {
34174 var col types.SetupHistory
34175 destAddr := &col
34176 if err := awsAwsjson11_deserializeDocumentSetupHistory(&destAddr, value); err != nil {
34177 return err
34178 }
34179 col = *destAddr
34180 cv = append(cv, col)
34181
34182 }
34183 *v = cv
34184 return nil
34185 }
34186
34187 func awsAwsjson11_deserializeDocumentSetupHistoryResource(v **types.SetupHistoryResource, value interface{}) error {
34188 if v == nil {
34189 return fmt.Errorf("unexpected nil of type %T", v)
34190 }
34191 if value == nil {
34192 return nil
34193 }
34194
34195 shape, ok := value.(map[string]interface{})
34196 if !ok {
34197 return fmt.Errorf("unexpected JSON type %v", value)
34198 }
34199
34200 var sv *types.SetupHistoryResource
34201 if *v == nil {
34202 sv = &types.SetupHistoryResource{}
34203 } else {
34204 sv = *v
34205 }
34206
34207 for key, value := range shape {
34208 switch key {
34209 case "arn":
34210 if value != nil {
34211 jtv, ok := value.(string)
34212 if !ok {
34213 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
34214 }
34215 sv.Arn = ptr.String(jtv)
34216 }
34217
34218 case "createdAt":
34219 if value != nil {
34220 switch jtv := value.(type) {
34221 case json.Number:
34222 f64, err := jtv.Float64()
34223 if err != nil {
34224 return err
34225 }
34226 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
34227
34228 default:
34229 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
34230
34231 }
34232 }
34233
34234 case "location":
34235 if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
34236 return err
34237 }
34238
34239 case "name":
34240 if value != nil {
34241 jtv, ok := value.(string)
34242 if !ok {
34243 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
34244 }
34245 sv.Name = ptr.String(jtv)
34246 }
34247
34248 case "resourceType":
34249 if value != nil {
34250 jtv, ok := value.(string)
34251 if !ok {
34252 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
34253 }
34254 sv.ResourceType = types.ResourceType(jtv)
34255 }
34256
34257 default:
34258 _, _ = key, value
34259
34260 }
34261 }
34262 *v = sv
34263 return nil
34264 }
34265
34266 func awsAwsjson11_deserializeDocumentSetupRequest(v **types.SetupRequest, value interface{}) error {
34267 if v == nil {
34268 return fmt.Errorf("unexpected nil of type %T", v)
34269 }
34270 if value == nil {
34271 return nil
34272 }
34273
34274 shape, ok := value.(map[string]interface{})
34275 if !ok {
34276 return fmt.Errorf("unexpected JSON type %v", value)
34277 }
34278
34279 var sv *types.SetupRequest
34280 if *v == nil {
34281 sv = &types.SetupRequest{}
34282 } else {
34283 sv = *v
34284 }
34285
34286 for key, value := range shape {
34287 switch key {
34288 case "certificateProvider":
34289 if value != nil {
34290 jtv, ok := value.(string)
34291 if !ok {
34292 return fmt.Errorf("expected CertificateProvider to be of type string, got %T instead", value)
34293 }
34294 sv.CertificateProvider = types.CertificateProvider(jtv)
34295 }
34296
34297 case "domainNames":
34298 if err := awsAwsjson11_deserializeDocumentSetupDomainNameList(&sv.DomainNames, value); err != nil {
34299 return err
34300 }
34301
34302 case "instanceName":
34303 if value != nil {
34304 jtv, ok := value.(string)
34305 if !ok {
34306 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
34307 }
34308 sv.InstanceName = ptr.String(jtv)
34309 }
34310
34311 default:
34312 _, _ = key, value
34313
34314 }
34315 }
34316 *v = sv
34317 return nil
34318 }
34319
34320 func awsAwsjson11_deserializeDocumentStaticIp(v **types.StaticIp, value interface{}) error {
34321 if v == nil {
34322 return fmt.Errorf("unexpected nil of type %T", v)
34323 }
34324 if value == nil {
34325 return nil
34326 }
34327
34328 shape, ok := value.(map[string]interface{})
34329 if !ok {
34330 return fmt.Errorf("unexpected JSON type %v", value)
34331 }
34332
34333 var sv *types.StaticIp
34334 if *v == nil {
34335 sv = &types.StaticIp{}
34336 } else {
34337 sv = *v
34338 }
34339
34340 for key, value := range shape {
34341 switch key {
34342 case "arn":
34343 if value != nil {
34344 jtv, ok := value.(string)
34345 if !ok {
34346 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
34347 }
34348 sv.Arn = ptr.String(jtv)
34349 }
34350
34351 case "attachedTo":
34352 if value != nil {
34353 jtv, ok := value.(string)
34354 if !ok {
34355 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
34356 }
34357 sv.AttachedTo = ptr.String(jtv)
34358 }
34359
34360 case "createdAt":
34361 if value != nil {
34362 switch jtv := value.(type) {
34363 case json.Number:
34364 f64, err := jtv.Float64()
34365 if err != nil {
34366 return err
34367 }
34368 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
34369
34370 default:
34371 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
34372
34373 }
34374 }
34375
34376 case "ipAddress":
34377 if value != nil {
34378 jtv, ok := value.(string)
34379 if !ok {
34380 return fmt.Errorf("expected IpAddress to be of type string, got %T instead", value)
34381 }
34382 sv.IpAddress = ptr.String(jtv)
34383 }
34384
34385 case "isAttached":
34386 if value != nil {
34387 jtv, ok := value.(bool)
34388 if !ok {
34389 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
34390 }
34391 sv.IsAttached = ptr.Bool(jtv)
34392 }
34393
34394 case "location":
34395 if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
34396 return err
34397 }
34398
34399 case "name":
34400 if value != nil {
34401 jtv, ok := value.(string)
34402 if !ok {
34403 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
34404 }
34405 sv.Name = ptr.String(jtv)
34406 }
34407
34408 case "resourceType":
34409 if value != nil {
34410 jtv, ok := value.(string)
34411 if !ok {
34412 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
34413 }
34414 sv.ResourceType = types.ResourceType(jtv)
34415 }
34416
34417 case "supportCode":
34418 if value != nil {
34419 jtv, ok := value.(string)
34420 if !ok {
34421 return fmt.Errorf("expected string to be of type string, got %T instead", value)
34422 }
34423 sv.SupportCode = ptr.String(jtv)
34424 }
34425
34426 default:
34427 _, _ = key, value
34428
34429 }
34430 }
34431 *v = sv
34432 return nil
34433 }
34434
34435 func awsAwsjson11_deserializeDocumentStaticIpList(v *[]types.StaticIp, value interface{}) error {
34436 if v == nil {
34437 return fmt.Errorf("unexpected nil of type %T", v)
34438 }
34439 if value == nil {
34440 return nil
34441 }
34442
34443 shape, ok := value.([]interface{})
34444 if !ok {
34445 return fmt.Errorf("unexpected JSON type %v", value)
34446 }
34447
34448 var cv []types.StaticIp
34449 if *v == nil {
34450 cv = []types.StaticIp{}
34451 } else {
34452 cv = *v
34453 }
34454
34455 for _, value := range shape {
34456 var col types.StaticIp
34457 destAddr := &col
34458 if err := awsAwsjson11_deserializeDocumentStaticIp(&destAddr, value); err != nil {
34459 return err
34460 }
34461 col = *destAddr
34462 cv = append(cv, col)
34463
34464 }
34465 *v = cv
34466 return nil
34467 }
34468
34469 func awsAwsjson11_deserializeDocumentStringList(v *[]string, value interface{}) error {
34470 if v == nil {
34471 return fmt.Errorf("unexpected nil of type %T", v)
34472 }
34473 if value == nil {
34474 return nil
34475 }
34476
34477 shape, ok := value.([]interface{})
34478 if !ok {
34479 return fmt.Errorf("unexpected JSON type %v", value)
34480 }
34481
34482 var cv []string
34483 if *v == nil {
34484 cv = []string{}
34485 } else {
34486 cv = *v
34487 }
34488
34489 for _, value := range shape {
34490 var col string
34491 if value != nil {
34492 jtv, ok := value.(string)
34493 if !ok {
34494 return fmt.Errorf("expected string to be of type string, got %T instead", value)
34495 }
34496 col = jtv
34497 }
34498 cv = append(cv, col)
34499
34500 }
34501 *v = cv
34502 return nil
34503 }
34504
34505 func awsAwsjson11_deserializeDocumentSubjectAlternativeNameList(v *[]string, value interface{}) error {
34506 if v == nil {
34507 return fmt.Errorf("unexpected nil of type %T", v)
34508 }
34509 if value == nil {
34510 return nil
34511 }
34512
34513 shape, ok := value.([]interface{})
34514 if !ok {
34515 return fmt.Errorf("unexpected JSON type %v", value)
34516 }
34517
34518 var cv []string
34519 if *v == nil {
34520 cv = []string{}
34521 } else {
34522 cv = *v
34523 }
34524
34525 for _, value := range shape {
34526 var col string
34527 if value != nil {
34528 jtv, ok := value.(string)
34529 if !ok {
34530 return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
34531 }
34532 col = jtv
34533 }
34534 cv = append(cv, col)
34535
34536 }
34537 *v = cv
34538 return nil
34539 }
34540
34541 func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error {
34542 if v == nil {
34543 return fmt.Errorf("unexpected nil of type %T", v)
34544 }
34545 if value == nil {
34546 return nil
34547 }
34548
34549 shape, ok := value.(map[string]interface{})
34550 if !ok {
34551 return fmt.Errorf("unexpected JSON type %v", value)
34552 }
34553
34554 var sv *types.Tag
34555 if *v == nil {
34556 sv = &types.Tag{}
34557 } else {
34558 sv = *v
34559 }
34560
34561 for key, value := range shape {
34562 switch key {
34563 case "key":
34564 if value != nil {
34565 jtv, ok := value.(string)
34566 if !ok {
34567 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value)
34568 }
34569 sv.Key = ptr.String(jtv)
34570 }
34571
34572 case "value":
34573 if value != nil {
34574 jtv, ok := value.(string)
34575 if !ok {
34576 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value)
34577 }
34578 sv.Value = ptr.String(jtv)
34579 }
34580
34581 default:
34582 _, _ = key, value
34583
34584 }
34585 }
34586 *v = sv
34587 return nil
34588 }
34589
34590 func awsAwsjson11_deserializeDocumentTagList(v *[]types.Tag, value interface{}) error {
34591 if v == nil {
34592 return fmt.Errorf("unexpected nil of type %T", v)
34593 }
34594 if value == nil {
34595 return nil
34596 }
34597
34598 shape, ok := value.([]interface{})
34599 if !ok {
34600 return fmt.Errorf("unexpected JSON type %v", value)
34601 }
34602
34603 var cv []types.Tag
34604 if *v == nil {
34605 cv = []types.Tag{}
34606 } else {
34607 cv = *v
34608 }
34609
34610 for _, value := range shape {
34611 var col types.Tag
34612 destAddr := &col
34613 if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil {
34614 return err
34615 }
34616 col = *destAddr
34617 cv = append(cv, col)
34618
34619 }
34620 *v = cv
34621 return nil
34622 }
34623
34624 func awsAwsjson11_deserializeDocumentTimePeriod(v **types.TimePeriod, value interface{}) error {
34625 if v == nil {
34626 return fmt.Errorf("unexpected nil of type %T", v)
34627 }
34628 if value == nil {
34629 return nil
34630 }
34631
34632 shape, ok := value.(map[string]interface{})
34633 if !ok {
34634 return fmt.Errorf("unexpected JSON type %v", value)
34635 }
34636
34637 var sv *types.TimePeriod
34638 if *v == nil {
34639 sv = &types.TimePeriod{}
34640 } else {
34641 sv = *v
34642 }
34643
34644 for key, value := range shape {
34645 switch key {
34646 case "end":
34647 if value != nil {
34648 switch jtv := value.(type) {
34649 case json.Number:
34650 f64, err := jtv.Float64()
34651 if err != nil {
34652 return err
34653 }
34654 sv.End = ptr.Time(smithytime.ParseEpochSeconds(f64))
34655
34656 default:
34657 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
34658
34659 }
34660 }
34661
34662 case "start":
34663 if value != nil {
34664 switch jtv := value.(type) {
34665 case json.Number:
34666 f64, err := jtv.Float64()
34667 if err != nil {
34668 return err
34669 }
34670 sv.Start = ptr.Time(smithytime.ParseEpochSeconds(f64))
34671
34672 default:
34673 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
34674
34675 }
34676 }
34677
34678 default:
34679 _, _ = key, value
34680
34681 }
34682 }
34683 *v = sv
34684 return nil
34685 }
34686
34687 func awsAwsjson11_deserializeDocumentUnauthenticatedException(v **types.UnauthenticatedException, value interface{}) error {
34688 if v == nil {
34689 return fmt.Errorf("unexpected nil of type %T", v)
34690 }
34691 if value == nil {
34692 return nil
34693 }
34694
34695 shape, ok := value.(map[string]interface{})
34696 if !ok {
34697 return fmt.Errorf("unexpected JSON type %v", value)
34698 }
34699
34700 var sv *types.UnauthenticatedException
34701 if *v == nil {
34702 sv = &types.UnauthenticatedException{}
34703 } else {
34704 sv = *v
34705 }
34706
34707 for key, value := range shape {
34708 switch key {
34709 case "code":
34710 if value != nil {
34711 jtv, ok := value.(string)
34712 if !ok {
34713 return fmt.Errorf("expected string to be of type string, got %T instead", value)
34714 }
34715 sv.Code = ptr.String(jtv)
34716 }
34717
34718 case "docs":
34719 if value != nil {
34720 jtv, ok := value.(string)
34721 if !ok {
34722 return fmt.Errorf("expected string to be of type string, got %T instead", value)
34723 }
34724 sv.Docs = ptr.String(jtv)
34725 }
34726
34727 case "message", "Message":
34728 if value != nil {
34729 jtv, ok := value.(string)
34730 if !ok {
34731 return fmt.Errorf("expected string to be of type string, got %T instead", value)
34732 }
34733 sv.Message = ptr.String(jtv)
34734 }
34735
34736 case "tip":
34737 if value != nil {
34738 jtv, ok := value.(string)
34739 if !ok {
34740 return fmt.Errorf("expected string to be of type string, got %T instead", value)
34741 }
34742 sv.Tip = ptr.String(jtv)
34743 }
34744
34745 default:
34746 _, _ = key, value
34747
34748 }
34749 }
34750 *v = sv
34751 return nil
34752 }
34753
34754 func awsAwsjson11_deserializeOpDocumentAllocateStaticIpOutput(v **AllocateStaticIpOutput, value interface{}) error {
34755 if v == nil {
34756 return fmt.Errorf("unexpected nil of type %T", v)
34757 }
34758 if value == nil {
34759 return nil
34760 }
34761
34762 shape, ok := value.(map[string]interface{})
34763 if !ok {
34764 return fmt.Errorf("unexpected JSON type %v", value)
34765 }
34766
34767 var sv *AllocateStaticIpOutput
34768 if *v == nil {
34769 sv = &AllocateStaticIpOutput{}
34770 } else {
34771 sv = *v
34772 }
34773
34774 for key, value := range shape {
34775 switch key {
34776 case "operations":
34777 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
34778 return err
34779 }
34780
34781 default:
34782 _, _ = key, value
34783
34784 }
34785 }
34786 *v = sv
34787 return nil
34788 }
34789
34790 func awsAwsjson11_deserializeOpDocumentAttachCertificateToDistributionOutput(v **AttachCertificateToDistributionOutput, value interface{}) error {
34791 if v == nil {
34792 return fmt.Errorf("unexpected nil of type %T", v)
34793 }
34794 if value == nil {
34795 return nil
34796 }
34797
34798 shape, ok := value.(map[string]interface{})
34799 if !ok {
34800 return fmt.Errorf("unexpected JSON type %v", value)
34801 }
34802
34803 var sv *AttachCertificateToDistributionOutput
34804 if *v == nil {
34805 sv = &AttachCertificateToDistributionOutput{}
34806 } else {
34807 sv = *v
34808 }
34809
34810 for key, value := range shape {
34811 switch key {
34812 case "operation":
34813 if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
34814 return err
34815 }
34816
34817 default:
34818 _, _ = key, value
34819
34820 }
34821 }
34822 *v = sv
34823 return nil
34824 }
34825
34826 func awsAwsjson11_deserializeOpDocumentAttachDiskOutput(v **AttachDiskOutput, value interface{}) error {
34827 if v == nil {
34828 return fmt.Errorf("unexpected nil of type %T", v)
34829 }
34830 if value == nil {
34831 return nil
34832 }
34833
34834 shape, ok := value.(map[string]interface{})
34835 if !ok {
34836 return fmt.Errorf("unexpected JSON type %v", value)
34837 }
34838
34839 var sv *AttachDiskOutput
34840 if *v == nil {
34841 sv = &AttachDiskOutput{}
34842 } else {
34843 sv = *v
34844 }
34845
34846 for key, value := range shape {
34847 switch key {
34848 case "operations":
34849 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
34850 return err
34851 }
34852
34853 default:
34854 _, _ = key, value
34855
34856 }
34857 }
34858 *v = sv
34859 return nil
34860 }
34861
34862 func awsAwsjson11_deserializeOpDocumentAttachInstancesToLoadBalancerOutput(v **AttachInstancesToLoadBalancerOutput, value interface{}) error {
34863 if v == nil {
34864 return fmt.Errorf("unexpected nil of type %T", v)
34865 }
34866 if value == nil {
34867 return nil
34868 }
34869
34870 shape, ok := value.(map[string]interface{})
34871 if !ok {
34872 return fmt.Errorf("unexpected JSON type %v", value)
34873 }
34874
34875 var sv *AttachInstancesToLoadBalancerOutput
34876 if *v == nil {
34877 sv = &AttachInstancesToLoadBalancerOutput{}
34878 } else {
34879 sv = *v
34880 }
34881
34882 for key, value := range shape {
34883 switch key {
34884 case "operations":
34885 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
34886 return err
34887 }
34888
34889 default:
34890 _, _ = key, value
34891
34892 }
34893 }
34894 *v = sv
34895 return nil
34896 }
34897
34898 func awsAwsjson11_deserializeOpDocumentAttachLoadBalancerTlsCertificateOutput(v **AttachLoadBalancerTlsCertificateOutput, value interface{}) error {
34899 if v == nil {
34900 return fmt.Errorf("unexpected nil of type %T", v)
34901 }
34902 if value == nil {
34903 return nil
34904 }
34905
34906 shape, ok := value.(map[string]interface{})
34907 if !ok {
34908 return fmt.Errorf("unexpected JSON type %v", value)
34909 }
34910
34911 var sv *AttachLoadBalancerTlsCertificateOutput
34912 if *v == nil {
34913 sv = &AttachLoadBalancerTlsCertificateOutput{}
34914 } else {
34915 sv = *v
34916 }
34917
34918 for key, value := range shape {
34919 switch key {
34920 case "operations":
34921 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
34922 return err
34923 }
34924
34925 default:
34926 _, _ = key, value
34927
34928 }
34929 }
34930 *v = sv
34931 return nil
34932 }
34933
34934 func awsAwsjson11_deserializeOpDocumentAttachStaticIpOutput(v **AttachStaticIpOutput, value interface{}) error {
34935 if v == nil {
34936 return fmt.Errorf("unexpected nil of type %T", v)
34937 }
34938 if value == nil {
34939 return nil
34940 }
34941
34942 shape, ok := value.(map[string]interface{})
34943 if !ok {
34944 return fmt.Errorf("unexpected JSON type %v", value)
34945 }
34946
34947 var sv *AttachStaticIpOutput
34948 if *v == nil {
34949 sv = &AttachStaticIpOutput{}
34950 } else {
34951 sv = *v
34952 }
34953
34954 for key, value := range shape {
34955 switch key {
34956 case "operations":
34957 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
34958 return err
34959 }
34960
34961 default:
34962 _, _ = key, value
34963
34964 }
34965 }
34966 *v = sv
34967 return nil
34968 }
34969
34970 func awsAwsjson11_deserializeOpDocumentCloseInstancePublicPortsOutput(v **CloseInstancePublicPortsOutput, value interface{}) error {
34971 if v == nil {
34972 return fmt.Errorf("unexpected nil of type %T", v)
34973 }
34974 if value == nil {
34975 return nil
34976 }
34977
34978 shape, ok := value.(map[string]interface{})
34979 if !ok {
34980 return fmt.Errorf("unexpected JSON type %v", value)
34981 }
34982
34983 var sv *CloseInstancePublicPortsOutput
34984 if *v == nil {
34985 sv = &CloseInstancePublicPortsOutput{}
34986 } else {
34987 sv = *v
34988 }
34989
34990 for key, value := range shape {
34991 switch key {
34992 case "operation":
34993 if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
34994 return err
34995 }
34996
34997 default:
34998 _, _ = key, value
34999
35000 }
35001 }
35002 *v = sv
35003 return nil
35004 }
35005
35006 func awsAwsjson11_deserializeOpDocumentCopySnapshotOutput(v **CopySnapshotOutput, value interface{}) error {
35007 if v == nil {
35008 return fmt.Errorf("unexpected nil of type %T", v)
35009 }
35010 if value == nil {
35011 return nil
35012 }
35013
35014 shape, ok := value.(map[string]interface{})
35015 if !ok {
35016 return fmt.Errorf("unexpected JSON type %v", value)
35017 }
35018
35019 var sv *CopySnapshotOutput
35020 if *v == nil {
35021 sv = &CopySnapshotOutput{}
35022 } else {
35023 sv = *v
35024 }
35025
35026 for key, value := range shape {
35027 switch key {
35028 case "operations":
35029 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
35030 return err
35031 }
35032
35033 default:
35034 _, _ = key, value
35035
35036 }
35037 }
35038 *v = sv
35039 return nil
35040 }
35041
35042 func awsAwsjson11_deserializeOpDocumentCreateBucketAccessKeyOutput(v **CreateBucketAccessKeyOutput, value interface{}) error {
35043 if v == nil {
35044 return fmt.Errorf("unexpected nil of type %T", v)
35045 }
35046 if value == nil {
35047 return nil
35048 }
35049
35050 shape, ok := value.(map[string]interface{})
35051 if !ok {
35052 return fmt.Errorf("unexpected JSON type %v", value)
35053 }
35054
35055 var sv *CreateBucketAccessKeyOutput
35056 if *v == nil {
35057 sv = &CreateBucketAccessKeyOutput{}
35058 } else {
35059 sv = *v
35060 }
35061
35062 for key, value := range shape {
35063 switch key {
35064 case "accessKey":
35065 if err := awsAwsjson11_deserializeDocumentAccessKey(&sv.AccessKey, value); err != nil {
35066 return err
35067 }
35068
35069 case "operations":
35070 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
35071 return err
35072 }
35073
35074 default:
35075 _, _ = key, value
35076
35077 }
35078 }
35079 *v = sv
35080 return nil
35081 }
35082
35083 func awsAwsjson11_deserializeOpDocumentCreateBucketOutput(v **CreateBucketOutput, value interface{}) error {
35084 if v == nil {
35085 return fmt.Errorf("unexpected nil of type %T", v)
35086 }
35087 if value == nil {
35088 return nil
35089 }
35090
35091 shape, ok := value.(map[string]interface{})
35092 if !ok {
35093 return fmt.Errorf("unexpected JSON type %v", value)
35094 }
35095
35096 var sv *CreateBucketOutput
35097 if *v == nil {
35098 sv = &CreateBucketOutput{}
35099 } else {
35100 sv = *v
35101 }
35102
35103 for key, value := range shape {
35104 switch key {
35105 case "bucket":
35106 if err := awsAwsjson11_deserializeDocumentBucket(&sv.Bucket, value); err != nil {
35107 return err
35108 }
35109
35110 case "operations":
35111 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
35112 return err
35113 }
35114
35115 default:
35116 _, _ = key, value
35117
35118 }
35119 }
35120 *v = sv
35121 return nil
35122 }
35123
35124 func awsAwsjson11_deserializeOpDocumentCreateCertificateOutput(v **CreateCertificateOutput, value interface{}) error {
35125 if v == nil {
35126 return fmt.Errorf("unexpected nil of type %T", v)
35127 }
35128 if value == nil {
35129 return nil
35130 }
35131
35132 shape, ok := value.(map[string]interface{})
35133 if !ok {
35134 return fmt.Errorf("unexpected JSON type %v", value)
35135 }
35136
35137 var sv *CreateCertificateOutput
35138 if *v == nil {
35139 sv = &CreateCertificateOutput{}
35140 } else {
35141 sv = *v
35142 }
35143
35144 for key, value := range shape {
35145 switch key {
35146 case "certificate":
35147 if err := awsAwsjson11_deserializeDocumentCertificateSummary(&sv.Certificate, value); err != nil {
35148 return err
35149 }
35150
35151 case "operations":
35152 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
35153 return err
35154 }
35155
35156 default:
35157 _, _ = key, value
35158
35159 }
35160 }
35161 *v = sv
35162 return nil
35163 }
35164
35165 func awsAwsjson11_deserializeOpDocumentCreateCloudFormationStackOutput(v **CreateCloudFormationStackOutput, value interface{}) error {
35166 if v == nil {
35167 return fmt.Errorf("unexpected nil of type %T", v)
35168 }
35169 if value == nil {
35170 return nil
35171 }
35172
35173 shape, ok := value.(map[string]interface{})
35174 if !ok {
35175 return fmt.Errorf("unexpected JSON type %v", value)
35176 }
35177
35178 var sv *CreateCloudFormationStackOutput
35179 if *v == nil {
35180 sv = &CreateCloudFormationStackOutput{}
35181 } else {
35182 sv = *v
35183 }
35184
35185 for key, value := range shape {
35186 switch key {
35187 case "operations":
35188 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
35189 return err
35190 }
35191
35192 default:
35193 _, _ = key, value
35194
35195 }
35196 }
35197 *v = sv
35198 return nil
35199 }
35200
35201 func awsAwsjson11_deserializeOpDocumentCreateContactMethodOutput(v **CreateContactMethodOutput, value interface{}) error {
35202 if v == nil {
35203 return fmt.Errorf("unexpected nil of type %T", v)
35204 }
35205 if value == nil {
35206 return nil
35207 }
35208
35209 shape, ok := value.(map[string]interface{})
35210 if !ok {
35211 return fmt.Errorf("unexpected JSON type %v", value)
35212 }
35213
35214 var sv *CreateContactMethodOutput
35215 if *v == nil {
35216 sv = &CreateContactMethodOutput{}
35217 } else {
35218 sv = *v
35219 }
35220
35221 for key, value := range shape {
35222 switch key {
35223 case "operations":
35224 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
35225 return err
35226 }
35227
35228 default:
35229 _, _ = key, value
35230
35231 }
35232 }
35233 *v = sv
35234 return nil
35235 }
35236
35237 func awsAwsjson11_deserializeOpDocumentCreateContainerServiceDeploymentOutput(v **CreateContainerServiceDeploymentOutput, value interface{}) error {
35238 if v == nil {
35239 return fmt.Errorf("unexpected nil of type %T", v)
35240 }
35241 if value == nil {
35242 return nil
35243 }
35244
35245 shape, ok := value.(map[string]interface{})
35246 if !ok {
35247 return fmt.Errorf("unexpected JSON type %v", value)
35248 }
35249
35250 var sv *CreateContainerServiceDeploymentOutput
35251 if *v == nil {
35252 sv = &CreateContainerServiceDeploymentOutput{}
35253 } else {
35254 sv = *v
35255 }
35256
35257 for key, value := range shape {
35258 switch key {
35259 case "containerService":
35260 if err := awsAwsjson11_deserializeDocumentContainerService(&sv.ContainerService, value); err != nil {
35261 return err
35262 }
35263
35264 default:
35265 _, _ = key, value
35266
35267 }
35268 }
35269 *v = sv
35270 return nil
35271 }
35272
35273 func awsAwsjson11_deserializeOpDocumentCreateContainerServiceOutput(v **CreateContainerServiceOutput, value interface{}) error {
35274 if v == nil {
35275 return fmt.Errorf("unexpected nil of type %T", v)
35276 }
35277 if value == nil {
35278 return nil
35279 }
35280
35281 shape, ok := value.(map[string]interface{})
35282 if !ok {
35283 return fmt.Errorf("unexpected JSON type %v", value)
35284 }
35285
35286 var sv *CreateContainerServiceOutput
35287 if *v == nil {
35288 sv = &CreateContainerServiceOutput{}
35289 } else {
35290 sv = *v
35291 }
35292
35293 for key, value := range shape {
35294 switch key {
35295 case "containerService":
35296 if err := awsAwsjson11_deserializeDocumentContainerService(&sv.ContainerService, value); err != nil {
35297 return err
35298 }
35299
35300 default:
35301 _, _ = key, value
35302
35303 }
35304 }
35305 *v = sv
35306 return nil
35307 }
35308
35309 func awsAwsjson11_deserializeOpDocumentCreateContainerServiceRegistryLoginOutput(v **CreateContainerServiceRegistryLoginOutput, value interface{}) error {
35310 if v == nil {
35311 return fmt.Errorf("unexpected nil of type %T", v)
35312 }
35313 if value == nil {
35314 return nil
35315 }
35316
35317 shape, ok := value.(map[string]interface{})
35318 if !ok {
35319 return fmt.Errorf("unexpected JSON type %v", value)
35320 }
35321
35322 var sv *CreateContainerServiceRegistryLoginOutput
35323 if *v == nil {
35324 sv = &CreateContainerServiceRegistryLoginOutput{}
35325 } else {
35326 sv = *v
35327 }
35328
35329 for key, value := range shape {
35330 switch key {
35331 case "registryLogin":
35332 if err := awsAwsjson11_deserializeDocumentContainerServiceRegistryLogin(&sv.RegistryLogin, value); err != nil {
35333 return err
35334 }
35335
35336 default:
35337 _, _ = key, value
35338
35339 }
35340 }
35341 *v = sv
35342 return nil
35343 }
35344
35345 func awsAwsjson11_deserializeOpDocumentCreateDiskFromSnapshotOutput(v **CreateDiskFromSnapshotOutput, value interface{}) error {
35346 if v == nil {
35347 return fmt.Errorf("unexpected nil of type %T", v)
35348 }
35349 if value == nil {
35350 return nil
35351 }
35352
35353 shape, ok := value.(map[string]interface{})
35354 if !ok {
35355 return fmt.Errorf("unexpected JSON type %v", value)
35356 }
35357
35358 var sv *CreateDiskFromSnapshotOutput
35359 if *v == nil {
35360 sv = &CreateDiskFromSnapshotOutput{}
35361 } else {
35362 sv = *v
35363 }
35364
35365 for key, value := range shape {
35366 switch key {
35367 case "operations":
35368 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
35369 return err
35370 }
35371
35372 default:
35373 _, _ = key, value
35374
35375 }
35376 }
35377 *v = sv
35378 return nil
35379 }
35380
35381 func awsAwsjson11_deserializeOpDocumentCreateDiskOutput(v **CreateDiskOutput, value interface{}) error {
35382 if v == nil {
35383 return fmt.Errorf("unexpected nil of type %T", v)
35384 }
35385 if value == nil {
35386 return nil
35387 }
35388
35389 shape, ok := value.(map[string]interface{})
35390 if !ok {
35391 return fmt.Errorf("unexpected JSON type %v", value)
35392 }
35393
35394 var sv *CreateDiskOutput
35395 if *v == nil {
35396 sv = &CreateDiskOutput{}
35397 } else {
35398 sv = *v
35399 }
35400
35401 for key, value := range shape {
35402 switch key {
35403 case "operations":
35404 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
35405 return err
35406 }
35407
35408 default:
35409 _, _ = key, value
35410
35411 }
35412 }
35413 *v = sv
35414 return nil
35415 }
35416
35417 func awsAwsjson11_deserializeOpDocumentCreateDiskSnapshotOutput(v **CreateDiskSnapshotOutput, value interface{}) error {
35418 if v == nil {
35419 return fmt.Errorf("unexpected nil of type %T", v)
35420 }
35421 if value == nil {
35422 return nil
35423 }
35424
35425 shape, ok := value.(map[string]interface{})
35426 if !ok {
35427 return fmt.Errorf("unexpected JSON type %v", value)
35428 }
35429
35430 var sv *CreateDiskSnapshotOutput
35431 if *v == nil {
35432 sv = &CreateDiskSnapshotOutput{}
35433 } else {
35434 sv = *v
35435 }
35436
35437 for key, value := range shape {
35438 switch key {
35439 case "operations":
35440 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
35441 return err
35442 }
35443
35444 default:
35445 _, _ = key, value
35446
35447 }
35448 }
35449 *v = sv
35450 return nil
35451 }
35452
35453 func awsAwsjson11_deserializeOpDocumentCreateDistributionOutput(v **CreateDistributionOutput, value interface{}) error {
35454 if v == nil {
35455 return fmt.Errorf("unexpected nil of type %T", v)
35456 }
35457 if value == nil {
35458 return nil
35459 }
35460
35461 shape, ok := value.(map[string]interface{})
35462 if !ok {
35463 return fmt.Errorf("unexpected JSON type %v", value)
35464 }
35465
35466 var sv *CreateDistributionOutput
35467 if *v == nil {
35468 sv = &CreateDistributionOutput{}
35469 } else {
35470 sv = *v
35471 }
35472
35473 for key, value := range shape {
35474 switch key {
35475 case "distribution":
35476 if err := awsAwsjson11_deserializeDocumentLightsailDistribution(&sv.Distribution, value); err != nil {
35477 return err
35478 }
35479
35480 case "operation":
35481 if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
35482 return err
35483 }
35484
35485 default:
35486 _, _ = key, value
35487
35488 }
35489 }
35490 *v = sv
35491 return nil
35492 }
35493
35494 func awsAwsjson11_deserializeOpDocumentCreateDomainEntryOutput(v **CreateDomainEntryOutput, value interface{}) error {
35495 if v == nil {
35496 return fmt.Errorf("unexpected nil of type %T", v)
35497 }
35498 if value == nil {
35499 return nil
35500 }
35501
35502 shape, ok := value.(map[string]interface{})
35503 if !ok {
35504 return fmt.Errorf("unexpected JSON type %v", value)
35505 }
35506
35507 var sv *CreateDomainEntryOutput
35508 if *v == nil {
35509 sv = &CreateDomainEntryOutput{}
35510 } else {
35511 sv = *v
35512 }
35513
35514 for key, value := range shape {
35515 switch key {
35516 case "operation":
35517 if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
35518 return err
35519 }
35520
35521 default:
35522 _, _ = key, value
35523
35524 }
35525 }
35526 *v = sv
35527 return nil
35528 }
35529
35530 func awsAwsjson11_deserializeOpDocumentCreateDomainOutput(v **CreateDomainOutput, value interface{}) error {
35531 if v == nil {
35532 return fmt.Errorf("unexpected nil of type %T", v)
35533 }
35534 if value == nil {
35535 return nil
35536 }
35537
35538 shape, ok := value.(map[string]interface{})
35539 if !ok {
35540 return fmt.Errorf("unexpected JSON type %v", value)
35541 }
35542
35543 var sv *CreateDomainOutput
35544 if *v == nil {
35545 sv = &CreateDomainOutput{}
35546 } else {
35547 sv = *v
35548 }
35549
35550 for key, value := range shape {
35551 switch key {
35552 case "operation":
35553 if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
35554 return err
35555 }
35556
35557 default:
35558 _, _ = key, value
35559
35560 }
35561 }
35562 *v = sv
35563 return nil
35564 }
35565
35566 func awsAwsjson11_deserializeOpDocumentCreateGUISessionAccessDetailsOutput(v **CreateGUISessionAccessDetailsOutput, value interface{}) error {
35567 if v == nil {
35568 return fmt.Errorf("unexpected nil of type %T", v)
35569 }
35570 if value == nil {
35571 return nil
35572 }
35573
35574 shape, ok := value.(map[string]interface{})
35575 if !ok {
35576 return fmt.Errorf("unexpected JSON type %v", value)
35577 }
35578
35579 var sv *CreateGUISessionAccessDetailsOutput
35580 if *v == nil {
35581 sv = &CreateGUISessionAccessDetailsOutput{}
35582 } else {
35583 sv = *v
35584 }
35585
35586 for key, value := range shape {
35587 switch key {
35588 case "failureReason":
35589 if value != nil {
35590 jtv, ok := value.(string)
35591 if !ok {
35592 return fmt.Errorf("expected string to be of type string, got %T instead", value)
35593 }
35594 sv.FailureReason = ptr.String(jtv)
35595 }
35596
35597 case "percentageComplete":
35598 if value != nil {
35599 jtv, ok := value.(json.Number)
35600 if !ok {
35601 return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
35602 }
35603 i64, err := jtv.Int64()
35604 if err != nil {
35605 return err
35606 }
35607 sv.PercentageComplete = ptr.Int32(int32(i64))
35608 }
35609
35610 case "resourceName":
35611 if value != nil {
35612 jtv, ok := value.(string)
35613 if !ok {
35614 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
35615 }
35616 sv.ResourceName = ptr.String(jtv)
35617 }
35618
35619 case "sessions":
35620 if err := awsAwsjson11_deserializeDocumentSessions(&sv.Sessions, value); err != nil {
35621 return err
35622 }
35623
35624 case "status":
35625 if value != nil {
35626 jtv, ok := value.(string)
35627 if !ok {
35628 return fmt.Errorf("expected Status to be of type string, got %T instead", value)
35629 }
35630 sv.Status = types.Status(jtv)
35631 }
35632
35633 default:
35634 _, _ = key, value
35635
35636 }
35637 }
35638 *v = sv
35639 return nil
35640 }
35641
35642 func awsAwsjson11_deserializeOpDocumentCreateInstancesFromSnapshotOutput(v **CreateInstancesFromSnapshotOutput, value interface{}) error {
35643 if v == nil {
35644 return fmt.Errorf("unexpected nil of type %T", v)
35645 }
35646 if value == nil {
35647 return nil
35648 }
35649
35650 shape, ok := value.(map[string]interface{})
35651 if !ok {
35652 return fmt.Errorf("unexpected JSON type %v", value)
35653 }
35654
35655 var sv *CreateInstancesFromSnapshotOutput
35656 if *v == nil {
35657 sv = &CreateInstancesFromSnapshotOutput{}
35658 } else {
35659 sv = *v
35660 }
35661
35662 for key, value := range shape {
35663 switch key {
35664 case "operations":
35665 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
35666 return err
35667 }
35668
35669 default:
35670 _, _ = key, value
35671
35672 }
35673 }
35674 *v = sv
35675 return nil
35676 }
35677
35678 func awsAwsjson11_deserializeOpDocumentCreateInstanceSnapshotOutput(v **CreateInstanceSnapshotOutput, value interface{}) error {
35679 if v == nil {
35680 return fmt.Errorf("unexpected nil of type %T", v)
35681 }
35682 if value == nil {
35683 return nil
35684 }
35685
35686 shape, ok := value.(map[string]interface{})
35687 if !ok {
35688 return fmt.Errorf("unexpected JSON type %v", value)
35689 }
35690
35691 var sv *CreateInstanceSnapshotOutput
35692 if *v == nil {
35693 sv = &CreateInstanceSnapshotOutput{}
35694 } else {
35695 sv = *v
35696 }
35697
35698 for key, value := range shape {
35699 switch key {
35700 case "operations":
35701 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
35702 return err
35703 }
35704
35705 default:
35706 _, _ = key, value
35707
35708 }
35709 }
35710 *v = sv
35711 return nil
35712 }
35713
35714 func awsAwsjson11_deserializeOpDocumentCreateInstancesOutput(v **CreateInstancesOutput, value interface{}) error {
35715 if v == nil {
35716 return fmt.Errorf("unexpected nil of type %T", v)
35717 }
35718 if value == nil {
35719 return nil
35720 }
35721
35722 shape, ok := value.(map[string]interface{})
35723 if !ok {
35724 return fmt.Errorf("unexpected JSON type %v", value)
35725 }
35726
35727 var sv *CreateInstancesOutput
35728 if *v == nil {
35729 sv = &CreateInstancesOutput{}
35730 } else {
35731 sv = *v
35732 }
35733
35734 for key, value := range shape {
35735 switch key {
35736 case "operations":
35737 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
35738 return err
35739 }
35740
35741 default:
35742 _, _ = key, value
35743
35744 }
35745 }
35746 *v = sv
35747 return nil
35748 }
35749
35750 func awsAwsjson11_deserializeOpDocumentCreateKeyPairOutput(v **CreateKeyPairOutput, value interface{}) error {
35751 if v == nil {
35752 return fmt.Errorf("unexpected nil of type %T", v)
35753 }
35754 if value == nil {
35755 return nil
35756 }
35757
35758 shape, ok := value.(map[string]interface{})
35759 if !ok {
35760 return fmt.Errorf("unexpected JSON type %v", value)
35761 }
35762
35763 var sv *CreateKeyPairOutput
35764 if *v == nil {
35765 sv = &CreateKeyPairOutput{}
35766 } else {
35767 sv = *v
35768 }
35769
35770 for key, value := range shape {
35771 switch key {
35772 case "keyPair":
35773 if err := awsAwsjson11_deserializeDocumentKeyPair(&sv.KeyPair, value); err != nil {
35774 return err
35775 }
35776
35777 case "operation":
35778 if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
35779 return err
35780 }
35781
35782 case "privateKeyBase64":
35783 if value != nil {
35784 jtv, ok := value.(string)
35785 if !ok {
35786 return fmt.Errorf("expected Base64 to be of type string, got %T instead", value)
35787 }
35788 sv.PrivateKeyBase64 = ptr.String(jtv)
35789 }
35790
35791 case "publicKeyBase64":
35792 if value != nil {
35793 jtv, ok := value.(string)
35794 if !ok {
35795 return fmt.Errorf("expected Base64 to be of type string, got %T instead", value)
35796 }
35797 sv.PublicKeyBase64 = ptr.String(jtv)
35798 }
35799
35800 default:
35801 _, _ = key, value
35802
35803 }
35804 }
35805 *v = sv
35806 return nil
35807 }
35808
35809 func awsAwsjson11_deserializeOpDocumentCreateLoadBalancerOutput(v **CreateLoadBalancerOutput, value interface{}) error {
35810 if v == nil {
35811 return fmt.Errorf("unexpected nil of type %T", v)
35812 }
35813 if value == nil {
35814 return nil
35815 }
35816
35817 shape, ok := value.(map[string]interface{})
35818 if !ok {
35819 return fmt.Errorf("unexpected JSON type %v", value)
35820 }
35821
35822 var sv *CreateLoadBalancerOutput
35823 if *v == nil {
35824 sv = &CreateLoadBalancerOutput{}
35825 } else {
35826 sv = *v
35827 }
35828
35829 for key, value := range shape {
35830 switch key {
35831 case "operations":
35832 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
35833 return err
35834 }
35835
35836 default:
35837 _, _ = key, value
35838
35839 }
35840 }
35841 *v = sv
35842 return nil
35843 }
35844
35845 func awsAwsjson11_deserializeOpDocumentCreateLoadBalancerTlsCertificateOutput(v **CreateLoadBalancerTlsCertificateOutput, value interface{}) error {
35846 if v == nil {
35847 return fmt.Errorf("unexpected nil of type %T", v)
35848 }
35849 if value == nil {
35850 return nil
35851 }
35852
35853 shape, ok := value.(map[string]interface{})
35854 if !ok {
35855 return fmt.Errorf("unexpected JSON type %v", value)
35856 }
35857
35858 var sv *CreateLoadBalancerTlsCertificateOutput
35859 if *v == nil {
35860 sv = &CreateLoadBalancerTlsCertificateOutput{}
35861 } else {
35862 sv = *v
35863 }
35864
35865 for key, value := range shape {
35866 switch key {
35867 case "operations":
35868 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
35869 return err
35870 }
35871
35872 default:
35873 _, _ = key, value
35874
35875 }
35876 }
35877 *v = sv
35878 return nil
35879 }
35880
35881 func awsAwsjson11_deserializeOpDocumentCreateRelationalDatabaseFromSnapshotOutput(v **CreateRelationalDatabaseFromSnapshotOutput, value interface{}) error {
35882 if v == nil {
35883 return fmt.Errorf("unexpected nil of type %T", v)
35884 }
35885 if value == nil {
35886 return nil
35887 }
35888
35889 shape, ok := value.(map[string]interface{})
35890 if !ok {
35891 return fmt.Errorf("unexpected JSON type %v", value)
35892 }
35893
35894 var sv *CreateRelationalDatabaseFromSnapshotOutput
35895 if *v == nil {
35896 sv = &CreateRelationalDatabaseFromSnapshotOutput{}
35897 } else {
35898 sv = *v
35899 }
35900
35901 for key, value := range shape {
35902 switch key {
35903 case "operations":
35904 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
35905 return err
35906 }
35907
35908 default:
35909 _, _ = key, value
35910
35911 }
35912 }
35913 *v = sv
35914 return nil
35915 }
35916
35917 func awsAwsjson11_deserializeOpDocumentCreateRelationalDatabaseOutput(v **CreateRelationalDatabaseOutput, value interface{}) error {
35918 if v == nil {
35919 return fmt.Errorf("unexpected nil of type %T", v)
35920 }
35921 if value == nil {
35922 return nil
35923 }
35924
35925 shape, ok := value.(map[string]interface{})
35926 if !ok {
35927 return fmt.Errorf("unexpected JSON type %v", value)
35928 }
35929
35930 var sv *CreateRelationalDatabaseOutput
35931 if *v == nil {
35932 sv = &CreateRelationalDatabaseOutput{}
35933 } else {
35934 sv = *v
35935 }
35936
35937 for key, value := range shape {
35938 switch key {
35939 case "operations":
35940 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
35941 return err
35942 }
35943
35944 default:
35945 _, _ = key, value
35946
35947 }
35948 }
35949 *v = sv
35950 return nil
35951 }
35952
35953 func awsAwsjson11_deserializeOpDocumentCreateRelationalDatabaseSnapshotOutput(v **CreateRelationalDatabaseSnapshotOutput, value interface{}) error {
35954 if v == nil {
35955 return fmt.Errorf("unexpected nil of type %T", v)
35956 }
35957 if value == nil {
35958 return nil
35959 }
35960
35961 shape, ok := value.(map[string]interface{})
35962 if !ok {
35963 return fmt.Errorf("unexpected JSON type %v", value)
35964 }
35965
35966 var sv *CreateRelationalDatabaseSnapshotOutput
35967 if *v == nil {
35968 sv = &CreateRelationalDatabaseSnapshotOutput{}
35969 } else {
35970 sv = *v
35971 }
35972
35973 for key, value := range shape {
35974 switch key {
35975 case "operations":
35976 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
35977 return err
35978 }
35979
35980 default:
35981 _, _ = key, value
35982
35983 }
35984 }
35985 *v = sv
35986 return nil
35987 }
35988
35989 func awsAwsjson11_deserializeOpDocumentDeleteAlarmOutput(v **DeleteAlarmOutput, value interface{}) error {
35990 if v == nil {
35991 return fmt.Errorf("unexpected nil of type %T", v)
35992 }
35993 if value == nil {
35994 return nil
35995 }
35996
35997 shape, ok := value.(map[string]interface{})
35998 if !ok {
35999 return fmt.Errorf("unexpected JSON type %v", value)
36000 }
36001
36002 var sv *DeleteAlarmOutput
36003 if *v == nil {
36004 sv = &DeleteAlarmOutput{}
36005 } else {
36006 sv = *v
36007 }
36008
36009 for key, value := range shape {
36010 switch key {
36011 case "operations":
36012 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36013 return err
36014 }
36015
36016 default:
36017 _, _ = key, value
36018
36019 }
36020 }
36021 *v = sv
36022 return nil
36023 }
36024
36025 func awsAwsjson11_deserializeOpDocumentDeleteAutoSnapshotOutput(v **DeleteAutoSnapshotOutput, value interface{}) error {
36026 if v == nil {
36027 return fmt.Errorf("unexpected nil of type %T", v)
36028 }
36029 if value == nil {
36030 return nil
36031 }
36032
36033 shape, ok := value.(map[string]interface{})
36034 if !ok {
36035 return fmt.Errorf("unexpected JSON type %v", value)
36036 }
36037
36038 var sv *DeleteAutoSnapshotOutput
36039 if *v == nil {
36040 sv = &DeleteAutoSnapshotOutput{}
36041 } else {
36042 sv = *v
36043 }
36044
36045 for key, value := range shape {
36046 switch key {
36047 case "operations":
36048 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36049 return err
36050 }
36051
36052 default:
36053 _, _ = key, value
36054
36055 }
36056 }
36057 *v = sv
36058 return nil
36059 }
36060
36061 func awsAwsjson11_deserializeOpDocumentDeleteBucketAccessKeyOutput(v **DeleteBucketAccessKeyOutput, value interface{}) error {
36062 if v == nil {
36063 return fmt.Errorf("unexpected nil of type %T", v)
36064 }
36065 if value == nil {
36066 return nil
36067 }
36068
36069 shape, ok := value.(map[string]interface{})
36070 if !ok {
36071 return fmt.Errorf("unexpected JSON type %v", value)
36072 }
36073
36074 var sv *DeleteBucketAccessKeyOutput
36075 if *v == nil {
36076 sv = &DeleteBucketAccessKeyOutput{}
36077 } else {
36078 sv = *v
36079 }
36080
36081 for key, value := range shape {
36082 switch key {
36083 case "operations":
36084 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36085 return err
36086 }
36087
36088 default:
36089 _, _ = key, value
36090
36091 }
36092 }
36093 *v = sv
36094 return nil
36095 }
36096
36097 func awsAwsjson11_deserializeOpDocumentDeleteBucketOutput(v **DeleteBucketOutput, value interface{}) error {
36098 if v == nil {
36099 return fmt.Errorf("unexpected nil of type %T", v)
36100 }
36101 if value == nil {
36102 return nil
36103 }
36104
36105 shape, ok := value.(map[string]interface{})
36106 if !ok {
36107 return fmt.Errorf("unexpected JSON type %v", value)
36108 }
36109
36110 var sv *DeleteBucketOutput
36111 if *v == nil {
36112 sv = &DeleteBucketOutput{}
36113 } else {
36114 sv = *v
36115 }
36116
36117 for key, value := range shape {
36118 switch key {
36119 case "operations":
36120 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36121 return err
36122 }
36123
36124 default:
36125 _, _ = key, value
36126
36127 }
36128 }
36129 *v = sv
36130 return nil
36131 }
36132
36133 func awsAwsjson11_deserializeOpDocumentDeleteCertificateOutput(v **DeleteCertificateOutput, value interface{}) error {
36134 if v == nil {
36135 return fmt.Errorf("unexpected nil of type %T", v)
36136 }
36137 if value == nil {
36138 return nil
36139 }
36140
36141 shape, ok := value.(map[string]interface{})
36142 if !ok {
36143 return fmt.Errorf("unexpected JSON type %v", value)
36144 }
36145
36146 var sv *DeleteCertificateOutput
36147 if *v == nil {
36148 sv = &DeleteCertificateOutput{}
36149 } else {
36150 sv = *v
36151 }
36152
36153 for key, value := range shape {
36154 switch key {
36155 case "operations":
36156 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36157 return err
36158 }
36159
36160 default:
36161 _, _ = key, value
36162
36163 }
36164 }
36165 *v = sv
36166 return nil
36167 }
36168
36169 func awsAwsjson11_deserializeOpDocumentDeleteContactMethodOutput(v **DeleteContactMethodOutput, value interface{}) error {
36170 if v == nil {
36171 return fmt.Errorf("unexpected nil of type %T", v)
36172 }
36173 if value == nil {
36174 return nil
36175 }
36176
36177 shape, ok := value.(map[string]interface{})
36178 if !ok {
36179 return fmt.Errorf("unexpected JSON type %v", value)
36180 }
36181
36182 var sv *DeleteContactMethodOutput
36183 if *v == nil {
36184 sv = &DeleteContactMethodOutput{}
36185 } else {
36186 sv = *v
36187 }
36188
36189 for key, value := range shape {
36190 switch key {
36191 case "operations":
36192 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36193 return err
36194 }
36195
36196 default:
36197 _, _ = key, value
36198
36199 }
36200 }
36201 *v = sv
36202 return nil
36203 }
36204
36205 func awsAwsjson11_deserializeOpDocumentDeleteContainerImageOutput(v **DeleteContainerImageOutput, value interface{}) error {
36206 if v == nil {
36207 return fmt.Errorf("unexpected nil of type %T", v)
36208 }
36209 if value == nil {
36210 return nil
36211 }
36212
36213 shape, ok := value.(map[string]interface{})
36214 if !ok {
36215 return fmt.Errorf("unexpected JSON type %v", value)
36216 }
36217
36218 var sv *DeleteContainerImageOutput
36219 if *v == nil {
36220 sv = &DeleteContainerImageOutput{}
36221 } else {
36222 sv = *v
36223 }
36224
36225 for key, value := range shape {
36226 switch key {
36227 default:
36228 _, _ = key, value
36229
36230 }
36231 }
36232 *v = sv
36233 return nil
36234 }
36235
36236 func awsAwsjson11_deserializeOpDocumentDeleteContainerServiceOutput(v **DeleteContainerServiceOutput, value interface{}) error {
36237 if v == nil {
36238 return fmt.Errorf("unexpected nil of type %T", v)
36239 }
36240 if value == nil {
36241 return nil
36242 }
36243
36244 shape, ok := value.(map[string]interface{})
36245 if !ok {
36246 return fmt.Errorf("unexpected JSON type %v", value)
36247 }
36248
36249 var sv *DeleteContainerServiceOutput
36250 if *v == nil {
36251 sv = &DeleteContainerServiceOutput{}
36252 } else {
36253 sv = *v
36254 }
36255
36256 for key, value := range shape {
36257 switch key {
36258 default:
36259 _, _ = key, value
36260
36261 }
36262 }
36263 *v = sv
36264 return nil
36265 }
36266
36267 func awsAwsjson11_deserializeOpDocumentDeleteDiskOutput(v **DeleteDiskOutput, value interface{}) error {
36268 if v == nil {
36269 return fmt.Errorf("unexpected nil of type %T", v)
36270 }
36271 if value == nil {
36272 return nil
36273 }
36274
36275 shape, ok := value.(map[string]interface{})
36276 if !ok {
36277 return fmt.Errorf("unexpected JSON type %v", value)
36278 }
36279
36280 var sv *DeleteDiskOutput
36281 if *v == nil {
36282 sv = &DeleteDiskOutput{}
36283 } else {
36284 sv = *v
36285 }
36286
36287 for key, value := range shape {
36288 switch key {
36289 case "operations":
36290 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36291 return err
36292 }
36293
36294 default:
36295 _, _ = key, value
36296
36297 }
36298 }
36299 *v = sv
36300 return nil
36301 }
36302
36303 func awsAwsjson11_deserializeOpDocumentDeleteDiskSnapshotOutput(v **DeleteDiskSnapshotOutput, value interface{}) error {
36304 if v == nil {
36305 return fmt.Errorf("unexpected nil of type %T", v)
36306 }
36307 if value == nil {
36308 return nil
36309 }
36310
36311 shape, ok := value.(map[string]interface{})
36312 if !ok {
36313 return fmt.Errorf("unexpected JSON type %v", value)
36314 }
36315
36316 var sv *DeleteDiskSnapshotOutput
36317 if *v == nil {
36318 sv = &DeleteDiskSnapshotOutput{}
36319 } else {
36320 sv = *v
36321 }
36322
36323 for key, value := range shape {
36324 switch key {
36325 case "operations":
36326 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36327 return err
36328 }
36329
36330 default:
36331 _, _ = key, value
36332
36333 }
36334 }
36335 *v = sv
36336 return nil
36337 }
36338
36339 func awsAwsjson11_deserializeOpDocumentDeleteDistributionOutput(v **DeleteDistributionOutput, value interface{}) error {
36340 if v == nil {
36341 return fmt.Errorf("unexpected nil of type %T", v)
36342 }
36343 if value == nil {
36344 return nil
36345 }
36346
36347 shape, ok := value.(map[string]interface{})
36348 if !ok {
36349 return fmt.Errorf("unexpected JSON type %v", value)
36350 }
36351
36352 var sv *DeleteDistributionOutput
36353 if *v == nil {
36354 sv = &DeleteDistributionOutput{}
36355 } else {
36356 sv = *v
36357 }
36358
36359 for key, value := range shape {
36360 switch key {
36361 case "operation":
36362 if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
36363 return err
36364 }
36365
36366 default:
36367 _, _ = key, value
36368
36369 }
36370 }
36371 *v = sv
36372 return nil
36373 }
36374
36375 func awsAwsjson11_deserializeOpDocumentDeleteDomainEntryOutput(v **DeleteDomainEntryOutput, value interface{}) error {
36376 if v == nil {
36377 return fmt.Errorf("unexpected nil of type %T", v)
36378 }
36379 if value == nil {
36380 return nil
36381 }
36382
36383 shape, ok := value.(map[string]interface{})
36384 if !ok {
36385 return fmt.Errorf("unexpected JSON type %v", value)
36386 }
36387
36388 var sv *DeleteDomainEntryOutput
36389 if *v == nil {
36390 sv = &DeleteDomainEntryOutput{}
36391 } else {
36392 sv = *v
36393 }
36394
36395 for key, value := range shape {
36396 switch key {
36397 case "operation":
36398 if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
36399 return err
36400 }
36401
36402 default:
36403 _, _ = key, value
36404
36405 }
36406 }
36407 *v = sv
36408 return nil
36409 }
36410
36411 func awsAwsjson11_deserializeOpDocumentDeleteDomainOutput(v **DeleteDomainOutput, value interface{}) error {
36412 if v == nil {
36413 return fmt.Errorf("unexpected nil of type %T", v)
36414 }
36415 if value == nil {
36416 return nil
36417 }
36418
36419 shape, ok := value.(map[string]interface{})
36420 if !ok {
36421 return fmt.Errorf("unexpected JSON type %v", value)
36422 }
36423
36424 var sv *DeleteDomainOutput
36425 if *v == nil {
36426 sv = &DeleteDomainOutput{}
36427 } else {
36428 sv = *v
36429 }
36430
36431 for key, value := range shape {
36432 switch key {
36433 case "operation":
36434 if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
36435 return err
36436 }
36437
36438 default:
36439 _, _ = key, value
36440
36441 }
36442 }
36443 *v = sv
36444 return nil
36445 }
36446
36447 func awsAwsjson11_deserializeOpDocumentDeleteInstanceOutput(v **DeleteInstanceOutput, value interface{}) error {
36448 if v == nil {
36449 return fmt.Errorf("unexpected nil of type %T", v)
36450 }
36451 if value == nil {
36452 return nil
36453 }
36454
36455 shape, ok := value.(map[string]interface{})
36456 if !ok {
36457 return fmt.Errorf("unexpected JSON type %v", value)
36458 }
36459
36460 var sv *DeleteInstanceOutput
36461 if *v == nil {
36462 sv = &DeleteInstanceOutput{}
36463 } else {
36464 sv = *v
36465 }
36466
36467 for key, value := range shape {
36468 switch key {
36469 case "operations":
36470 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36471 return err
36472 }
36473
36474 default:
36475 _, _ = key, value
36476
36477 }
36478 }
36479 *v = sv
36480 return nil
36481 }
36482
36483 func awsAwsjson11_deserializeOpDocumentDeleteInstanceSnapshotOutput(v **DeleteInstanceSnapshotOutput, value interface{}) error {
36484 if v == nil {
36485 return fmt.Errorf("unexpected nil of type %T", v)
36486 }
36487 if value == nil {
36488 return nil
36489 }
36490
36491 shape, ok := value.(map[string]interface{})
36492 if !ok {
36493 return fmt.Errorf("unexpected JSON type %v", value)
36494 }
36495
36496 var sv *DeleteInstanceSnapshotOutput
36497 if *v == nil {
36498 sv = &DeleteInstanceSnapshotOutput{}
36499 } else {
36500 sv = *v
36501 }
36502
36503 for key, value := range shape {
36504 switch key {
36505 case "operations":
36506 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36507 return err
36508 }
36509
36510 default:
36511 _, _ = key, value
36512
36513 }
36514 }
36515 *v = sv
36516 return nil
36517 }
36518
36519 func awsAwsjson11_deserializeOpDocumentDeleteKeyPairOutput(v **DeleteKeyPairOutput, value interface{}) error {
36520 if v == nil {
36521 return fmt.Errorf("unexpected nil of type %T", v)
36522 }
36523 if value == nil {
36524 return nil
36525 }
36526
36527 shape, ok := value.(map[string]interface{})
36528 if !ok {
36529 return fmt.Errorf("unexpected JSON type %v", value)
36530 }
36531
36532 var sv *DeleteKeyPairOutput
36533 if *v == nil {
36534 sv = &DeleteKeyPairOutput{}
36535 } else {
36536 sv = *v
36537 }
36538
36539 for key, value := range shape {
36540 switch key {
36541 case "operation":
36542 if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
36543 return err
36544 }
36545
36546 default:
36547 _, _ = key, value
36548
36549 }
36550 }
36551 *v = sv
36552 return nil
36553 }
36554
36555 func awsAwsjson11_deserializeOpDocumentDeleteKnownHostKeysOutput(v **DeleteKnownHostKeysOutput, value interface{}) error {
36556 if v == nil {
36557 return fmt.Errorf("unexpected nil of type %T", v)
36558 }
36559 if value == nil {
36560 return nil
36561 }
36562
36563 shape, ok := value.(map[string]interface{})
36564 if !ok {
36565 return fmt.Errorf("unexpected JSON type %v", value)
36566 }
36567
36568 var sv *DeleteKnownHostKeysOutput
36569 if *v == nil {
36570 sv = &DeleteKnownHostKeysOutput{}
36571 } else {
36572 sv = *v
36573 }
36574
36575 for key, value := range shape {
36576 switch key {
36577 case "operations":
36578 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36579 return err
36580 }
36581
36582 default:
36583 _, _ = key, value
36584
36585 }
36586 }
36587 *v = sv
36588 return nil
36589 }
36590
36591 func awsAwsjson11_deserializeOpDocumentDeleteLoadBalancerOutput(v **DeleteLoadBalancerOutput, value interface{}) error {
36592 if v == nil {
36593 return fmt.Errorf("unexpected nil of type %T", v)
36594 }
36595 if value == nil {
36596 return nil
36597 }
36598
36599 shape, ok := value.(map[string]interface{})
36600 if !ok {
36601 return fmt.Errorf("unexpected JSON type %v", value)
36602 }
36603
36604 var sv *DeleteLoadBalancerOutput
36605 if *v == nil {
36606 sv = &DeleteLoadBalancerOutput{}
36607 } else {
36608 sv = *v
36609 }
36610
36611 for key, value := range shape {
36612 switch key {
36613 case "operations":
36614 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36615 return err
36616 }
36617
36618 default:
36619 _, _ = key, value
36620
36621 }
36622 }
36623 *v = sv
36624 return nil
36625 }
36626
36627 func awsAwsjson11_deserializeOpDocumentDeleteLoadBalancerTlsCertificateOutput(v **DeleteLoadBalancerTlsCertificateOutput, value interface{}) error {
36628 if v == nil {
36629 return fmt.Errorf("unexpected nil of type %T", v)
36630 }
36631 if value == nil {
36632 return nil
36633 }
36634
36635 shape, ok := value.(map[string]interface{})
36636 if !ok {
36637 return fmt.Errorf("unexpected JSON type %v", value)
36638 }
36639
36640 var sv *DeleteLoadBalancerTlsCertificateOutput
36641 if *v == nil {
36642 sv = &DeleteLoadBalancerTlsCertificateOutput{}
36643 } else {
36644 sv = *v
36645 }
36646
36647 for key, value := range shape {
36648 switch key {
36649 case "operations":
36650 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36651 return err
36652 }
36653
36654 default:
36655 _, _ = key, value
36656
36657 }
36658 }
36659 *v = sv
36660 return nil
36661 }
36662
36663 func awsAwsjson11_deserializeOpDocumentDeleteRelationalDatabaseOutput(v **DeleteRelationalDatabaseOutput, value interface{}) error {
36664 if v == nil {
36665 return fmt.Errorf("unexpected nil of type %T", v)
36666 }
36667 if value == nil {
36668 return nil
36669 }
36670
36671 shape, ok := value.(map[string]interface{})
36672 if !ok {
36673 return fmt.Errorf("unexpected JSON type %v", value)
36674 }
36675
36676 var sv *DeleteRelationalDatabaseOutput
36677 if *v == nil {
36678 sv = &DeleteRelationalDatabaseOutput{}
36679 } else {
36680 sv = *v
36681 }
36682
36683 for key, value := range shape {
36684 switch key {
36685 case "operations":
36686 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36687 return err
36688 }
36689
36690 default:
36691 _, _ = key, value
36692
36693 }
36694 }
36695 *v = sv
36696 return nil
36697 }
36698
36699 func awsAwsjson11_deserializeOpDocumentDeleteRelationalDatabaseSnapshotOutput(v **DeleteRelationalDatabaseSnapshotOutput, value interface{}) error {
36700 if v == nil {
36701 return fmt.Errorf("unexpected nil of type %T", v)
36702 }
36703 if value == nil {
36704 return nil
36705 }
36706
36707 shape, ok := value.(map[string]interface{})
36708 if !ok {
36709 return fmt.Errorf("unexpected JSON type %v", value)
36710 }
36711
36712 var sv *DeleteRelationalDatabaseSnapshotOutput
36713 if *v == nil {
36714 sv = &DeleteRelationalDatabaseSnapshotOutput{}
36715 } else {
36716 sv = *v
36717 }
36718
36719 for key, value := range shape {
36720 switch key {
36721 case "operations":
36722 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36723 return err
36724 }
36725
36726 default:
36727 _, _ = key, value
36728
36729 }
36730 }
36731 *v = sv
36732 return nil
36733 }
36734
36735 func awsAwsjson11_deserializeOpDocumentDetachCertificateFromDistributionOutput(v **DetachCertificateFromDistributionOutput, value interface{}) error {
36736 if v == nil {
36737 return fmt.Errorf("unexpected nil of type %T", v)
36738 }
36739 if value == nil {
36740 return nil
36741 }
36742
36743 shape, ok := value.(map[string]interface{})
36744 if !ok {
36745 return fmt.Errorf("unexpected JSON type %v", value)
36746 }
36747
36748 var sv *DetachCertificateFromDistributionOutput
36749 if *v == nil {
36750 sv = &DetachCertificateFromDistributionOutput{}
36751 } else {
36752 sv = *v
36753 }
36754
36755 for key, value := range shape {
36756 switch key {
36757 case "operation":
36758 if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
36759 return err
36760 }
36761
36762 default:
36763 _, _ = key, value
36764
36765 }
36766 }
36767 *v = sv
36768 return nil
36769 }
36770
36771 func awsAwsjson11_deserializeOpDocumentDetachDiskOutput(v **DetachDiskOutput, value interface{}) error {
36772 if v == nil {
36773 return fmt.Errorf("unexpected nil of type %T", v)
36774 }
36775 if value == nil {
36776 return nil
36777 }
36778
36779 shape, ok := value.(map[string]interface{})
36780 if !ok {
36781 return fmt.Errorf("unexpected JSON type %v", value)
36782 }
36783
36784 var sv *DetachDiskOutput
36785 if *v == nil {
36786 sv = &DetachDiskOutput{}
36787 } else {
36788 sv = *v
36789 }
36790
36791 for key, value := range shape {
36792 switch key {
36793 case "operations":
36794 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36795 return err
36796 }
36797
36798 default:
36799 _, _ = key, value
36800
36801 }
36802 }
36803 *v = sv
36804 return nil
36805 }
36806
36807 func awsAwsjson11_deserializeOpDocumentDetachInstancesFromLoadBalancerOutput(v **DetachInstancesFromLoadBalancerOutput, value interface{}) error {
36808 if v == nil {
36809 return fmt.Errorf("unexpected nil of type %T", v)
36810 }
36811 if value == nil {
36812 return nil
36813 }
36814
36815 shape, ok := value.(map[string]interface{})
36816 if !ok {
36817 return fmt.Errorf("unexpected JSON type %v", value)
36818 }
36819
36820 var sv *DetachInstancesFromLoadBalancerOutput
36821 if *v == nil {
36822 sv = &DetachInstancesFromLoadBalancerOutput{}
36823 } else {
36824 sv = *v
36825 }
36826
36827 for key, value := range shape {
36828 switch key {
36829 case "operations":
36830 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36831 return err
36832 }
36833
36834 default:
36835 _, _ = key, value
36836
36837 }
36838 }
36839 *v = sv
36840 return nil
36841 }
36842
36843 func awsAwsjson11_deserializeOpDocumentDetachStaticIpOutput(v **DetachStaticIpOutput, value interface{}) error {
36844 if v == nil {
36845 return fmt.Errorf("unexpected nil of type %T", v)
36846 }
36847 if value == nil {
36848 return nil
36849 }
36850
36851 shape, ok := value.(map[string]interface{})
36852 if !ok {
36853 return fmt.Errorf("unexpected JSON type %v", value)
36854 }
36855
36856 var sv *DetachStaticIpOutput
36857 if *v == nil {
36858 sv = &DetachStaticIpOutput{}
36859 } else {
36860 sv = *v
36861 }
36862
36863 for key, value := range shape {
36864 switch key {
36865 case "operations":
36866 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36867 return err
36868 }
36869
36870 default:
36871 _, _ = key, value
36872
36873 }
36874 }
36875 *v = sv
36876 return nil
36877 }
36878
36879 func awsAwsjson11_deserializeOpDocumentDisableAddOnOutput(v **DisableAddOnOutput, value interface{}) error {
36880 if v == nil {
36881 return fmt.Errorf("unexpected nil of type %T", v)
36882 }
36883 if value == nil {
36884 return nil
36885 }
36886
36887 shape, ok := value.(map[string]interface{})
36888 if !ok {
36889 return fmt.Errorf("unexpected JSON type %v", value)
36890 }
36891
36892 var sv *DisableAddOnOutput
36893 if *v == nil {
36894 sv = &DisableAddOnOutput{}
36895 } else {
36896 sv = *v
36897 }
36898
36899 for key, value := range shape {
36900 switch key {
36901 case "operations":
36902 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36903 return err
36904 }
36905
36906 default:
36907 _, _ = key, value
36908
36909 }
36910 }
36911 *v = sv
36912 return nil
36913 }
36914
36915 func awsAwsjson11_deserializeOpDocumentDownloadDefaultKeyPairOutput(v **DownloadDefaultKeyPairOutput, value interface{}) error {
36916 if v == nil {
36917 return fmt.Errorf("unexpected nil of type %T", v)
36918 }
36919 if value == nil {
36920 return nil
36921 }
36922
36923 shape, ok := value.(map[string]interface{})
36924 if !ok {
36925 return fmt.Errorf("unexpected JSON type %v", value)
36926 }
36927
36928 var sv *DownloadDefaultKeyPairOutput
36929 if *v == nil {
36930 sv = &DownloadDefaultKeyPairOutput{}
36931 } else {
36932 sv = *v
36933 }
36934
36935 for key, value := range shape {
36936 switch key {
36937 case "createdAt":
36938 if value != nil {
36939 switch jtv := value.(type) {
36940 case json.Number:
36941 f64, err := jtv.Float64()
36942 if err != nil {
36943 return err
36944 }
36945 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
36946
36947 default:
36948 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
36949
36950 }
36951 }
36952
36953 case "privateKeyBase64":
36954 if value != nil {
36955 jtv, ok := value.(string)
36956 if !ok {
36957 return fmt.Errorf("expected Base64 to be of type string, got %T instead", value)
36958 }
36959 sv.PrivateKeyBase64 = ptr.String(jtv)
36960 }
36961
36962 case "publicKeyBase64":
36963 if value != nil {
36964 jtv, ok := value.(string)
36965 if !ok {
36966 return fmt.Errorf("expected Base64 to be of type string, got %T instead", value)
36967 }
36968 sv.PublicKeyBase64 = ptr.String(jtv)
36969 }
36970
36971 default:
36972 _, _ = key, value
36973
36974 }
36975 }
36976 *v = sv
36977 return nil
36978 }
36979
36980 func awsAwsjson11_deserializeOpDocumentEnableAddOnOutput(v **EnableAddOnOutput, value interface{}) error {
36981 if v == nil {
36982 return fmt.Errorf("unexpected nil of type %T", v)
36983 }
36984 if value == nil {
36985 return nil
36986 }
36987
36988 shape, ok := value.(map[string]interface{})
36989 if !ok {
36990 return fmt.Errorf("unexpected JSON type %v", value)
36991 }
36992
36993 var sv *EnableAddOnOutput
36994 if *v == nil {
36995 sv = &EnableAddOnOutput{}
36996 } else {
36997 sv = *v
36998 }
36999
37000 for key, value := range shape {
37001 switch key {
37002 case "operations":
37003 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
37004 return err
37005 }
37006
37007 default:
37008 _, _ = key, value
37009
37010 }
37011 }
37012 *v = sv
37013 return nil
37014 }
37015
37016 func awsAwsjson11_deserializeOpDocumentExportSnapshotOutput(v **ExportSnapshotOutput, value interface{}) error {
37017 if v == nil {
37018 return fmt.Errorf("unexpected nil of type %T", v)
37019 }
37020 if value == nil {
37021 return nil
37022 }
37023
37024 shape, ok := value.(map[string]interface{})
37025 if !ok {
37026 return fmt.Errorf("unexpected JSON type %v", value)
37027 }
37028
37029 var sv *ExportSnapshotOutput
37030 if *v == nil {
37031 sv = &ExportSnapshotOutput{}
37032 } else {
37033 sv = *v
37034 }
37035
37036 for key, value := range shape {
37037 switch key {
37038 case "operations":
37039 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
37040 return err
37041 }
37042
37043 default:
37044 _, _ = key, value
37045
37046 }
37047 }
37048 *v = sv
37049 return nil
37050 }
37051
37052 func awsAwsjson11_deserializeOpDocumentGetActiveNamesOutput(v **GetActiveNamesOutput, value interface{}) error {
37053 if v == nil {
37054 return fmt.Errorf("unexpected nil of type %T", v)
37055 }
37056 if value == nil {
37057 return nil
37058 }
37059
37060 shape, ok := value.(map[string]interface{})
37061 if !ok {
37062 return fmt.Errorf("unexpected JSON type %v", value)
37063 }
37064
37065 var sv *GetActiveNamesOutput
37066 if *v == nil {
37067 sv = &GetActiveNamesOutput{}
37068 } else {
37069 sv = *v
37070 }
37071
37072 for key, value := range shape {
37073 switch key {
37074 case "activeNames":
37075 if err := awsAwsjson11_deserializeDocumentStringList(&sv.ActiveNames, value); err != nil {
37076 return err
37077 }
37078
37079 case "nextPageToken":
37080 if value != nil {
37081 jtv, ok := value.(string)
37082 if !ok {
37083 return fmt.Errorf("expected string to be of type string, got %T instead", value)
37084 }
37085 sv.NextPageToken = ptr.String(jtv)
37086 }
37087
37088 default:
37089 _, _ = key, value
37090
37091 }
37092 }
37093 *v = sv
37094 return nil
37095 }
37096
37097 func awsAwsjson11_deserializeOpDocumentGetAlarmsOutput(v **GetAlarmsOutput, value interface{}) error {
37098 if v == nil {
37099 return fmt.Errorf("unexpected nil of type %T", v)
37100 }
37101 if value == nil {
37102 return nil
37103 }
37104
37105 shape, ok := value.(map[string]interface{})
37106 if !ok {
37107 return fmt.Errorf("unexpected JSON type %v", value)
37108 }
37109
37110 var sv *GetAlarmsOutput
37111 if *v == nil {
37112 sv = &GetAlarmsOutput{}
37113 } else {
37114 sv = *v
37115 }
37116
37117 for key, value := range shape {
37118 switch key {
37119 case "alarms":
37120 if err := awsAwsjson11_deserializeDocumentAlarmsList(&sv.Alarms, value); err != nil {
37121 return err
37122 }
37123
37124 case "nextPageToken":
37125 if value != nil {
37126 jtv, ok := value.(string)
37127 if !ok {
37128 return fmt.Errorf("expected string to be of type string, got %T instead", value)
37129 }
37130 sv.NextPageToken = ptr.String(jtv)
37131 }
37132
37133 default:
37134 _, _ = key, value
37135
37136 }
37137 }
37138 *v = sv
37139 return nil
37140 }
37141
37142 func awsAwsjson11_deserializeOpDocumentGetAutoSnapshotsOutput(v **GetAutoSnapshotsOutput, value interface{}) error {
37143 if v == nil {
37144 return fmt.Errorf("unexpected nil of type %T", v)
37145 }
37146 if value == nil {
37147 return nil
37148 }
37149
37150 shape, ok := value.(map[string]interface{})
37151 if !ok {
37152 return fmt.Errorf("unexpected JSON type %v", value)
37153 }
37154
37155 var sv *GetAutoSnapshotsOutput
37156 if *v == nil {
37157 sv = &GetAutoSnapshotsOutput{}
37158 } else {
37159 sv = *v
37160 }
37161
37162 for key, value := range shape {
37163 switch key {
37164 case "autoSnapshots":
37165 if err := awsAwsjson11_deserializeDocumentAutoSnapshotDetailsList(&sv.AutoSnapshots, value); err != nil {
37166 return err
37167 }
37168
37169 case "resourceName":
37170 if value != nil {
37171 jtv, ok := value.(string)
37172 if !ok {
37173 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
37174 }
37175 sv.ResourceName = ptr.String(jtv)
37176 }
37177
37178 case "resourceType":
37179 if value != nil {
37180 jtv, ok := value.(string)
37181 if !ok {
37182 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
37183 }
37184 sv.ResourceType = types.ResourceType(jtv)
37185 }
37186
37187 default:
37188 _, _ = key, value
37189
37190 }
37191 }
37192 *v = sv
37193 return nil
37194 }
37195
37196 func awsAwsjson11_deserializeOpDocumentGetBlueprintsOutput(v **GetBlueprintsOutput, value interface{}) error {
37197 if v == nil {
37198 return fmt.Errorf("unexpected nil of type %T", v)
37199 }
37200 if value == nil {
37201 return nil
37202 }
37203
37204 shape, ok := value.(map[string]interface{})
37205 if !ok {
37206 return fmt.Errorf("unexpected JSON type %v", value)
37207 }
37208
37209 var sv *GetBlueprintsOutput
37210 if *v == nil {
37211 sv = &GetBlueprintsOutput{}
37212 } else {
37213 sv = *v
37214 }
37215
37216 for key, value := range shape {
37217 switch key {
37218 case "blueprints":
37219 if err := awsAwsjson11_deserializeDocumentBlueprintList(&sv.Blueprints, value); err != nil {
37220 return err
37221 }
37222
37223 case "nextPageToken":
37224 if value != nil {
37225 jtv, ok := value.(string)
37226 if !ok {
37227 return fmt.Errorf("expected string to be of type string, got %T instead", value)
37228 }
37229 sv.NextPageToken = ptr.String(jtv)
37230 }
37231
37232 default:
37233 _, _ = key, value
37234
37235 }
37236 }
37237 *v = sv
37238 return nil
37239 }
37240
37241 func awsAwsjson11_deserializeOpDocumentGetBucketAccessKeysOutput(v **GetBucketAccessKeysOutput, value interface{}) error {
37242 if v == nil {
37243 return fmt.Errorf("unexpected nil of type %T", v)
37244 }
37245 if value == nil {
37246 return nil
37247 }
37248
37249 shape, ok := value.(map[string]interface{})
37250 if !ok {
37251 return fmt.Errorf("unexpected JSON type %v", value)
37252 }
37253
37254 var sv *GetBucketAccessKeysOutput
37255 if *v == nil {
37256 sv = &GetBucketAccessKeysOutput{}
37257 } else {
37258 sv = *v
37259 }
37260
37261 for key, value := range shape {
37262 switch key {
37263 case "accessKeys":
37264 if err := awsAwsjson11_deserializeDocumentAccessKeyList(&sv.AccessKeys, value); err != nil {
37265 return err
37266 }
37267
37268 default:
37269 _, _ = key, value
37270
37271 }
37272 }
37273 *v = sv
37274 return nil
37275 }
37276
37277 func awsAwsjson11_deserializeOpDocumentGetBucketBundlesOutput(v **GetBucketBundlesOutput, value interface{}) error {
37278 if v == nil {
37279 return fmt.Errorf("unexpected nil of type %T", v)
37280 }
37281 if value == nil {
37282 return nil
37283 }
37284
37285 shape, ok := value.(map[string]interface{})
37286 if !ok {
37287 return fmt.Errorf("unexpected JSON type %v", value)
37288 }
37289
37290 var sv *GetBucketBundlesOutput
37291 if *v == nil {
37292 sv = &GetBucketBundlesOutput{}
37293 } else {
37294 sv = *v
37295 }
37296
37297 for key, value := range shape {
37298 switch key {
37299 case "bundles":
37300 if err := awsAwsjson11_deserializeDocumentBucketBundleList(&sv.Bundles, value); err != nil {
37301 return err
37302 }
37303
37304 default:
37305 _, _ = key, value
37306
37307 }
37308 }
37309 *v = sv
37310 return nil
37311 }
37312
37313 func awsAwsjson11_deserializeOpDocumentGetBucketMetricDataOutput(v **GetBucketMetricDataOutput, value interface{}) error {
37314 if v == nil {
37315 return fmt.Errorf("unexpected nil of type %T", v)
37316 }
37317 if value == nil {
37318 return nil
37319 }
37320
37321 shape, ok := value.(map[string]interface{})
37322 if !ok {
37323 return fmt.Errorf("unexpected JSON type %v", value)
37324 }
37325
37326 var sv *GetBucketMetricDataOutput
37327 if *v == nil {
37328 sv = &GetBucketMetricDataOutput{}
37329 } else {
37330 sv = *v
37331 }
37332
37333 for key, value := range shape {
37334 switch key {
37335 case "metricData":
37336 if err := awsAwsjson11_deserializeDocumentMetricDatapointList(&sv.MetricData, value); err != nil {
37337 return err
37338 }
37339
37340 case "metricName":
37341 if value != nil {
37342 jtv, ok := value.(string)
37343 if !ok {
37344 return fmt.Errorf("expected BucketMetricName to be of type string, got %T instead", value)
37345 }
37346 sv.MetricName = types.BucketMetricName(jtv)
37347 }
37348
37349 default:
37350 _, _ = key, value
37351
37352 }
37353 }
37354 *v = sv
37355 return nil
37356 }
37357
37358 func awsAwsjson11_deserializeOpDocumentGetBucketsOutput(v **GetBucketsOutput, value interface{}) error {
37359 if v == nil {
37360 return fmt.Errorf("unexpected nil of type %T", v)
37361 }
37362 if value == nil {
37363 return nil
37364 }
37365
37366 shape, ok := value.(map[string]interface{})
37367 if !ok {
37368 return fmt.Errorf("unexpected JSON type %v", value)
37369 }
37370
37371 var sv *GetBucketsOutput
37372 if *v == nil {
37373 sv = &GetBucketsOutput{}
37374 } else {
37375 sv = *v
37376 }
37377
37378 for key, value := range shape {
37379 switch key {
37380 case "accountLevelBpaSync":
37381 if err := awsAwsjson11_deserializeDocumentAccountLevelBpaSync(&sv.AccountLevelBpaSync, value); err != nil {
37382 return err
37383 }
37384
37385 case "buckets":
37386 if err := awsAwsjson11_deserializeDocumentBucketList(&sv.Buckets, value); err != nil {
37387 return err
37388 }
37389
37390 case "nextPageToken":
37391 if value != nil {
37392 jtv, ok := value.(string)
37393 if !ok {
37394 return fmt.Errorf("expected string to be of type string, got %T instead", value)
37395 }
37396 sv.NextPageToken = ptr.String(jtv)
37397 }
37398
37399 default:
37400 _, _ = key, value
37401
37402 }
37403 }
37404 *v = sv
37405 return nil
37406 }
37407
37408 func awsAwsjson11_deserializeOpDocumentGetBundlesOutput(v **GetBundlesOutput, value interface{}) error {
37409 if v == nil {
37410 return fmt.Errorf("unexpected nil of type %T", v)
37411 }
37412 if value == nil {
37413 return nil
37414 }
37415
37416 shape, ok := value.(map[string]interface{})
37417 if !ok {
37418 return fmt.Errorf("unexpected JSON type %v", value)
37419 }
37420
37421 var sv *GetBundlesOutput
37422 if *v == nil {
37423 sv = &GetBundlesOutput{}
37424 } else {
37425 sv = *v
37426 }
37427
37428 for key, value := range shape {
37429 switch key {
37430 case "bundles":
37431 if err := awsAwsjson11_deserializeDocumentBundleList(&sv.Bundles, value); err != nil {
37432 return err
37433 }
37434
37435 case "nextPageToken":
37436 if value != nil {
37437 jtv, ok := value.(string)
37438 if !ok {
37439 return fmt.Errorf("expected string to be of type string, got %T instead", value)
37440 }
37441 sv.NextPageToken = ptr.String(jtv)
37442 }
37443
37444 default:
37445 _, _ = key, value
37446
37447 }
37448 }
37449 *v = sv
37450 return nil
37451 }
37452
37453 func awsAwsjson11_deserializeOpDocumentGetCertificatesOutput(v **GetCertificatesOutput, value interface{}) error {
37454 if v == nil {
37455 return fmt.Errorf("unexpected nil of type %T", v)
37456 }
37457 if value == nil {
37458 return nil
37459 }
37460
37461 shape, ok := value.(map[string]interface{})
37462 if !ok {
37463 return fmt.Errorf("unexpected JSON type %v", value)
37464 }
37465
37466 var sv *GetCertificatesOutput
37467 if *v == nil {
37468 sv = &GetCertificatesOutput{}
37469 } else {
37470 sv = *v
37471 }
37472
37473 for key, value := range shape {
37474 switch key {
37475 case "certificates":
37476 if err := awsAwsjson11_deserializeDocumentCertificateSummaryList(&sv.Certificates, value); err != nil {
37477 return err
37478 }
37479
37480 case "nextPageToken":
37481 if value != nil {
37482 jtv, ok := value.(string)
37483 if !ok {
37484 return fmt.Errorf("expected string to be of type string, got %T instead", value)
37485 }
37486 sv.NextPageToken = ptr.String(jtv)
37487 }
37488
37489 default:
37490 _, _ = key, value
37491
37492 }
37493 }
37494 *v = sv
37495 return nil
37496 }
37497
37498 func awsAwsjson11_deserializeOpDocumentGetCloudFormationStackRecordsOutput(v **GetCloudFormationStackRecordsOutput, value interface{}) error {
37499 if v == nil {
37500 return fmt.Errorf("unexpected nil of type %T", v)
37501 }
37502 if value == nil {
37503 return nil
37504 }
37505
37506 shape, ok := value.(map[string]interface{})
37507 if !ok {
37508 return fmt.Errorf("unexpected JSON type %v", value)
37509 }
37510
37511 var sv *GetCloudFormationStackRecordsOutput
37512 if *v == nil {
37513 sv = &GetCloudFormationStackRecordsOutput{}
37514 } else {
37515 sv = *v
37516 }
37517
37518 for key, value := range shape {
37519 switch key {
37520 case "cloudFormationStackRecords":
37521 if err := awsAwsjson11_deserializeDocumentCloudFormationStackRecordList(&sv.CloudFormationStackRecords, value); err != nil {
37522 return err
37523 }
37524
37525 case "nextPageToken":
37526 if value != nil {
37527 jtv, ok := value.(string)
37528 if !ok {
37529 return fmt.Errorf("expected string to be of type string, got %T instead", value)
37530 }
37531 sv.NextPageToken = ptr.String(jtv)
37532 }
37533
37534 default:
37535 _, _ = key, value
37536
37537 }
37538 }
37539 *v = sv
37540 return nil
37541 }
37542
37543 func awsAwsjson11_deserializeOpDocumentGetContactMethodsOutput(v **GetContactMethodsOutput, value interface{}) error {
37544 if v == nil {
37545 return fmt.Errorf("unexpected nil of type %T", v)
37546 }
37547 if value == nil {
37548 return nil
37549 }
37550
37551 shape, ok := value.(map[string]interface{})
37552 if !ok {
37553 return fmt.Errorf("unexpected JSON type %v", value)
37554 }
37555
37556 var sv *GetContactMethodsOutput
37557 if *v == nil {
37558 sv = &GetContactMethodsOutput{}
37559 } else {
37560 sv = *v
37561 }
37562
37563 for key, value := range shape {
37564 switch key {
37565 case "contactMethods":
37566 if err := awsAwsjson11_deserializeDocumentContactMethodsList(&sv.ContactMethods, value); err != nil {
37567 return err
37568 }
37569
37570 default:
37571 _, _ = key, value
37572
37573 }
37574 }
37575 *v = sv
37576 return nil
37577 }
37578
37579 func awsAwsjson11_deserializeOpDocumentGetContainerAPIMetadataOutput(v **GetContainerAPIMetadataOutput, value interface{}) error {
37580 if v == nil {
37581 return fmt.Errorf("unexpected nil of type %T", v)
37582 }
37583 if value == nil {
37584 return nil
37585 }
37586
37587 shape, ok := value.(map[string]interface{})
37588 if !ok {
37589 return fmt.Errorf("unexpected JSON type %v", value)
37590 }
37591
37592 var sv *GetContainerAPIMetadataOutput
37593 if *v == nil {
37594 sv = &GetContainerAPIMetadataOutput{}
37595 } else {
37596 sv = *v
37597 }
37598
37599 for key, value := range shape {
37600 switch key {
37601 case "metadata":
37602 if err := awsAwsjson11_deserializeDocumentContainerServiceMetadataEntryList(&sv.Metadata, value); err != nil {
37603 return err
37604 }
37605
37606 default:
37607 _, _ = key, value
37608
37609 }
37610 }
37611 *v = sv
37612 return nil
37613 }
37614
37615 func awsAwsjson11_deserializeOpDocumentGetContainerImagesOutput(v **GetContainerImagesOutput, value interface{}) error {
37616 if v == nil {
37617 return fmt.Errorf("unexpected nil of type %T", v)
37618 }
37619 if value == nil {
37620 return nil
37621 }
37622
37623 shape, ok := value.(map[string]interface{})
37624 if !ok {
37625 return fmt.Errorf("unexpected JSON type %v", value)
37626 }
37627
37628 var sv *GetContainerImagesOutput
37629 if *v == nil {
37630 sv = &GetContainerImagesOutput{}
37631 } else {
37632 sv = *v
37633 }
37634
37635 for key, value := range shape {
37636 switch key {
37637 case "containerImages":
37638 if err := awsAwsjson11_deserializeDocumentContainerImageList(&sv.ContainerImages, value); err != nil {
37639 return err
37640 }
37641
37642 default:
37643 _, _ = key, value
37644
37645 }
37646 }
37647 *v = sv
37648 return nil
37649 }
37650
37651 func awsAwsjson11_deserializeOpDocumentGetContainerLogOutput(v **GetContainerLogOutput, value interface{}) error {
37652 if v == nil {
37653 return fmt.Errorf("unexpected nil of type %T", v)
37654 }
37655 if value == nil {
37656 return nil
37657 }
37658
37659 shape, ok := value.(map[string]interface{})
37660 if !ok {
37661 return fmt.Errorf("unexpected JSON type %v", value)
37662 }
37663
37664 var sv *GetContainerLogOutput
37665 if *v == nil {
37666 sv = &GetContainerLogOutput{}
37667 } else {
37668 sv = *v
37669 }
37670
37671 for key, value := range shape {
37672 switch key {
37673 case "logEvents":
37674 if err := awsAwsjson11_deserializeDocumentContainerServiceLogEventList(&sv.LogEvents, value); err != nil {
37675 return err
37676 }
37677
37678 case "nextPageToken":
37679 if value != nil {
37680 jtv, ok := value.(string)
37681 if !ok {
37682 return fmt.Errorf("expected string to be of type string, got %T instead", value)
37683 }
37684 sv.NextPageToken = ptr.String(jtv)
37685 }
37686
37687 default:
37688 _, _ = key, value
37689
37690 }
37691 }
37692 *v = sv
37693 return nil
37694 }
37695
37696 func awsAwsjson11_deserializeOpDocumentGetContainerServiceDeploymentsOutput(v **GetContainerServiceDeploymentsOutput, value interface{}) error {
37697 if v == nil {
37698 return fmt.Errorf("unexpected nil of type %T", v)
37699 }
37700 if value == nil {
37701 return nil
37702 }
37703
37704 shape, ok := value.(map[string]interface{})
37705 if !ok {
37706 return fmt.Errorf("unexpected JSON type %v", value)
37707 }
37708
37709 var sv *GetContainerServiceDeploymentsOutput
37710 if *v == nil {
37711 sv = &GetContainerServiceDeploymentsOutput{}
37712 } else {
37713 sv = *v
37714 }
37715
37716 for key, value := range shape {
37717 switch key {
37718 case "deployments":
37719 if err := awsAwsjson11_deserializeDocumentContainerServiceDeploymentList(&sv.Deployments, value); err != nil {
37720 return err
37721 }
37722
37723 default:
37724 _, _ = key, value
37725
37726 }
37727 }
37728 *v = sv
37729 return nil
37730 }
37731
37732 func awsAwsjson11_deserializeOpDocumentGetContainerServiceMetricDataOutput(v **GetContainerServiceMetricDataOutput, value interface{}) error {
37733 if v == nil {
37734 return fmt.Errorf("unexpected nil of type %T", v)
37735 }
37736 if value == nil {
37737 return nil
37738 }
37739
37740 shape, ok := value.(map[string]interface{})
37741 if !ok {
37742 return fmt.Errorf("unexpected JSON type %v", value)
37743 }
37744
37745 var sv *GetContainerServiceMetricDataOutput
37746 if *v == nil {
37747 sv = &GetContainerServiceMetricDataOutput{}
37748 } else {
37749 sv = *v
37750 }
37751
37752 for key, value := range shape {
37753 switch key {
37754 case "metricData":
37755 if err := awsAwsjson11_deserializeDocumentMetricDatapointList(&sv.MetricData, value); err != nil {
37756 return err
37757 }
37758
37759 case "metricName":
37760 if value != nil {
37761 jtv, ok := value.(string)
37762 if !ok {
37763 return fmt.Errorf("expected ContainerServiceMetricName to be of type string, got %T instead", value)
37764 }
37765 sv.MetricName = types.ContainerServiceMetricName(jtv)
37766 }
37767
37768 default:
37769 _, _ = key, value
37770
37771 }
37772 }
37773 *v = sv
37774 return nil
37775 }
37776
37777 func awsAwsjson11_deserializeOpDocumentGetContainerServicePowersOutput(v **GetContainerServicePowersOutput, value interface{}) error {
37778 if v == nil {
37779 return fmt.Errorf("unexpected nil of type %T", v)
37780 }
37781 if value == nil {
37782 return nil
37783 }
37784
37785 shape, ok := value.(map[string]interface{})
37786 if !ok {
37787 return fmt.Errorf("unexpected JSON type %v", value)
37788 }
37789
37790 var sv *GetContainerServicePowersOutput
37791 if *v == nil {
37792 sv = &GetContainerServicePowersOutput{}
37793 } else {
37794 sv = *v
37795 }
37796
37797 for key, value := range shape {
37798 switch key {
37799 case "powers":
37800 if err := awsAwsjson11_deserializeDocumentContainerServicePowerList(&sv.Powers, value); err != nil {
37801 return err
37802 }
37803
37804 default:
37805 _, _ = key, value
37806
37807 }
37808 }
37809 *v = sv
37810 return nil
37811 }
37812
37813 func awsAwsjson11_deserializeOpDocumentGetContainerServicesOutput(v **GetContainerServicesOutput, value interface{}) error {
37814 if v == nil {
37815 return fmt.Errorf("unexpected nil of type %T", v)
37816 }
37817 if value == nil {
37818 return nil
37819 }
37820
37821 shape, ok := value.(map[string]interface{})
37822 if !ok {
37823 return fmt.Errorf("unexpected JSON type %v", value)
37824 }
37825
37826 var sv *GetContainerServicesOutput
37827 if *v == nil {
37828 sv = &GetContainerServicesOutput{}
37829 } else {
37830 sv = *v
37831 }
37832
37833 for key, value := range shape {
37834 switch key {
37835 case "containerServices":
37836 if err := awsAwsjson11_deserializeDocumentContainerServiceList(&sv.ContainerServices, value); err != nil {
37837 return err
37838 }
37839
37840 default:
37841 _, _ = key, value
37842
37843 }
37844 }
37845 *v = sv
37846 return nil
37847 }
37848
37849 func awsAwsjson11_deserializeOpDocumentGetCostEstimateOutput(v **GetCostEstimateOutput, value interface{}) error {
37850 if v == nil {
37851 return fmt.Errorf("unexpected nil of type %T", v)
37852 }
37853 if value == nil {
37854 return nil
37855 }
37856
37857 shape, ok := value.(map[string]interface{})
37858 if !ok {
37859 return fmt.Errorf("unexpected JSON type %v", value)
37860 }
37861
37862 var sv *GetCostEstimateOutput
37863 if *v == nil {
37864 sv = &GetCostEstimateOutput{}
37865 } else {
37866 sv = *v
37867 }
37868
37869 for key, value := range shape {
37870 switch key {
37871 case "resourcesBudgetEstimate":
37872 if err := awsAwsjson11_deserializeDocumentResourcesBudgetEstimate(&sv.ResourcesBudgetEstimate, value); err != nil {
37873 return err
37874 }
37875
37876 default:
37877 _, _ = key, value
37878
37879 }
37880 }
37881 *v = sv
37882 return nil
37883 }
37884
37885 func awsAwsjson11_deserializeOpDocumentGetDiskOutput(v **GetDiskOutput, value interface{}) error {
37886 if v == nil {
37887 return fmt.Errorf("unexpected nil of type %T", v)
37888 }
37889 if value == nil {
37890 return nil
37891 }
37892
37893 shape, ok := value.(map[string]interface{})
37894 if !ok {
37895 return fmt.Errorf("unexpected JSON type %v", value)
37896 }
37897
37898 var sv *GetDiskOutput
37899 if *v == nil {
37900 sv = &GetDiskOutput{}
37901 } else {
37902 sv = *v
37903 }
37904
37905 for key, value := range shape {
37906 switch key {
37907 case "disk":
37908 if err := awsAwsjson11_deserializeDocumentDisk(&sv.Disk, value); err != nil {
37909 return err
37910 }
37911
37912 default:
37913 _, _ = key, value
37914
37915 }
37916 }
37917 *v = sv
37918 return nil
37919 }
37920
37921 func awsAwsjson11_deserializeOpDocumentGetDiskSnapshotOutput(v **GetDiskSnapshotOutput, value interface{}) error {
37922 if v == nil {
37923 return fmt.Errorf("unexpected nil of type %T", v)
37924 }
37925 if value == nil {
37926 return nil
37927 }
37928
37929 shape, ok := value.(map[string]interface{})
37930 if !ok {
37931 return fmt.Errorf("unexpected JSON type %v", value)
37932 }
37933
37934 var sv *GetDiskSnapshotOutput
37935 if *v == nil {
37936 sv = &GetDiskSnapshotOutput{}
37937 } else {
37938 sv = *v
37939 }
37940
37941 for key, value := range shape {
37942 switch key {
37943 case "diskSnapshot":
37944 if err := awsAwsjson11_deserializeDocumentDiskSnapshot(&sv.DiskSnapshot, value); err != nil {
37945 return err
37946 }
37947
37948 default:
37949 _, _ = key, value
37950
37951 }
37952 }
37953 *v = sv
37954 return nil
37955 }
37956
37957 func awsAwsjson11_deserializeOpDocumentGetDiskSnapshotsOutput(v **GetDiskSnapshotsOutput, value interface{}) error {
37958 if v == nil {
37959 return fmt.Errorf("unexpected nil of type %T", v)
37960 }
37961 if value == nil {
37962 return nil
37963 }
37964
37965 shape, ok := value.(map[string]interface{})
37966 if !ok {
37967 return fmt.Errorf("unexpected JSON type %v", value)
37968 }
37969
37970 var sv *GetDiskSnapshotsOutput
37971 if *v == nil {
37972 sv = &GetDiskSnapshotsOutput{}
37973 } else {
37974 sv = *v
37975 }
37976
37977 for key, value := range shape {
37978 switch key {
37979 case "diskSnapshots":
37980 if err := awsAwsjson11_deserializeDocumentDiskSnapshotList(&sv.DiskSnapshots, value); err != nil {
37981 return err
37982 }
37983
37984 case "nextPageToken":
37985 if value != nil {
37986 jtv, ok := value.(string)
37987 if !ok {
37988 return fmt.Errorf("expected string to be of type string, got %T instead", value)
37989 }
37990 sv.NextPageToken = ptr.String(jtv)
37991 }
37992
37993 default:
37994 _, _ = key, value
37995
37996 }
37997 }
37998 *v = sv
37999 return nil
38000 }
38001
38002 func awsAwsjson11_deserializeOpDocumentGetDisksOutput(v **GetDisksOutput, value interface{}) error {
38003 if v == nil {
38004 return fmt.Errorf("unexpected nil of type %T", v)
38005 }
38006 if value == nil {
38007 return nil
38008 }
38009
38010 shape, ok := value.(map[string]interface{})
38011 if !ok {
38012 return fmt.Errorf("unexpected JSON type %v", value)
38013 }
38014
38015 var sv *GetDisksOutput
38016 if *v == nil {
38017 sv = &GetDisksOutput{}
38018 } else {
38019 sv = *v
38020 }
38021
38022 for key, value := range shape {
38023 switch key {
38024 case "disks":
38025 if err := awsAwsjson11_deserializeDocumentDiskList(&sv.Disks, value); err != nil {
38026 return err
38027 }
38028
38029 case "nextPageToken":
38030 if value != nil {
38031 jtv, ok := value.(string)
38032 if !ok {
38033 return fmt.Errorf("expected string to be of type string, got %T instead", value)
38034 }
38035 sv.NextPageToken = ptr.String(jtv)
38036 }
38037
38038 default:
38039 _, _ = key, value
38040
38041 }
38042 }
38043 *v = sv
38044 return nil
38045 }
38046
38047 func awsAwsjson11_deserializeOpDocumentGetDistributionBundlesOutput(v **GetDistributionBundlesOutput, value interface{}) error {
38048 if v == nil {
38049 return fmt.Errorf("unexpected nil of type %T", v)
38050 }
38051 if value == nil {
38052 return nil
38053 }
38054
38055 shape, ok := value.(map[string]interface{})
38056 if !ok {
38057 return fmt.Errorf("unexpected JSON type %v", value)
38058 }
38059
38060 var sv *GetDistributionBundlesOutput
38061 if *v == nil {
38062 sv = &GetDistributionBundlesOutput{}
38063 } else {
38064 sv = *v
38065 }
38066
38067 for key, value := range shape {
38068 switch key {
38069 case "bundles":
38070 if err := awsAwsjson11_deserializeDocumentDistributionBundleList(&sv.Bundles, value); err != nil {
38071 return err
38072 }
38073
38074 default:
38075 _, _ = key, value
38076
38077 }
38078 }
38079 *v = sv
38080 return nil
38081 }
38082
38083 func awsAwsjson11_deserializeOpDocumentGetDistributionLatestCacheResetOutput(v **GetDistributionLatestCacheResetOutput, value interface{}) error {
38084 if v == nil {
38085 return fmt.Errorf("unexpected nil of type %T", v)
38086 }
38087 if value == nil {
38088 return nil
38089 }
38090
38091 shape, ok := value.(map[string]interface{})
38092 if !ok {
38093 return fmt.Errorf("unexpected JSON type %v", value)
38094 }
38095
38096 var sv *GetDistributionLatestCacheResetOutput
38097 if *v == nil {
38098 sv = &GetDistributionLatestCacheResetOutput{}
38099 } else {
38100 sv = *v
38101 }
38102
38103 for key, value := range shape {
38104 switch key {
38105 case "createTime":
38106 if value != nil {
38107 switch jtv := value.(type) {
38108 case json.Number:
38109 f64, err := jtv.Float64()
38110 if err != nil {
38111 return err
38112 }
38113 sv.CreateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
38114
38115 default:
38116 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
38117
38118 }
38119 }
38120
38121 case "status":
38122 if value != nil {
38123 jtv, ok := value.(string)
38124 if !ok {
38125 return fmt.Errorf("expected string to be of type string, got %T instead", value)
38126 }
38127 sv.Status = ptr.String(jtv)
38128 }
38129
38130 default:
38131 _, _ = key, value
38132
38133 }
38134 }
38135 *v = sv
38136 return nil
38137 }
38138
38139 func awsAwsjson11_deserializeOpDocumentGetDistributionMetricDataOutput(v **GetDistributionMetricDataOutput, value interface{}) error {
38140 if v == nil {
38141 return fmt.Errorf("unexpected nil of type %T", v)
38142 }
38143 if value == nil {
38144 return nil
38145 }
38146
38147 shape, ok := value.(map[string]interface{})
38148 if !ok {
38149 return fmt.Errorf("unexpected JSON type %v", value)
38150 }
38151
38152 var sv *GetDistributionMetricDataOutput
38153 if *v == nil {
38154 sv = &GetDistributionMetricDataOutput{}
38155 } else {
38156 sv = *v
38157 }
38158
38159 for key, value := range shape {
38160 switch key {
38161 case "metricData":
38162 if err := awsAwsjson11_deserializeDocumentMetricDatapointList(&sv.MetricData, value); err != nil {
38163 return err
38164 }
38165
38166 case "metricName":
38167 if value != nil {
38168 jtv, ok := value.(string)
38169 if !ok {
38170 return fmt.Errorf("expected DistributionMetricName to be of type string, got %T instead", value)
38171 }
38172 sv.MetricName = types.DistributionMetricName(jtv)
38173 }
38174
38175 default:
38176 _, _ = key, value
38177
38178 }
38179 }
38180 *v = sv
38181 return nil
38182 }
38183
38184 func awsAwsjson11_deserializeOpDocumentGetDistributionsOutput(v **GetDistributionsOutput, value interface{}) error {
38185 if v == nil {
38186 return fmt.Errorf("unexpected nil of type %T", v)
38187 }
38188 if value == nil {
38189 return nil
38190 }
38191
38192 shape, ok := value.(map[string]interface{})
38193 if !ok {
38194 return fmt.Errorf("unexpected JSON type %v", value)
38195 }
38196
38197 var sv *GetDistributionsOutput
38198 if *v == nil {
38199 sv = &GetDistributionsOutput{}
38200 } else {
38201 sv = *v
38202 }
38203
38204 for key, value := range shape {
38205 switch key {
38206 case "distributions":
38207 if err := awsAwsjson11_deserializeDocumentDistributionList(&sv.Distributions, value); err != nil {
38208 return err
38209 }
38210
38211 case "nextPageToken":
38212 if value != nil {
38213 jtv, ok := value.(string)
38214 if !ok {
38215 return fmt.Errorf("expected string to be of type string, got %T instead", value)
38216 }
38217 sv.NextPageToken = ptr.String(jtv)
38218 }
38219
38220 default:
38221 _, _ = key, value
38222
38223 }
38224 }
38225 *v = sv
38226 return nil
38227 }
38228
38229 func awsAwsjson11_deserializeOpDocumentGetDomainOutput(v **GetDomainOutput, value interface{}) error {
38230 if v == nil {
38231 return fmt.Errorf("unexpected nil of type %T", v)
38232 }
38233 if value == nil {
38234 return nil
38235 }
38236
38237 shape, ok := value.(map[string]interface{})
38238 if !ok {
38239 return fmt.Errorf("unexpected JSON type %v", value)
38240 }
38241
38242 var sv *GetDomainOutput
38243 if *v == nil {
38244 sv = &GetDomainOutput{}
38245 } else {
38246 sv = *v
38247 }
38248
38249 for key, value := range shape {
38250 switch key {
38251 case "domain":
38252 if err := awsAwsjson11_deserializeDocumentDomain(&sv.Domain, value); err != nil {
38253 return err
38254 }
38255
38256 default:
38257 _, _ = key, value
38258
38259 }
38260 }
38261 *v = sv
38262 return nil
38263 }
38264
38265 func awsAwsjson11_deserializeOpDocumentGetDomainsOutput(v **GetDomainsOutput, value interface{}) error {
38266 if v == nil {
38267 return fmt.Errorf("unexpected nil of type %T", v)
38268 }
38269 if value == nil {
38270 return nil
38271 }
38272
38273 shape, ok := value.(map[string]interface{})
38274 if !ok {
38275 return fmt.Errorf("unexpected JSON type %v", value)
38276 }
38277
38278 var sv *GetDomainsOutput
38279 if *v == nil {
38280 sv = &GetDomainsOutput{}
38281 } else {
38282 sv = *v
38283 }
38284
38285 for key, value := range shape {
38286 switch key {
38287 case "domains":
38288 if err := awsAwsjson11_deserializeDocumentDomainList(&sv.Domains, value); err != nil {
38289 return err
38290 }
38291
38292 case "nextPageToken":
38293 if value != nil {
38294 jtv, ok := value.(string)
38295 if !ok {
38296 return fmt.Errorf("expected string to be of type string, got %T instead", value)
38297 }
38298 sv.NextPageToken = ptr.String(jtv)
38299 }
38300
38301 default:
38302 _, _ = key, value
38303
38304 }
38305 }
38306 *v = sv
38307 return nil
38308 }
38309
38310 func awsAwsjson11_deserializeOpDocumentGetExportSnapshotRecordsOutput(v **GetExportSnapshotRecordsOutput, value interface{}) error {
38311 if v == nil {
38312 return fmt.Errorf("unexpected nil of type %T", v)
38313 }
38314 if value == nil {
38315 return nil
38316 }
38317
38318 shape, ok := value.(map[string]interface{})
38319 if !ok {
38320 return fmt.Errorf("unexpected JSON type %v", value)
38321 }
38322
38323 var sv *GetExportSnapshotRecordsOutput
38324 if *v == nil {
38325 sv = &GetExportSnapshotRecordsOutput{}
38326 } else {
38327 sv = *v
38328 }
38329
38330 for key, value := range shape {
38331 switch key {
38332 case "exportSnapshotRecords":
38333 if err := awsAwsjson11_deserializeDocumentExportSnapshotRecordList(&sv.ExportSnapshotRecords, value); err != nil {
38334 return err
38335 }
38336
38337 case "nextPageToken":
38338 if value != nil {
38339 jtv, ok := value.(string)
38340 if !ok {
38341 return fmt.Errorf("expected string to be of type string, got %T instead", value)
38342 }
38343 sv.NextPageToken = ptr.String(jtv)
38344 }
38345
38346 default:
38347 _, _ = key, value
38348
38349 }
38350 }
38351 *v = sv
38352 return nil
38353 }
38354
38355 func awsAwsjson11_deserializeOpDocumentGetInstanceAccessDetailsOutput(v **GetInstanceAccessDetailsOutput, value interface{}) error {
38356 if v == nil {
38357 return fmt.Errorf("unexpected nil of type %T", v)
38358 }
38359 if value == nil {
38360 return nil
38361 }
38362
38363 shape, ok := value.(map[string]interface{})
38364 if !ok {
38365 return fmt.Errorf("unexpected JSON type %v", value)
38366 }
38367
38368 var sv *GetInstanceAccessDetailsOutput
38369 if *v == nil {
38370 sv = &GetInstanceAccessDetailsOutput{}
38371 } else {
38372 sv = *v
38373 }
38374
38375 for key, value := range shape {
38376 switch key {
38377 case "accessDetails":
38378 if err := awsAwsjson11_deserializeDocumentInstanceAccessDetails(&sv.AccessDetails, value); err != nil {
38379 return err
38380 }
38381
38382 default:
38383 _, _ = key, value
38384
38385 }
38386 }
38387 *v = sv
38388 return nil
38389 }
38390
38391 func awsAwsjson11_deserializeOpDocumentGetInstanceMetricDataOutput(v **GetInstanceMetricDataOutput, value interface{}) error {
38392 if v == nil {
38393 return fmt.Errorf("unexpected nil of type %T", v)
38394 }
38395 if value == nil {
38396 return nil
38397 }
38398
38399 shape, ok := value.(map[string]interface{})
38400 if !ok {
38401 return fmt.Errorf("unexpected JSON type %v", value)
38402 }
38403
38404 var sv *GetInstanceMetricDataOutput
38405 if *v == nil {
38406 sv = &GetInstanceMetricDataOutput{}
38407 } else {
38408 sv = *v
38409 }
38410
38411 for key, value := range shape {
38412 switch key {
38413 case "metricData":
38414 if err := awsAwsjson11_deserializeDocumentMetricDatapointList(&sv.MetricData, value); err != nil {
38415 return err
38416 }
38417
38418 case "metricName":
38419 if value != nil {
38420 jtv, ok := value.(string)
38421 if !ok {
38422 return fmt.Errorf("expected InstanceMetricName to be of type string, got %T instead", value)
38423 }
38424 sv.MetricName = types.InstanceMetricName(jtv)
38425 }
38426
38427 default:
38428 _, _ = key, value
38429
38430 }
38431 }
38432 *v = sv
38433 return nil
38434 }
38435
38436 func awsAwsjson11_deserializeOpDocumentGetInstanceOutput(v **GetInstanceOutput, value interface{}) error {
38437 if v == nil {
38438 return fmt.Errorf("unexpected nil of type %T", v)
38439 }
38440 if value == nil {
38441 return nil
38442 }
38443
38444 shape, ok := value.(map[string]interface{})
38445 if !ok {
38446 return fmt.Errorf("unexpected JSON type %v", value)
38447 }
38448
38449 var sv *GetInstanceOutput
38450 if *v == nil {
38451 sv = &GetInstanceOutput{}
38452 } else {
38453 sv = *v
38454 }
38455
38456 for key, value := range shape {
38457 switch key {
38458 case "instance":
38459 if err := awsAwsjson11_deserializeDocumentInstance(&sv.Instance, value); err != nil {
38460 return err
38461 }
38462
38463 default:
38464 _, _ = key, value
38465
38466 }
38467 }
38468 *v = sv
38469 return nil
38470 }
38471
38472 func awsAwsjson11_deserializeOpDocumentGetInstancePortStatesOutput(v **GetInstancePortStatesOutput, value interface{}) error {
38473 if v == nil {
38474 return fmt.Errorf("unexpected nil of type %T", v)
38475 }
38476 if value == nil {
38477 return nil
38478 }
38479
38480 shape, ok := value.(map[string]interface{})
38481 if !ok {
38482 return fmt.Errorf("unexpected JSON type %v", value)
38483 }
38484
38485 var sv *GetInstancePortStatesOutput
38486 if *v == nil {
38487 sv = &GetInstancePortStatesOutput{}
38488 } else {
38489 sv = *v
38490 }
38491
38492 for key, value := range shape {
38493 switch key {
38494 case "portStates":
38495 if err := awsAwsjson11_deserializeDocumentInstancePortStateList(&sv.PortStates, value); err != nil {
38496 return err
38497 }
38498
38499 default:
38500 _, _ = key, value
38501
38502 }
38503 }
38504 *v = sv
38505 return nil
38506 }
38507
38508 func awsAwsjson11_deserializeOpDocumentGetInstanceSnapshotOutput(v **GetInstanceSnapshotOutput, value interface{}) error {
38509 if v == nil {
38510 return fmt.Errorf("unexpected nil of type %T", v)
38511 }
38512 if value == nil {
38513 return nil
38514 }
38515
38516 shape, ok := value.(map[string]interface{})
38517 if !ok {
38518 return fmt.Errorf("unexpected JSON type %v", value)
38519 }
38520
38521 var sv *GetInstanceSnapshotOutput
38522 if *v == nil {
38523 sv = &GetInstanceSnapshotOutput{}
38524 } else {
38525 sv = *v
38526 }
38527
38528 for key, value := range shape {
38529 switch key {
38530 case "instanceSnapshot":
38531 if err := awsAwsjson11_deserializeDocumentInstanceSnapshot(&sv.InstanceSnapshot, value); err != nil {
38532 return err
38533 }
38534
38535 default:
38536 _, _ = key, value
38537
38538 }
38539 }
38540 *v = sv
38541 return nil
38542 }
38543
38544 func awsAwsjson11_deserializeOpDocumentGetInstanceSnapshotsOutput(v **GetInstanceSnapshotsOutput, value interface{}) error {
38545 if v == nil {
38546 return fmt.Errorf("unexpected nil of type %T", v)
38547 }
38548 if value == nil {
38549 return nil
38550 }
38551
38552 shape, ok := value.(map[string]interface{})
38553 if !ok {
38554 return fmt.Errorf("unexpected JSON type %v", value)
38555 }
38556
38557 var sv *GetInstanceSnapshotsOutput
38558 if *v == nil {
38559 sv = &GetInstanceSnapshotsOutput{}
38560 } else {
38561 sv = *v
38562 }
38563
38564 for key, value := range shape {
38565 switch key {
38566 case "instanceSnapshots":
38567 if err := awsAwsjson11_deserializeDocumentInstanceSnapshotList(&sv.InstanceSnapshots, value); err != nil {
38568 return err
38569 }
38570
38571 case "nextPageToken":
38572 if value != nil {
38573 jtv, ok := value.(string)
38574 if !ok {
38575 return fmt.Errorf("expected string to be of type string, got %T instead", value)
38576 }
38577 sv.NextPageToken = ptr.String(jtv)
38578 }
38579
38580 default:
38581 _, _ = key, value
38582
38583 }
38584 }
38585 *v = sv
38586 return nil
38587 }
38588
38589 func awsAwsjson11_deserializeOpDocumentGetInstancesOutput(v **GetInstancesOutput, value interface{}) error {
38590 if v == nil {
38591 return fmt.Errorf("unexpected nil of type %T", v)
38592 }
38593 if value == nil {
38594 return nil
38595 }
38596
38597 shape, ok := value.(map[string]interface{})
38598 if !ok {
38599 return fmt.Errorf("unexpected JSON type %v", value)
38600 }
38601
38602 var sv *GetInstancesOutput
38603 if *v == nil {
38604 sv = &GetInstancesOutput{}
38605 } else {
38606 sv = *v
38607 }
38608
38609 for key, value := range shape {
38610 switch key {
38611 case "instances":
38612 if err := awsAwsjson11_deserializeDocumentInstanceList(&sv.Instances, value); err != nil {
38613 return err
38614 }
38615
38616 case "nextPageToken":
38617 if value != nil {
38618 jtv, ok := value.(string)
38619 if !ok {
38620 return fmt.Errorf("expected string to be of type string, got %T instead", value)
38621 }
38622 sv.NextPageToken = ptr.String(jtv)
38623 }
38624
38625 default:
38626 _, _ = key, value
38627
38628 }
38629 }
38630 *v = sv
38631 return nil
38632 }
38633
38634 func awsAwsjson11_deserializeOpDocumentGetInstanceStateOutput(v **GetInstanceStateOutput, value interface{}) error {
38635 if v == nil {
38636 return fmt.Errorf("unexpected nil of type %T", v)
38637 }
38638 if value == nil {
38639 return nil
38640 }
38641
38642 shape, ok := value.(map[string]interface{})
38643 if !ok {
38644 return fmt.Errorf("unexpected JSON type %v", value)
38645 }
38646
38647 var sv *GetInstanceStateOutput
38648 if *v == nil {
38649 sv = &GetInstanceStateOutput{}
38650 } else {
38651 sv = *v
38652 }
38653
38654 for key, value := range shape {
38655 switch key {
38656 case "state":
38657 if err := awsAwsjson11_deserializeDocumentInstanceState(&sv.State, value); err != nil {
38658 return err
38659 }
38660
38661 default:
38662 _, _ = key, value
38663
38664 }
38665 }
38666 *v = sv
38667 return nil
38668 }
38669
38670 func awsAwsjson11_deserializeOpDocumentGetKeyPairOutput(v **GetKeyPairOutput, value interface{}) error {
38671 if v == nil {
38672 return fmt.Errorf("unexpected nil of type %T", v)
38673 }
38674 if value == nil {
38675 return nil
38676 }
38677
38678 shape, ok := value.(map[string]interface{})
38679 if !ok {
38680 return fmt.Errorf("unexpected JSON type %v", value)
38681 }
38682
38683 var sv *GetKeyPairOutput
38684 if *v == nil {
38685 sv = &GetKeyPairOutput{}
38686 } else {
38687 sv = *v
38688 }
38689
38690 for key, value := range shape {
38691 switch key {
38692 case "keyPair":
38693 if err := awsAwsjson11_deserializeDocumentKeyPair(&sv.KeyPair, value); err != nil {
38694 return err
38695 }
38696
38697 default:
38698 _, _ = key, value
38699
38700 }
38701 }
38702 *v = sv
38703 return nil
38704 }
38705
38706 func awsAwsjson11_deserializeOpDocumentGetKeyPairsOutput(v **GetKeyPairsOutput, value interface{}) error {
38707 if v == nil {
38708 return fmt.Errorf("unexpected nil of type %T", v)
38709 }
38710 if value == nil {
38711 return nil
38712 }
38713
38714 shape, ok := value.(map[string]interface{})
38715 if !ok {
38716 return fmt.Errorf("unexpected JSON type %v", value)
38717 }
38718
38719 var sv *GetKeyPairsOutput
38720 if *v == nil {
38721 sv = &GetKeyPairsOutput{}
38722 } else {
38723 sv = *v
38724 }
38725
38726 for key, value := range shape {
38727 switch key {
38728 case "keyPairs":
38729 if err := awsAwsjson11_deserializeDocumentKeyPairList(&sv.KeyPairs, value); err != nil {
38730 return err
38731 }
38732
38733 case "nextPageToken":
38734 if value != nil {
38735 jtv, ok := value.(string)
38736 if !ok {
38737 return fmt.Errorf("expected string to be of type string, got %T instead", value)
38738 }
38739 sv.NextPageToken = ptr.String(jtv)
38740 }
38741
38742 default:
38743 _, _ = key, value
38744
38745 }
38746 }
38747 *v = sv
38748 return nil
38749 }
38750
38751 func awsAwsjson11_deserializeOpDocumentGetLoadBalancerMetricDataOutput(v **GetLoadBalancerMetricDataOutput, value interface{}) error {
38752 if v == nil {
38753 return fmt.Errorf("unexpected nil of type %T", v)
38754 }
38755 if value == nil {
38756 return nil
38757 }
38758
38759 shape, ok := value.(map[string]interface{})
38760 if !ok {
38761 return fmt.Errorf("unexpected JSON type %v", value)
38762 }
38763
38764 var sv *GetLoadBalancerMetricDataOutput
38765 if *v == nil {
38766 sv = &GetLoadBalancerMetricDataOutput{}
38767 } else {
38768 sv = *v
38769 }
38770
38771 for key, value := range shape {
38772 switch key {
38773 case "metricData":
38774 if err := awsAwsjson11_deserializeDocumentMetricDatapointList(&sv.MetricData, value); err != nil {
38775 return err
38776 }
38777
38778 case "metricName":
38779 if value != nil {
38780 jtv, ok := value.(string)
38781 if !ok {
38782 return fmt.Errorf("expected LoadBalancerMetricName to be of type string, got %T instead", value)
38783 }
38784 sv.MetricName = types.LoadBalancerMetricName(jtv)
38785 }
38786
38787 default:
38788 _, _ = key, value
38789
38790 }
38791 }
38792 *v = sv
38793 return nil
38794 }
38795
38796 func awsAwsjson11_deserializeOpDocumentGetLoadBalancerOutput(v **GetLoadBalancerOutput, value interface{}) error {
38797 if v == nil {
38798 return fmt.Errorf("unexpected nil of type %T", v)
38799 }
38800 if value == nil {
38801 return nil
38802 }
38803
38804 shape, ok := value.(map[string]interface{})
38805 if !ok {
38806 return fmt.Errorf("unexpected JSON type %v", value)
38807 }
38808
38809 var sv *GetLoadBalancerOutput
38810 if *v == nil {
38811 sv = &GetLoadBalancerOutput{}
38812 } else {
38813 sv = *v
38814 }
38815
38816 for key, value := range shape {
38817 switch key {
38818 case "loadBalancer":
38819 if err := awsAwsjson11_deserializeDocumentLoadBalancer(&sv.LoadBalancer, value); err != nil {
38820 return err
38821 }
38822
38823 default:
38824 _, _ = key, value
38825
38826 }
38827 }
38828 *v = sv
38829 return nil
38830 }
38831
38832 func awsAwsjson11_deserializeOpDocumentGetLoadBalancersOutput(v **GetLoadBalancersOutput, value interface{}) error {
38833 if v == nil {
38834 return fmt.Errorf("unexpected nil of type %T", v)
38835 }
38836 if value == nil {
38837 return nil
38838 }
38839
38840 shape, ok := value.(map[string]interface{})
38841 if !ok {
38842 return fmt.Errorf("unexpected JSON type %v", value)
38843 }
38844
38845 var sv *GetLoadBalancersOutput
38846 if *v == nil {
38847 sv = &GetLoadBalancersOutput{}
38848 } else {
38849 sv = *v
38850 }
38851
38852 for key, value := range shape {
38853 switch key {
38854 case "loadBalancers":
38855 if err := awsAwsjson11_deserializeDocumentLoadBalancerList(&sv.LoadBalancers, value); err != nil {
38856 return err
38857 }
38858
38859 case "nextPageToken":
38860 if value != nil {
38861 jtv, ok := value.(string)
38862 if !ok {
38863 return fmt.Errorf("expected string to be of type string, got %T instead", value)
38864 }
38865 sv.NextPageToken = ptr.String(jtv)
38866 }
38867
38868 default:
38869 _, _ = key, value
38870
38871 }
38872 }
38873 *v = sv
38874 return nil
38875 }
38876
38877 func awsAwsjson11_deserializeOpDocumentGetLoadBalancerTlsCertificatesOutput(v **GetLoadBalancerTlsCertificatesOutput, value interface{}) error {
38878 if v == nil {
38879 return fmt.Errorf("unexpected nil of type %T", v)
38880 }
38881 if value == nil {
38882 return nil
38883 }
38884
38885 shape, ok := value.(map[string]interface{})
38886 if !ok {
38887 return fmt.Errorf("unexpected JSON type %v", value)
38888 }
38889
38890 var sv *GetLoadBalancerTlsCertificatesOutput
38891 if *v == nil {
38892 sv = &GetLoadBalancerTlsCertificatesOutput{}
38893 } else {
38894 sv = *v
38895 }
38896
38897 for key, value := range shape {
38898 switch key {
38899 case "tlsCertificates":
38900 if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateList(&sv.TlsCertificates, value); err != nil {
38901 return err
38902 }
38903
38904 default:
38905 _, _ = key, value
38906
38907 }
38908 }
38909 *v = sv
38910 return nil
38911 }
38912
38913 func awsAwsjson11_deserializeOpDocumentGetLoadBalancerTlsPoliciesOutput(v **GetLoadBalancerTlsPoliciesOutput, value interface{}) error {
38914 if v == nil {
38915 return fmt.Errorf("unexpected nil of type %T", v)
38916 }
38917 if value == nil {
38918 return nil
38919 }
38920
38921 shape, ok := value.(map[string]interface{})
38922 if !ok {
38923 return fmt.Errorf("unexpected JSON type %v", value)
38924 }
38925
38926 var sv *GetLoadBalancerTlsPoliciesOutput
38927 if *v == nil {
38928 sv = &GetLoadBalancerTlsPoliciesOutput{}
38929 } else {
38930 sv = *v
38931 }
38932
38933 for key, value := range shape {
38934 switch key {
38935 case "nextPageToken":
38936 if value != nil {
38937 jtv, ok := value.(string)
38938 if !ok {
38939 return fmt.Errorf("expected string to be of type string, got %T instead", value)
38940 }
38941 sv.NextPageToken = ptr.String(jtv)
38942 }
38943
38944 case "tlsPolicies":
38945 if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsPolicyList(&sv.TlsPolicies, value); err != nil {
38946 return err
38947 }
38948
38949 default:
38950 _, _ = key, value
38951
38952 }
38953 }
38954 *v = sv
38955 return nil
38956 }
38957
38958 func awsAwsjson11_deserializeOpDocumentGetOperationOutput(v **GetOperationOutput, value interface{}) error {
38959 if v == nil {
38960 return fmt.Errorf("unexpected nil of type %T", v)
38961 }
38962 if value == nil {
38963 return nil
38964 }
38965
38966 shape, ok := value.(map[string]interface{})
38967 if !ok {
38968 return fmt.Errorf("unexpected JSON type %v", value)
38969 }
38970
38971 var sv *GetOperationOutput
38972 if *v == nil {
38973 sv = &GetOperationOutput{}
38974 } else {
38975 sv = *v
38976 }
38977
38978 for key, value := range shape {
38979 switch key {
38980 case "operation":
38981 if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
38982 return err
38983 }
38984
38985 default:
38986 _, _ = key, value
38987
38988 }
38989 }
38990 *v = sv
38991 return nil
38992 }
38993
38994 func awsAwsjson11_deserializeOpDocumentGetOperationsForResourceOutput(v **GetOperationsForResourceOutput, value interface{}) error {
38995 if v == nil {
38996 return fmt.Errorf("unexpected nil of type %T", v)
38997 }
38998 if value == nil {
38999 return nil
39000 }
39001
39002 shape, ok := value.(map[string]interface{})
39003 if !ok {
39004 return fmt.Errorf("unexpected JSON type %v", value)
39005 }
39006
39007 var sv *GetOperationsForResourceOutput
39008 if *v == nil {
39009 sv = &GetOperationsForResourceOutput{}
39010 } else {
39011 sv = *v
39012 }
39013
39014 for key, value := range shape {
39015 switch key {
39016 case "nextPageCount":
39017 if value != nil {
39018 jtv, ok := value.(string)
39019 if !ok {
39020 return fmt.Errorf("expected string to be of type string, got %T instead", value)
39021 }
39022 sv.NextPageCount = ptr.String(jtv)
39023 }
39024
39025 case "nextPageToken":
39026 if value != nil {
39027 jtv, ok := value.(string)
39028 if !ok {
39029 return fmt.Errorf("expected string to be of type string, got %T instead", value)
39030 }
39031 sv.NextPageToken = ptr.String(jtv)
39032 }
39033
39034 case "operations":
39035 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
39036 return err
39037 }
39038
39039 default:
39040 _, _ = key, value
39041
39042 }
39043 }
39044 *v = sv
39045 return nil
39046 }
39047
39048 func awsAwsjson11_deserializeOpDocumentGetOperationsOutput(v **GetOperationsOutput, value interface{}) error {
39049 if v == nil {
39050 return fmt.Errorf("unexpected nil of type %T", v)
39051 }
39052 if value == nil {
39053 return nil
39054 }
39055
39056 shape, ok := value.(map[string]interface{})
39057 if !ok {
39058 return fmt.Errorf("unexpected JSON type %v", value)
39059 }
39060
39061 var sv *GetOperationsOutput
39062 if *v == nil {
39063 sv = &GetOperationsOutput{}
39064 } else {
39065 sv = *v
39066 }
39067
39068 for key, value := range shape {
39069 switch key {
39070 case "nextPageToken":
39071 if value != nil {
39072 jtv, ok := value.(string)
39073 if !ok {
39074 return fmt.Errorf("expected string to be of type string, got %T instead", value)
39075 }
39076 sv.NextPageToken = ptr.String(jtv)
39077 }
39078
39079 case "operations":
39080 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
39081 return err
39082 }
39083
39084 default:
39085 _, _ = key, value
39086
39087 }
39088 }
39089 *v = sv
39090 return nil
39091 }
39092
39093 func awsAwsjson11_deserializeOpDocumentGetRegionsOutput(v **GetRegionsOutput, value interface{}) error {
39094 if v == nil {
39095 return fmt.Errorf("unexpected nil of type %T", v)
39096 }
39097 if value == nil {
39098 return nil
39099 }
39100
39101 shape, ok := value.(map[string]interface{})
39102 if !ok {
39103 return fmt.Errorf("unexpected JSON type %v", value)
39104 }
39105
39106 var sv *GetRegionsOutput
39107 if *v == nil {
39108 sv = &GetRegionsOutput{}
39109 } else {
39110 sv = *v
39111 }
39112
39113 for key, value := range shape {
39114 switch key {
39115 case "regions":
39116 if err := awsAwsjson11_deserializeDocumentRegionList(&sv.Regions, value); err != nil {
39117 return err
39118 }
39119
39120 default:
39121 _, _ = key, value
39122
39123 }
39124 }
39125 *v = sv
39126 return nil
39127 }
39128
39129 func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseBlueprintsOutput(v **GetRelationalDatabaseBlueprintsOutput, value interface{}) error {
39130 if v == nil {
39131 return fmt.Errorf("unexpected nil of type %T", v)
39132 }
39133 if value == nil {
39134 return nil
39135 }
39136
39137 shape, ok := value.(map[string]interface{})
39138 if !ok {
39139 return fmt.Errorf("unexpected JSON type %v", value)
39140 }
39141
39142 var sv *GetRelationalDatabaseBlueprintsOutput
39143 if *v == nil {
39144 sv = &GetRelationalDatabaseBlueprintsOutput{}
39145 } else {
39146 sv = *v
39147 }
39148
39149 for key, value := range shape {
39150 switch key {
39151 case "blueprints":
39152 if err := awsAwsjson11_deserializeDocumentRelationalDatabaseBlueprintList(&sv.Blueprints, value); err != nil {
39153 return err
39154 }
39155
39156 case "nextPageToken":
39157 if value != nil {
39158 jtv, ok := value.(string)
39159 if !ok {
39160 return fmt.Errorf("expected string to be of type string, got %T instead", value)
39161 }
39162 sv.NextPageToken = ptr.String(jtv)
39163 }
39164
39165 default:
39166 _, _ = key, value
39167
39168 }
39169 }
39170 *v = sv
39171 return nil
39172 }
39173
39174 func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseBundlesOutput(v **GetRelationalDatabaseBundlesOutput, value interface{}) error {
39175 if v == nil {
39176 return fmt.Errorf("unexpected nil of type %T", v)
39177 }
39178 if value == nil {
39179 return nil
39180 }
39181
39182 shape, ok := value.(map[string]interface{})
39183 if !ok {
39184 return fmt.Errorf("unexpected JSON type %v", value)
39185 }
39186
39187 var sv *GetRelationalDatabaseBundlesOutput
39188 if *v == nil {
39189 sv = &GetRelationalDatabaseBundlesOutput{}
39190 } else {
39191 sv = *v
39192 }
39193
39194 for key, value := range shape {
39195 switch key {
39196 case "bundles":
39197 if err := awsAwsjson11_deserializeDocumentRelationalDatabaseBundleList(&sv.Bundles, value); err != nil {
39198 return err
39199 }
39200
39201 case "nextPageToken":
39202 if value != nil {
39203 jtv, ok := value.(string)
39204 if !ok {
39205 return fmt.Errorf("expected string to be of type string, got %T instead", value)
39206 }
39207 sv.NextPageToken = ptr.String(jtv)
39208 }
39209
39210 default:
39211 _, _ = key, value
39212
39213 }
39214 }
39215 *v = sv
39216 return nil
39217 }
39218
39219 func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseEventsOutput(v **GetRelationalDatabaseEventsOutput, value interface{}) error {
39220 if v == nil {
39221 return fmt.Errorf("unexpected nil of type %T", v)
39222 }
39223 if value == nil {
39224 return nil
39225 }
39226
39227 shape, ok := value.(map[string]interface{})
39228 if !ok {
39229 return fmt.Errorf("unexpected JSON type %v", value)
39230 }
39231
39232 var sv *GetRelationalDatabaseEventsOutput
39233 if *v == nil {
39234 sv = &GetRelationalDatabaseEventsOutput{}
39235 } else {
39236 sv = *v
39237 }
39238
39239 for key, value := range shape {
39240 switch key {
39241 case "nextPageToken":
39242 if value != nil {
39243 jtv, ok := value.(string)
39244 if !ok {
39245 return fmt.Errorf("expected string to be of type string, got %T instead", value)
39246 }
39247 sv.NextPageToken = ptr.String(jtv)
39248 }
39249
39250 case "relationalDatabaseEvents":
39251 if err := awsAwsjson11_deserializeDocumentRelationalDatabaseEventList(&sv.RelationalDatabaseEvents, value); err != nil {
39252 return err
39253 }
39254
39255 default:
39256 _, _ = key, value
39257
39258 }
39259 }
39260 *v = sv
39261 return nil
39262 }
39263
39264 func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseLogEventsOutput(v **GetRelationalDatabaseLogEventsOutput, value interface{}) error {
39265 if v == nil {
39266 return fmt.Errorf("unexpected nil of type %T", v)
39267 }
39268 if value == nil {
39269 return nil
39270 }
39271
39272 shape, ok := value.(map[string]interface{})
39273 if !ok {
39274 return fmt.Errorf("unexpected JSON type %v", value)
39275 }
39276
39277 var sv *GetRelationalDatabaseLogEventsOutput
39278 if *v == nil {
39279 sv = &GetRelationalDatabaseLogEventsOutput{}
39280 } else {
39281 sv = *v
39282 }
39283
39284 for key, value := range shape {
39285 switch key {
39286 case "nextBackwardToken":
39287 if value != nil {
39288 jtv, ok := value.(string)
39289 if !ok {
39290 return fmt.Errorf("expected string to be of type string, got %T instead", value)
39291 }
39292 sv.NextBackwardToken = ptr.String(jtv)
39293 }
39294
39295 case "nextForwardToken":
39296 if value != nil {
39297 jtv, ok := value.(string)
39298 if !ok {
39299 return fmt.Errorf("expected string to be of type string, got %T instead", value)
39300 }
39301 sv.NextForwardToken = ptr.String(jtv)
39302 }
39303
39304 case "resourceLogEvents":
39305 if err := awsAwsjson11_deserializeDocumentLogEventList(&sv.ResourceLogEvents, value); err != nil {
39306 return err
39307 }
39308
39309 default:
39310 _, _ = key, value
39311
39312 }
39313 }
39314 *v = sv
39315 return nil
39316 }
39317
39318 func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseLogStreamsOutput(v **GetRelationalDatabaseLogStreamsOutput, value interface{}) error {
39319 if v == nil {
39320 return fmt.Errorf("unexpected nil of type %T", v)
39321 }
39322 if value == nil {
39323 return nil
39324 }
39325
39326 shape, ok := value.(map[string]interface{})
39327 if !ok {
39328 return fmt.Errorf("unexpected JSON type %v", value)
39329 }
39330
39331 var sv *GetRelationalDatabaseLogStreamsOutput
39332 if *v == nil {
39333 sv = &GetRelationalDatabaseLogStreamsOutput{}
39334 } else {
39335 sv = *v
39336 }
39337
39338 for key, value := range shape {
39339 switch key {
39340 case "logStreams":
39341 if err := awsAwsjson11_deserializeDocumentStringList(&sv.LogStreams, value); err != nil {
39342 return err
39343 }
39344
39345 default:
39346 _, _ = key, value
39347
39348 }
39349 }
39350 *v = sv
39351 return nil
39352 }
39353
39354 func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseMasterUserPasswordOutput(v **GetRelationalDatabaseMasterUserPasswordOutput, value interface{}) error {
39355 if v == nil {
39356 return fmt.Errorf("unexpected nil of type %T", v)
39357 }
39358 if value == nil {
39359 return nil
39360 }
39361
39362 shape, ok := value.(map[string]interface{})
39363 if !ok {
39364 return fmt.Errorf("unexpected JSON type %v", value)
39365 }
39366
39367 var sv *GetRelationalDatabaseMasterUserPasswordOutput
39368 if *v == nil {
39369 sv = &GetRelationalDatabaseMasterUserPasswordOutput{}
39370 } else {
39371 sv = *v
39372 }
39373
39374 for key, value := range shape {
39375 switch key {
39376 case "createdAt":
39377 if value != nil {
39378 switch jtv := value.(type) {
39379 case json.Number:
39380 f64, err := jtv.Float64()
39381 if err != nil {
39382 return err
39383 }
39384 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
39385
39386 default:
39387 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
39388
39389 }
39390 }
39391
39392 case "masterUserPassword":
39393 if value != nil {
39394 jtv, ok := value.(string)
39395 if !ok {
39396 return fmt.Errorf("expected SensitiveString to be of type string, got %T instead", value)
39397 }
39398 sv.MasterUserPassword = ptr.String(jtv)
39399 }
39400
39401 default:
39402 _, _ = key, value
39403
39404 }
39405 }
39406 *v = sv
39407 return nil
39408 }
39409
39410 func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseMetricDataOutput(v **GetRelationalDatabaseMetricDataOutput, value interface{}) error {
39411 if v == nil {
39412 return fmt.Errorf("unexpected nil of type %T", v)
39413 }
39414 if value == nil {
39415 return nil
39416 }
39417
39418 shape, ok := value.(map[string]interface{})
39419 if !ok {
39420 return fmt.Errorf("unexpected JSON type %v", value)
39421 }
39422
39423 var sv *GetRelationalDatabaseMetricDataOutput
39424 if *v == nil {
39425 sv = &GetRelationalDatabaseMetricDataOutput{}
39426 } else {
39427 sv = *v
39428 }
39429
39430 for key, value := range shape {
39431 switch key {
39432 case "metricData":
39433 if err := awsAwsjson11_deserializeDocumentMetricDatapointList(&sv.MetricData, value); err != nil {
39434 return err
39435 }
39436
39437 case "metricName":
39438 if value != nil {
39439 jtv, ok := value.(string)
39440 if !ok {
39441 return fmt.Errorf("expected RelationalDatabaseMetricName to be of type string, got %T instead", value)
39442 }
39443 sv.MetricName = types.RelationalDatabaseMetricName(jtv)
39444 }
39445
39446 default:
39447 _, _ = key, value
39448
39449 }
39450 }
39451 *v = sv
39452 return nil
39453 }
39454
39455 func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseOutput(v **GetRelationalDatabaseOutput, value interface{}) error {
39456 if v == nil {
39457 return fmt.Errorf("unexpected nil of type %T", v)
39458 }
39459 if value == nil {
39460 return nil
39461 }
39462
39463 shape, ok := value.(map[string]interface{})
39464 if !ok {
39465 return fmt.Errorf("unexpected JSON type %v", value)
39466 }
39467
39468 var sv *GetRelationalDatabaseOutput
39469 if *v == nil {
39470 sv = &GetRelationalDatabaseOutput{}
39471 } else {
39472 sv = *v
39473 }
39474
39475 for key, value := range shape {
39476 switch key {
39477 case "relationalDatabase":
39478 if err := awsAwsjson11_deserializeDocumentRelationalDatabase(&sv.RelationalDatabase, value); err != nil {
39479 return err
39480 }
39481
39482 default:
39483 _, _ = key, value
39484
39485 }
39486 }
39487 *v = sv
39488 return nil
39489 }
39490
39491 func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseParametersOutput(v **GetRelationalDatabaseParametersOutput, value interface{}) error {
39492 if v == nil {
39493 return fmt.Errorf("unexpected nil of type %T", v)
39494 }
39495 if value == nil {
39496 return nil
39497 }
39498
39499 shape, ok := value.(map[string]interface{})
39500 if !ok {
39501 return fmt.Errorf("unexpected JSON type %v", value)
39502 }
39503
39504 var sv *GetRelationalDatabaseParametersOutput
39505 if *v == nil {
39506 sv = &GetRelationalDatabaseParametersOutput{}
39507 } else {
39508 sv = *v
39509 }
39510
39511 for key, value := range shape {
39512 switch key {
39513 case "nextPageToken":
39514 if value != nil {
39515 jtv, ok := value.(string)
39516 if !ok {
39517 return fmt.Errorf("expected string to be of type string, got %T instead", value)
39518 }
39519 sv.NextPageToken = ptr.String(jtv)
39520 }
39521
39522 case "parameters":
39523 if err := awsAwsjson11_deserializeDocumentRelationalDatabaseParameterList(&sv.Parameters, value); err != nil {
39524 return err
39525 }
39526
39527 default:
39528 _, _ = key, value
39529
39530 }
39531 }
39532 *v = sv
39533 return nil
39534 }
39535
39536 func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseSnapshotOutput(v **GetRelationalDatabaseSnapshotOutput, value interface{}) error {
39537 if v == nil {
39538 return fmt.Errorf("unexpected nil of type %T", v)
39539 }
39540 if value == nil {
39541 return nil
39542 }
39543
39544 shape, ok := value.(map[string]interface{})
39545 if !ok {
39546 return fmt.Errorf("unexpected JSON type %v", value)
39547 }
39548
39549 var sv *GetRelationalDatabaseSnapshotOutput
39550 if *v == nil {
39551 sv = &GetRelationalDatabaseSnapshotOutput{}
39552 } else {
39553 sv = *v
39554 }
39555
39556 for key, value := range shape {
39557 switch key {
39558 case "relationalDatabaseSnapshot":
39559 if err := awsAwsjson11_deserializeDocumentRelationalDatabaseSnapshot(&sv.RelationalDatabaseSnapshot, value); err != nil {
39560 return err
39561 }
39562
39563 default:
39564 _, _ = key, value
39565
39566 }
39567 }
39568 *v = sv
39569 return nil
39570 }
39571
39572 func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseSnapshotsOutput(v **GetRelationalDatabaseSnapshotsOutput, value interface{}) error {
39573 if v == nil {
39574 return fmt.Errorf("unexpected nil of type %T", v)
39575 }
39576 if value == nil {
39577 return nil
39578 }
39579
39580 shape, ok := value.(map[string]interface{})
39581 if !ok {
39582 return fmt.Errorf("unexpected JSON type %v", value)
39583 }
39584
39585 var sv *GetRelationalDatabaseSnapshotsOutput
39586 if *v == nil {
39587 sv = &GetRelationalDatabaseSnapshotsOutput{}
39588 } else {
39589 sv = *v
39590 }
39591
39592 for key, value := range shape {
39593 switch key {
39594 case "nextPageToken":
39595 if value != nil {
39596 jtv, ok := value.(string)
39597 if !ok {
39598 return fmt.Errorf("expected string to be of type string, got %T instead", value)
39599 }
39600 sv.NextPageToken = ptr.String(jtv)
39601 }
39602
39603 case "relationalDatabaseSnapshots":
39604 if err := awsAwsjson11_deserializeDocumentRelationalDatabaseSnapshotList(&sv.RelationalDatabaseSnapshots, value); err != nil {
39605 return err
39606 }
39607
39608 default:
39609 _, _ = key, value
39610
39611 }
39612 }
39613 *v = sv
39614 return nil
39615 }
39616
39617 func awsAwsjson11_deserializeOpDocumentGetRelationalDatabasesOutput(v **GetRelationalDatabasesOutput, value interface{}) error {
39618 if v == nil {
39619 return fmt.Errorf("unexpected nil of type %T", v)
39620 }
39621 if value == nil {
39622 return nil
39623 }
39624
39625 shape, ok := value.(map[string]interface{})
39626 if !ok {
39627 return fmt.Errorf("unexpected JSON type %v", value)
39628 }
39629
39630 var sv *GetRelationalDatabasesOutput
39631 if *v == nil {
39632 sv = &GetRelationalDatabasesOutput{}
39633 } else {
39634 sv = *v
39635 }
39636
39637 for key, value := range shape {
39638 switch key {
39639 case "nextPageToken":
39640 if value != nil {
39641 jtv, ok := value.(string)
39642 if !ok {
39643 return fmt.Errorf("expected string to be of type string, got %T instead", value)
39644 }
39645 sv.NextPageToken = ptr.String(jtv)
39646 }
39647
39648 case "relationalDatabases":
39649 if err := awsAwsjson11_deserializeDocumentRelationalDatabaseList(&sv.RelationalDatabases, value); err != nil {
39650 return err
39651 }
39652
39653 default:
39654 _, _ = key, value
39655
39656 }
39657 }
39658 *v = sv
39659 return nil
39660 }
39661
39662 func awsAwsjson11_deserializeOpDocumentGetSetupHistoryOutput(v **GetSetupHistoryOutput, value interface{}) error {
39663 if v == nil {
39664 return fmt.Errorf("unexpected nil of type %T", v)
39665 }
39666 if value == nil {
39667 return nil
39668 }
39669
39670 shape, ok := value.(map[string]interface{})
39671 if !ok {
39672 return fmt.Errorf("unexpected JSON type %v", value)
39673 }
39674
39675 var sv *GetSetupHistoryOutput
39676 if *v == nil {
39677 sv = &GetSetupHistoryOutput{}
39678 } else {
39679 sv = *v
39680 }
39681
39682 for key, value := range shape {
39683 switch key {
39684 case "nextPageToken":
39685 if value != nil {
39686 jtv, ok := value.(string)
39687 if !ok {
39688 return fmt.Errorf("expected SetupHistoryPageToken to be of type string, got %T instead", value)
39689 }
39690 sv.NextPageToken = ptr.String(jtv)
39691 }
39692
39693 case "setupHistory":
39694 if err := awsAwsjson11_deserializeDocumentSetupHistoryList(&sv.SetupHistory, value); err != nil {
39695 return err
39696 }
39697
39698 default:
39699 _, _ = key, value
39700
39701 }
39702 }
39703 *v = sv
39704 return nil
39705 }
39706
39707 func awsAwsjson11_deserializeOpDocumentGetStaticIpOutput(v **GetStaticIpOutput, value interface{}) error {
39708 if v == nil {
39709 return fmt.Errorf("unexpected nil of type %T", v)
39710 }
39711 if value == nil {
39712 return nil
39713 }
39714
39715 shape, ok := value.(map[string]interface{})
39716 if !ok {
39717 return fmt.Errorf("unexpected JSON type %v", value)
39718 }
39719
39720 var sv *GetStaticIpOutput
39721 if *v == nil {
39722 sv = &GetStaticIpOutput{}
39723 } else {
39724 sv = *v
39725 }
39726
39727 for key, value := range shape {
39728 switch key {
39729 case "staticIp":
39730 if err := awsAwsjson11_deserializeDocumentStaticIp(&sv.StaticIp, value); err != nil {
39731 return err
39732 }
39733
39734 default:
39735 _, _ = key, value
39736
39737 }
39738 }
39739 *v = sv
39740 return nil
39741 }
39742
39743 func awsAwsjson11_deserializeOpDocumentGetStaticIpsOutput(v **GetStaticIpsOutput, value interface{}) error {
39744 if v == nil {
39745 return fmt.Errorf("unexpected nil of type %T", v)
39746 }
39747 if value == nil {
39748 return nil
39749 }
39750
39751 shape, ok := value.(map[string]interface{})
39752 if !ok {
39753 return fmt.Errorf("unexpected JSON type %v", value)
39754 }
39755
39756 var sv *GetStaticIpsOutput
39757 if *v == nil {
39758 sv = &GetStaticIpsOutput{}
39759 } else {
39760 sv = *v
39761 }
39762
39763 for key, value := range shape {
39764 switch key {
39765 case "nextPageToken":
39766 if value != nil {
39767 jtv, ok := value.(string)
39768 if !ok {
39769 return fmt.Errorf("expected string to be of type string, got %T instead", value)
39770 }
39771 sv.NextPageToken = ptr.String(jtv)
39772 }
39773
39774 case "staticIps":
39775 if err := awsAwsjson11_deserializeDocumentStaticIpList(&sv.StaticIps, value); err != nil {
39776 return err
39777 }
39778
39779 default:
39780 _, _ = key, value
39781
39782 }
39783 }
39784 *v = sv
39785 return nil
39786 }
39787
39788 func awsAwsjson11_deserializeOpDocumentImportKeyPairOutput(v **ImportKeyPairOutput, value interface{}) error {
39789 if v == nil {
39790 return fmt.Errorf("unexpected nil of type %T", v)
39791 }
39792 if value == nil {
39793 return nil
39794 }
39795
39796 shape, ok := value.(map[string]interface{})
39797 if !ok {
39798 return fmt.Errorf("unexpected JSON type %v", value)
39799 }
39800
39801 var sv *ImportKeyPairOutput
39802 if *v == nil {
39803 sv = &ImportKeyPairOutput{}
39804 } else {
39805 sv = *v
39806 }
39807
39808 for key, value := range shape {
39809 switch key {
39810 case "operation":
39811 if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
39812 return err
39813 }
39814
39815 default:
39816 _, _ = key, value
39817
39818 }
39819 }
39820 *v = sv
39821 return nil
39822 }
39823
39824 func awsAwsjson11_deserializeOpDocumentIsVpcPeeredOutput(v **IsVpcPeeredOutput, value interface{}) error {
39825 if v == nil {
39826 return fmt.Errorf("unexpected nil of type %T", v)
39827 }
39828 if value == nil {
39829 return nil
39830 }
39831
39832 shape, ok := value.(map[string]interface{})
39833 if !ok {
39834 return fmt.Errorf("unexpected JSON type %v", value)
39835 }
39836
39837 var sv *IsVpcPeeredOutput
39838 if *v == nil {
39839 sv = &IsVpcPeeredOutput{}
39840 } else {
39841 sv = *v
39842 }
39843
39844 for key, value := range shape {
39845 switch key {
39846 case "isPeered":
39847 if value != nil {
39848 jtv, ok := value.(bool)
39849 if !ok {
39850 return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
39851 }
39852 sv.IsPeered = ptr.Bool(jtv)
39853 }
39854
39855 default:
39856 _, _ = key, value
39857
39858 }
39859 }
39860 *v = sv
39861 return nil
39862 }
39863
39864 func awsAwsjson11_deserializeOpDocumentOpenInstancePublicPortsOutput(v **OpenInstancePublicPortsOutput, value interface{}) error {
39865 if v == nil {
39866 return fmt.Errorf("unexpected nil of type %T", v)
39867 }
39868 if value == nil {
39869 return nil
39870 }
39871
39872 shape, ok := value.(map[string]interface{})
39873 if !ok {
39874 return fmt.Errorf("unexpected JSON type %v", value)
39875 }
39876
39877 var sv *OpenInstancePublicPortsOutput
39878 if *v == nil {
39879 sv = &OpenInstancePublicPortsOutput{}
39880 } else {
39881 sv = *v
39882 }
39883
39884 for key, value := range shape {
39885 switch key {
39886 case "operation":
39887 if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
39888 return err
39889 }
39890
39891 default:
39892 _, _ = key, value
39893
39894 }
39895 }
39896 *v = sv
39897 return nil
39898 }
39899
39900 func awsAwsjson11_deserializeOpDocumentPeerVpcOutput(v **PeerVpcOutput, value interface{}) error {
39901 if v == nil {
39902 return fmt.Errorf("unexpected nil of type %T", v)
39903 }
39904 if value == nil {
39905 return nil
39906 }
39907
39908 shape, ok := value.(map[string]interface{})
39909 if !ok {
39910 return fmt.Errorf("unexpected JSON type %v", value)
39911 }
39912
39913 var sv *PeerVpcOutput
39914 if *v == nil {
39915 sv = &PeerVpcOutput{}
39916 } else {
39917 sv = *v
39918 }
39919
39920 for key, value := range shape {
39921 switch key {
39922 case "operation":
39923 if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
39924 return err
39925 }
39926
39927 default:
39928 _, _ = key, value
39929
39930 }
39931 }
39932 *v = sv
39933 return nil
39934 }
39935
39936 func awsAwsjson11_deserializeOpDocumentPutAlarmOutput(v **PutAlarmOutput, value interface{}) error {
39937 if v == nil {
39938 return fmt.Errorf("unexpected nil of type %T", v)
39939 }
39940 if value == nil {
39941 return nil
39942 }
39943
39944 shape, ok := value.(map[string]interface{})
39945 if !ok {
39946 return fmt.Errorf("unexpected JSON type %v", value)
39947 }
39948
39949 var sv *PutAlarmOutput
39950 if *v == nil {
39951 sv = &PutAlarmOutput{}
39952 } else {
39953 sv = *v
39954 }
39955
39956 for key, value := range shape {
39957 switch key {
39958 case "operations":
39959 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
39960 return err
39961 }
39962
39963 default:
39964 _, _ = key, value
39965
39966 }
39967 }
39968 *v = sv
39969 return nil
39970 }
39971
39972 func awsAwsjson11_deserializeOpDocumentPutInstancePublicPortsOutput(v **PutInstancePublicPortsOutput, value interface{}) error {
39973 if v == nil {
39974 return fmt.Errorf("unexpected nil of type %T", v)
39975 }
39976 if value == nil {
39977 return nil
39978 }
39979
39980 shape, ok := value.(map[string]interface{})
39981 if !ok {
39982 return fmt.Errorf("unexpected JSON type %v", value)
39983 }
39984
39985 var sv *PutInstancePublicPortsOutput
39986 if *v == nil {
39987 sv = &PutInstancePublicPortsOutput{}
39988 } else {
39989 sv = *v
39990 }
39991
39992 for key, value := range shape {
39993 switch key {
39994 case "operation":
39995 if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
39996 return err
39997 }
39998
39999 default:
40000 _, _ = key, value
40001
40002 }
40003 }
40004 *v = sv
40005 return nil
40006 }
40007
40008 func awsAwsjson11_deserializeOpDocumentRebootInstanceOutput(v **RebootInstanceOutput, value interface{}) error {
40009 if v == nil {
40010 return fmt.Errorf("unexpected nil of type %T", v)
40011 }
40012 if value == nil {
40013 return nil
40014 }
40015
40016 shape, ok := value.(map[string]interface{})
40017 if !ok {
40018 return fmt.Errorf("unexpected JSON type %v", value)
40019 }
40020
40021 var sv *RebootInstanceOutput
40022 if *v == nil {
40023 sv = &RebootInstanceOutput{}
40024 } else {
40025 sv = *v
40026 }
40027
40028 for key, value := range shape {
40029 switch key {
40030 case "operations":
40031 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
40032 return err
40033 }
40034
40035 default:
40036 _, _ = key, value
40037
40038 }
40039 }
40040 *v = sv
40041 return nil
40042 }
40043
40044 func awsAwsjson11_deserializeOpDocumentRebootRelationalDatabaseOutput(v **RebootRelationalDatabaseOutput, value interface{}) error {
40045 if v == nil {
40046 return fmt.Errorf("unexpected nil of type %T", v)
40047 }
40048 if value == nil {
40049 return nil
40050 }
40051
40052 shape, ok := value.(map[string]interface{})
40053 if !ok {
40054 return fmt.Errorf("unexpected JSON type %v", value)
40055 }
40056
40057 var sv *RebootRelationalDatabaseOutput
40058 if *v == nil {
40059 sv = &RebootRelationalDatabaseOutput{}
40060 } else {
40061 sv = *v
40062 }
40063
40064 for key, value := range shape {
40065 switch key {
40066 case "operations":
40067 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
40068 return err
40069 }
40070
40071 default:
40072 _, _ = key, value
40073
40074 }
40075 }
40076 *v = sv
40077 return nil
40078 }
40079
40080 func awsAwsjson11_deserializeOpDocumentRegisterContainerImageOutput(v **RegisterContainerImageOutput, value interface{}) error {
40081 if v == nil {
40082 return fmt.Errorf("unexpected nil of type %T", v)
40083 }
40084 if value == nil {
40085 return nil
40086 }
40087
40088 shape, ok := value.(map[string]interface{})
40089 if !ok {
40090 return fmt.Errorf("unexpected JSON type %v", value)
40091 }
40092
40093 var sv *RegisterContainerImageOutput
40094 if *v == nil {
40095 sv = &RegisterContainerImageOutput{}
40096 } else {
40097 sv = *v
40098 }
40099
40100 for key, value := range shape {
40101 switch key {
40102 case "containerImage":
40103 if err := awsAwsjson11_deserializeDocumentContainerImage(&sv.ContainerImage, value); err != nil {
40104 return err
40105 }
40106
40107 default:
40108 _, _ = key, value
40109
40110 }
40111 }
40112 *v = sv
40113 return nil
40114 }
40115
40116 func awsAwsjson11_deserializeOpDocumentReleaseStaticIpOutput(v **ReleaseStaticIpOutput, value interface{}) error {
40117 if v == nil {
40118 return fmt.Errorf("unexpected nil of type %T", v)
40119 }
40120 if value == nil {
40121 return nil
40122 }
40123
40124 shape, ok := value.(map[string]interface{})
40125 if !ok {
40126 return fmt.Errorf("unexpected JSON type %v", value)
40127 }
40128
40129 var sv *ReleaseStaticIpOutput
40130 if *v == nil {
40131 sv = &ReleaseStaticIpOutput{}
40132 } else {
40133 sv = *v
40134 }
40135
40136 for key, value := range shape {
40137 switch key {
40138 case "operations":
40139 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
40140 return err
40141 }
40142
40143 default:
40144 _, _ = key, value
40145
40146 }
40147 }
40148 *v = sv
40149 return nil
40150 }
40151
40152 func awsAwsjson11_deserializeOpDocumentResetDistributionCacheOutput(v **ResetDistributionCacheOutput, value interface{}) error {
40153 if v == nil {
40154 return fmt.Errorf("unexpected nil of type %T", v)
40155 }
40156 if value == nil {
40157 return nil
40158 }
40159
40160 shape, ok := value.(map[string]interface{})
40161 if !ok {
40162 return fmt.Errorf("unexpected JSON type %v", value)
40163 }
40164
40165 var sv *ResetDistributionCacheOutput
40166 if *v == nil {
40167 sv = &ResetDistributionCacheOutput{}
40168 } else {
40169 sv = *v
40170 }
40171
40172 for key, value := range shape {
40173 switch key {
40174 case "createTime":
40175 if value != nil {
40176 switch jtv := value.(type) {
40177 case json.Number:
40178 f64, err := jtv.Float64()
40179 if err != nil {
40180 return err
40181 }
40182 sv.CreateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
40183
40184 default:
40185 return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
40186
40187 }
40188 }
40189
40190 case "operation":
40191 if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
40192 return err
40193 }
40194
40195 case "status":
40196 if value != nil {
40197 jtv, ok := value.(string)
40198 if !ok {
40199 return fmt.Errorf("expected string to be of type string, got %T instead", value)
40200 }
40201 sv.Status = ptr.String(jtv)
40202 }
40203
40204 default:
40205 _, _ = key, value
40206
40207 }
40208 }
40209 *v = sv
40210 return nil
40211 }
40212
40213 func awsAwsjson11_deserializeOpDocumentSendContactMethodVerificationOutput(v **SendContactMethodVerificationOutput, value interface{}) error {
40214 if v == nil {
40215 return fmt.Errorf("unexpected nil of type %T", v)
40216 }
40217 if value == nil {
40218 return nil
40219 }
40220
40221 shape, ok := value.(map[string]interface{})
40222 if !ok {
40223 return fmt.Errorf("unexpected JSON type %v", value)
40224 }
40225
40226 var sv *SendContactMethodVerificationOutput
40227 if *v == nil {
40228 sv = &SendContactMethodVerificationOutput{}
40229 } else {
40230 sv = *v
40231 }
40232
40233 for key, value := range shape {
40234 switch key {
40235 case "operations":
40236 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
40237 return err
40238 }
40239
40240 default:
40241 _, _ = key, value
40242
40243 }
40244 }
40245 *v = sv
40246 return nil
40247 }
40248
40249 func awsAwsjson11_deserializeOpDocumentSetIpAddressTypeOutput(v **SetIpAddressTypeOutput, value interface{}) error {
40250 if v == nil {
40251 return fmt.Errorf("unexpected nil of type %T", v)
40252 }
40253 if value == nil {
40254 return nil
40255 }
40256
40257 shape, ok := value.(map[string]interface{})
40258 if !ok {
40259 return fmt.Errorf("unexpected JSON type %v", value)
40260 }
40261
40262 var sv *SetIpAddressTypeOutput
40263 if *v == nil {
40264 sv = &SetIpAddressTypeOutput{}
40265 } else {
40266 sv = *v
40267 }
40268
40269 for key, value := range shape {
40270 switch key {
40271 case "operations":
40272 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
40273 return err
40274 }
40275
40276 default:
40277 _, _ = key, value
40278
40279 }
40280 }
40281 *v = sv
40282 return nil
40283 }
40284
40285 func awsAwsjson11_deserializeOpDocumentSetResourceAccessForBucketOutput(v **SetResourceAccessForBucketOutput, value interface{}) error {
40286 if v == nil {
40287 return fmt.Errorf("unexpected nil of type %T", v)
40288 }
40289 if value == nil {
40290 return nil
40291 }
40292
40293 shape, ok := value.(map[string]interface{})
40294 if !ok {
40295 return fmt.Errorf("unexpected JSON type %v", value)
40296 }
40297
40298 var sv *SetResourceAccessForBucketOutput
40299 if *v == nil {
40300 sv = &SetResourceAccessForBucketOutput{}
40301 } else {
40302 sv = *v
40303 }
40304
40305 for key, value := range shape {
40306 switch key {
40307 case "operations":
40308 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
40309 return err
40310 }
40311
40312 default:
40313 _, _ = key, value
40314
40315 }
40316 }
40317 *v = sv
40318 return nil
40319 }
40320
40321 func awsAwsjson11_deserializeOpDocumentSetupInstanceHttpsOutput(v **SetupInstanceHttpsOutput, value interface{}) error {
40322 if v == nil {
40323 return fmt.Errorf("unexpected nil of type %T", v)
40324 }
40325 if value == nil {
40326 return nil
40327 }
40328
40329 shape, ok := value.(map[string]interface{})
40330 if !ok {
40331 return fmt.Errorf("unexpected JSON type %v", value)
40332 }
40333
40334 var sv *SetupInstanceHttpsOutput
40335 if *v == nil {
40336 sv = &SetupInstanceHttpsOutput{}
40337 } else {
40338 sv = *v
40339 }
40340
40341 for key, value := range shape {
40342 switch key {
40343 case "operations":
40344 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
40345 return err
40346 }
40347
40348 default:
40349 _, _ = key, value
40350
40351 }
40352 }
40353 *v = sv
40354 return nil
40355 }
40356
40357 func awsAwsjson11_deserializeOpDocumentStartGUISessionOutput(v **StartGUISessionOutput, value interface{}) error {
40358 if v == nil {
40359 return fmt.Errorf("unexpected nil of type %T", v)
40360 }
40361 if value == nil {
40362 return nil
40363 }
40364
40365 shape, ok := value.(map[string]interface{})
40366 if !ok {
40367 return fmt.Errorf("unexpected JSON type %v", value)
40368 }
40369
40370 var sv *StartGUISessionOutput
40371 if *v == nil {
40372 sv = &StartGUISessionOutput{}
40373 } else {
40374 sv = *v
40375 }
40376
40377 for key, value := range shape {
40378 switch key {
40379 case "operations":
40380 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
40381 return err
40382 }
40383
40384 default:
40385 _, _ = key, value
40386
40387 }
40388 }
40389 *v = sv
40390 return nil
40391 }
40392
40393 func awsAwsjson11_deserializeOpDocumentStartInstanceOutput(v **StartInstanceOutput, value interface{}) error {
40394 if v == nil {
40395 return fmt.Errorf("unexpected nil of type %T", v)
40396 }
40397 if value == nil {
40398 return nil
40399 }
40400
40401 shape, ok := value.(map[string]interface{})
40402 if !ok {
40403 return fmt.Errorf("unexpected JSON type %v", value)
40404 }
40405
40406 var sv *StartInstanceOutput
40407 if *v == nil {
40408 sv = &StartInstanceOutput{}
40409 } else {
40410 sv = *v
40411 }
40412
40413 for key, value := range shape {
40414 switch key {
40415 case "operations":
40416 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
40417 return err
40418 }
40419
40420 default:
40421 _, _ = key, value
40422
40423 }
40424 }
40425 *v = sv
40426 return nil
40427 }
40428
40429 func awsAwsjson11_deserializeOpDocumentStartRelationalDatabaseOutput(v **StartRelationalDatabaseOutput, value interface{}) error {
40430 if v == nil {
40431 return fmt.Errorf("unexpected nil of type %T", v)
40432 }
40433 if value == nil {
40434 return nil
40435 }
40436
40437 shape, ok := value.(map[string]interface{})
40438 if !ok {
40439 return fmt.Errorf("unexpected JSON type %v", value)
40440 }
40441
40442 var sv *StartRelationalDatabaseOutput
40443 if *v == nil {
40444 sv = &StartRelationalDatabaseOutput{}
40445 } else {
40446 sv = *v
40447 }
40448
40449 for key, value := range shape {
40450 switch key {
40451 case "operations":
40452 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
40453 return err
40454 }
40455
40456 default:
40457 _, _ = key, value
40458
40459 }
40460 }
40461 *v = sv
40462 return nil
40463 }
40464
40465 func awsAwsjson11_deserializeOpDocumentStopGUISessionOutput(v **StopGUISessionOutput, value interface{}) error {
40466 if v == nil {
40467 return fmt.Errorf("unexpected nil of type %T", v)
40468 }
40469 if value == nil {
40470 return nil
40471 }
40472
40473 shape, ok := value.(map[string]interface{})
40474 if !ok {
40475 return fmt.Errorf("unexpected JSON type %v", value)
40476 }
40477
40478 var sv *StopGUISessionOutput
40479 if *v == nil {
40480 sv = &StopGUISessionOutput{}
40481 } else {
40482 sv = *v
40483 }
40484
40485 for key, value := range shape {
40486 switch key {
40487 case "operations":
40488 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
40489 return err
40490 }
40491
40492 default:
40493 _, _ = key, value
40494
40495 }
40496 }
40497 *v = sv
40498 return nil
40499 }
40500
40501 func awsAwsjson11_deserializeOpDocumentStopInstanceOutput(v **StopInstanceOutput, value interface{}) error {
40502 if v == nil {
40503 return fmt.Errorf("unexpected nil of type %T", v)
40504 }
40505 if value == nil {
40506 return nil
40507 }
40508
40509 shape, ok := value.(map[string]interface{})
40510 if !ok {
40511 return fmt.Errorf("unexpected JSON type %v", value)
40512 }
40513
40514 var sv *StopInstanceOutput
40515 if *v == nil {
40516 sv = &StopInstanceOutput{}
40517 } else {
40518 sv = *v
40519 }
40520
40521 for key, value := range shape {
40522 switch key {
40523 case "operations":
40524 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
40525 return err
40526 }
40527
40528 default:
40529 _, _ = key, value
40530
40531 }
40532 }
40533 *v = sv
40534 return nil
40535 }
40536
40537 func awsAwsjson11_deserializeOpDocumentStopRelationalDatabaseOutput(v **StopRelationalDatabaseOutput, value interface{}) error {
40538 if v == nil {
40539 return fmt.Errorf("unexpected nil of type %T", v)
40540 }
40541 if value == nil {
40542 return nil
40543 }
40544
40545 shape, ok := value.(map[string]interface{})
40546 if !ok {
40547 return fmt.Errorf("unexpected JSON type %v", value)
40548 }
40549
40550 var sv *StopRelationalDatabaseOutput
40551 if *v == nil {
40552 sv = &StopRelationalDatabaseOutput{}
40553 } else {
40554 sv = *v
40555 }
40556
40557 for key, value := range shape {
40558 switch key {
40559 case "operations":
40560 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
40561 return err
40562 }
40563
40564 default:
40565 _, _ = key, value
40566
40567 }
40568 }
40569 *v = sv
40570 return nil
40571 }
40572
40573 func awsAwsjson11_deserializeOpDocumentTagResourceOutput(v **TagResourceOutput, value interface{}) error {
40574 if v == nil {
40575 return fmt.Errorf("unexpected nil of type %T", v)
40576 }
40577 if value == nil {
40578 return nil
40579 }
40580
40581 shape, ok := value.(map[string]interface{})
40582 if !ok {
40583 return fmt.Errorf("unexpected JSON type %v", value)
40584 }
40585
40586 var sv *TagResourceOutput
40587 if *v == nil {
40588 sv = &TagResourceOutput{}
40589 } else {
40590 sv = *v
40591 }
40592
40593 for key, value := range shape {
40594 switch key {
40595 case "operations":
40596 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
40597 return err
40598 }
40599
40600 default:
40601 _, _ = key, value
40602
40603 }
40604 }
40605 *v = sv
40606 return nil
40607 }
40608
40609 func awsAwsjson11_deserializeOpDocumentTestAlarmOutput(v **TestAlarmOutput, value interface{}) error {
40610 if v == nil {
40611 return fmt.Errorf("unexpected nil of type %T", v)
40612 }
40613 if value == nil {
40614 return nil
40615 }
40616
40617 shape, ok := value.(map[string]interface{})
40618 if !ok {
40619 return fmt.Errorf("unexpected JSON type %v", value)
40620 }
40621
40622 var sv *TestAlarmOutput
40623 if *v == nil {
40624 sv = &TestAlarmOutput{}
40625 } else {
40626 sv = *v
40627 }
40628
40629 for key, value := range shape {
40630 switch key {
40631 case "operations":
40632 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
40633 return err
40634 }
40635
40636 default:
40637 _, _ = key, value
40638
40639 }
40640 }
40641 *v = sv
40642 return nil
40643 }
40644
40645 func awsAwsjson11_deserializeOpDocumentUnpeerVpcOutput(v **UnpeerVpcOutput, value interface{}) error {
40646 if v == nil {
40647 return fmt.Errorf("unexpected nil of type %T", v)
40648 }
40649 if value == nil {
40650 return nil
40651 }
40652
40653 shape, ok := value.(map[string]interface{})
40654 if !ok {
40655 return fmt.Errorf("unexpected JSON type %v", value)
40656 }
40657
40658 var sv *UnpeerVpcOutput
40659 if *v == nil {
40660 sv = &UnpeerVpcOutput{}
40661 } else {
40662 sv = *v
40663 }
40664
40665 for key, value := range shape {
40666 switch key {
40667 case "operation":
40668 if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
40669 return err
40670 }
40671
40672 default:
40673 _, _ = key, value
40674
40675 }
40676 }
40677 *v = sv
40678 return nil
40679 }
40680
40681 func awsAwsjson11_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutput, value interface{}) error {
40682 if v == nil {
40683 return fmt.Errorf("unexpected nil of type %T", v)
40684 }
40685 if value == nil {
40686 return nil
40687 }
40688
40689 shape, ok := value.(map[string]interface{})
40690 if !ok {
40691 return fmt.Errorf("unexpected JSON type %v", value)
40692 }
40693
40694 var sv *UntagResourceOutput
40695 if *v == nil {
40696 sv = &UntagResourceOutput{}
40697 } else {
40698 sv = *v
40699 }
40700
40701 for key, value := range shape {
40702 switch key {
40703 case "operations":
40704 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
40705 return err
40706 }
40707
40708 default:
40709 _, _ = key, value
40710
40711 }
40712 }
40713 *v = sv
40714 return nil
40715 }
40716
40717 func awsAwsjson11_deserializeOpDocumentUpdateBucketBundleOutput(v **UpdateBucketBundleOutput, value interface{}) error {
40718 if v == nil {
40719 return fmt.Errorf("unexpected nil of type %T", v)
40720 }
40721 if value == nil {
40722 return nil
40723 }
40724
40725 shape, ok := value.(map[string]interface{})
40726 if !ok {
40727 return fmt.Errorf("unexpected JSON type %v", value)
40728 }
40729
40730 var sv *UpdateBucketBundleOutput
40731 if *v == nil {
40732 sv = &UpdateBucketBundleOutput{}
40733 } else {
40734 sv = *v
40735 }
40736
40737 for key, value := range shape {
40738 switch key {
40739 case "operations":
40740 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
40741 return err
40742 }
40743
40744 default:
40745 _, _ = key, value
40746
40747 }
40748 }
40749 *v = sv
40750 return nil
40751 }
40752
40753 func awsAwsjson11_deserializeOpDocumentUpdateBucketOutput(v **UpdateBucketOutput, value interface{}) error {
40754 if v == nil {
40755 return fmt.Errorf("unexpected nil of type %T", v)
40756 }
40757 if value == nil {
40758 return nil
40759 }
40760
40761 shape, ok := value.(map[string]interface{})
40762 if !ok {
40763 return fmt.Errorf("unexpected JSON type %v", value)
40764 }
40765
40766 var sv *UpdateBucketOutput
40767 if *v == nil {
40768 sv = &UpdateBucketOutput{}
40769 } else {
40770 sv = *v
40771 }
40772
40773 for key, value := range shape {
40774 switch key {
40775 case "bucket":
40776 if err := awsAwsjson11_deserializeDocumentBucket(&sv.Bucket, value); err != nil {
40777 return err
40778 }
40779
40780 case "operations":
40781 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
40782 return err
40783 }
40784
40785 default:
40786 _, _ = key, value
40787
40788 }
40789 }
40790 *v = sv
40791 return nil
40792 }
40793
40794 func awsAwsjson11_deserializeOpDocumentUpdateContainerServiceOutput(v **UpdateContainerServiceOutput, value interface{}) error {
40795 if v == nil {
40796 return fmt.Errorf("unexpected nil of type %T", v)
40797 }
40798 if value == nil {
40799 return nil
40800 }
40801
40802 shape, ok := value.(map[string]interface{})
40803 if !ok {
40804 return fmt.Errorf("unexpected JSON type %v", value)
40805 }
40806
40807 var sv *UpdateContainerServiceOutput
40808 if *v == nil {
40809 sv = &UpdateContainerServiceOutput{}
40810 } else {
40811 sv = *v
40812 }
40813
40814 for key, value := range shape {
40815 switch key {
40816 case "containerService":
40817 if err := awsAwsjson11_deserializeDocumentContainerService(&sv.ContainerService, value); err != nil {
40818 return err
40819 }
40820
40821 default:
40822 _, _ = key, value
40823
40824 }
40825 }
40826 *v = sv
40827 return nil
40828 }
40829
40830 func awsAwsjson11_deserializeOpDocumentUpdateDistributionBundleOutput(v **UpdateDistributionBundleOutput, value interface{}) error {
40831 if v == nil {
40832 return fmt.Errorf("unexpected nil of type %T", v)
40833 }
40834 if value == nil {
40835 return nil
40836 }
40837
40838 shape, ok := value.(map[string]interface{})
40839 if !ok {
40840 return fmt.Errorf("unexpected JSON type %v", value)
40841 }
40842
40843 var sv *UpdateDistributionBundleOutput
40844 if *v == nil {
40845 sv = &UpdateDistributionBundleOutput{}
40846 } else {
40847 sv = *v
40848 }
40849
40850 for key, value := range shape {
40851 switch key {
40852 case "operation":
40853 if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
40854 return err
40855 }
40856
40857 default:
40858 _, _ = key, value
40859
40860 }
40861 }
40862 *v = sv
40863 return nil
40864 }
40865
40866 func awsAwsjson11_deserializeOpDocumentUpdateDistributionOutput(v **UpdateDistributionOutput, value interface{}) error {
40867 if v == nil {
40868 return fmt.Errorf("unexpected nil of type %T", v)
40869 }
40870 if value == nil {
40871 return nil
40872 }
40873
40874 shape, ok := value.(map[string]interface{})
40875 if !ok {
40876 return fmt.Errorf("unexpected JSON type %v", value)
40877 }
40878
40879 var sv *UpdateDistributionOutput
40880 if *v == nil {
40881 sv = &UpdateDistributionOutput{}
40882 } else {
40883 sv = *v
40884 }
40885
40886 for key, value := range shape {
40887 switch key {
40888 case "operation":
40889 if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
40890 return err
40891 }
40892
40893 default:
40894 _, _ = key, value
40895
40896 }
40897 }
40898 *v = sv
40899 return nil
40900 }
40901
40902 func awsAwsjson11_deserializeOpDocumentUpdateDomainEntryOutput(v **UpdateDomainEntryOutput, value interface{}) error {
40903 if v == nil {
40904 return fmt.Errorf("unexpected nil of type %T", v)
40905 }
40906 if value == nil {
40907 return nil
40908 }
40909
40910 shape, ok := value.(map[string]interface{})
40911 if !ok {
40912 return fmt.Errorf("unexpected JSON type %v", value)
40913 }
40914
40915 var sv *UpdateDomainEntryOutput
40916 if *v == nil {
40917 sv = &UpdateDomainEntryOutput{}
40918 } else {
40919 sv = *v
40920 }
40921
40922 for key, value := range shape {
40923 switch key {
40924 case "operations":
40925 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
40926 return err
40927 }
40928
40929 default:
40930 _, _ = key, value
40931
40932 }
40933 }
40934 *v = sv
40935 return nil
40936 }
40937
40938 func awsAwsjson11_deserializeOpDocumentUpdateInstanceMetadataOptionsOutput(v **UpdateInstanceMetadataOptionsOutput, value interface{}) error {
40939 if v == nil {
40940 return fmt.Errorf("unexpected nil of type %T", v)
40941 }
40942 if value == nil {
40943 return nil
40944 }
40945
40946 shape, ok := value.(map[string]interface{})
40947 if !ok {
40948 return fmt.Errorf("unexpected JSON type %v", value)
40949 }
40950
40951 var sv *UpdateInstanceMetadataOptionsOutput
40952 if *v == nil {
40953 sv = &UpdateInstanceMetadataOptionsOutput{}
40954 } else {
40955 sv = *v
40956 }
40957
40958 for key, value := range shape {
40959 switch key {
40960 case "operation":
40961 if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
40962 return err
40963 }
40964
40965 default:
40966 _, _ = key, value
40967
40968 }
40969 }
40970 *v = sv
40971 return nil
40972 }
40973
40974 func awsAwsjson11_deserializeOpDocumentUpdateLoadBalancerAttributeOutput(v **UpdateLoadBalancerAttributeOutput, value interface{}) error {
40975 if v == nil {
40976 return fmt.Errorf("unexpected nil of type %T", v)
40977 }
40978 if value == nil {
40979 return nil
40980 }
40981
40982 shape, ok := value.(map[string]interface{})
40983 if !ok {
40984 return fmt.Errorf("unexpected JSON type %v", value)
40985 }
40986
40987 var sv *UpdateLoadBalancerAttributeOutput
40988 if *v == nil {
40989 sv = &UpdateLoadBalancerAttributeOutput{}
40990 } else {
40991 sv = *v
40992 }
40993
40994 for key, value := range shape {
40995 switch key {
40996 case "operations":
40997 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
40998 return err
40999 }
41000
41001 default:
41002 _, _ = key, value
41003
41004 }
41005 }
41006 *v = sv
41007 return nil
41008 }
41009
41010 func awsAwsjson11_deserializeOpDocumentUpdateRelationalDatabaseOutput(v **UpdateRelationalDatabaseOutput, value interface{}) error {
41011 if v == nil {
41012 return fmt.Errorf("unexpected nil of type %T", v)
41013 }
41014 if value == nil {
41015 return nil
41016 }
41017
41018 shape, ok := value.(map[string]interface{})
41019 if !ok {
41020 return fmt.Errorf("unexpected JSON type %v", value)
41021 }
41022
41023 var sv *UpdateRelationalDatabaseOutput
41024 if *v == nil {
41025 sv = &UpdateRelationalDatabaseOutput{}
41026 } else {
41027 sv = *v
41028 }
41029
41030 for key, value := range shape {
41031 switch key {
41032 case "operations":
41033 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
41034 return err
41035 }
41036
41037 default:
41038 _, _ = key, value
41039
41040 }
41041 }
41042 *v = sv
41043 return nil
41044 }
41045
41046 func awsAwsjson11_deserializeOpDocumentUpdateRelationalDatabaseParametersOutput(v **UpdateRelationalDatabaseParametersOutput, value interface{}) error {
41047 if v == nil {
41048 return fmt.Errorf("unexpected nil of type %T", v)
41049 }
41050 if value == nil {
41051 return nil
41052 }
41053
41054 shape, ok := value.(map[string]interface{})
41055 if !ok {
41056 return fmt.Errorf("unexpected JSON type %v", value)
41057 }
41058
41059 var sv *UpdateRelationalDatabaseParametersOutput
41060 if *v == nil {
41061 sv = &UpdateRelationalDatabaseParametersOutput{}
41062 } else {
41063 sv = *v
41064 }
41065
41066 for key, value := range shape {
41067 switch key {
41068 case "operations":
41069 if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
41070 return err
41071 }
41072
41073 default:
41074 _, _ = key, value
41075
41076 }
41077 }
41078 *v = sv
41079 return nil
41080 }
41081
41082 type protocolErrorInfo struct {
41083 Type string `json:"__type"`
41084 Message string
41085 Code any // nonstandard for awsjson but some services do present the type here
41086 }
41087
41088 func getProtocolErrorInfo(decoder *json.Decoder) (protocolErrorInfo, error) {
41089 var errInfo protocolErrorInfo
41090 if err := decoder.Decode(&errInfo); err != nil {
41091 if err == io.EOF {
41092 return errInfo, nil
41093 }
41094 return errInfo, err
41095 }
41096
41097 return errInfo, nil
41098 }
41099
41100 func resolveProtocolErrorType(headerType string, bodyInfo protocolErrorInfo) (string, bool) {
41101 if len(headerType) != 0 {
41102 return headerType, true
41103 } else if len(bodyInfo.Type) != 0 {
41104 return bodyInfo.Type, true
41105 } else if code, ok := bodyInfo.Code.(string); ok && len(code) != 0 {
41106 return code, true
41107 }
41108 return "", false
41109 }
41110