1
2
3 package ecr
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/ecr/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 smithyhttp "github.com/aws/smithy-go/transport/http"
18 "io"
19 "math"
20 "strings"
21 )
22
23 type awsAwsjson11_deserializeOpBatchCheckLayerAvailability struct {
24 }
25
26 func (*awsAwsjson11_deserializeOpBatchCheckLayerAvailability) ID() string {
27 return "OperationDeserializer"
28 }
29
30 func (m *awsAwsjson11_deserializeOpBatchCheckLayerAvailability) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
31 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
32 ) {
33 out, metadata, err = next.HandleDeserialize(ctx, in)
34 if err != nil {
35 return out, metadata, err
36 }
37
38 response, ok := out.RawResponse.(*smithyhttp.Response)
39 if !ok {
40 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
41 }
42
43 if response.StatusCode < 200 || response.StatusCode >= 300 {
44 return out, metadata, awsAwsjson11_deserializeOpErrorBatchCheckLayerAvailability(response, &metadata)
45 }
46 output := &BatchCheckLayerAvailabilityOutput{}
47 out.Result = output
48
49 var buff [1024]byte
50 ringBuffer := smithyio.NewRingBuffer(buff[:])
51
52 body := io.TeeReader(response.Body, ringBuffer)
53 decoder := json.NewDecoder(body)
54 decoder.UseNumber()
55 var shape interface{}
56 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
57 var snapshot bytes.Buffer
58 io.Copy(&snapshot, ringBuffer)
59 err = &smithy.DeserializationError{
60 Err: fmt.Errorf("failed to decode response body, %w", err),
61 Snapshot: snapshot.Bytes(),
62 }
63 return out, metadata, err
64 }
65
66 err = awsAwsjson11_deserializeOpDocumentBatchCheckLayerAvailabilityOutput(&output, shape)
67 if err != nil {
68 var snapshot bytes.Buffer
69 io.Copy(&snapshot, ringBuffer)
70 err = &smithy.DeserializationError{
71 Err: fmt.Errorf("failed to decode response body, %w", err),
72 Snapshot: snapshot.Bytes(),
73 }
74 return out, metadata, err
75 }
76
77 return out, metadata, err
78 }
79
80 func awsAwsjson11_deserializeOpErrorBatchCheckLayerAvailability(response *smithyhttp.Response, metadata *middleware.Metadata) error {
81 var errorBuffer bytes.Buffer
82 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
83 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
84 }
85 errorBody := bytes.NewReader(errorBuffer.Bytes())
86
87 errorCode := "UnknownError"
88 errorMessage := errorCode
89
90 headerCode := response.Header.Get("X-Amzn-ErrorType")
91 if len(headerCode) != 0 {
92 errorCode = restjson.SanitizeErrorCode(headerCode)
93 }
94
95 var buff [1024]byte
96 ringBuffer := smithyio.NewRingBuffer(buff[:])
97
98 body := io.TeeReader(errorBody, ringBuffer)
99 decoder := json.NewDecoder(body)
100 decoder.UseNumber()
101 jsonCode, message, err := restjson.GetErrorInfo(decoder)
102 if err != nil {
103 var snapshot bytes.Buffer
104 io.Copy(&snapshot, ringBuffer)
105 err = &smithy.DeserializationError{
106 Err: fmt.Errorf("failed to decode response body, %w", err),
107 Snapshot: snapshot.Bytes(),
108 }
109 return err
110 }
111
112 errorBody.Seek(0, io.SeekStart)
113 if len(headerCode) == 0 && len(jsonCode) != 0 {
114 errorCode = restjson.SanitizeErrorCode(jsonCode)
115 }
116 if len(message) != 0 {
117 errorMessage = message
118 }
119
120 switch {
121 case strings.EqualFold("InvalidParameterException", errorCode):
122 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
123
124 case strings.EqualFold("RepositoryNotFoundException", errorCode):
125 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
126
127 case strings.EqualFold("ServerException", errorCode):
128 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
129
130 default:
131 genericError := &smithy.GenericAPIError{
132 Code: errorCode,
133 Message: errorMessage,
134 }
135 return genericError
136
137 }
138 }
139
140 type awsAwsjson11_deserializeOpBatchDeleteImage struct {
141 }
142
143 func (*awsAwsjson11_deserializeOpBatchDeleteImage) ID() string {
144 return "OperationDeserializer"
145 }
146
147 func (m *awsAwsjson11_deserializeOpBatchDeleteImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
148 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
149 ) {
150 out, metadata, err = next.HandleDeserialize(ctx, in)
151 if err != nil {
152 return out, metadata, err
153 }
154
155 response, ok := out.RawResponse.(*smithyhttp.Response)
156 if !ok {
157 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
158 }
159
160 if response.StatusCode < 200 || response.StatusCode >= 300 {
161 return out, metadata, awsAwsjson11_deserializeOpErrorBatchDeleteImage(response, &metadata)
162 }
163 output := &BatchDeleteImageOutput{}
164 out.Result = output
165
166 var buff [1024]byte
167 ringBuffer := smithyio.NewRingBuffer(buff[:])
168
169 body := io.TeeReader(response.Body, ringBuffer)
170 decoder := json.NewDecoder(body)
171 decoder.UseNumber()
172 var shape interface{}
173 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
174 var snapshot bytes.Buffer
175 io.Copy(&snapshot, ringBuffer)
176 err = &smithy.DeserializationError{
177 Err: fmt.Errorf("failed to decode response body, %w", err),
178 Snapshot: snapshot.Bytes(),
179 }
180 return out, metadata, err
181 }
182
183 err = awsAwsjson11_deserializeOpDocumentBatchDeleteImageOutput(&output, shape)
184 if err != nil {
185 var snapshot bytes.Buffer
186 io.Copy(&snapshot, ringBuffer)
187 err = &smithy.DeserializationError{
188 Err: fmt.Errorf("failed to decode response body, %w", err),
189 Snapshot: snapshot.Bytes(),
190 }
191 return out, metadata, err
192 }
193
194 return out, metadata, err
195 }
196
197 func awsAwsjson11_deserializeOpErrorBatchDeleteImage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
198 var errorBuffer bytes.Buffer
199 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
200 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
201 }
202 errorBody := bytes.NewReader(errorBuffer.Bytes())
203
204 errorCode := "UnknownError"
205 errorMessage := errorCode
206
207 headerCode := response.Header.Get("X-Amzn-ErrorType")
208 if len(headerCode) != 0 {
209 errorCode = restjson.SanitizeErrorCode(headerCode)
210 }
211
212 var buff [1024]byte
213 ringBuffer := smithyio.NewRingBuffer(buff[:])
214
215 body := io.TeeReader(errorBody, ringBuffer)
216 decoder := json.NewDecoder(body)
217 decoder.UseNumber()
218 jsonCode, message, err := restjson.GetErrorInfo(decoder)
219 if err != nil {
220 var snapshot bytes.Buffer
221 io.Copy(&snapshot, ringBuffer)
222 err = &smithy.DeserializationError{
223 Err: fmt.Errorf("failed to decode response body, %w", err),
224 Snapshot: snapshot.Bytes(),
225 }
226 return err
227 }
228
229 errorBody.Seek(0, io.SeekStart)
230 if len(headerCode) == 0 && len(jsonCode) != 0 {
231 errorCode = restjson.SanitizeErrorCode(jsonCode)
232 }
233 if len(message) != 0 {
234 errorMessage = message
235 }
236
237 switch {
238 case strings.EqualFold("InvalidParameterException", errorCode):
239 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
240
241 case strings.EqualFold("RepositoryNotFoundException", errorCode):
242 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
243
244 case strings.EqualFold("ServerException", errorCode):
245 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
246
247 default:
248 genericError := &smithy.GenericAPIError{
249 Code: errorCode,
250 Message: errorMessage,
251 }
252 return genericError
253
254 }
255 }
256
257 type awsAwsjson11_deserializeOpBatchGetImage struct {
258 }
259
260 func (*awsAwsjson11_deserializeOpBatchGetImage) ID() string {
261 return "OperationDeserializer"
262 }
263
264 func (m *awsAwsjson11_deserializeOpBatchGetImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
265 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
266 ) {
267 out, metadata, err = next.HandleDeserialize(ctx, in)
268 if err != nil {
269 return out, metadata, err
270 }
271
272 response, ok := out.RawResponse.(*smithyhttp.Response)
273 if !ok {
274 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
275 }
276
277 if response.StatusCode < 200 || response.StatusCode >= 300 {
278 return out, metadata, awsAwsjson11_deserializeOpErrorBatchGetImage(response, &metadata)
279 }
280 output := &BatchGetImageOutput{}
281 out.Result = output
282
283 var buff [1024]byte
284 ringBuffer := smithyio.NewRingBuffer(buff[:])
285
286 body := io.TeeReader(response.Body, ringBuffer)
287 decoder := json.NewDecoder(body)
288 decoder.UseNumber()
289 var shape interface{}
290 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
291 var snapshot bytes.Buffer
292 io.Copy(&snapshot, ringBuffer)
293 err = &smithy.DeserializationError{
294 Err: fmt.Errorf("failed to decode response body, %w", err),
295 Snapshot: snapshot.Bytes(),
296 }
297 return out, metadata, err
298 }
299
300 err = awsAwsjson11_deserializeOpDocumentBatchGetImageOutput(&output, shape)
301 if err != nil {
302 var snapshot bytes.Buffer
303 io.Copy(&snapshot, ringBuffer)
304 err = &smithy.DeserializationError{
305 Err: fmt.Errorf("failed to decode response body, %w", err),
306 Snapshot: snapshot.Bytes(),
307 }
308 return out, metadata, err
309 }
310
311 return out, metadata, err
312 }
313
314 func awsAwsjson11_deserializeOpErrorBatchGetImage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
315 var errorBuffer bytes.Buffer
316 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
317 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
318 }
319 errorBody := bytes.NewReader(errorBuffer.Bytes())
320
321 errorCode := "UnknownError"
322 errorMessage := errorCode
323
324 headerCode := response.Header.Get("X-Amzn-ErrorType")
325 if len(headerCode) != 0 {
326 errorCode = restjson.SanitizeErrorCode(headerCode)
327 }
328
329 var buff [1024]byte
330 ringBuffer := smithyio.NewRingBuffer(buff[:])
331
332 body := io.TeeReader(errorBody, ringBuffer)
333 decoder := json.NewDecoder(body)
334 decoder.UseNumber()
335 jsonCode, message, err := restjson.GetErrorInfo(decoder)
336 if err != nil {
337 var snapshot bytes.Buffer
338 io.Copy(&snapshot, ringBuffer)
339 err = &smithy.DeserializationError{
340 Err: fmt.Errorf("failed to decode response body, %w", err),
341 Snapshot: snapshot.Bytes(),
342 }
343 return err
344 }
345
346 errorBody.Seek(0, io.SeekStart)
347 if len(headerCode) == 0 && len(jsonCode) != 0 {
348 errorCode = restjson.SanitizeErrorCode(jsonCode)
349 }
350 if len(message) != 0 {
351 errorMessage = message
352 }
353
354 switch {
355 case strings.EqualFold("InvalidParameterException", errorCode):
356 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
357
358 case strings.EqualFold("RepositoryNotFoundException", errorCode):
359 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
360
361 case strings.EqualFold("ServerException", errorCode):
362 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
363
364 default:
365 genericError := &smithy.GenericAPIError{
366 Code: errorCode,
367 Message: errorMessage,
368 }
369 return genericError
370
371 }
372 }
373
374 type awsAwsjson11_deserializeOpBatchGetRepositoryScanningConfiguration struct {
375 }
376
377 func (*awsAwsjson11_deserializeOpBatchGetRepositoryScanningConfiguration) ID() string {
378 return "OperationDeserializer"
379 }
380
381 func (m *awsAwsjson11_deserializeOpBatchGetRepositoryScanningConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
382 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
383 ) {
384 out, metadata, err = next.HandleDeserialize(ctx, in)
385 if err != nil {
386 return out, metadata, err
387 }
388
389 response, ok := out.RawResponse.(*smithyhttp.Response)
390 if !ok {
391 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
392 }
393
394 if response.StatusCode < 200 || response.StatusCode >= 300 {
395 return out, metadata, awsAwsjson11_deserializeOpErrorBatchGetRepositoryScanningConfiguration(response, &metadata)
396 }
397 output := &BatchGetRepositoryScanningConfigurationOutput{}
398 out.Result = output
399
400 var buff [1024]byte
401 ringBuffer := smithyio.NewRingBuffer(buff[:])
402
403 body := io.TeeReader(response.Body, ringBuffer)
404 decoder := json.NewDecoder(body)
405 decoder.UseNumber()
406 var shape interface{}
407 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
408 var snapshot bytes.Buffer
409 io.Copy(&snapshot, ringBuffer)
410 err = &smithy.DeserializationError{
411 Err: fmt.Errorf("failed to decode response body, %w", err),
412 Snapshot: snapshot.Bytes(),
413 }
414 return out, metadata, err
415 }
416
417 err = awsAwsjson11_deserializeOpDocumentBatchGetRepositoryScanningConfigurationOutput(&output, shape)
418 if err != nil {
419 var snapshot bytes.Buffer
420 io.Copy(&snapshot, ringBuffer)
421 err = &smithy.DeserializationError{
422 Err: fmt.Errorf("failed to decode response body, %w", err),
423 Snapshot: snapshot.Bytes(),
424 }
425 return out, metadata, err
426 }
427
428 return out, metadata, err
429 }
430
431 func awsAwsjson11_deserializeOpErrorBatchGetRepositoryScanningConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
432 var errorBuffer bytes.Buffer
433 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
434 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
435 }
436 errorBody := bytes.NewReader(errorBuffer.Bytes())
437
438 errorCode := "UnknownError"
439 errorMessage := errorCode
440
441 headerCode := response.Header.Get("X-Amzn-ErrorType")
442 if len(headerCode) != 0 {
443 errorCode = restjson.SanitizeErrorCode(headerCode)
444 }
445
446 var buff [1024]byte
447 ringBuffer := smithyio.NewRingBuffer(buff[:])
448
449 body := io.TeeReader(errorBody, ringBuffer)
450 decoder := json.NewDecoder(body)
451 decoder.UseNumber()
452 jsonCode, message, err := restjson.GetErrorInfo(decoder)
453 if err != nil {
454 var snapshot bytes.Buffer
455 io.Copy(&snapshot, ringBuffer)
456 err = &smithy.DeserializationError{
457 Err: fmt.Errorf("failed to decode response body, %w", err),
458 Snapshot: snapshot.Bytes(),
459 }
460 return err
461 }
462
463 errorBody.Seek(0, io.SeekStart)
464 if len(headerCode) == 0 && len(jsonCode) != 0 {
465 errorCode = restjson.SanitizeErrorCode(jsonCode)
466 }
467 if len(message) != 0 {
468 errorMessage = message
469 }
470
471 switch {
472 case strings.EqualFold("InvalidParameterException", errorCode):
473 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
474
475 case strings.EqualFold("RepositoryNotFoundException", errorCode):
476 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
477
478 case strings.EqualFold("ServerException", errorCode):
479 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
480
481 case strings.EqualFold("ValidationException", errorCode):
482 return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
483
484 default:
485 genericError := &smithy.GenericAPIError{
486 Code: errorCode,
487 Message: errorMessage,
488 }
489 return genericError
490
491 }
492 }
493
494 type awsAwsjson11_deserializeOpCompleteLayerUpload struct {
495 }
496
497 func (*awsAwsjson11_deserializeOpCompleteLayerUpload) ID() string {
498 return "OperationDeserializer"
499 }
500
501 func (m *awsAwsjson11_deserializeOpCompleteLayerUpload) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
502 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
503 ) {
504 out, metadata, err = next.HandleDeserialize(ctx, in)
505 if err != nil {
506 return out, metadata, err
507 }
508
509 response, ok := out.RawResponse.(*smithyhttp.Response)
510 if !ok {
511 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
512 }
513
514 if response.StatusCode < 200 || response.StatusCode >= 300 {
515 return out, metadata, awsAwsjson11_deserializeOpErrorCompleteLayerUpload(response, &metadata)
516 }
517 output := &CompleteLayerUploadOutput{}
518 out.Result = output
519
520 var buff [1024]byte
521 ringBuffer := smithyio.NewRingBuffer(buff[:])
522
523 body := io.TeeReader(response.Body, ringBuffer)
524 decoder := json.NewDecoder(body)
525 decoder.UseNumber()
526 var shape interface{}
527 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
528 var snapshot bytes.Buffer
529 io.Copy(&snapshot, ringBuffer)
530 err = &smithy.DeserializationError{
531 Err: fmt.Errorf("failed to decode response body, %w", err),
532 Snapshot: snapshot.Bytes(),
533 }
534 return out, metadata, err
535 }
536
537 err = awsAwsjson11_deserializeOpDocumentCompleteLayerUploadOutput(&output, shape)
538 if err != nil {
539 var snapshot bytes.Buffer
540 io.Copy(&snapshot, ringBuffer)
541 err = &smithy.DeserializationError{
542 Err: fmt.Errorf("failed to decode response body, %w", err),
543 Snapshot: snapshot.Bytes(),
544 }
545 return out, metadata, err
546 }
547
548 return out, metadata, err
549 }
550
551 func awsAwsjson11_deserializeOpErrorCompleteLayerUpload(response *smithyhttp.Response, metadata *middleware.Metadata) error {
552 var errorBuffer bytes.Buffer
553 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
554 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
555 }
556 errorBody := bytes.NewReader(errorBuffer.Bytes())
557
558 errorCode := "UnknownError"
559 errorMessage := errorCode
560
561 headerCode := response.Header.Get("X-Amzn-ErrorType")
562 if len(headerCode) != 0 {
563 errorCode = restjson.SanitizeErrorCode(headerCode)
564 }
565
566 var buff [1024]byte
567 ringBuffer := smithyio.NewRingBuffer(buff[:])
568
569 body := io.TeeReader(errorBody, ringBuffer)
570 decoder := json.NewDecoder(body)
571 decoder.UseNumber()
572 jsonCode, message, err := restjson.GetErrorInfo(decoder)
573 if err != nil {
574 var snapshot bytes.Buffer
575 io.Copy(&snapshot, ringBuffer)
576 err = &smithy.DeserializationError{
577 Err: fmt.Errorf("failed to decode response body, %w", err),
578 Snapshot: snapshot.Bytes(),
579 }
580 return err
581 }
582
583 errorBody.Seek(0, io.SeekStart)
584 if len(headerCode) == 0 && len(jsonCode) != 0 {
585 errorCode = restjson.SanitizeErrorCode(jsonCode)
586 }
587 if len(message) != 0 {
588 errorMessage = message
589 }
590
591 switch {
592 case strings.EqualFold("EmptyUploadException", errorCode):
593 return awsAwsjson11_deserializeErrorEmptyUploadException(response, errorBody)
594
595 case strings.EqualFold("InvalidLayerException", errorCode):
596 return awsAwsjson11_deserializeErrorInvalidLayerException(response, errorBody)
597
598 case strings.EqualFold("InvalidParameterException", errorCode):
599 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
600
601 case strings.EqualFold("KmsException", errorCode):
602 return awsAwsjson11_deserializeErrorKmsException(response, errorBody)
603
604 case strings.EqualFold("LayerAlreadyExistsException", errorCode):
605 return awsAwsjson11_deserializeErrorLayerAlreadyExistsException(response, errorBody)
606
607 case strings.EqualFold("LayerPartTooSmallException", errorCode):
608 return awsAwsjson11_deserializeErrorLayerPartTooSmallException(response, errorBody)
609
610 case strings.EqualFold("RepositoryNotFoundException", errorCode):
611 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
612
613 case strings.EqualFold("ServerException", errorCode):
614 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
615
616 case strings.EqualFold("UploadNotFoundException", errorCode):
617 return awsAwsjson11_deserializeErrorUploadNotFoundException(response, errorBody)
618
619 default:
620 genericError := &smithy.GenericAPIError{
621 Code: errorCode,
622 Message: errorMessage,
623 }
624 return genericError
625
626 }
627 }
628
629 type awsAwsjson11_deserializeOpCreatePullThroughCacheRule struct {
630 }
631
632 func (*awsAwsjson11_deserializeOpCreatePullThroughCacheRule) ID() string {
633 return "OperationDeserializer"
634 }
635
636 func (m *awsAwsjson11_deserializeOpCreatePullThroughCacheRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
637 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
638 ) {
639 out, metadata, err = next.HandleDeserialize(ctx, in)
640 if err != nil {
641 return out, metadata, err
642 }
643
644 response, ok := out.RawResponse.(*smithyhttp.Response)
645 if !ok {
646 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
647 }
648
649 if response.StatusCode < 200 || response.StatusCode >= 300 {
650 return out, metadata, awsAwsjson11_deserializeOpErrorCreatePullThroughCacheRule(response, &metadata)
651 }
652 output := &CreatePullThroughCacheRuleOutput{}
653 out.Result = output
654
655 var buff [1024]byte
656 ringBuffer := smithyio.NewRingBuffer(buff[:])
657
658 body := io.TeeReader(response.Body, ringBuffer)
659 decoder := json.NewDecoder(body)
660 decoder.UseNumber()
661 var shape interface{}
662 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
663 var snapshot bytes.Buffer
664 io.Copy(&snapshot, ringBuffer)
665 err = &smithy.DeserializationError{
666 Err: fmt.Errorf("failed to decode response body, %w", err),
667 Snapshot: snapshot.Bytes(),
668 }
669 return out, metadata, err
670 }
671
672 err = awsAwsjson11_deserializeOpDocumentCreatePullThroughCacheRuleOutput(&output, shape)
673 if err != nil {
674 var snapshot bytes.Buffer
675 io.Copy(&snapshot, ringBuffer)
676 err = &smithy.DeserializationError{
677 Err: fmt.Errorf("failed to decode response body, %w", err),
678 Snapshot: snapshot.Bytes(),
679 }
680 return out, metadata, err
681 }
682
683 return out, metadata, err
684 }
685
686 func awsAwsjson11_deserializeOpErrorCreatePullThroughCacheRule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
687 var errorBuffer bytes.Buffer
688 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
689 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
690 }
691 errorBody := bytes.NewReader(errorBuffer.Bytes())
692
693 errorCode := "UnknownError"
694 errorMessage := errorCode
695
696 headerCode := response.Header.Get("X-Amzn-ErrorType")
697 if len(headerCode) != 0 {
698 errorCode = restjson.SanitizeErrorCode(headerCode)
699 }
700
701 var buff [1024]byte
702 ringBuffer := smithyio.NewRingBuffer(buff[:])
703
704 body := io.TeeReader(errorBody, ringBuffer)
705 decoder := json.NewDecoder(body)
706 decoder.UseNumber()
707 jsonCode, message, err := restjson.GetErrorInfo(decoder)
708 if err != nil {
709 var snapshot bytes.Buffer
710 io.Copy(&snapshot, ringBuffer)
711 err = &smithy.DeserializationError{
712 Err: fmt.Errorf("failed to decode response body, %w", err),
713 Snapshot: snapshot.Bytes(),
714 }
715 return err
716 }
717
718 errorBody.Seek(0, io.SeekStart)
719 if len(headerCode) == 0 && len(jsonCode) != 0 {
720 errorCode = restjson.SanitizeErrorCode(jsonCode)
721 }
722 if len(message) != 0 {
723 errorMessage = message
724 }
725
726 switch {
727 case strings.EqualFold("InvalidParameterException", errorCode):
728 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
729
730 case strings.EqualFold("LimitExceededException", errorCode):
731 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
732
733 case strings.EqualFold("PullThroughCacheRuleAlreadyExistsException", errorCode):
734 return awsAwsjson11_deserializeErrorPullThroughCacheRuleAlreadyExistsException(response, errorBody)
735
736 case strings.EqualFold("ServerException", errorCode):
737 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
738
739 case strings.EqualFold("UnsupportedUpstreamRegistryException", errorCode):
740 return awsAwsjson11_deserializeErrorUnsupportedUpstreamRegistryException(response, errorBody)
741
742 case strings.EqualFold("ValidationException", errorCode):
743 return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
744
745 default:
746 genericError := &smithy.GenericAPIError{
747 Code: errorCode,
748 Message: errorMessage,
749 }
750 return genericError
751
752 }
753 }
754
755 type awsAwsjson11_deserializeOpCreateRepository struct {
756 }
757
758 func (*awsAwsjson11_deserializeOpCreateRepository) ID() string {
759 return "OperationDeserializer"
760 }
761
762 func (m *awsAwsjson11_deserializeOpCreateRepository) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
763 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
764 ) {
765 out, metadata, err = next.HandleDeserialize(ctx, in)
766 if err != nil {
767 return out, metadata, err
768 }
769
770 response, ok := out.RawResponse.(*smithyhttp.Response)
771 if !ok {
772 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
773 }
774
775 if response.StatusCode < 200 || response.StatusCode >= 300 {
776 return out, metadata, awsAwsjson11_deserializeOpErrorCreateRepository(response, &metadata)
777 }
778 output := &CreateRepositoryOutput{}
779 out.Result = output
780
781 var buff [1024]byte
782 ringBuffer := smithyio.NewRingBuffer(buff[:])
783
784 body := io.TeeReader(response.Body, ringBuffer)
785 decoder := json.NewDecoder(body)
786 decoder.UseNumber()
787 var shape interface{}
788 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
789 var snapshot bytes.Buffer
790 io.Copy(&snapshot, ringBuffer)
791 err = &smithy.DeserializationError{
792 Err: fmt.Errorf("failed to decode response body, %w", err),
793 Snapshot: snapshot.Bytes(),
794 }
795 return out, metadata, err
796 }
797
798 err = awsAwsjson11_deserializeOpDocumentCreateRepositoryOutput(&output, shape)
799 if err != nil {
800 var snapshot bytes.Buffer
801 io.Copy(&snapshot, ringBuffer)
802 err = &smithy.DeserializationError{
803 Err: fmt.Errorf("failed to decode response body, %w", err),
804 Snapshot: snapshot.Bytes(),
805 }
806 return out, metadata, err
807 }
808
809 return out, metadata, err
810 }
811
812 func awsAwsjson11_deserializeOpErrorCreateRepository(response *smithyhttp.Response, metadata *middleware.Metadata) error {
813 var errorBuffer bytes.Buffer
814 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
815 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
816 }
817 errorBody := bytes.NewReader(errorBuffer.Bytes())
818
819 errorCode := "UnknownError"
820 errorMessage := errorCode
821
822 headerCode := response.Header.Get("X-Amzn-ErrorType")
823 if len(headerCode) != 0 {
824 errorCode = restjson.SanitizeErrorCode(headerCode)
825 }
826
827 var buff [1024]byte
828 ringBuffer := smithyio.NewRingBuffer(buff[:])
829
830 body := io.TeeReader(errorBody, ringBuffer)
831 decoder := json.NewDecoder(body)
832 decoder.UseNumber()
833 jsonCode, message, err := restjson.GetErrorInfo(decoder)
834 if err != nil {
835 var snapshot bytes.Buffer
836 io.Copy(&snapshot, ringBuffer)
837 err = &smithy.DeserializationError{
838 Err: fmt.Errorf("failed to decode response body, %w", err),
839 Snapshot: snapshot.Bytes(),
840 }
841 return err
842 }
843
844 errorBody.Seek(0, io.SeekStart)
845 if len(headerCode) == 0 && len(jsonCode) != 0 {
846 errorCode = restjson.SanitizeErrorCode(jsonCode)
847 }
848 if len(message) != 0 {
849 errorMessage = message
850 }
851
852 switch {
853 case strings.EqualFold("InvalidParameterException", errorCode):
854 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
855
856 case strings.EqualFold("InvalidTagParameterException", errorCode):
857 return awsAwsjson11_deserializeErrorInvalidTagParameterException(response, errorBody)
858
859 case strings.EqualFold("KmsException", errorCode):
860 return awsAwsjson11_deserializeErrorKmsException(response, errorBody)
861
862 case strings.EqualFold("LimitExceededException", errorCode):
863 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
864
865 case strings.EqualFold("RepositoryAlreadyExistsException", errorCode):
866 return awsAwsjson11_deserializeErrorRepositoryAlreadyExistsException(response, errorBody)
867
868 case strings.EqualFold("ServerException", errorCode):
869 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
870
871 case strings.EqualFold("TooManyTagsException", errorCode):
872 return awsAwsjson11_deserializeErrorTooManyTagsException(response, errorBody)
873
874 default:
875 genericError := &smithy.GenericAPIError{
876 Code: errorCode,
877 Message: errorMessage,
878 }
879 return genericError
880
881 }
882 }
883
884 type awsAwsjson11_deserializeOpDeleteLifecyclePolicy struct {
885 }
886
887 func (*awsAwsjson11_deserializeOpDeleteLifecyclePolicy) ID() string {
888 return "OperationDeserializer"
889 }
890
891 func (m *awsAwsjson11_deserializeOpDeleteLifecyclePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
892 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
893 ) {
894 out, metadata, err = next.HandleDeserialize(ctx, in)
895 if err != nil {
896 return out, metadata, err
897 }
898
899 response, ok := out.RawResponse.(*smithyhttp.Response)
900 if !ok {
901 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
902 }
903
904 if response.StatusCode < 200 || response.StatusCode >= 300 {
905 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteLifecyclePolicy(response, &metadata)
906 }
907 output := &DeleteLifecyclePolicyOutput{}
908 out.Result = output
909
910 var buff [1024]byte
911 ringBuffer := smithyio.NewRingBuffer(buff[:])
912
913 body := io.TeeReader(response.Body, ringBuffer)
914 decoder := json.NewDecoder(body)
915 decoder.UseNumber()
916 var shape interface{}
917 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
918 var snapshot bytes.Buffer
919 io.Copy(&snapshot, ringBuffer)
920 err = &smithy.DeserializationError{
921 Err: fmt.Errorf("failed to decode response body, %w", err),
922 Snapshot: snapshot.Bytes(),
923 }
924 return out, metadata, err
925 }
926
927 err = awsAwsjson11_deserializeOpDocumentDeleteLifecyclePolicyOutput(&output, shape)
928 if err != nil {
929 var snapshot bytes.Buffer
930 io.Copy(&snapshot, ringBuffer)
931 err = &smithy.DeserializationError{
932 Err: fmt.Errorf("failed to decode response body, %w", err),
933 Snapshot: snapshot.Bytes(),
934 }
935 return out, metadata, err
936 }
937
938 return out, metadata, err
939 }
940
941 func awsAwsjson11_deserializeOpErrorDeleteLifecyclePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
942 var errorBuffer bytes.Buffer
943 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
944 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
945 }
946 errorBody := bytes.NewReader(errorBuffer.Bytes())
947
948 errorCode := "UnknownError"
949 errorMessage := errorCode
950
951 headerCode := response.Header.Get("X-Amzn-ErrorType")
952 if len(headerCode) != 0 {
953 errorCode = restjson.SanitizeErrorCode(headerCode)
954 }
955
956 var buff [1024]byte
957 ringBuffer := smithyio.NewRingBuffer(buff[:])
958
959 body := io.TeeReader(errorBody, ringBuffer)
960 decoder := json.NewDecoder(body)
961 decoder.UseNumber()
962 jsonCode, message, err := restjson.GetErrorInfo(decoder)
963 if err != nil {
964 var snapshot bytes.Buffer
965 io.Copy(&snapshot, ringBuffer)
966 err = &smithy.DeserializationError{
967 Err: fmt.Errorf("failed to decode response body, %w", err),
968 Snapshot: snapshot.Bytes(),
969 }
970 return err
971 }
972
973 errorBody.Seek(0, io.SeekStart)
974 if len(headerCode) == 0 && len(jsonCode) != 0 {
975 errorCode = restjson.SanitizeErrorCode(jsonCode)
976 }
977 if len(message) != 0 {
978 errorMessage = message
979 }
980
981 switch {
982 case strings.EqualFold("InvalidParameterException", errorCode):
983 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
984
985 case strings.EqualFold("LifecyclePolicyNotFoundException", errorCode):
986 return awsAwsjson11_deserializeErrorLifecyclePolicyNotFoundException(response, errorBody)
987
988 case strings.EqualFold("RepositoryNotFoundException", errorCode):
989 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
990
991 case strings.EqualFold("ServerException", errorCode):
992 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
993
994 case strings.EqualFold("ValidationException", errorCode):
995 return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
996
997 default:
998 genericError := &smithy.GenericAPIError{
999 Code: errorCode,
1000 Message: errorMessage,
1001 }
1002 return genericError
1003
1004 }
1005 }
1006
1007 type awsAwsjson11_deserializeOpDeletePullThroughCacheRule struct {
1008 }
1009
1010 func (*awsAwsjson11_deserializeOpDeletePullThroughCacheRule) ID() string {
1011 return "OperationDeserializer"
1012 }
1013
1014 func (m *awsAwsjson11_deserializeOpDeletePullThroughCacheRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1015 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1016 ) {
1017 out, metadata, err = next.HandleDeserialize(ctx, in)
1018 if err != nil {
1019 return out, metadata, err
1020 }
1021
1022 response, ok := out.RawResponse.(*smithyhttp.Response)
1023 if !ok {
1024 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1025 }
1026
1027 if response.StatusCode < 200 || response.StatusCode >= 300 {
1028 return out, metadata, awsAwsjson11_deserializeOpErrorDeletePullThroughCacheRule(response, &metadata)
1029 }
1030 output := &DeletePullThroughCacheRuleOutput{}
1031 out.Result = output
1032
1033 var buff [1024]byte
1034 ringBuffer := smithyio.NewRingBuffer(buff[:])
1035
1036 body := io.TeeReader(response.Body, ringBuffer)
1037 decoder := json.NewDecoder(body)
1038 decoder.UseNumber()
1039 var shape interface{}
1040 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1041 var snapshot bytes.Buffer
1042 io.Copy(&snapshot, ringBuffer)
1043 err = &smithy.DeserializationError{
1044 Err: fmt.Errorf("failed to decode response body, %w", err),
1045 Snapshot: snapshot.Bytes(),
1046 }
1047 return out, metadata, err
1048 }
1049
1050 err = awsAwsjson11_deserializeOpDocumentDeletePullThroughCacheRuleOutput(&output, shape)
1051 if err != nil {
1052 var snapshot bytes.Buffer
1053 io.Copy(&snapshot, ringBuffer)
1054 err = &smithy.DeserializationError{
1055 Err: fmt.Errorf("failed to decode response body, %w", err),
1056 Snapshot: snapshot.Bytes(),
1057 }
1058 return out, metadata, err
1059 }
1060
1061 return out, metadata, err
1062 }
1063
1064 func awsAwsjson11_deserializeOpErrorDeletePullThroughCacheRule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1065 var errorBuffer bytes.Buffer
1066 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1067 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1068 }
1069 errorBody := bytes.NewReader(errorBuffer.Bytes())
1070
1071 errorCode := "UnknownError"
1072 errorMessage := errorCode
1073
1074 headerCode := response.Header.Get("X-Amzn-ErrorType")
1075 if len(headerCode) != 0 {
1076 errorCode = restjson.SanitizeErrorCode(headerCode)
1077 }
1078
1079 var buff [1024]byte
1080 ringBuffer := smithyio.NewRingBuffer(buff[:])
1081
1082 body := io.TeeReader(errorBody, ringBuffer)
1083 decoder := json.NewDecoder(body)
1084 decoder.UseNumber()
1085 jsonCode, message, err := restjson.GetErrorInfo(decoder)
1086 if err != nil {
1087 var snapshot bytes.Buffer
1088 io.Copy(&snapshot, ringBuffer)
1089 err = &smithy.DeserializationError{
1090 Err: fmt.Errorf("failed to decode response body, %w", err),
1091 Snapshot: snapshot.Bytes(),
1092 }
1093 return err
1094 }
1095
1096 errorBody.Seek(0, io.SeekStart)
1097 if len(headerCode) == 0 && len(jsonCode) != 0 {
1098 errorCode = restjson.SanitizeErrorCode(jsonCode)
1099 }
1100 if len(message) != 0 {
1101 errorMessage = message
1102 }
1103
1104 switch {
1105 case strings.EqualFold("InvalidParameterException", errorCode):
1106 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1107
1108 case strings.EqualFold("PullThroughCacheRuleNotFoundException", errorCode):
1109 return awsAwsjson11_deserializeErrorPullThroughCacheRuleNotFoundException(response, errorBody)
1110
1111 case strings.EqualFold("ServerException", errorCode):
1112 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
1113
1114 case strings.EqualFold("ValidationException", errorCode):
1115 return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
1116
1117 default:
1118 genericError := &smithy.GenericAPIError{
1119 Code: errorCode,
1120 Message: errorMessage,
1121 }
1122 return genericError
1123
1124 }
1125 }
1126
1127 type awsAwsjson11_deserializeOpDeleteRegistryPolicy struct {
1128 }
1129
1130 func (*awsAwsjson11_deserializeOpDeleteRegistryPolicy) ID() string {
1131 return "OperationDeserializer"
1132 }
1133
1134 func (m *awsAwsjson11_deserializeOpDeleteRegistryPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1135 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1136 ) {
1137 out, metadata, err = next.HandleDeserialize(ctx, in)
1138 if err != nil {
1139 return out, metadata, err
1140 }
1141
1142 response, ok := out.RawResponse.(*smithyhttp.Response)
1143 if !ok {
1144 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1145 }
1146
1147 if response.StatusCode < 200 || response.StatusCode >= 300 {
1148 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteRegistryPolicy(response, &metadata)
1149 }
1150 output := &DeleteRegistryPolicyOutput{}
1151 out.Result = output
1152
1153 var buff [1024]byte
1154 ringBuffer := smithyio.NewRingBuffer(buff[:])
1155
1156 body := io.TeeReader(response.Body, ringBuffer)
1157 decoder := json.NewDecoder(body)
1158 decoder.UseNumber()
1159 var shape interface{}
1160 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1161 var snapshot bytes.Buffer
1162 io.Copy(&snapshot, ringBuffer)
1163 err = &smithy.DeserializationError{
1164 Err: fmt.Errorf("failed to decode response body, %w", err),
1165 Snapshot: snapshot.Bytes(),
1166 }
1167 return out, metadata, err
1168 }
1169
1170 err = awsAwsjson11_deserializeOpDocumentDeleteRegistryPolicyOutput(&output, shape)
1171 if err != nil {
1172 var snapshot bytes.Buffer
1173 io.Copy(&snapshot, ringBuffer)
1174 err = &smithy.DeserializationError{
1175 Err: fmt.Errorf("failed to decode response body, %w", err),
1176 Snapshot: snapshot.Bytes(),
1177 }
1178 return out, metadata, err
1179 }
1180
1181 return out, metadata, err
1182 }
1183
1184 func awsAwsjson11_deserializeOpErrorDeleteRegistryPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1185 var errorBuffer bytes.Buffer
1186 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1187 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1188 }
1189 errorBody := bytes.NewReader(errorBuffer.Bytes())
1190
1191 errorCode := "UnknownError"
1192 errorMessage := errorCode
1193
1194 headerCode := response.Header.Get("X-Amzn-ErrorType")
1195 if len(headerCode) != 0 {
1196 errorCode = restjson.SanitizeErrorCode(headerCode)
1197 }
1198
1199 var buff [1024]byte
1200 ringBuffer := smithyio.NewRingBuffer(buff[:])
1201
1202 body := io.TeeReader(errorBody, ringBuffer)
1203 decoder := json.NewDecoder(body)
1204 decoder.UseNumber()
1205 jsonCode, message, err := restjson.GetErrorInfo(decoder)
1206 if err != nil {
1207 var snapshot bytes.Buffer
1208 io.Copy(&snapshot, ringBuffer)
1209 err = &smithy.DeserializationError{
1210 Err: fmt.Errorf("failed to decode response body, %w", err),
1211 Snapshot: snapshot.Bytes(),
1212 }
1213 return err
1214 }
1215
1216 errorBody.Seek(0, io.SeekStart)
1217 if len(headerCode) == 0 && len(jsonCode) != 0 {
1218 errorCode = restjson.SanitizeErrorCode(jsonCode)
1219 }
1220 if len(message) != 0 {
1221 errorMessage = message
1222 }
1223
1224 switch {
1225 case strings.EqualFold("InvalidParameterException", errorCode):
1226 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1227
1228 case strings.EqualFold("RegistryPolicyNotFoundException", errorCode):
1229 return awsAwsjson11_deserializeErrorRegistryPolicyNotFoundException(response, errorBody)
1230
1231 case strings.EqualFold("ServerException", errorCode):
1232 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
1233
1234 case strings.EqualFold("ValidationException", errorCode):
1235 return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
1236
1237 default:
1238 genericError := &smithy.GenericAPIError{
1239 Code: errorCode,
1240 Message: errorMessage,
1241 }
1242 return genericError
1243
1244 }
1245 }
1246
1247 type awsAwsjson11_deserializeOpDeleteRepository struct {
1248 }
1249
1250 func (*awsAwsjson11_deserializeOpDeleteRepository) ID() string {
1251 return "OperationDeserializer"
1252 }
1253
1254 func (m *awsAwsjson11_deserializeOpDeleteRepository) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1255 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1256 ) {
1257 out, metadata, err = next.HandleDeserialize(ctx, in)
1258 if err != nil {
1259 return out, metadata, err
1260 }
1261
1262 response, ok := out.RawResponse.(*smithyhttp.Response)
1263 if !ok {
1264 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1265 }
1266
1267 if response.StatusCode < 200 || response.StatusCode >= 300 {
1268 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteRepository(response, &metadata)
1269 }
1270 output := &DeleteRepositoryOutput{}
1271 out.Result = output
1272
1273 var buff [1024]byte
1274 ringBuffer := smithyio.NewRingBuffer(buff[:])
1275
1276 body := io.TeeReader(response.Body, ringBuffer)
1277 decoder := json.NewDecoder(body)
1278 decoder.UseNumber()
1279 var shape interface{}
1280 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1281 var snapshot bytes.Buffer
1282 io.Copy(&snapshot, ringBuffer)
1283 err = &smithy.DeserializationError{
1284 Err: fmt.Errorf("failed to decode response body, %w", err),
1285 Snapshot: snapshot.Bytes(),
1286 }
1287 return out, metadata, err
1288 }
1289
1290 err = awsAwsjson11_deserializeOpDocumentDeleteRepositoryOutput(&output, shape)
1291 if err != nil {
1292 var snapshot bytes.Buffer
1293 io.Copy(&snapshot, ringBuffer)
1294 err = &smithy.DeserializationError{
1295 Err: fmt.Errorf("failed to decode response body, %w", err),
1296 Snapshot: snapshot.Bytes(),
1297 }
1298 return out, metadata, err
1299 }
1300
1301 return out, metadata, err
1302 }
1303
1304 func awsAwsjson11_deserializeOpErrorDeleteRepository(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1305 var errorBuffer bytes.Buffer
1306 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1307 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1308 }
1309 errorBody := bytes.NewReader(errorBuffer.Bytes())
1310
1311 errorCode := "UnknownError"
1312 errorMessage := errorCode
1313
1314 headerCode := response.Header.Get("X-Amzn-ErrorType")
1315 if len(headerCode) != 0 {
1316 errorCode = restjson.SanitizeErrorCode(headerCode)
1317 }
1318
1319 var buff [1024]byte
1320 ringBuffer := smithyio.NewRingBuffer(buff[:])
1321
1322 body := io.TeeReader(errorBody, ringBuffer)
1323 decoder := json.NewDecoder(body)
1324 decoder.UseNumber()
1325 jsonCode, message, err := restjson.GetErrorInfo(decoder)
1326 if err != nil {
1327 var snapshot bytes.Buffer
1328 io.Copy(&snapshot, ringBuffer)
1329 err = &smithy.DeserializationError{
1330 Err: fmt.Errorf("failed to decode response body, %w", err),
1331 Snapshot: snapshot.Bytes(),
1332 }
1333 return err
1334 }
1335
1336 errorBody.Seek(0, io.SeekStart)
1337 if len(headerCode) == 0 && len(jsonCode) != 0 {
1338 errorCode = restjson.SanitizeErrorCode(jsonCode)
1339 }
1340 if len(message) != 0 {
1341 errorMessage = message
1342 }
1343
1344 switch {
1345 case strings.EqualFold("InvalidParameterException", errorCode):
1346 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1347
1348 case strings.EqualFold("KmsException", errorCode):
1349 return awsAwsjson11_deserializeErrorKmsException(response, errorBody)
1350
1351 case strings.EqualFold("RepositoryNotEmptyException", errorCode):
1352 return awsAwsjson11_deserializeErrorRepositoryNotEmptyException(response, errorBody)
1353
1354 case strings.EqualFold("RepositoryNotFoundException", errorCode):
1355 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
1356
1357 case strings.EqualFold("ServerException", errorCode):
1358 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
1359
1360 default:
1361 genericError := &smithy.GenericAPIError{
1362 Code: errorCode,
1363 Message: errorMessage,
1364 }
1365 return genericError
1366
1367 }
1368 }
1369
1370 type awsAwsjson11_deserializeOpDeleteRepositoryPolicy struct {
1371 }
1372
1373 func (*awsAwsjson11_deserializeOpDeleteRepositoryPolicy) ID() string {
1374 return "OperationDeserializer"
1375 }
1376
1377 func (m *awsAwsjson11_deserializeOpDeleteRepositoryPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1378 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1379 ) {
1380 out, metadata, err = next.HandleDeserialize(ctx, in)
1381 if err != nil {
1382 return out, metadata, err
1383 }
1384
1385 response, ok := out.RawResponse.(*smithyhttp.Response)
1386 if !ok {
1387 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1388 }
1389
1390 if response.StatusCode < 200 || response.StatusCode >= 300 {
1391 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteRepositoryPolicy(response, &metadata)
1392 }
1393 output := &DeleteRepositoryPolicyOutput{}
1394 out.Result = output
1395
1396 var buff [1024]byte
1397 ringBuffer := smithyio.NewRingBuffer(buff[:])
1398
1399 body := io.TeeReader(response.Body, ringBuffer)
1400 decoder := json.NewDecoder(body)
1401 decoder.UseNumber()
1402 var shape interface{}
1403 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1404 var snapshot bytes.Buffer
1405 io.Copy(&snapshot, ringBuffer)
1406 err = &smithy.DeserializationError{
1407 Err: fmt.Errorf("failed to decode response body, %w", err),
1408 Snapshot: snapshot.Bytes(),
1409 }
1410 return out, metadata, err
1411 }
1412
1413 err = awsAwsjson11_deserializeOpDocumentDeleteRepositoryPolicyOutput(&output, shape)
1414 if err != nil {
1415 var snapshot bytes.Buffer
1416 io.Copy(&snapshot, ringBuffer)
1417 err = &smithy.DeserializationError{
1418 Err: fmt.Errorf("failed to decode response body, %w", err),
1419 Snapshot: snapshot.Bytes(),
1420 }
1421 return out, metadata, err
1422 }
1423
1424 return out, metadata, err
1425 }
1426
1427 func awsAwsjson11_deserializeOpErrorDeleteRepositoryPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1428 var errorBuffer bytes.Buffer
1429 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1430 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1431 }
1432 errorBody := bytes.NewReader(errorBuffer.Bytes())
1433
1434 errorCode := "UnknownError"
1435 errorMessage := errorCode
1436
1437 headerCode := response.Header.Get("X-Amzn-ErrorType")
1438 if len(headerCode) != 0 {
1439 errorCode = restjson.SanitizeErrorCode(headerCode)
1440 }
1441
1442 var buff [1024]byte
1443 ringBuffer := smithyio.NewRingBuffer(buff[:])
1444
1445 body := io.TeeReader(errorBody, ringBuffer)
1446 decoder := json.NewDecoder(body)
1447 decoder.UseNumber()
1448 jsonCode, message, err := restjson.GetErrorInfo(decoder)
1449 if err != nil {
1450 var snapshot bytes.Buffer
1451 io.Copy(&snapshot, ringBuffer)
1452 err = &smithy.DeserializationError{
1453 Err: fmt.Errorf("failed to decode response body, %w", err),
1454 Snapshot: snapshot.Bytes(),
1455 }
1456 return err
1457 }
1458
1459 errorBody.Seek(0, io.SeekStart)
1460 if len(headerCode) == 0 && len(jsonCode) != 0 {
1461 errorCode = restjson.SanitizeErrorCode(jsonCode)
1462 }
1463 if len(message) != 0 {
1464 errorMessage = message
1465 }
1466
1467 switch {
1468 case strings.EqualFold("InvalidParameterException", errorCode):
1469 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1470
1471 case strings.EqualFold("RepositoryNotFoundException", errorCode):
1472 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
1473
1474 case strings.EqualFold("RepositoryPolicyNotFoundException", errorCode):
1475 return awsAwsjson11_deserializeErrorRepositoryPolicyNotFoundException(response, errorBody)
1476
1477 case strings.EqualFold("ServerException", errorCode):
1478 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
1479
1480 default:
1481 genericError := &smithy.GenericAPIError{
1482 Code: errorCode,
1483 Message: errorMessage,
1484 }
1485 return genericError
1486
1487 }
1488 }
1489
1490 type awsAwsjson11_deserializeOpDescribeImageReplicationStatus struct {
1491 }
1492
1493 func (*awsAwsjson11_deserializeOpDescribeImageReplicationStatus) ID() string {
1494 return "OperationDeserializer"
1495 }
1496
1497 func (m *awsAwsjson11_deserializeOpDescribeImageReplicationStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1498 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1499 ) {
1500 out, metadata, err = next.HandleDeserialize(ctx, in)
1501 if err != nil {
1502 return out, metadata, err
1503 }
1504
1505 response, ok := out.RawResponse.(*smithyhttp.Response)
1506 if !ok {
1507 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1508 }
1509
1510 if response.StatusCode < 200 || response.StatusCode >= 300 {
1511 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeImageReplicationStatus(response, &metadata)
1512 }
1513 output := &DescribeImageReplicationStatusOutput{}
1514 out.Result = output
1515
1516 var buff [1024]byte
1517 ringBuffer := smithyio.NewRingBuffer(buff[:])
1518
1519 body := io.TeeReader(response.Body, ringBuffer)
1520 decoder := json.NewDecoder(body)
1521 decoder.UseNumber()
1522 var shape interface{}
1523 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1524 var snapshot bytes.Buffer
1525 io.Copy(&snapshot, ringBuffer)
1526 err = &smithy.DeserializationError{
1527 Err: fmt.Errorf("failed to decode response body, %w", err),
1528 Snapshot: snapshot.Bytes(),
1529 }
1530 return out, metadata, err
1531 }
1532
1533 err = awsAwsjson11_deserializeOpDocumentDescribeImageReplicationStatusOutput(&output, shape)
1534 if err != nil {
1535 var snapshot bytes.Buffer
1536 io.Copy(&snapshot, ringBuffer)
1537 err = &smithy.DeserializationError{
1538 Err: fmt.Errorf("failed to decode response body, %w", err),
1539 Snapshot: snapshot.Bytes(),
1540 }
1541 return out, metadata, err
1542 }
1543
1544 return out, metadata, err
1545 }
1546
1547 func awsAwsjson11_deserializeOpErrorDescribeImageReplicationStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1548 var errorBuffer bytes.Buffer
1549 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1550 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1551 }
1552 errorBody := bytes.NewReader(errorBuffer.Bytes())
1553
1554 errorCode := "UnknownError"
1555 errorMessage := errorCode
1556
1557 headerCode := response.Header.Get("X-Amzn-ErrorType")
1558 if len(headerCode) != 0 {
1559 errorCode = restjson.SanitizeErrorCode(headerCode)
1560 }
1561
1562 var buff [1024]byte
1563 ringBuffer := smithyio.NewRingBuffer(buff[:])
1564
1565 body := io.TeeReader(errorBody, ringBuffer)
1566 decoder := json.NewDecoder(body)
1567 decoder.UseNumber()
1568 jsonCode, message, err := restjson.GetErrorInfo(decoder)
1569 if err != nil {
1570 var snapshot bytes.Buffer
1571 io.Copy(&snapshot, ringBuffer)
1572 err = &smithy.DeserializationError{
1573 Err: fmt.Errorf("failed to decode response body, %w", err),
1574 Snapshot: snapshot.Bytes(),
1575 }
1576 return err
1577 }
1578
1579 errorBody.Seek(0, io.SeekStart)
1580 if len(headerCode) == 0 && len(jsonCode) != 0 {
1581 errorCode = restjson.SanitizeErrorCode(jsonCode)
1582 }
1583 if len(message) != 0 {
1584 errorMessage = message
1585 }
1586
1587 switch {
1588 case strings.EqualFold("ImageNotFoundException", errorCode):
1589 return awsAwsjson11_deserializeErrorImageNotFoundException(response, errorBody)
1590
1591 case strings.EqualFold("InvalidParameterException", errorCode):
1592 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1593
1594 case strings.EqualFold("RepositoryNotFoundException", errorCode):
1595 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
1596
1597 case strings.EqualFold("ServerException", errorCode):
1598 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
1599
1600 case strings.EqualFold("ValidationException", errorCode):
1601 return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
1602
1603 default:
1604 genericError := &smithy.GenericAPIError{
1605 Code: errorCode,
1606 Message: errorMessage,
1607 }
1608 return genericError
1609
1610 }
1611 }
1612
1613 type awsAwsjson11_deserializeOpDescribeImages struct {
1614 }
1615
1616 func (*awsAwsjson11_deserializeOpDescribeImages) ID() string {
1617 return "OperationDeserializer"
1618 }
1619
1620 func (m *awsAwsjson11_deserializeOpDescribeImages) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1621 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1622 ) {
1623 out, metadata, err = next.HandleDeserialize(ctx, in)
1624 if err != nil {
1625 return out, metadata, err
1626 }
1627
1628 response, ok := out.RawResponse.(*smithyhttp.Response)
1629 if !ok {
1630 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1631 }
1632
1633 if response.StatusCode < 200 || response.StatusCode >= 300 {
1634 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeImages(response, &metadata)
1635 }
1636 output := &DescribeImagesOutput{}
1637 out.Result = output
1638
1639 var buff [1024]byte
1640 ringBuffer := smithyio.NewRingBuffer(buff[:])
1641
1642 body := io.TeeReader(response.Body, ringBuffer)
1643 decoder := json.NewDecoder(body)
1644 decoder.UseNumber()
1645 var shape interface{}
1646 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1647 var snapshot bytes.Buffer
1648 io.Copy(&snapshot, ringBuffer)
1649 err = &smithy.DeserializationError{
1650 Err: fmt.Errorf("failed to decode response body, %w", err),
1651 Snapshot: snapshot.Bytes(),
1652 }
1653 return out, metadata, err
1654 }
1655
1656 err = awsAwsjson11_deserializeOpDocumentDescribeImagesOutput(&output, shape)
1657 if err != nil {
1658 var snapshot bytes.Buffer
1659 io.Copy(&snapshot, ringBuffer)
1660 err = &smithy.DeserializationError{
1661 Err: fmt.Errorf("failed to decode response body, %w", err),
1662 Snapshot: snapshot.Bytes(),
1663 }
1664 return out, metadata, err
1665 }
1666
1667 return out, metadata, err
1668 }
1669
1670 func awsAwsjson11_deserializeOpErrorDescribeImages(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1671 var errorBuffer bytes.Buffer
1672 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1673 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1674 }
1675 errorBody := bytes.NewReader(errorBuffer.Bytes())
1676
1677 errorCode := "UnknownError"
1678 errorMessage := errorCode
1679
1680 headerCode := response.Header.Get("X-Amzn-ErrorType")
1681 if len(headerCode) != 0 {
1682 errorCode = restjson.SanitizeErrorCode(headerCode)
1683 }
1684
1685 var buff [1024]byte
1686 ringBuffer := smithyio.NewRingBuffer(buff[:])
1687
1688 body := io.TeeReader(errorBody, ringBuffer)
1689 decoder := json.NewDecoder(body)
1690 decoder.UseNumber()
1691 jsonCode, message, err := restjson.GetErrorInfo(decoder)
1692 if err != nil {
1693 var snapshot bytes.Buffer
1694 io.Copy(&snapshot, ringBuffer)
1695 err = &smithy.DeserializationError{
1696 Err: fmt.Errorf("failed to decode response body, %w", err),
1697 Snapshot: snapshot.Bytes(),
1698 }
1699 return err
1700 }
1701
1702 errorBody.Seek(0, io.SeekStart)
1703 if len(headerCode) == 0 && len(jsonCode) != 0 {
1704 errorCode = restjson.SanitizeErrorCode(jsonCode)
1705 }
1706 if len(message) != 0 {
1707 errorMessage = message
1708 }
1709
1710 switch {
1711 case strings.EqualFold("ImageNotFoundException", errorCode):
1712 return awsAwsjson11_deserializeErrorImageNotFoundException(response, errorBody)
1713
1714 case strings.EqualFold("InvalidParameterException", errorCode):
1715 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1716
1717 case strings.EqualFold("RepositoryNotFoundException", errorCode):
1718 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
1719
1720 case strings.EqualFold("ServerException", errorCode):
1721 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
1722
1723 default:
1724 genericError := &smithy.GenericAPIError{
1725 Code: errorCode,
1726 Message: errorMessage,
1727 }
1728 return genericError
1729
1730 }
1731 }
1732
1733 type awsAwsjson11_deserializeOpDescribeImageScanFindings struct {
1734 }
1735
1736 func (*awsAwsjson11_deserializeOpDescribeImageScanFindings) ID() string {
1737 return "OperationDeserializer"
1738 }
1739
1740 func (m *awsAwsjson11_deserializeOpDescribeImageScanFindings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1741 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1742 ) {
1743 out, metadata, err = next.HandleDeserialize(ctx, in)
1744 if err != nil {
1745 return out, metadata, err
1746 }
1747
1748 response, ok := out.RawResponse.(*smithyhttp.Response)
1749 if !ok {
1750 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1751 }
1752
1753 if response.StatusCode < 200 || response.StatusCode >= 300 {
1754 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeImageScanFindings(response, &metadata)
1755 }
1756 output := &DescribeImageScanFindingsOutput{}
1757 out.Result = output
1758
1759 var buff [1024]byte
1760 ringBuffer := smithyio.NewRingBuffer(buff[:])
1761
1762 body := io.TeeReader(response.Body, ringBuffer)
1763 decoder := json.NewDecoder(body)
1764 decoder.UseNumber()
1765 var shape interface{}
1766 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1767 var snapshot bytes.Buffer
1768 io.Copy(&snapshot, ringBuffer)
1769 err = &smithy.DeserializationError{
1770 Err: fmt.Errorf("failed to decode response body, %w", err),
1771 Snapshot: snapshot.Bytes(),
1772 }
1773 return out, metadata, err
1774 }
1775
1776 err = awsAwsjson11_deserializeOpDocumentDescribeImageScanFindingsOutput(&output, shape)
1777 if err != nil {
1778 var snapshot bytes.Buffer
1779 io.Copy(&snapshot, ringBuffer)
1780 err = &smithy.DeserializationError{
1781 Err: fmt.Errorf("failed to decode response body, %w", err),
1782 Snapshot: snapshot.Bytes(),
1783 }
1784 return out, metadata, err
1785 }
1786
1787 return out, metadata, err
1788 }
1789
1790 func awsAwsjson11_deserializeOpErrorDescribeImageScanFindings(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1791 var errorBuffer bytes.Buffer
1792 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1793 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1794 }
1795 errorBody := bytes.NewReader(errorBuffer.Bytes())
1796
1797 errorCode := "UnknownError"
1798 errorMessage := errorCode
1799
1800 headerCode := response.Header.Get("X-Amzn-ErrorType")
1801 if len(headerCode) != 0 {
1802 errorCode = restjson.SanitizeErrorCode(headerCode)
1803 }
1804
1805 var buff [1024]byte
1806 ringBuffer := smithyio.NewRingBuffer(buff[:])
1807
1808 body := io.TeeReader(errorBody, ringBuffer)
1809 decoder := json.NewDecoder(body)
1810 decoder.UseNumber()
1811 jsonCode, message, err := restjson.GetErrorInfo(decoder)
1812 if err != nil {
1813 var snapshot bytes.Buffer
1814 io.Copy(&snapshot, ringBuffer)
1815 err = &smithy.DeserializationError{
1816 Err: fmt.Errorf("failed to decode response body, %w", err),
1817 Snapshot: snapshot.Bytes(),
1818 }
1819 return err
1820 }
1821
1822 errorBody.Seek(0, io.SeekStart)
1823 if len(headerCode) == 0 && len(jsonCode) != 0 {
1824 errorCode = restjson.SanitizeErrorCode(jsonCode)
1825 }
1826 if len(message) != 0 {
1827 errorMessage = message
1828 }
1829
1830 switch {
1831 case strings.EqualFold("ImageNotFoundException", errorCode):
1832 return awsAwsjson11_deserializeErrorImageNotFoundException(response, errorBody)
1833
1834 case strings.EqualFold("InvalidParameterException", errorCode):
1835 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1836
1837 case strings.EqualFold("RepositoryNotFoundException", errorCode):
1838 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
1839
1840 case strings.EqualFold("ScanNotFoundException", errorCode):
1841 return awsAwsjson11_deserializeErrorScanNotFoundException(response, errorBody)
1842
1843 case strings.EqualFold("ServerException", errorCode):
1844 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
1845
1846 case strings.EqualFold("ValidationException", errorCode):
1847 return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
1848
1849 default:
1850 genericError := &smithy.GenericAPIError{
1851 Code: errorCode,
1852 Message: errorMessage,
1853 }
1854 return genericError
1855
1856 }
1857 }
1858
1859 type awsAwsjson11_deserializeOpDescribePullThroughCacheRules struct {
1860 }
1861
1862 func (*awsAwsjson11_deserializeOpDescribePullThroughCacheRules) ID() string {
1863 return "OperationDeserializer"
1864 }
1865
1866 func (m *awsAwsjson11_deserializeOpDescribePullThroughCacheRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1867 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1868 ) {
1869 out, metadata, err = next.HandleDeserialize(ctx, in)
1870 if err != nil {
1871 return out, metadata, err
1872 }
1873
1874 response, ok := out.RawResponse.(*smithyhttp.Response)
1875 if !ok {
1876 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1877 }
1878
1879 if response.StatusCode < 200 || response.StatusCode >= 300 {
1880 return out, metadata, awsAwsjson11_deserializeOpErrorDescribePullThroughCacheRules(response, &metadata)
1881 }
1882 output := &DescribePullThroughCacheRulesOutput{}
1883 out.Result = output
1884
1885 var buff [1024]byte
1886 ringBuffer := smithyio.NewRingBuffer(buff[:])
1887
1888 body := io.TeeReader(response.Body, ringBuffer)
1889 decoder := json.NewDecoder(body)
1890 decoder.UseNumber()
1891 var shape interface{}
1892 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1893 var snapshot bytes.Buffer
1894 io.Copy(&snapshot, ringBuffer)
1895 err = &smithy.DeserializationError{
1896 Err: fmt.Errorf("failed to decode response body, %w", err),
1897 Snapshot: snapshot.Bytes(),
1898 }
1899 return out, metadata, err
1900 }
1901
1902 err = awsAwsjson11_deserializeOpDocumentDescribePullThroughCacheRulesOutput(&output, shape)
1903 if err != nil {
1904 var snapshot bytes.Buffer
1905 io.Copy(&snapshot, ringBuffer)
1906 err = &smithy.DeserializationError{
1907 Err: fmt.Errorf("failed to decode response body, %w", err),
1908 Snapshot: snapshot.Bytes(),
1909 }
1910 return out, metadata, err
1911 }
1912
1913 return out, metadata, err
1914 }
1915
1916 func awsAwsjson11_deserializeOpErrorDescribePullThroughCacheRules(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1917 var errorBuffer bytes.Buffer
1918 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1919 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1920 }
1921 errorBody := bytes.NewReader(errorBuffer.Bytes())
1922
1923 errorCode := "UnknownError"
1924 errorMessage := errorCode
1925
1926 headerCode := response.Header.Get("X-Amzn-ErrorType")
1927 if len(headerCode) != 0 {
1928 errorCode = restjson.SanitizeErrorCode(headerCode)
1929 }
1930
1931 var buff [1024]byte
1932 ringBuffer := smithyio.NewRingBuffer(buff[:])
1933
1934 body := io.TeeReader(errorBody, ringBuffer)
1935 decoder := json.NewDecoder(body)
1936 decoder.UseNumber()
1937 jsonCode, message, err := restjson.GetErrorInfo(decoder)
1938 if err != nil {
1939 var snapshot bytes.Buffer
1940 io.Copy(&snapshot, ringBuffer)
1941 err = &smithy.DeserializationError{
1942 Err: fmt.Errorf("failed to decode response body, %w", err),
1943 Snapshot: snapshot.Bytes(),
1944 }
1945 return err
1946 }
1947
1948 errorBody.Seek(0, io.SeekStart)
1949 if len(headerCode) == 0 && len(jsonCode) != 0 {
1950 errorCode = restjson.SanitizeErrorCode(jsonCode)
1951 }
1952 if len(message) != 0 {
1953 errorMessage = message
1954 }
1955
1956 switch {
1957 case strings.EqualFold("InvalidParameterException", errorCode):
1958 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1959
1960 case strings.EqualFold("PullThroughCacheRuleNotFoundException", errorCode):
1961 return awsAwsjson11_deserializeErrorPullThroughCacheRuleNotFoundException(response, errorBody)
1962
1963 case strings.EqualFold("ServerException", errorCode):
1964 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
1965
1966 case strings.EqualFold("ValidationException", errorCode):
1967 return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
1968
1969 default:
1970 genericError := &smithy.GenericAPIError{
1971 Code: errorCode,
1972 Message: errorMessage,
1973 }
1974 return genericError
1975
1976 }
1977 }
1978
1979 type awsAwsjson11_deserializeOpDescribeRegistry struct {
1980 }
1981
1982 func (*awsAwsjson11_deserializeOpDescribeRegistry) ID() string {
1983 return "OperationDeserializer"
1984 }
1985
1986 func (m *awsAwsjson11_deserializeOpDescribeRegistry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1987 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1988 ) {
1989 out, metadata, err = next.HandleDeserialize(ctx, in)
1990 if err != nil {
1991 return out, metadata, err
1992 }
1993
1994 response, ok := out.RawResponse.(*smithyhttp.Response)
1995 if !ok {
1996 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1997 }
1998
1999 if response.StatusCode < 200 || response.StatusCode >= 300 {
2000 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeRegistry(response, &metadata)
2001 }
2002 output := &DescribeRegistryOutput{}
2003 out.Result = output
2004
2005 var buff [1024]byte
2006 ringBuffer := smithyio.NewRingBuffer(buff[:])
2007
2008 body := io.TeeReader(response.Body, ringBuffer)
2009 decoder := json.NewDecoder(body)
2010 decoder.UseNumber()
2011 var shape interface{}
2012 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2013 var snapshot bytes.Buffer
2014 io.Copy(&snapshot, ringBuffer)
2015 err = &smithy.DeserializationError{
2016 Err: fmt.Errorf("failed to decode response body, %w", err),
2017 Snapshot: snapshot.Bytes(),
2018 }
2019 return out, metadata, err
2020 }
2021
2022 err = awsAwsjson11_deserializeOpDocumentDescribeRegistryOutput(&output, shape)
2023 if err != nil {
2024 var snapshot bytes.Buffer
2025 io.Copy(&snapshot, ringBuffer)
2026 err = &smithy.DeserializationError{
2027 Err: fmt.Errorf("failed to decode response body, %w", err),
2028 Snapshot: snapshot.Bytes(),
2029 }
2030 return out, metadata, err
2031 }
2032
2033 return out, metadata, err
2034 }
2035
2036 func awsAwsjson11_deserializeOpErrorDescribeRegistry(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2037 var errorBuffer bytes.Buffer
2038 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2039 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2040 }
2041 errorBody := bytes.NewReader(errorBuffer.Bytes())
2042
2043 errorCode := "UnknownError"
2044 errorMessage := errorCode
2045
2046 headerCode := response.Header.Get("X-Amzn-ErrorType")
2047 if len(headerCode) != 0 {
2048 errorCode = restjson.SanitizeErrorCode(headerCode)
2049 }
2050
2051 var buff [1024]byte
2052 ringBuffer := smithyio.NewRingBuffer(buff[:])
2053
2054 body := io.TeeReader(errorBody, ringBuffer)
2055 decoder := json.NewDecoder(body)
2056 decoder.UseNumber()
2057 jsonCode, message, err := restjson.GetErrorInfo(decoder)
2058 if err != nil {
2059 var snapshot bytes.Buffer
2060 io.Copy(&snapshot, ringBuffer)
2061 err = &smithy.DeserializationError{
2062 Err: fmt.Errorf("failed to decode response body, %w", err),
2063 Snapshot: snapshot.Bytes(),
2064 }
2065 return err
2066 }
2067
2068 errorBody.Seek(0, io.SeekStart)
2069 if len(headerCode) == 0 && len(jsonCode) != 0 {
2070 errorCode = restjson.SanitizeErrorCode(jsonCode)
2071 }
2072 if len(message) != 0 {
2073 errorMessage = message
2074 }
2075
2076 switch {
2077 case strings.EqualFold("InvalidParameterException", errorCode):
2078 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
2079
2080 case strings.EqualFold("ServerException", errorCode):
2081 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
2082
2083 case strings.EqualFold("ValidationException", errorCode):
2084 return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
2085
2086 default:
2087 genericError := &smithy.GenericAPIError{
2088 Code: errorCode,
2089 Message: errorMessage,
2090 }
2091 return genericError
2092
2093 }
2094 }
2095
2096 type awsAwsjson11_deserializeOpDescribeRepositories struct {
2097 }
2098
2099 func (*awsAwsjson11_deserializeOpDescribeRepositories) ID() string {
2100 return "OperationDeserializer"
2101 }
2102
2103 func (m *awsAwsjson11_deserializeOpDescribeRepositories) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2104 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2105 ) {
2106 out, metadata, err = next.HandleDeserialize(ctx, in)
2107 if err != nil {
2108 return out, metadata, err
2109 }
2110
2111 response, ok := out.RawResponse.(*smithyhttp.Response)
2112 if !ok {
2113 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2114 }
2115
2116 if response.StatusCode < 200 || response.StatusCode >= 300 {
2117 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeRepositories(response, &metadata)
2118 }
2119 output := &DescribeRepositoriesOutput{}
2120 out.Result = output
2121
2122 var buff [1024]byte
2123 ringBuffer := smithyio.NewRingBuffer(buff[:])
2124
2125 body := io.TeeReader(response.Body, ringBuffer)
2126 decoder := json.NewDecoder(body)
2127 decoder.UseNumber()
2128 var shape interface{}
2129 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2130 var snapshot bytes.Buffer
2131 io.Copy(&snapshot, ringBuffer)
2132 err = &smithy.DeserializationError{
2133 Err: fmt.Errorf("failed to decode response body, %w", err),
2134 Snapshot: snapshot.Bytes(),
2135 }
2136 return out, metadata, err
2137 }
2138
2139 err = awsAwsjson11_deserializeOpDocumentDescribeRepositoriesOutput(&output, shape)
2140 if err != nil {
2141 var snapshot bytes.Buffer
2142 io.Copy(&snapshot, ringBuffer)
2143 err = &smithy.DeserializationError{
2144 Err: fmt.Errorf("failed to decode response body, %w", err),
2145 Snapshot: snapshot.Bytes(),
2146 }
2147 return out, metadata, err
2148 }
2149
2150 return out, metadata, err
2151 }
2152
2153 func awsAwsjson11_deserializeOpErrorDescribeRepositories(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2154 var errorBuffer bytes.Buffer
2155 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2156 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2157 }
2158 errorBody := bytes.NewReader(errorBuffer.Bytes())
2159
2160 errorCode := "UnknownError"
2161 errorMessage := errorCode
2162
2163 headerCode := response.Header.Get("X-Amzn-ErrorType")
2164 if len(headerCode) != 0 {
2165 errorCode = restjson.SanitizeErrorCode(headerCode)
2166 }
2167
2168 var buff [1024]byte
2169 ringBuffer := smithyio.NewRingBuffer(buff[:])
2170
2171 body := io.TeeReader(errorBody, ringBuffer)
2172 decoder := json.NewDecoder(body)
2173 decoder.UseNumber()
2174 jsonCode, message, err := restjson.GetErrorInfo(decoder)
2175 if err != nil {
2176 var snapshot bytes.Buffer
2177 io.Copy(&snapshot, ringBuffer)
2178 err = &smithy.DeserializationError{
2179 Err: fmt.Errorf("failed to decode response body, %w", err),
2180 Snapshot: snapshot.Bytes(),
2181 }
2182 return err
2183 }
2184
2185 errorBody.Seek(0, io.SeekStart)
2186 if len(headerCode) == 0 && len(jsonCode) != 0 {
2187 errorCode = restjson.SanitizeErrorCode(jsonCode)
2188 }
2189 if len(message) != 0 {
2190 errorMessage = message
2191 }
2192
2193 switch {
2194 case strings.EqualFold("InvalidParameterException", errorCode):
2195 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
2196
2197 case strings.EqualFold("RepositoryNotFoundException", errorCode):
2198 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
2199
2200 case strings.EqualFold("ServerException", errorCode):
2201 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
2202
2203 default:
2204 genericError := &smithy.GenericAPIError{
2205 Code: errorCode,
2206 Message: errorMessage,
2207 }
2208 return genericError
2209
2210 }
2211 }
2212
2213 type awsAwsjson11_deserializeOpGetAuthorizationToken struct {
2214 }
2215
2216 func (*awsAwsjson11_deserializeOpGetAuthorizationToken) ID() string {
2217 return "OperationDeserializer"
2218 }
2219
2220 func (m *awsAwsjson11_deserializeOpGetAuthorizationToken) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2221 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2222 ) {
2223 out, metadata, err = next.HandleDeserialize(ctx, in)
2224 if err != nil {
2225 return out, metadata, err
2226 }
2227
2228 response, ok := out.RawResponse.(*smithyhttp.Response)
2229 if !ok {
2230 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2231 }
2232
2233 if response.StatusCode < 200 || response.StatusCode >= 300 {
2234 return out, metadata, awsAwsjson11_deserializeOpErrorGetAuthorizationToken(response, &metadata)
2235 }
2236 output := &GetAuthorizationTokenOutput{}
2237 out.Result = output
2238
2239 var buff [1024]byte
2240 ringBuffer := smithyio.NewRingBuffer(buff[:])
2241
2242 body := io.TeeReader(response.Body, ringBuffer)
2243 decoder := json.NewDecoder(body)
2244 decoder.UseNumber()
2245 var shape interface{}
2246 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2247 var snapshot bytes.Buffer
2248 io.Copy(&snapshot, ringBuffer)
2249 err = &smithy.DeserializationError{
2250 Err: fmt.Errorf("failed to decode response body, %w", err),
2251 Snapshot: snapshot.Bytes(),
2252 }
2253 return out, metadata, err
2254 }
2255
2256 err = awsAwsjson11_deserializeOpDocumentGetAuthorizationTokenOutput(&output, shape)
2257 if err != nil {
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 return out, metadata, err
2268 }
2269
2270 func awsAwsjson11_deserializeOpErrorGetAuthorizationToken(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2271 var errorBuffer bytes.Buffer
2272 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2273 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2274 }
2275 errorBody := bytes.NewReader(errorBuffer.Bytes())
2276
2277 errorCode := "UnknownError"
2278 errorMessage := errorCode
2279
2280 headerCode := response.Header.Get("X-Amzn-ErrorType")
2281 if len(headerCode) != 0 {
2282 errorCode = restjson.SanitizeErrorCode(headerCode)
2283 }
2284
2285 var buff [1024]byte
2286 ringBuffer := smithyio.NewRingBuffer(buff[:])
2287
2288 body := io.TeeReader(errorBody, ringBuffer)
2289 decoder := json.NewDecoder(body)
2290 decoder.UseNumber()
2291 jsonCode, message, err := restjson.GetErrorInfo(decoder)
2292 if err != nil {
2293 var snapshot bytes.Buffer
2294 io.Copy(&snapshot, ringBuffer)
2295 err = &smithy.DeserializationError{
2296 Err: fmt.Errorf("failed to decode response body, %w", err),
2297 Snapshot: snapshot.Bytes(),
2298 }
2299 return err
2300 }
2301
2302 errorBody.Seek(0, io.SeekStart)
2303 if len(headerCode) == 0 && len(jsonCode) != 0 {
2304 errorCode = restjson.SanitizeErrorCode(jsonCode)
2305 }
2306 if len(message) != 0 {
2307 errorMessage = message
2308 }
2309
2310 switch {
2311 case strings.EqualFold("InvalidParameterException", errorCode):
2312 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
2313
2314 case strings.EqualFold("ServerException", errorCode):
2315 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
2316
2317 default:
2318 genericError := &smithy.GenericAPIError{
2319 Code: errorCode,
2320 Message: errorMessage,
2321 }
2322 return genericError
2323
2324 }
2325 }
2326
2327 type awsAwsjson11_deserializeOpGetDownloadUrlForLayer struct {
2328 }
2329
2330 func (*awsAwsjson11_deserializeOpGetDownloadUrlForLayer) ID() string {
2331 return "OperationDeserializer"
2332 }
2333
2334 func (m *awsAwsjson11_deserializeOpGetDownloadUrlForLayer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2335 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2336 ) {
2337 out, metadata, err = next.HandleDeserialize(ctx, in)
2338 if err != nil {
2339 return out, metadata, err
2340 }
2341
2342 response, ok := out.RawResponse.(*smithyhttp.Response)
2343 if !ok {
2344 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2345 }
2346
2347 if response.StatusCode < 200 || response.StatusCode >= 300 {
2348 return out, metadata, awsAwsjson11_deserializeOpErrorGetDownloadUrlForLayer(response, &metadata)
2349 }
2350 output := &GetDownloadUrlForLayerOutput{}
2351 out.Result = output
2352
2353 var buff [1024]byte
2354 ringBuffer := smithyio.NewRingBuffer(buff[:])
2355
2356 body := io.TeeReader(response.Body, ringBuffer)
2357 decoder := json.NewDecoder(body)
2358 decoder.UseNumber()
2359 var shape interface{}
2360 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2361 var snapshot bytes.Buffer
2362 io.Copy(&snapshot, ringBuffer)
2363 err = &smithy.DeserializationError{
2364 Err: fmt.Errorf("failed to decode response body, %w", err),
2365 Snapshot: snapshot.Bytes(),
2366 }
2367 return out, metadata, err
2368 }
2369
2370 err = awsAwsjson11_deserializeOpDocumentGetDownloadUrlForLayerOutput(&output, shape)
2371 if err != nil {
2372 var snapshot bytes.Buffer
2373 io.Copy(&snapshot, ringBuffer)
2374 err = &smithy.DeserializationError{
2375 Err: fmt.Errorf("failed to decode response body, %w", err),
2376 Snapshot: snapshot.Bytes(),
2377 }
2378 return out, metadata, err
2379 }
2380
2381 return out, metadata, err
2382 }
2383
2384 func awsAwsjson11_deserializeOpErrorGetDownloadUrlForLayer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2385 var errorBuffer bytes.Buffer
2386 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2387 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2388 }
2389 errorBody := bytes.NewReader(errorBuffer.Bytes())
2390
2391 errorCode := "UnknownError"
2392 errorMessage := errorCode
2393
2394 headerCode := response.Header.Get("X-Amzn-ErrorType")
2395 if len(headerCode) != 0 {
2396 errorCode = restjson.SanitizeErrorCode(headerCode)
2397 }
2398
2399 var buff [1024]byte
2400 ringBuffer := smithyio.NewRingBuffer(buff[:])
2401
2402 body := io.TeeReader(errorBody, ringBuffer)
2403 decoder := json.NewDecoder(body)
2404 decoder.UseNumber()
2405 jsonCode, message, err := restjson.GetErrorInfo(decoder)
2406 if err != nil {
2407 var snapshot bytes.Buffer
2408 io.Copy(&snapshot, ringBuffer)
2409 err = &smithy.DeserializationError{
2410 Err: fmt.Errorf("failed to decode response body, %w", err),
2411 Snapshot: snapshot.Bytes(),
2412 }
2413 return err
2414 }
2415
2416 errorBody.Seek(0, io.SeekStart)
2417 if len(headerCode) == 0 && len(jsonCode) != 0 {
2418 errorCode = restjson.SanitizeErrorCode(jsonCode)
2419 }
2420 if len(message) != 0 {
2421 errorMessage = message
2422 }
2423
2424 switch {
2425 case strings.EqualFold("InvalidParameterException", errorCode):
2426 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
2427
2428 case strings.EqualFold("LayerInaccessibleException", errorCode):
2429 return awsAwsjson11_deserializeErrorLayerInaccessibleException(response, errorBody)
2430
2431 case strings.EqualFold("LayersNotFoundException", errorCode):
2432 return awsAwsjson11_deserializeErrorLayersNotFoundException(response, errorBody)
2433
2434 case strings.EqualFold("RepositoryNotFoundException", errorCode):
2435 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
2436
2437 case strings.EqualFold("ServerException", errorCode):
2438 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
2439
2440 default:
2441 genericError := &smithy.GenericAPIError{
2442 Code: errorCode,
2443 Message: errorMessage,
2444 }
2445 return genericError
2446
2447 }
2448 }
2449
2450 type awsAwsjson11_deserializeOpGetLifecyclePolicy struct {
2451 }
2452
2453 func (*awsAwsjson11_deserializeOpGetLifecyclePolicy) ID() string {
2454 return "OperationDeserializer"
2455 }
2456
2457 func (m *awsAwsjson11_deserializeOpGetLifecyclePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2458 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2459 ) {
2460 out, metadata, err = next.HandleDeserialize(ctx, in)
2461 if err != nil {
2462 return out, metadata, err
2463 }
2464
2465 response, ok := out.RawResponse.(*smithyhttp.Response)
2466 if !ok {
2467 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2468 }
2469
2470 if response.StatusCode < 200 || response.StatusCode >= 300 {
2471 return out, metadata, awsAwsjson11_deserializeOpErrorGetLifecyclePolicy(response, &metadata)
2472 }
2473 output := &GetLifecyclePolicyOutput{}
2474 out.Result = output
2475
2476 var buff [1024]byte
2477 ringBuffer := smithyio.NewRingBuffer(buff[:])
2478
2479 body := io.TeeReader(response.Body, ringBuffer)
2480 decoder := json.NewDecoder(body)
2481 decoder.UseNumber()
2482 var shape interface{}
2483 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2484 var snapshot bytes.Buffer
2485 io.Copy(&snapshot, ringBuffer)
2486 err = &smithy.DeserializationError{
2487 Err: fmt.Errorf("failed to decode response body, %w", err),
2488 Snapshot: snapshot.Bytes(),
2489 }
2490 return out, metadata, err
2491 }
2492
2493 err = awsAwsjson11_deserializeOpDocumentGetLifecyclePolicyOutput(&output, shape)
2494 if err != nil {
2495 var snapshot bytes.Buffer
2496 io.Copy(&snapshot, ringBuffer)
2497 err = &smithy.DeserializationError{
2498 Err: fmt.Errorf("failed to decode response body, %w", err),
2499 Snapshot: snapshot.Bytes(),
2500 }
2501 return out, metadata, err
2502 }
2503
2504 return out, metadata, err
2505 }
2506
2507 func awsAwsjson11_deserializeOpErrorGetLifecyclePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2508 var errorBuffer bytes.Buffer
2509 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2510 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2511 }
2512 errorBody := bytes.NewReader(errorBuffer.Bytes())
2513
2514 errorCode := "UnknownError"
2515 errorMessage := errorCode
2516
2517 headerCode := response.Header.Get("X-Amzn-ErrorType")
2518 if len(headerCode) != 0 {
2519 errorCode = restjson.SanitizeErrorCode(headerCode)
2520 }
2521
2522 var buff [1024]byte
2523 ringBuffer := smithyio.NewRingBuffer(buff[:])
2524
2525 body := io.TeeReader(errorBody, ringBuffer)
2526 decoder := json.NewDecoder(body)
2527 decoder.UseNumber()
2528 jsonCode, message, err := restjson.GetErrorInfo(decoder)
2529 if err != nil {
2530 var snapshot bytes.Buffer
2531 io.Copy(&snapshot, ringBuffer)
2532 err = &smithy.DeserializationError{
2533 Err: fmt.Errorf("failed to decode response body, %w", err),
2534 Snapshot: snapshot.Bytes(),
2535 }
2536 return err
2537 }
2538
2539 errorBody.Seek(0, io.SeekStart)
2540 if len(headerCode) == 0 && len(jsonCode) != 0 {
2541 errorCode = restjson.SanitizeErrorCode(jsonCode)
2542 }
2543 if len(message) != 0 {
2544 errorMessage = message
2545 }
2546
2547 switch {
2548 case strings.EqualFold("InvalidParameterException", errorCode):
2549 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
2550
2551 case strings.EqualFold("LifecyclePolicyNotFoundException", errorCode):
2552 return awsAwsjson11_deserializeErrorLifecyclePolicyNotFoundException(response, errorBody)
2553
2554 case strings.EqualFold("RepositoryNotFoundException", errorCode):
2555 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
2556
2557 case strings.EqualFold("ServerException", errorCode):
2558 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
2559
2560 case strings.EqualFold("ValidationException", errorCode):
2561 return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
2562
2563 default:
2564 genericError := &smithy.GenericAPIError{
2565 Code: errorCode,
2566 Message: errorMessage,
2567 }
2568 return genericError
2569
2570 }
2571 }
2572
2573 type awsAwsjson11_deserializeOpGetLifecyclePolicyPreview struct {
2574 }
2575
2576 func (*awsAwsjson11_deserializeOpGetLifecyclePolicyPreview) ID() string {
2577 return "OperationDeserializer"
2578 }
2579
2580 func (m *awsAwsjson11_deserializeOpGetLifecyclePolicyPreview) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2581 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2582 ) {
2583 out, metadata, err = next.HandleDeserialize(ctx, in)
2584 if err != nil {
2585 return out, metadata, err
2586 }
2587
2588 response, ok := out.RawResponse.(*smithyhttp.Response)
2589 if !ok {
2590 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2591 }
2592
2593 if response.StatusCode < 200 || response.StatusCode >= 300 {
2594 return out, metadata, awsAwsjson11_deserializeOpErrorGetLifecyclePolicyPreview(response, &metadata)
2595 }
2596 output := &GetLifecyclePolicyPreviewOutput{}
2597 out.Result = output
2598
2599 var buff [1024]byte
2600 ringBuffer := smithyio.NewRingBuffer(buff[:])
2601
2602 body := io.TeeReader(response.Body, ringBuffer)
2603 decoder := json.NewDecoder(body)
2604 decoder.UseNumber()
2605 var shape interface{}
2606 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2607 var snapshot bytes.Buffer
2608 io.Copy(&snapshot, ringBuffer)
2609 err = &smithy.DeserializationError{
2610 Err: fmt.Errorf("failed to decode response body, %w", err),
2611 Snapshot: snapshot.Bytes(),
2612 }
2613 return out, metadata, err
2614 }
2615
2616 err = awsAwsjson11_deserializeOpDocumentGetLifecyclePolicyPreviewOutput(&output, shape)
2617 if err != nil {
2618 var snapshot bytes.Buffer
2619 io.Copy(&snapshot, ringBuffer)
2620 err = &smithy.DeserializationError{
2621 Err: fmt.Errorf("failed to decode response body, %w", err),
2622 Snapshot: snapshot.Bytes(),
2623 }
2624 return out, metadata, err
2625 }
2626
2627 return out, metadata, err
2628 }
2629
2630 func awsAwsjson11_deserializeOpErrorGetLifecyclePolicyPreview(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2631 var errorBuffer bytes.Buffer
2632 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2633 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2634 }
2635 errorBody := bytes.NewReader(errorBuffer.Bytes())
2636
2637 errorCode := "UnknownError"
2638 errorMessage := errorCode
2639
2640 headerCode := response.Header.Get("X-Amzn-ErrorType")
2641 if len(headerCode) != 0 {
2642 errorCode = restjson.SanitizeErrorCode(headerCode)
2643 }
2644
2645 var buff [1024]byte
2646 ringBuffer := smithyio.NewRingBuffer(buff[:])
2647
2648 body := io.TeeReader(errorBody, ringBuffer)
2649 decoder := json.NewDecoder(body)
2650 decoder.UseNumber()
2651 jsonCode, message, err := restjson.GetErrorInfo(decoder)
2652 if err != nil {
2653 var snapshot bytes.Buffer
2654 io.Copy(&snapshot, ringBuffer)
2655 err = &smithy.DeserializationError{
2656 Err: fmt.Errorf("failed to decode response body, %w", err),
2657 Snapshot: snapshot.Bytes(),
2658 }
2659 return err
2660 }
2661
2662 errorBody.Seek(0, io.SeekStart)
2663 if len(headerCode) == 0 && len(jsonCode) != 0 {
2664 errorCode = restjson.SanitizeErrorCode(jsonCode)
2665 }
2666 if len(message) != 0 {
2667 errorMessage = message
2668 }
2669
2670 switch {
2671 case strings.EqualFold("InvalidParameterException", errorCode):
2672 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
2673
2674 case strings.EqualFold("LifecyclePolicyPreviewNotFoundException", errorCode):
2675 return awsAwsjson11_deserializeErrorLifecyclePolicyPreviewNotFoundException(response, errorBody)
2676
2677 case strings.EqualFold("RepositoryNotFoundException", errorCode):
2678 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
2679
2680 case strings.EqualFold("ServerException", errorCode):
2681 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
2682
2683 case strings.EqualFold("ValidationException", errorCode):
2684 return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
2685
2686 default:
2687 genericError := &smithy.GenericAPIError{
2688 Code: errorCode,
2689 Message: errorMessage,
2690 }
2691 return genericError
2692
2693 }
2694 }
2695
2696 type awsAwsjson11_deserializeOpGetRegistryPolicy struct {
2697 }
2698
2699 func (*awsAwsjson11_deserializeOpGetRegistryPolicy) ID() string {
2700 return "OperationDeserializer"
2701 }
2702
2703 func (m *awsAwsjson11_deserializeOpGetRegistryPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2704 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2705 ) {
2706 out, metadata, err = next.HandleDeserialize(ctx, in)
2707 if err != nil {
2708 return out, metadata, err
2709 }
2710
2711 response, ok := out.RawResponse.(*smithyhttp.Response)
2712 if !ok {
2713 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2714 }
2715
2716 if response.StatusCode < 200 || response.StatusCode >= 300 {
2717 return out, metadata, awsAwsjson11_deserializeOpErrorGetRegistryPolicy(response, &metadata)
2718 }
2719 output := &GetRegistryPolicyOutput{}
2720 out.Result = output
2721
2722 var buff [1024]byte
2723 ringBuffer := smithyio.NewRingBuffer(buff[:])
2724
2725 body := io.TeeReader(response.Body, ringBuffer)
2726 decoder := json.NewDecoder(body)
2727 decoder.UseNumber()
2728 var shape interface{}
2729 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2730 var snapshot bytes.Buffer
2731 io.Copy(&snapshot, ringBuffer)
2732 err = &smithy.DeserializationError{
2733 Err: fmt.Errorf("failed to decode response body, %w", err),
2734 Snapshot: snapshot.Bytes(),
2735 }
2736 return out, metadata, err
2737 }
2738
2739 err = awsAwsjson11_deserializeOpDocumentGetRegistryPolicyOutput(&output, shape)
2740 if err != nil {
2741 var snapshot bytes.Buffer
2742 io.Copy(&snapshot, ringBuffer)
2743 err = &smithy.DeserializationError{
2744 Err: fmt.Errorf("failed to decode response body, %w", err),
2745 Snapshot: snapshot.Bytes(),
2746 }
2747 return out, metadata, err
2748 }
2749
2750 return out, metadata, err
2751 }
2752
2753 func awsAwsjson11_deserializeOpErrorGetRegistryPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2754 var errorBuffer bytes.Buffer
2755 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2756 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2757 }
2758 errorBody := bytes.NewReader(errorBuffer.Bytes())
2759
2760 errorCode := "UnknownError"
2761 errorMessage := errorCode
2762
2763 headerCode := response.Header.Get("X-Amzn-ErrorType")
2764 if len(headerCode) != 0 {
2765 errorCode = restjson.SanitizeErrorCode(headerCode)
2766 }
2767
2768 var buff [1024]byte
2769 ringBuffer := smithyio.NewRingBuffer(buff[:])
2770
2771 body := io.TeeReader(errorBody, ringBuffer)
2772 decoder := json.NewDecoder(body)
2773 decoder.UseNumber()
2774 jsonCode, message, err := restjson.GetErrorInfo(decoder)
2775 if err != nil {
2776 var snapshot bytes.Buffer
2777 io.Copy(&snapshot, ringBuffer)
2778 err = &smithy.DeserializationError{
2779 Err: fmt.Errorf("failed to decode response body, %w", err),
2780 Snapshot: snapshot.Bytes(),
2781 }
2782 return err
2783 }
2784
2785 errorBody.Seek(0, io.SeekStart)
2786 if len(headerCode) == 0 && len(jsonCode) != 0 {
2787 errorCode = restjson.SanitizeErrorCode(jsonCode)
2788 }
2789 if len(message) != 0 {
2790 errorMessage = message
2791 }
2792
2793 switch {
2794 case strings.EqualFold("InvalidParameterException", errorCode):
2795 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
2796
2797 case strings.EqualFold("RegistryPolicyNotFoundException", errorCode):
2798 return awsAwsjson11_deserializeErrorRegistryPolicyNotFoundException(response, errorBody)
2799
2800 case strings.EqualFold("ServerException", errorCode):
2801 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
2802
2803 case strings.EqualFold("ValidationException", errorCode):
2804 return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
2805
2806 default:
2807 genericError := &smithy.GenericAPIError{
2808 Code: errorCode,
2809 Message: errorMessage,
2810 }
2811 return genericError
2812
2813 }
2814 }
2815
2816 type awsAwsjson11_deserializeOpGetRegistryScanningConfiguration struct {
2817 }
2818
2819 func (*awsAwsjson11_deserializeOpGetRegistryScanningConfiguration) ID() string {
2820 return "OperationDeserializer"
2821 }
2822
2823 func (m *awsAwsjson11_deserializeOpGetRegistryScanningConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2824 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2825 ) {
2826 out, metadata, err = next.HandleDeserialize(ctx, in)
2827 if err != nil {
2828 return out, metadata, err
2829 }
2830
2831 response, ok := out.RawResponse.(*smithyhttp.Response)
2832 if !ok {
2833 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2834 }
2835
2836 if response.StatusCode < 200 || response.StatusCode >= 300 {
2837 return out, metadata, awsAwsjson11_deserializeOpErrorGetRegistryScanningConfiguration(response, &metadata)
2838 }
2839 output := &GetRegistryScanningConfigurationOutput{}
2840 out.Result = output
2841
2842 var buff [1024]byte
2843 ringBuffer := smithyio.NewRingBuffer(buff[:])
2844
2845 body := io.TeeReader(response.Body, ringBuffer)
2846 decoder := json.NewDecoder(body)
2847 decoder.UseNumber()
2848 var shape interface{}
2849 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2850 var snapshot bytes.Buffer
2851 io.Copy(&snapshot, ringBuffer)
2852 err = &smithy.DeserializationError{
2853 Err: fmt.Errorf("failed to decode response body, %w", err),
2854 Snapshot: snapshot.Bytes(),
2855 }
2856 return out, metadata, err
2857 }
2858
2859 err = awsAwsjson11_deserializeOpDocumentGetRegistryScanningConfigurationOutput(&output, shape)
2860 if err != nil {
2861 var snapshot bytes.Buffer
2862 io.Copy(&snapshot, ringBuffer)
2863 err = &smithy.DeserializationError{
2864 Err: fmt.Errorf("failed to decode response body, %w", err),
2865 Snapshot: snapshot.Bytes(),
2866 }
2867 return out, metadata, err
2868 }
2869
2870 return out, metadata, err
2871 }
2872
2873 func awsAwsjson11_deserializeOpErrorGetRegistryScanningConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2874 var errorBuffer bytes.Buffer
2875 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2876 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2877 }
2878 errorBody := bytes.NewReader(errorBuffer.Bytes())
2879
2880 errorCode := "UnknownError"
2881 errorMessage := errorCode
2882
2883 headerCode := response.Header.Get("X-Amzn-ErrorType")
2884 if len(headerCode) != 0 {
2885 errorCode = restjson.SanitizeErrorCode(headerCode)
2886 }
2887
2888 var buff [1024]byte
2889 ringBuffer := smithyio.NewRingBuffer(buff[:])
2890
2891 body := io.TeeReader(errorBody, ringBuffer)
2892 decoder := json.NewDecoder(body)
2893 decoder.UseNumber()
2894 jsonCode, message, err := restjson.GetErrorInfo(decoder)
2895 if err != nil {
2896 var snapshot bytes.Buffer
2897 io.Copy(&snapshot, ringBuffer)
2898 err = &smithy.DeserializationError{
2899 Err: fmt.Errorf("failed to decode response body, %w", err),
2900 Snapshot: snapshot.Bytes(),
2901 }
2902 return err
2903 }
2904
2905 errorBody.Seek(0, io.SeekStart)
2906 if len(headerCode) == 0 && len(jsonCode) != 0 {
2907 errorCode = restjson.SanitizeErrorCode(jsonCode)
2908 }
2909 if len(message) != 0 {
2910 errorMessage = message
2911 }
2912
2913 switch {
2914 case strings.EqualFold("InvalidParameterException", errorCode):
2915 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
2916
2917 case strings.EqualFold("ServerException", errorCode):
2918 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
2919
2920 case strings.EqualFold("ValidationException", errorCode):
2921 return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
2922
2923 default:
2924 genericError := &smithy.GenericAPIError{
2925 Code: errorCode,
2926 Message: errorMessage,
2927 }
2928 return genericError
2929
2930 }
2931 }
2932
2933 type awsAwsjson11_deserializeOpGetRepositoryPolicy struct {
2934 }
2935
2936 func (*awsAwsjson11_deserializeOpGetRepositoryPolicy) ID() string {
2937 return "OperationDeserializer"
2938 }
2939
2940 func (m *awsAwsjson11_deserializeOpGetRepositoryPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2941 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2942 ) {
2943 out, metadata, err = next.HandleDeserialize(ctx, in)
2944 if err != nil {
2945 return out, metadata, err
2946 }
2947
2948 response, ok := out.RawResponse.(*smithyhttp.Response)
2949 if !ok {
2950 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2951 }
2952
2953 if response.StatusCode < 200 || response.StatusCode >= 300 {
2954 return out, metadata, awsAwsjson11_deserializeOpErrorGetRepositoryPolicy(response, &metadata)
2955 }
2956 output := &GetRepositoryPolicyOutput{}
2957 out.Result = output
2958
2959 var buff [1024]byte
2960 ringBuffer := smithyio.NewRingBuffer(buff[:])
2961
2962 body := io.TeeReader(response.Body, ringBuffer)
2963 decoder := json.NewDecoder(body)
2964 decoder.UseNumber()
2965 var shape interface{}
2966 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2967 var snapshot bytes.Buffer
2968 io.Copy(&snapshot, ringBuffer)
2969 err = &smithy.DeserializationError{
2970 Err: fmt.Errorf("failed to decode response body, %w", err),
2971 Snapshot: snapshot.Bytes(),
2972 }
2973 return out, metadata, err
2974 }
2975
2976 err = awsAwsjson11_deserializeOpDocumentGetRepositoryPolicyOutput(&output, shape)
2977 if err != nil {
2978 var snapshot bytes.Buffer
2979 io.Copy(&snapshot, ringBuffer)
2980 err = &smithy.DeserializationError{
2981 Err: fmt.Errorf("failed to decode response body, %w", err),
2982 Snapshot: snapshot.Bytes(),
2983 }
2984 return out, metadata, err
2985 }
2986
2987 return out, metadata, err
2988 }
2989
2990 func awsAwsjson11_deserializeOpErrorGetRepositoryPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2991 var errorBuffer bytes.Buffer
2992 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2993 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2994 }
2995 errorBody := bytes.NewReader(errorBuffer.Bytes())
2996
2997 errorCode := "UnknownError"
2998 errorMessage := errorCode
2999
3000 headerCode := response.Header.Get("X-Amzn-ErrorType")
3001 if len(headerCode) != 0 {
3002 errorCode = restjson.SanitizeErrorCode(headerCode)
3003 }
3004
3005 var buff [1024]byte
3006 ringBuffer := smithyio.NewRingBuffer(buff[:])
3007
3008 body := io.TeeReader(errorBody, ringBuffer)
3009 decoder := json.NewDecoder(body)
3010 decoder.UseNumber()
3011 jsonCode, message, err := restjson.GetErrorInfo(decoder)
3012 if err != nil {
3013 var snapshot bytes.Buffer
3014 io.Copy(&snapshot, ringBuffer)
3015 err = &smithy.DeserializationError{
3016 Err: fmt.Errorf("failed to decode response body, %w", err),
3017 Snapshot: snapshot.Bytes(),
3018 }
3019 return err
3020 }
3021
3022 errorBody.Seek(0, io.SeekStart)
3023 if len(headerCode) == 0 && len(jsonCode) != 0 {
3024 errorCode = restjson.SanitizeErrorCode(jsonCode)
3025 }
3026 if len(message) != 0 {
3027 errorMessage = message
3028 }
3029
3030 switch {
3031 case strings.EqualFold("InvalidParameterException", errorCode):
3032 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
3033
3034 case strings.EqualFold("RepositoryNotFoundException", errorCode):
3035 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
3036
3037 case strings.EqualFold("RepositoryPolicyNotFoundException", errorCode):
3038 return awsAwsjson11_deserializeErrorRepositoryPolicyNotFoundException(response, errorBody)
3039
3040 case strings.EqualFold("ServerException", errorCode):
3041 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
3042
3043 default:
3044 genericError := &smithy.GenericAPIError{
3045 Code: errorCode,
3046 Message: errorMessage,
3047 }
3048 return genericError
3049
3050 }
3051 }
3052
3053 type awsAwsjson11_deserializeOpInitiateLayerUpload struct {
3054 }
3055
3056 func (*awsAwsjson11_deserializeOpInitiateLayerUpload) ID() string {
3057 return "OperationDeserializer"
3058 }
3059
3060 func (m *awsAwsjson11_deserializeOpInitiateLayerUpload) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3061 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3062 ) {
3063 out, metadata, err = next.HandleDeserialize(ctx, in)
3064 if err != nil {
3065 return out, metadata, err
3066 }
3067
3068 response, ok := out.RawResponse.(*smithyhttp.Response)
3069 if !ok {
3070 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3071 }
3072
3073 if response.StatusCode < 200 || response.StatusCode >= 300 {
3074 return out, metadata, awsAwsjson11_deserializeOpErrorInitiateLayerUpload(response, &metadata)
3075 }
3076 output := &InitiateLayerUploadOutput{}
3077 out.Result = output
3078
3079 var buff [1024]byte
3080 ringBuffer := smithyio.NewRingBuffer(buff[:])
3081
3082 body := io.TeeReader(response.Body, ringBuffer)
3083 decoder := json.NewDecoder(body)
3084 decoder.UseNumber()
3085 var shape interface{}
3086 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3087 var snapshot bytes.Buffer
3088 io.Copy(&snapshot, ringBuffer)
3089 err = &smithy.DeserializationError{
3090 Err: fmt.Errorf("failed to decode response body, %w", err),
3091 Snapshot: snapshot.Bytes(),
3092 }
3093 return out, metadata, err
3094 }
3095
3096 err = awsAwsjson11_deserializeOpDocumentInitiateLayerUploadOutput(&output, shape)
3097 if err != nil {
3098 var snapshot bytes.Buffer
3099 io.Copy(&snapshot, ringBuffer)
3100 err = &smithy.DeserializationError{
3101 Err: fmt.Errorf("failed to decode response body, %w", err),
3102 Snapshot: snapshot.Bytes(),
3103 }
3104 return out, metadata, err
3105 }
3106
3107 return out, metadata, err
3108 }
3109
3110 func awsAwsjson11_deserializeOpErrorInitiateLayerUpload(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3111 var errorBuffer bytes.Buffer
3112 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3113 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3114 }
3115 errorBody := bytes.NewReader(errorBuffer.Bytes())
3116
3117 errorCode := "UnknownError"
3118 errorMessage := errorCode
3119
3120 headerCode := response.Header.Get("X-Amzn-ErrorType")
3121 if len(headerCode) != 0 {
3122 errorCode = restjson.SanitizeErrorCode(headerCode)
3123 }
3124
3125 var buff [1024]byte
3126 ringBuffer := smithyio.NewRingBuffer(buff[:])
3127
3128 body := io.TeeReader(errorBody, ringBuffer)
3129 decoder := json.NewDecoder(body)
3130 decoder.UseNumber()
3131 jsonCode, message, err := restjson.GetErrorInfo(decoder)
3132 if err != nil {
3133 var snapshot bytes.Buffer
3134 io.Copy(&snapshot, ringBuffer)
3135 err = &smithy.DeserializationError{
3136 Err: fmt.Errorf("failed to decode response body, %w", err),
3137 Snapshot: snapshot.Bytes(),
3138 }
3139 return err
3140 }
3141
3142 errorBody.Seek(0, io.SeekStart)
3143 if len(headerCode) == 0 && len(jsonCode) != 0 {
3144 errorCode = restjson.SanitizeErrorCode(jsonCode)
3145 }
3146 if len(message) != 0 {
3147 errorMessage = message
3148 }
3149
3150 switch {
3151 case strings.EqualFold("InvalidParameterException", errorCode):
3152 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
3153
3154 case strings.EqualFold("KmsException", errorCode):
3155 return awsAwsjson11_deserializeErrorKmsException(response, errorBody)
3156
3157 case strings.EqualFold("RepositoryNotFoundException", errorCode):
3158 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
3159
3160 case strings.EqualFold("ServerException", errorCode):
3161 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
3162
3163 default:
3164 genericError := &smithy.GenericAPIError{
3165 Code: errorCode,
3166 Message: errorMessage,
3167 }
3168 return genericError
3169
3170 }
3171 }
3172
3173 type awsAwsjson11_deserializeOpListImages struct {
3174 }
3175
3176 func (*awsAwsjson11_deserializeOpListImages) ID() string {
3177 return "OperationDeserializer"
3178 }
3179
3180 func (m *awsAwsjson11_deserializeOpListImages) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3181 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3182 ) {
3183 out, metadata, err = next.HandleDeserialize(ctx, in)
3184 if err != nil {
3185 return out, metadata, err
3186 }
3187
3188 response, ok := out.RawResponse.(*smithyhttp.Response)
3189 if !ok {
3190 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3191 }
3192
3193 if response.StatusCode < 200 || response.StatusCode >= 300 {
3194 return out, metadata, awsAwsjson11_deserializeOpErrorListImages(response, &metadata)
3195 }
3196 output := &ListImagesOutput{}
3197 out.Result = output
3198
3199 var buff [1024]byte
3200 ringBuffer := smithyio.NewRingBuffer(buff[:])
3201
3202 body := io.TeeReader(response.Body, ringBuffer)
3203 decoder := json.NewDecoder(body)
3204 decoder.UseNumber()
3205 var shape interface{}
3206 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3207 var snapshot bytes.Buffer
3208 io.Copy(&snapshot, ringBuffer)
3209 err = &smithy.DeserializationError{
3210 Err: fmt.Errorf("failed to decode response body, %w", err),
3211 Snapshot: snapshot.Bytes(),
3212 }
3213 return out, metadata, err
3214 }
3215
3216 err = awsAwsjson11_deserializeOpDocumentListImagesOutput(&output, shape)
3217 if err != nil {
3218 var snapshot bytes.Buffer
3219 io.Copy(&snapshot, ringBuffer)
3220 err = &smithy.DeserializationError{
3221 Err: fmt.Errorf("failed to decode response body, %w", err),
3222 Snapshot: snapshot.Bytes(),
3223 }
3224 return out, metadata, err
3225 }
3226
3227 return out, metadata, err
3228 }
3229
3230 func awsAwsjson11_deserializeOpErrorListImages(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3231 var errorBuffer bytes.Buffer
3232 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3233 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3234 }
3235 errorBody := bytes.NewReader(errorBuffer.Bytes())
3236
3237 errorCode := "UnknownError"
3238 errorMessage := errorCode
3239
3240 headerCode := response.Header.Get("X-Amzn-ErrorType")
3241 if len(headerCode) != 0 {
3242 errorCode = restjson.SanitizeErrorCode(headerCode)
3243 }
3244
3245 var buff [1024]byte
3246 ringBuffer := smithyio.NewRingBuffer(buff[:])
3247
3248 body := io.TeeReader(errorBody, ringBuffer)
3249 decoder := json.NewDecoder(body)
3250 decoder.UseNumber()
3251 jsonCode, message, err := restjson.GetErrorInfo(decoder)
3252 if err != nil {
3253 var snapshot bytes.Buffer
3254 io.Copy(&snapshot, ringBuffer)
3255 err = &smithy.DeserializationError{
3256 Err: fmt.Errorf("failed to decode response body, %w", err),
3257 Snapshot: snapshot.Bytes(),
3258 }
3259 return err
3260 }
3261
3262 errorBody.Seek(0, io.SeekStart)
3263 if len(headerCode) == 0 && len(jsonCode) != 0 {
3264 errorCode = restjson.SanitizeErrorCode(jsonCode)
3265 }
3266 if len(message) != 0 {
3267 errorMessage = message
3268 }
3269
3270 switch {
3271 case strings.EqualFold("InvalidParameterException", errorCode):
3272 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
3273
3274 case strings.EqualFold("RepositoryNotFoundException", errorCode):
3275 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
3276
3277 case strings.EqualFold("ServerException", errorCode):
3278 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
3279
3280 default:
3281 genericError := &smithy.GenericAPIError{
3282 Code: errorCode,
3283 Message: errorMessage,
3284 }
3285 return genericError
3286
3287 }
3288 }
3289
3290 type awsAwsjson11_deserializeOpListTagsForResource struct {
3291 }
3292
3293 func (*awsAwsjson11_deserializeOpListTagsForResource) ID() string {
3294 return "OperationDeserializer"
3295 }
3296
3297 func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3298 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3299 ) {
3300 out, metadata, err = next.HandleDeserialize(ctx, in)
3301 if err != nil {
3302 return out, metadata, err
3303 }
3304
3305 response, ok := out.RawResponse.(*smithyhttp.Response)
3306 if !ok {
3307 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3308 }
3309
3310 if response.StatusCode < 200 || response.StatusCode >= 300 {
3311 return out, metadata, awsAwsjson11_deserializeOpErrorListTagsForResource(response, &metadata)
3312 }
3313 output := &ListTagsForResourceOutput{}
3314 out.Result = output
3315
3316 var buff [1024]byte
3317 ringBuffer := smithyio.NewRingBuffer(buff[:])
3318
3319 body := io.TeeReader(response.Body, ringBuffer)
3320 decoder := json.NewDecoder(body)
3321 decoder.UseNumber()
3322 var shape interface{}
3323 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3324 var snapshot bytes.Buffer
3325 io.Copy(&snapshot, ringBuffer)
3326 err = &smithy.DeserializationError{
3327 Err: fmt.Errorf("failed to decode response body, %w", err),
3328 Snapshot: snapshot.Bytes(),
3329 }
3330 return out, metadata, err
3331 }
3332
3333 err = awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(&output, shape)
3334 if err != nil {
3335 var snapshot bytes.Buffer
3336 io.Copy(&snapshot, ringBuffer)
3337 err = &smithy.DeserializationError{
3338 Err: fmt.Errorf("failed to decode response body, %w", err),
3339 Snapshot: snapshot.Bytes(),
3340 }
3341 return out, metadata, err
3342 }
3343
3344 return out, metadata, err
3345 }
3346
3347 func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3348 var errorBuffer bytes.Buffer
3349 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3350 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3351 }
3352 errorBody := bytes.NewReader(errorBuffer.Bytes())
3353
3354 errorCode := "UnknownError"
3355 errorMessage := errorCode
3356
3357 headerCode := response.Header.Get("X-Amzn-ErrorType")
3358 if len(headerCode) != 0 {
3359 errorCode = restjson.SanitizeErrorCode(headerCode)
3360 }
3361
3362 var buff [1024]byte
3363 ringBuffer := smithyio.NewRingBuffer(buff[:])
3364
3365 body := io.TeeReader(errorBody, ringBuffer)
3366 decoder := json.NewDecoder(body)
3367 decoder.UseNumber()
3368 jsonCode, message, err := restjson.GetErrorInfo(decoder)
3369 if err != nil {
3370 var snapshot bytes.Buffer
3371 io.Copy(&snapshot, ringBuffer)
3372 err = &smithy.DeserializationError{
3373 Err: fmt.Errorf("failed to decode response body, %w", err),
3374 Snapshot: snapshot.Bytes(),
3375 }
3376 return err
3377 }
3378
3379 errorBody.Seek(0, io.SeekStart)
3380 if len(headerCode) == 0 && len(jsonCode) != 0 {
3381 errorCode = restjson.SanitizeErrorCode(jsonCode)
3382 }
3383 if len(message) != 0 {
3384 errorMessage = message
3385 }
3386
3387 switch {
3388 case strings.EqualFold("InvalidParameterException", errorCode):
3389 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
3390
3391 case strings.EqualFold("RepositoryNotFoundException", errorCode):
3392 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
3393
3394 case strings.EqualFold("ServerException", errorCode):
3395 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
3396
3397 default:
3398 genericError := &smithy.GenericAPIError{
3399 Code: errorCode,
3400 Message: errorMessage,
3401 }
3402 return genericError
3403
3404 }
3405 }
3406
3407 type awsAwsjson11_deserializeOpPutImage struct {
3408 }
3409
3410 func (*awsAwsjson11_deserializeOpPutImage) ID() string {
3411 return "OperationDeserializer"
3412 }
3413
3414 func (m *awsAwsjson11_deserializeOpPutImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3415 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3416 ) {
3417 out, metadata, err = next.HandleDeserialize(ctx, in)
3418 if err != nil {
3419 return out, metadata, err
3420 }
3421
3422 response, ok := out.RawResponse.(*smithyhttp.Response)
3423 if !ok {
3424 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3425 }
3426
3427 if response.StatusCode < 200 || response.StatusCode >= 300 {
3428 return out, metadata, awsAwsjson11_deserializeOpErrorPutImage(response, &metadata)
3429 }
3430 output := &PutImageOutput{}
3431 out.Result = output
3432
3433 var buff [1024]byte
3434 ringBuffer := smithyio.NewRingBuffer(buff[:])
3435
3436 body := io.TeeReader(response.Body, ringBuffer)
3437 decoder := json.NewDecoder(body)
3438 decoder.UseNumber()
3439 var shape interface{}
3440 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3441 var snapshot bytes.Buffer
3442 io.Copy(&snapshot, ringBuffer)
3443 err = &smithy.DeserializationError{
3444 Err: fmt.Errorf("failed to decode response body, %w", err),
3445 Snapshot: snapshot.Bytes(),
3446 }
3447 return out, metadata, err
3448 }
3449
3450 err = awsAwsjson11_deserializeOpDocumentPutImageOutput(&output, shape)
3451 if err != nil {
3452 var snapshot bytes.Buffer
3453 io.Copy(&snapshot, ringBuffer)
3454 err = &smithy.DeserializationError{
3455 Err: fmt.Errorf("failed to decode response body, %w", err),
3456 Snapshot: snapshot.Bytes(),
3457 }
3458 return out, metadata, err
3459 }
3460
3461 return out, metadata, err
3462 }
3463
3464 func awsAwsjson11_deserializeOpErrorPutImage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3465 var errorBuffer bytes.Buffer
3466 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3467 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3468 }
3469 errorBody := bytes.NewReader(errorBuffer.Bytes())
3470
3471 errorCode := "UnknownError"
3472 errorMessage := errorCode
3473
3474 headerCode := response.Header.Get("X-Amzn-ErrorType")
3475 if len(headerCode) != 0 {
3476 errorCode = restjson.SanitizeErrorCode(headerCode)
3477 }
3478
3479 var buff [1024]byte
3480 ringBuffer := smithyio.NewRingBuffer(buff[:])
3481
3482 body := io.TeeReader(errorBody, ringBuffer)
3483 decoder := json.NewDecoder(body)
3484 decoder.UseNumber()
3485 jsonCode, message, err := restjson.GetErrorInfo(decoder)
3486 if err != nil {
3487 var snapshot bytes.Buffer
3488 io.Copy(&snapshot, ringBuffer)
3489 err = &smithy.DeserializationError{
3490 Err: fmt.Errorf("failed to decode response body, %w", err),
3491 Snapshot: snapshot.Bytes(),
3492 }
3493 return err
3494 }
3495
3496 errorBody.Seek(0, io.SeekStart)
3497 if len(headerCode) == 0 && len(jsonCode) != 0 {
3498 errorCode = restjson.SanitizeErrorCode(jsonCode)
3499 }
3500 if len(message) != 0 {
3501 errorMessage = message
3502 }
3503
3504 switch {
3505 case strings.EqualFold("ImageAlreadyExistsException", errorCode):
3506 return awsAwsjson11_deserializeErrorImageAlreadyExistsException(response, errorBody)
3507
3508 case strings.EqualFold("ImageDigestDoesNotMatchException", errorCode):
3509 return awsAwsjson11_deserializeErrorImageDigestDoesNotMatchException(response, errorBody)
3510
3511 case strings.EqualFold("ImageTagAlreadyExistsException", errorCode):
3512 return awsAwsjson11_deserializeErrorImageTagAlreadyExistsException(response, errorBody)
3513
3514 case strings.EqualFold("InvalidParameterException", errorCode):
3515 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
3516
3517 case strings.EqualFold("KmsException", errorCode):
3518 return awsAwsjson11_deserializeErrorKmsException(response, errorBody)
3519
3520 case strings.EqualFold("LayersNotFoundException", errorCode):
3521 return awsAwsjson11_deserializeErrorLayersNotFoundException(response, errorBody)
3522
3523 case strings.EqualFold("LimitExceededException", errorCode):
3524 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
3525
3526 case strings.EqualFold("ReferencedImagesNotFoundException", errorCode):
3527 return awsAwsjson11_deserializeErrorReferencedImagesNotFoundException(response, errorBody)
3528
3529 case strings.EqualFold("RepositoryNotFoundException", errorCode):
3530 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
3531
3532 case strings.EqualFold("ServerException", errorCode):
3533 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
3534
3535 default:
3536 genericError := &smithy.GenericAPIError{
3537 Code: errorCode,
3538 Message: errorMessage,
3539 }
3540 return genericError
3541
3542 }
3543 }
3544
3545 type awsAwsjson11_deserializeOpPutImageScanningConfiguration struct {
3546 }
3547
3548 func (*awsAwsjson11_deserializeOpPutImageScanningConfiguration) ID() string {
3549 return "OperationDeserializer"
3550 }
3551
3552 func (m *awsAwsjson11_deserializeOpPutImageScanningConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3553 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3554 ) {
3555 out, metadata, err = next.HandleDeserialize(ctx, in)
3556 if err != nil {
3557 return out, metadata, err
3558 }
3559
3560 response, ok := out.RawResponse.(*smithyhttp.Response)
3561 if !ok {
3562 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3563 }
3564
3565 if response.StatusCode < 200 || response.StatusCode >= 300 {
3566 return out, metadata, awsAwsjson11_deserializeOpErrorPutImageScanningConfiguration(response, &metadata)
3567 }
3568 output := &PutImageScanningConfigurationOutput{}
3569 out.Result = output
3570
3571 var buff [1024]byte
3572 ringBuffer := smithyio.NewRingBuffer(buff[:])
3573
3574 body := io.TeeReader(response.Body, ringBuffer)
3575 decoder := json.NewDecoder(body)
3576 decoder.UseNumber()
3577 var shape interface{}
3578 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3579 var snapshot bytes.Buffer
3580 io.Copy(&snapshot, ringBuffer)
3581 err = &smithy.DeserializationError{
3582 Err: fmt.Errorf("failed to decode response body, %w", err),
3583 Snapshot: snapshot.Bytes(),
3584 }
3585 return out, metadata, err
3586 }
3587
3588 err = awsAwsjson11_deserializeOpDocumentPutImageScanningConfigurationOutput(&output, shape)
3589 if err != nil {
3590 var snapshot bytes.Buffer
3591 io.Copy(&snapshot, ringBuffer)
3592 err = &smithy.DeserializationError{
3593 Err: fmt.Errorf("failed to decode response body, %w", err),
3594 Snapshot: snapshot.Bytes(),
3595 }
3596 return out, metadata, err
3597 }
3598
3599 return out, metadata, err
3600 }
3601
3602 func awsAwsjson11_deserializeOpErrorPutImageScanningConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3603 var errorBuffer bytes.Buffer
3604 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3605 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3606 }
3607 errorBody := bytes.NewReader(errorBuffer.Bytes())
3608
3609 errorCode := "UnknownError"
3610 errorMessage := errorCode
3611
3612 headerCode := response.Header.Get("X-Amzn-ErrorType")
3613 if len(headerCode) != 0 {
3614 errorCode = restjson.SanitizeErrorCode(headerCode)
3615 }
3616
3617 var buff [1024]byte
3618 ringBuffer := smithyio.NewRingBuffer(buff[:])
3619
3620 body := io.TeeReader(errorBody, ringBuffer)
3621 decoder := json.NewDecoder(body)
3622 decoder.UseNumber()
3623 jsonCode, message, err := restjson.GetErrorInfo(decoder)
3624 if err != nil {
3625 var snapshot bytes.Buffer
3626 io.Copy(&snapshot, ringBuffer)
3627 err = &smithy.DeserializationError{
3628 Err: fmt.Errorf("failed to decode response body, %w", err),
3629 Snapshot: snapshot.Bytes(),
3630 }
3631 return err
3632 }
3633
3634 errorBody.Seek(0, io.SeekStart)
3635 if len(headerCode) == 0 && len(jsonCode) != 0 {
3636 errorCode = restjson.SanitizeErrorCode(jsonCode)
3637 }
3638 if len(message) != 0 {
3639 errorMessage = message
3640 }
3641
3642 switch {
3643 case strings.EqualFold("InvalidParameterException", errorCode):
3644 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
3645
3646 case strings.EqualFold("RepositoryNotFoundException", errorCode):
3647 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
3648
3649 case strings.EqualFold("ServerException", errorCode):
3650 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
3651
3652 case strings.EqualFold("ValidationException", errorCode):
3653 return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
3654
3655 default:
3656 genericError := &smithy.GenericAPIError{
3657 Code: errorCode,
3658 Message: errorMessage,
3659 }
3660 return genericError
3661
3662 }
3663 }
3664
3665 type awsAwsjson11_deserializeOpPutImageTagMutability struct {
3666 }
3667
3668 func (*awsAwsjson11_deserializeOpPutImageTagMutability) ID() string {
3669 return "OperationDeserializer"
3670 }
3671
3672 func (m *awsAwsjson11_deserializeOpPutImageTagMutability) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3673 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3674 ) {
3675 out, metadata, err = next.HandleDeserialize(ctx, in)
3676 if err != nil {
3677 return out, metadata, err
3678 }
3679
3680 response, ok := out.RawResponse.(*smithyhttp.Response)
3681 if !ok {
3682 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3683 }
3684
3685 if response.StatusCode < 200 || response.StatusCode >= 300 {
3686 return out, metadata, awsAwsjson11_deserializeOpErrorPutImageTagMutability(response, &metadata)
3687 }
3688 output := &PutImageTagMutabilityOutput{}
3689 out.Result = output
3690
3691 var buff [1024]byte
3692 ringBuffer := smithyio.NewRingBuffer(buff[:])
3693
3694 body := io.TeeReader(response.Body, ringBuffer)
3695 decoder := json.NewDecoder(body)
3696 decoder.UseNumber()
3697 var shape interface{}
3698 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3699 var snapshot bytes.Buffer
3700 io.Copy(&snapshot, ringBuffer)
3701 err = &smithy.DeserializationError{
3702 Err: fmt.Errorf("failed to decode response body, %w", err),
3703 Snapshot: snapshot.Bytes(),
3704 }
3705 return out, metadata, err
3706 }
3707
3708 err = awsAwsjson11_deserializeOpDocumentPutImageTagMutabilityOutput(&output, shape)
3709 if err != nil {
3710 var snapshot bytes.Buffer
3711 io.Copy(&snapshot, ringBuffer)
3712 err = &smithy.DeserializationError{
3713 Err: fmt.Errorf("failed to decode response body, %w", err),
3714 Snapshot: snapshot.Bytes(),
3715 }
3716 return out, metadata, err
3717 }
3718
3719 return out, metadata, err
3720 }
3721
3722 func awsAwsjson11_deserializeOpErrorPutImageTagMutability(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3723 var errorBuffer bytes.Buffer
3724 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3725 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3726 }
3727 errorBody := bytes.NewReader(errorBuffer.Bytes())
3728
3729 errorCode := "UnknownError"
3730 errorMessage := errorCode
3731
3732 headerCode := response.Header.Get("X-Amzn-ErrorType")
3733 if len(headerCode) != 0 {
3734 errorCode = restjson.SanitizeErrorCode(headerCode)
3735 }
3736
3737 var buff [1024]byte
3738 ringBuffer := smithyio.NewRingBuffer(buff[:])
3739
3740 body := io.TeeReader(errorBody, ringBuffer)
3741 decoder := json.NewDecoder(body)
3742 decoder.UseNumber()
3743 jsonCode, message, err := restjson.GetErrorInfo(decoder)
3744 if err != nil {
3745 var snapshot bytes.Buffer
3746 io.Copy(&snapshot, ringBuffer)
3747 err = &smithy.DeserializationError{
3748 Err: fmt.Errorf("failed to decode response body, %w", err),
3749 Snapshot: snapshot.Bytes(),
3750 }
3751 return err
3752 }
3753
3754 errorBody.Seek(0, io.SeekStart)
3755 if len(headerCode) == 0 && len(jsonCode) != 0 {
3756 errorCode = restjson.SanitizeErrorCode(jsonCode)
3757 }
3758 if len(message) != 0 {
3759 errorMessage = message
3760 }
3761
3762 switch {
3763 case strings.EqualFold("InvalidParameterException", errorCode):
3764 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
3765
3766 case strings.EqualFold("RepositoryNotFoundException", errorCode):
3767 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
3768
3769 case strings.EqualFold("ServerException", errorCode):
3770 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
3771
3772 default:
3773 genericError := &smithy.GenericAPIError{
3774 Code: errorCode,
3775 Message: errorMessage,
3776 }
3777 return genericError
3778
3779 }
3780 }
3781
3782 type awsAwsjson11_deserializeOpPutLifecyclePolicy struct {
3783 }
3784
3785 func (*awsAwsjson11_deserializeOpPutLifecyclePolicy) ID() string {
3786 return "OperationDeserializer"
3787 }
3788
3789 func (m *awsAwsjson11_deserializeOpPutLifecyclePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3790 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3791 ) {
3792 out, metadata, err = next.HandleDeserialize(ctx, in)
3793 if err != nil {
3794 return out, metadata, err
3795 }
3796
3797 response, ok := out.RawResponse.(*smithyhttp.Response)
3798 if !ok {
3799 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3800 }
3801
3802 if response.StatusCode < 200 || response.StatusCode >= 300 {
3803 return out, metadata, awsAwsjson11_deserializeOpErrorPutLifecyclePolicy(response, &metadata)
3804 }
3805 output := &PutLifecyclePolicyOutput{}
3806 out.Result = output
3807
3808 var buff [1024]byte
3809 ringBuffer := smithyio.NewRingBuffer(buff[:])
3810
3811 body := io.TeeReader(response.Body, ringBuffer)
3812 decoder := json.NewDecoder(body)
3813 decoder.UseNumber()
3814 var shape interface{}
3815 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3816 var snapshot bytes.Buffer
3817 io.Copy(&snapshot, ringBuffer)
3818 err = &smithy.DeserializationError{
3819 Err: fmt.Errorf("failed to decode response body, %w", err),
3820 Snapshot: snapshot.Bytes(),
3821 }
3822 return out, metadata, err
3823 }
3824
3825 err = awsAwsjson11_deserializeOpDocumentPutLifecyclePolicyOutput(&output, shape)
3826 if err != nil {
3827 var snapshot bytes.Buffer
3828 io.Copy(&snapshot, ringBuffer)
3829 err = &smithy.DeserializationError{
3830 Err: fmt.Errorf("failed to decode response body, %w", err),
3831 Snapshot: snapshot.Bytes(),
3832 }
3833 return out, metadata, err
3834 }
3835
3836 return out, metadata, err
3837 }
3838
3839 func awsAwsjson11_deserializeOpErrorPutLifecyclePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3840 var errorBuffer bytes.Buffer
3841 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3842 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3843 }
3844 errorBody := bytes.NewReader(errorBuffer.Bytes())
3845
3846 errorCode := "UnknownError"
3847 errorMessage := errorCode
3848
3849 headerCode := response.Header.Get("X-Amzn-ErrorType")
3850 if len(headerCode) != 0 {
3851 errorCode = restjson.SanitizeErrorCode(headerCode)
3852 }
3853
3854 var buff [1024]byte
3855 ringBuffer := smithyio.NewRingBuffer(buff[:])
3856
3857 body := io.TeeReader(errorBody, ringBuffer)
3858 decoder := json.NewDecoder(body)
3859 decoder.UseNumber()
3860 jsonCode, message, err := restjson.GetErrorInfo(decoder)
3861 if err != nil {
3862 var snapshot bytes.Buffer
3863 io.Copy(&snapshot, ringBuffer)
3864 err = &smithy.DeserializationError{
3865 Err: fmt.Errorf("failed to decode response body, %w", err),
3866 Snapshot: snapshot.Bytes(),
3867 }
3868 return err
3869 }
3870
3871 errorBody.Seek(0, io.SeekStart)
3872 if len(headerCode) == 0 && len(jsonCode) != 0 {
3873 errorCode = restjson.SanitizeErrorCode(jsonCode)
3874 }
3875 if len(message) != 0 {
3876 errorMessage = message
3877 }
3878
3879 switch {
3880 case strings.EqualFold("InvalidParameterException", errorCode):
3881 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
3882
3883 case strings.EqualFold("RepositoryNotFoundException", errorCode):
3884 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
3885
3886 case strings.EqualFold("ServerException", errorCode):
3887 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
3888
3889 case strings.EqualFold("ValidationException", errorCode):
3890 return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
3891
3892 default:
3893 genericError := &smithy.GenericAPIError{
3894 Code: errorCode,
3895 Message: errorMessage,
3896 }
3897 return genericError
3898
3899 }
3900 }
3901
3902 type awsAwsjson11_deserializeOpPutRegistryPolicy struct {
3903 }
3904
3905 func (*awsAwsjson11_deserializeOpPutRegistryPolicy) ID() string {
3906 return "OperationDeserializer"
3907 }
3908
3909 func (m *awsAwsjson11_deserializeOpPutRegistryPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3910 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3911 ) {
3912 out, metadata, err = next.HandleDeserialize(ctx, in)
3913 if err != nil {
3914 return out, metadata, err
3915 }
3916
3917 response, ok := out.RawResponse.(*smithyhttp.Response)
3918 if !ok {
3919 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3920 }
3921
3922 if response.StatusCode < 200 || response.StatusCode >= 300 {
3923 return out, metadata, awsAwsjson11_deserializeOpErrorPutRegistryPolicy(response, &metadata)
3924 }
3925 output := &PutRegistryPolicyOutput{}
3926 out.Result = output
3927
3928 var buff [1024]byte
3929 ringBuffer := smithyio.NewRingBuffer(buff[:])
3930
3931 body := io.TeeReader(response.Body, ringBuffer)
3932 decoder := json.NewDecoder(body)
3933 decoder.UseNumber()
3934 var shape interface{}
3935 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3936 var snapshot bytes.Buffer
3937 io.Copy(&snapshot, ringBuffer)
3938 err = &smithy.DeserializationError{
3939 Err: fmt.Errorf("failed to decode response body, %w", err),
3940 Snapshot: snapshot.Bytes(),
3941 }
3942 return out, metadata, err
3943 }
3944
3945 err = awsAwsjson11_deserializeOpDocumentPutRegistryPolicyOutput(&output, shape)
3946 if err != nil {
3947 var snapshot bytes.Buffer
3948 io.Copy(&snapshot, ringBuffer)
3949 err = &smithy.DeserializationError{
3950 Err: fmt.Errorf("failed to decode response body, %w", err),
3951 Snapshot: snapshot.Bytes(),
3952 }
3953 return out, metadata, err
3954 }
3955
3956 return out, metadata, err
3957 }
3958
3959 func awsAwsjson11_deserializeOpErrorPutRegistryPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3960 var errorBuffer bytes.Buffer
3961 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3962 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3963 }
3964 errorBody := bytes.NewReader(errorBuffer.Bytes())
3965
3966 errorCode := "UnknownError"
3967 errorMessage := errorCode
3968
3969 headerCode := response.Header.Get("X-Amzn-ErrorType")
3970 if len(headerCode) != 0 {
3971 errorCode = restjson.SanitizeErrorCode(headerCode)
3972 }
3973
3974 var buff [1024]byte
3975 ringBuffer := smithyio.NewRingBuffer(buff[:])
3976
3977 body := io.TeeReader(errorBody, ringBuffer)
3978 decoder := json.NewDecoder(body)
3979 decoder.UseNumber()
3980 jsonCode, message, err := restjson.GetErrorInfo(decoder)
3981 if err != nil {
3982 var snapshot bytes.Buffer
3983 io.Copy(&snapshot, ringBuffer)
3984 err = &smithy.DeserializationError{
3985 Err: fmt.Errorf("failed to decode response body, %w", err),
3986 Snapshot: snapshot.Bytes(),
3987 }
3988 return err
3989 }
3990
3991 errorBody.Seek(0, io.SeekStart)
3992 if len(headerCode) == 0 && len(jsonCode) != 0 {
3993 errorCode = restjson.SanitizeErrorCode(jsonCode)
3994 }
3995 if len(message) != 0 {
3996 errorMessage = message
3997 }
3998
3999 switch {
4000 case strings.EqualFold("InvalidParameterException", errorCode):
4001 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
4002
4003 case strings.EqualFold("ServerException", errorCode):
4004 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
4005
4006 case strings.EqualFold("ValidationException", errorCode):
4007 return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
4008
4009 default:
4010 genericError := &smithy.GenericAPIError{
4011 Code: errorCode,
4012 Message: errorMessage,
4013 }
4014 return genericError
4015
4016 }
4017 }
4018
4019 type awsAwsjson11_deserializeOpPutRegistryScanningConfiguration struct {
4020 }
4021
4022 func (*awsAwsjson11_deserializeOpPutRegistryScanningConfiguration) ID() string {
4023 return "OperationDeserializer"
4024 }
4025
4026 func (m *awsAwsjson11_deserializeOpPutRegistryScanningConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4027 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4028 ) {
4029 out, metadata, err = next.HandleDeserialize(ctx, in)
4030 if err != nil {
4031 return out, metadata, err
4032 }
4033
4034 response, ok := out.RawResponse.(*smithyhttp.Response)
4035 if !ok {
4036 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4037 }
4038
4039 if response.StatusCode < 200 || response.StatusCode >= 300 {
4040 return out, metadata, awsAwsjson11_deserializeOpErrorPutRegistryScanningConfiguration(response, &metadata)
4041 }
4042 output := &PutRegistryScanningConfigurationOutput{}
4043 out.Result = output
4044
4045 var buff [1024]byte
4046 ringBuffer := smithyio.NewRingBuffer(buff[:])
4047
4048 body := io.TeeReader(response.Body, ringBuffer)
4049 decoder := json.NewDecoder(body)
4050 decoder.UseNumber()
4051 var shape interface{}
4052 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4053 var snapshot bytes.Buffer
4054 io.Copy(&snapshot, ringBuffer)
4055 err = &smithy.DeserializationError{
4056 Err: fmt.Errorf("failed to decode response body, %w", err),
4057 Snapshot: snapshot.Bytes(),
4058 }
4059 return out, metadata, err
4060 }
4061
4062 err = awsAwsjson11_deserializeOpDocumentPutRegistryScanningConfigurationOutput(&output, shape)
4063 if err != nil {
4064 var snapshot bytes.Buffer
4065 io.Copy(&snapshot, ringBuffer)
4066 err = &smithy.DeserializationError{
4067 Err: fmt.Errorf("failed to decode response body, %w", err),
4068 Snapshot: snapshot.Bytes(),
4069 }
4070 return out, metadata, err
4071 }
4072
4073 return out, metadata, err
4074 }
4075
4076 func awsAwsjson11_deserializeOpErrorPutRegistryScanningConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4077 var errorBuffer bytes.Buffer
4078 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4079 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4080 }
4081 errorBody := bytes.NewReader(errorBuffer.Bytes())
4082
4083 errorCode := "UnknownError"
4084 errorMessage := errorCode
4085
4086 headerCode := response.Header.Get("X-Amzn-ErrorType")
4087 if len(headerCode) != 0 {
4088 errorCode = restjson.SanitizeErrorCode(headerCode)
4089 }
4090
4091 var buff [1024]byte
4092 ringBuffer := smithyio.NewRingBuffer(buff[:])
4093
4094 body := io.TeeReader(errorBody, ringBuffer)
4095 decoder := json.NewDecoder(body)
4096 decoder.UseNumber()
4097 jsonCode, message, err := restjson.GetErrorInfo(decoder)
4098 if err != nil {
4099 var snapshot bytes.Buffer
4100 io.Copy(&snapshot, ringBuffer)
4101 err = &smithy.DeserializationError{
4102 Err: fmt.Errorf("failed to decode response body, %w", err),
4103 Snapshot: snapshot.Bytes(),
4104 }
4105 return err
4106 }
4107
4108 errorBody.Seek(0, io.SeekStart)
4109 if len(headerCode) == 0 && len(jsonCode) != 0 {
4110 errorCode = restjson.SanitizeErrorCode(jsonCode)
4111 }
4112 if len(message) != 0 {
4113 errorMessage = message
4114 }
4115
4116 switch {
4117 case strings.EqualFold("InvalidParameterException", errorCode):
4118 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
4119
4120 case strings.EqualFold("ServerException", errorCode):
4121 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
4122
4123 case strings.EqualFold("ValidationException", errorCode):
4124 return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
4125
4126 default:
4127 genericError := &smithy.GenericAPIError{
4128 Code: errorCode,
4129 Message: errorMessage,
4130 }
4131 return genericError
4132
4133 }
4134 }
4135
4136 type awsAwsjson11_deserializeOpPutReplicationConfiguration struct {
4137 }
4138
4139 func (*awsAwsjson11_deserializeOpPutReplicationConfiguration) ID() string {
4140 return "OperationDeserializer"
4141 }
4142
4143 func (m *awsAwsjson11_deserializeOpPutReplicationConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4144 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4145 ) {
4146 out, metadata, err = next.HandleDeserialize(ctx, in)
4147 if err != nil {
4148 return out, metadata, err
4149 }
4150
4151 response, ok := out.RawResponse.(*smithyhttp.Response)
4152 if !ok {
4153 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4154 }
4155
4156 if response.StatusCode < 200 || response.StatusCode >= 300 {
4157 return out, metadata, awsAwsjson11_deserializeOpErrorPutReplicationConfiguration(response, &metadata)
4158 }
4159 output := &PutReplicationConfigurationOutput{}
4160 out.Result = output
4161
4162 var buff [1024]byte
4163 ringBuffer := smithyio.NewRingBuffer(buff[:])
4164
4165 body := io.TeeReader(response.Body, ringBuffer)
4166 decoder := json.NewDecoder(body)
4167 decoder.UseNumber()
4168 var shape interface{}
4169 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4170 var snapshot bytes.Buffer
4171 io.Copy(&snapshot, ringBuffer)
4172 err = &smithy.DeserializationError{
4173 Err: fmt.Errorf("failed to decode response body, %w", err),
4174 Snapshot: snapshot.Bytes(),
4175 }
4176 return out, metadata, err
4177 }
4178
4179 err = awsAwsjson11_deserializeOpDocumentPutReplicationConfigurationOutput(&output, shape)
4180 if err != nil {
4181 var snapshot bytes.Buffer
4182 io.Copy(&snapshot, ringBuffer)
4183 err = &smithy.DeserializationError{
4184 Err: fmt.Errorf("failed to decode response body, %w", err),
4185 Snapshot: snapshot.Bytes(),
4186 }
4187 return out, metadata, err
4188 }
4189
4190 return out, metadata, err
4191 }
4192
4193 func awsAwsjson11_deserializeOpErrorPutReplicationConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4194 var errorBuffer bytes.Buffer
4195 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4196 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4197 }
4198 errorBody := bytes.NewReader(errorBuffer.Bytes())
4199
4200 errorCode := "UnknownError"
4201 errorMessage := errorCode
4202
4203 headerCode := response.Header.Get("X-Amzn-ErrorType")
4204 if len(headerCode) != 0 {
4205 errorCode = restjson.SanitizeErrorCode(headerCode)
4206 }
4207
4208 var buff [1024]byte
4209 ringBuffer := smithyio.NewRingBuffer(buff[:])
4210
4211 body := io.TeeReader(errorBody, ringBuffer)
4212 decoder := json.NewDecoder(body)
4213 decoder.UseNumber()
4214 jsonCode, message, err := restjson.GetErrorInfo(decoder)
4215 if err != nil {
4216 var snapshot bytes.Buffer
4217 io.Copy(&snapshot, ringBuffer)
4218 err = &smithy.DeserializationError{
4219 Err: fmt.Errorf("failed to decode response body, %w", err),
4220 Snapshot: snapshot.Bytes(),
4221 }
4222 return err
4223 }
4224
4225 errorBody.Seek(0, io.SeekStart)
4226 if len(headerCode) == 0 && len(jsonCode) != 0 {
4227 errorCode = restjson.SanitizeErrorCode(jsonCode)
4228 }
4229 if len(message) != 0 {
4230 errorMessage = message
4231 }
4232
4233 switch {
4234 case strings.EqualFold("InvalidParameterException", errorCode):
4235 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
4236
4237 case strings.EqualFold("ServerException", errorCode):
4238 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
4239
4240 case strings.EqualFold("ValidationException", errorCode):
4241 return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
4242
4243 default:
4244 genericError := &smithy.GenericAPIError{
4245 Code: errorCode,
4246 Message: errorMessage,
4247 }
4248 return genericError
4249
4250 }
4251 }
4252
4253 type awsAwsjson11_deserializeOpSetRepositoryPolicy struct {
4254 }
4255
4256 func (*awsAwsjson11_deserializeOpSetRepositoryPolicy) ID() string {
4257 return "OperationDeserializer"
4258 }
4259
4260 func (m *awsAwsjson11_deserializeOpSetRepositoryPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4261 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4262 ) {
4263 out, metadata, err = next.HandleDeserialize(ctx, in)
4264 if err != nil {
4265 return out, metadata, err
4266 }
4267
4268 response, ok := out.RawResponse.(*smithyhttp.Response)
4269 if !ok {
4270 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4271 }
4272
4273 if response.StatusCode < 200 || response.StatusCode >= 300 {
4274 return out, metadata, awsAwsjson11_deserializeOpErrorSetRepositoryPolicy(response, &metadata)
4275 }
4276 output := &SetRepositoryPolicyOutput{}
4277 out.Result = output
4278
4279 var buff [1024]byte
4280 ringBuffer := smithyio.NewRingBuffer(buff[:])
4281
4282 body := io.TeeReader(response.Body, ringBuffer)
4283 decoder := json.NewDecoder(body)
4284 decoder.UseNumber()
4285 var shape interface{}
4286 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4287 var snapshot bytes.Buffer
4288 io.Copy(&snapshot, ringBuffer)
4289 err = &smithy.DeserializationError{
4290 Err: fmt.Errorf("failed to decode response body, %w", err),
4291 Snapshot: snapshot.Bytes(),
4292 }
4293 return out, metadata, err
4294 }
4295
4296 err = awsAwsjson11_deserializeOpDocumentSetRepositoryPolicyOutput(&output, shape)
4297 if err != nil {
4298 var snapshot bytes.Buffer
4299 io.Copy(&snapshot, ringBuffer)
4300 err = &smithy.DeserializationError{
4301 Err: fmt.Errorf("failed to decode response body, %w", err),
4302 Snapshot: snapshot.Bytes(),
4303 }
4304 return out, metadata, err
4305 }
4306
4307 return out, metadata, err
4308 }
4309
4310 func awsAwsjson11_deserializeOpErrorSetRepositoryPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4311 var errorBuffer bytes.Buffer
4312 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4313 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4314 }
4315 errorBody := bytes.NewReader(errorBuffer.Bytes())
4316
4317 errorCode := "UnknownError"
4318 errorMessage := errorCode
4319
4320 headerCode := response.Header.Get("X-Amzn-ErrorType")
4321 if len(headerCode) != 0 {
4322 errorCode = restjson.SanitizeErrorCode(headerCode)
4323 }
4324
4325 var buff [1024]byte
4326 ringBuffer := smithyio.NewRingBuffer(buff[:])
4327
4328 body := io.TeeReader(errorBody, ringBuffer)
4329 decoder := json.NewDecoder(body)
4330 decoder.UseNumber()
4331 jsonCode, message, err := restjson.GetErrorInfo(decoder)
4332 if err != nil {
4333 var snapshot bytes.Buffer
4334 io.Copy(&snapshot, ringBuffer)
4335 err = &smithy.DeserializationError{
4336 Err: fmt.Errorf("failed to decode response body, %w", err),
4337 Snapshot: snapshot.Bytes(),
4338 }
4339 return err
4340 }
4341
4342 errorBody.Seek(0, io.SeekStart)
4343 if len(headerCode) == 0 && len(jsonCode) != 0 {
4344 errorCode = restjson.SanitizeErrorCode(jsonCode)
4345 }
4346 if len(message) != 0 {
4347 errorMessage = message
4348 }
4349
4350 switch {
4351 case strings.EqualFold("InvalidParameterException", errorCode):
4352 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
4353
4354 case strings.EqualFold("RepositoryNotFoundException", errorCode):
4355 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
4356
4357 case strings.EqualFold("ServerException", errorCode):
4358 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
4359
4360 default:
4361 genericError := &smithy.GenericAPIError{
4362 Code: errorCode,
4363 Message: errorMessage,
4364 }
4365 return genericError
4366
4367 }
4368 }
4369
4370 type awsAwsjson11_deserializeOpStartImageScan struct {
4371 }
4372
4373 func (*awsAwsjson11_deserializeOpStartImageScan) ID() string {
4374 return "OperationDeserializer"
4375 }
4376
4377 func (m *awsAwsjson11_deserializeOpStartImageScan) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4378 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4379 ) {
4380 out, metadata, err = next.HandleDeserialize(ctx, in)
4381 if err != nil {
4382 return out, metadata, err
4383 }
4384
4385 response, ok := out.RawResponse.(*smithyhttp.Response)
4386 if !ok {
4387 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4388 }
4389
4390 if response.StatusCode < 200 || response.StatusCode >= 300 {
4391 return out, metadata, awsAwsjson11_deserializeOpErrorStartImageScan(response, &metadata)
4392 }
4393 output := &StartImageScanOutput{}
4394 out.Result = output
4395
4396 var buff [1024]byte
4397 ringBuffer := smithyio.NewRingBuffer(buff[:])
4398
4399 body := io.TeeReader(response.Body, ringBuffer)
4400 decoder := json.NewDecoder(body)
4401 decoder.UseNumber()
4402 var shape interface{}
4403 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4404 var snapshot bytes.Buffer
4405 io.Copy(&snapshot, ringBuffer)
4406 err = &smithy.DeserializationError{
4407 Err: fmt.Errorf("failed to decode response body, %w", err),
4408 Snapshot: snapshot.Bytes(),
4409 }
4410 return out, metadata, err
4411 }
4412
4413 err = awsAwsjson11_deserializeOpDocumentStartImageScanOutput(&output, shape)
4414 if err != nil {
4415 var snapshot bytes.Buffer
4416 io.Copy(&snapshot, ringBuffer)
4417 err = &smithy.DeserializationError{
4418 Err: fmt.Errorf("failed to decode response body, %w", err),
4419 Snapshot: snapshot.Bytes(),
4420 }
4421 return out, metadata, err
4422 }
4423
4424 return out, metadata, err
4425 }
4426
4427 func awsAwsjson11_deserializeOpErrorStartImageScan(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4428 var errorBuffer bytes.Buffer
4429 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4430 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4431 }
4432 errorBody := bytes.NewReader(errorBuffer.Bytes())
4433
4434 errorCode := "UnknownError"
4435 errorMessage := errorCode
4436
4437 headerCode := response.Header.Get("X-Amzn-ErrorType")
4438 if len(headerCode) != 0 {
4439 errorCode = restjson.SanitizeErrorCode(headerCode)
4440 }
4441
4442 var buff [1024]byte
4443 ringBuffer := smithyio.NewRingBuffer(buff[:])
4444
4445 body := io.TeeReader(errorBody, ringBuffer)
4446 decoder := json.NewDecoder(body)
4447 decoder.UseNumber()
4448 jsonCode, message, err := restjson.GetErrorInfo(decoder)
4449 if err != nil {
4450 var snapshot bytes.Buffer
4451 io.Copy(&snapshot, ringBuffer)
4452 err = &smithy.DeserializationError{
4453 Err: fmt.Errorf("failed to decode response body, %w", err),
4454 Snapshot: snapshot.Bytes(),
4455 }
4456 return err
4457 }
4458
4459 errorBody.Seek(0, io.SeekStart)
4460 if len(headerCode) == 0 && len(jsonCode) != 0 {
4461 errorCode = restjson.SanitizeErrorCode(jsonCode)
4462 }
4463 if len(message) != 0 {
4464 errorMessage = message
4465 }
4466
4467 switch {
4468 case strings.EqualFold("ImageNotFoundException", errorCode):
4469 return awsAwsjson11_deserializeErrorImageNotFoundException(response, errorBody)
4470
4471 case strings.EqualFold("InvalidParameterException", errorCode):
4472 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
4473
4474 case strings.EqualFold("LimitExceededException", errorCode):
4475 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
4476
4477 case strings.EqualFold("RepositoryNotFoundException", errorCode):
4478 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
4479
4480 case strings.EqualFold("ServerException", errorCode):
4481 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
4482
4483 case strings.EqualFold("UnsupportedImageTypeException", errorCode):
4484 return awsAwsjson11_deserializeErrorUnsupportedImageTypeException(response, errorBody)
4485
4486 case strings.EqualFold("ValidationException", errorCode):
4487 return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
4488
4489 default:
4490 genericError := &smithy.GenericAPIError{
4491 Code: errorCode,
4492 Message: errorMessage,
4493 }
4494 return genericError
4495
4496 }
4497 }
4498
4499 type awsAwsjson11_deserializeOpStartLifecyclePolicyPreview struct {
4500 }
4501
4502 func (*awsAwsjson11_deserializeOpStartLifecyclePolicyPreview) ID() string {
4503 return "OperationDeserializer"
4504 }
4505
4506 func (m *awsAwsjson11_deserializeOpStartLifecyclePolicyPreview) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4507 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4508 ) {
4509 out, metadata, err = next.HandleDeserialize(ctx, in)
4510 if err != nil {
4511 return out, metadata, err
4512 }
4513
4514 response, ok := out.RawResponse.(*smithyhttp.Response)
4515 if !ok {
4516 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4517 }
4518
4519 if response.StatusCode < 200 || response.StatusCode >= 300 {
4520 return out, metadata, awsAwsjson11_deserializeOpErrorStartLifecyclePolicyPreview(response, &metadata)
4521 }
4522 output := &StartLifecyclePolicyPreviewOutput{}
4523 out.Result = output
4524
4525 var buff [1024]byte
4526 ringBuffer := smithyio.NewRingBuffer(buff[:])
4527
4528 body := io.TeeReader(response.Body, ringBuffer)
4529 decoder := json.NewDecoder(body)
4530 decoder.UseNumber()
4531 var shape interface{}
4532 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4533 var snapshot bytes.Buffer
4534 io.Copy(&snapshot, ringBuffer)
4535 err = &smithy.DeserializationError{
4536 Err: fmt.Errorf("failed to decode response body, %w", err),
4537 Snapshot: snapshot.Bytes(),
4538 }
4539 return out, metadata, err
4540 }
4541
4542 err = awsAwsjson11_deserializeOpDocumentStartLifecyclePolicyPreviewOutput(&output, shape)
4543 if err != nil {
4544 var snapshot bytes.Buffer
4545 io.Copy(&snapshot, ringBuffer)
4546 err = &smithy.DeserializationError{
4547 Err: fmt.Errorf("failed to decode response body, %w", err),
4548 Snapshot: snapshot.Bytes(),
4549 }
4550 return out, metadata, err
4551 }
4552
4553 return out, metadata, err
4554 }
4555
4556 func awsAwsjson11_deserializeOpErrorStartLifecyclePolicyPreview(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4557 var errorBuffer bytes.Buffer
4558 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4559 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4560 }
4561 errorBody := bytes.NewReader(errorBuffer.Bytes())
4562
4563 errorCode := "UnknownError"
4564 errorMessage := errorCode
4565
4566 headerCode := response.Header.Get("X-Amzn-ErrorType")
4567 if len(headerCode) != 0 {
4568 errorCode = restjson.SanitizeErrorCode(headerCode)
4569 }
4570
4571 var buff [1024]byte
4572 ringBuffer := smithyio.NewRingBuffer(buff[:])
4573
4574 body := io.TeeReader(errorBody, ringBuffer)
4575 decoder := json.NewDecoder(body)
4576 decoder.UseNumber()
4577 jsonCode, message, err := restjson.GetErrorInfo(decoder)
4578 if err != nil {
4579 var snapshot bytes.Buffer
4580 io.Copy(&snapshot, ringBuffer)
4581 err = &smithy.DeserializationError{
4582 Err: fmt.Errorf("failed to decode response body, %w", err),
4583 Snapshot: snapshot.Bytes(),
4584 }
4585 return err
4586 }
4587
4588 errorBody.Seek(0, io.SeekStart)
4589 if len(headerCode) == 0 && len(jsonCode) != 0 {
4590 errorCode = restjson.SanitizeErrorCode(jsonCode)
4591 }
4592 if len(message) != 0 {
4593 errorMessage = message
4594 }
4595
4596 switch {
4597 case strings.EqualFold("InvalidParameterException", errorCode):
4598 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
4599
4600 case strings.EqualFold("LifecyclePolicyNotFoundException", errorCode):
4601 return awsAwsjson11_deserializeErrorLifecyclePolicyNotFoundException(response, errorBody)
4602
4603 case strings.EqualFold("LifecyclePolicyPreviewInProgressException", errorCode):
4604 return awsAwsjson11_deserializeErrorLifecyclePolicyPreviewInProgressException(response, errorBody)
4605
4606 case strings.EqualFold("RepositoryNotFoundException", errorCode):
4607 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
4608
4609 case strings.EqualFold("ServerException", errorCode):
4610 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
4611
4612 case strings.EqualFold("ValidationException", errorCode):
4613 return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
4614
4615 default:
4616 genericError := &smithy.GenericAPIError{
4617 Code: errorCode,
4618 Message: errorMessage,
4619 }
4620 return genericError
4621
4622 }
4623 }
4624
4625 type awsAwsjson11_deserializeOpTagResource struct {
4626 }
4627
4628 func (*awsAwsjson11_deserializeOpTagResource) ID() string {
4629 return "OperationDeserializer"
4630 }
4631
4632 func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4633 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4634 ) {
4635 out, metadata, err = next.HandleDeserialize(ctx, in)
4636 if err != nil {
4637 return out, metadata, err
4638 }
4639
4640 response, ok := out.RawResponse.(*smithyhttp.Response)
4641 if !ok {
4642 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4643 }
4644
4645 if response.StatusCode < 200 || response.StatusCode >= 300 {
4646 return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata)
4647 }
4648 output := &TagResourceOutput{}
4649 out.Result = output
4650
4651 var buff [1024]byte
4652 ringBuffer := smithyio.NewRingBuffer(buff[:])
4653
4654 body := io.TeeReader(response.Body, ringBuffer)
4655 decoder := json.NewDecoder(body)
4656 decoder.UseNumber()
4657 var shape interface{}
4658 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4659 var snapshot bytes.Buffer
4660 io.Copy(&snapshot, ringBuffer)
4661 err = &smithy.DeserializationError{
4662 Err: fmt.Errorf("failed to decode response body, %w", err),
4663 Snapshot: snapshot.Bytes(),
4664 }
4665 return out, metadata, err
4666 }
4667
4668 err = awsAwsjson11_deserializeOpDocumentTagResourceOutput(&output, shape)
4669 if err != nil {
4670 var snapshot bytes.Buffer
4671 io.Copy(&snapshot, ringBuffer)
4672 err = &smithy.DeserializationError{
4673 Err: fmt.Errorf("failed to decode response body, %w", err),
4674 Snapshot: snapshot.Bytes(),
4675 }
4676 return out, metadata, err
4677 }
4678
4679 return out, metadata, err
4680 }
4681
4682 func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4683 var errorBuffer bytes.Buffer
4684 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4685 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4686 }
4687 errorBody := bytes.NewReader(errorBuffer.Bytes())
4688
4689 errorCode := "UnknownError"
4690 errorMessage := errorCode
4691
4692 headerCode := response.Header.Get("X-Amzn-ErrorType")
4693 if len(headerCode) != 0 {
4694 errorCode = restjson.SanitizeErrorCode(headerCode)
4695 }
4696
4697 var buff [1024]byte
4698 ringBuffer := smithyio.NewRingBuffer(buff[:])
4699
4700 body := io.TeeReader(errorBody, ringBuffer)
4701 decoder := json.NewDecoder(body)
4702 decoder.UseNumber()
4703 jsonCode, message, err := restjson.GetErrorInfo(decoder)
4704 if err != nil {
4705 var snapshot bytes.Buffer
4706 io.Copy(&snapshot, ringBuffer)
4707 err = &smithy.DeserializationError{
4708 Err: fmt.Errorf("failed to decode response body, %w", err),
4709 Snapshot: snapshot.Bytes(),
4710 }
4711 return err
4712 }
4713
4714 errorBody.Seek(0, io.SeekStart)
4715 if len(headerCode) == 0 && len(jsonCode) != 0 {
4716 errorCode = restjson.SanitizeErrorCode(jsonCode)
4717 }
4718 if len(message) != 0 {
4719 errorMessage = message
4720 }
4721
4722 switch {
4723 case strings.EqualFold("InvalidParameterException", errorCode):
4724 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
4725
4726 case strings.EqualFold("InvalidTagParameterException", errorCode):
4727 return awsAwsjson11_deserializeErrorInvalidTagParameterException(response, errorBody)
4728
4729 case strings.EqualFold("RepositoryNotFoundException", errorCode):
4730 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
4731
4732 case strings.EqualFold("ServerException", errorCode):
4733 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
4734
4735 case strings.EqualFold("TooManyTagsException", errorCode):
4736 return awsAwsjson11_deserializeErrorTooManyTagsException(response, errorBody)
4737
4738 default:
4739 genericError := &smithy.GenericAPIError{
4740 Code: errorCode,
4741 Message: errorMessage,
4742 }
4743 return genericError
4744
4745 }
4746 }
4747
4748 type awsAwsjson11_deserializeOpUntagResource struct {
4749 }
4750
4751 func (*awsAwsjson11_deserializeOpUntagResource) ID() string {
4752 return "OperationDeserializer"
4753 }
4754
4755 func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4756 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4757 ) {
4758 out, metadata, err = next.HandleDeserialize(ctx, in)
4759 if err != nil {
4760 return out, metadata, err
4761 }
4762
4763 response, ok := out.RawResponse.(*smithyhttp.Response)
4764 if !ok {
4765 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4766 }
4767
4768 if response.StatusCode < 200 || response.StatusCode >= 300 {
4769 return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata)
4770 }
4771 output := &UntagResourceOutput{}
4772 out.Result = output
4773
4774 var buff [1024]byte
4775 ringBuffer := smithyio.NewRingBuffer(buff[:])
4776
4777 body := io.TeeReader(response.Body, ringBuffer)
4778 decoder := json.NewDecoder(body)
4779 decoder.UseNumber()
4780 var shape interface{}
4781 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4782 var snapshot bytes.Buffer
4783 io.Copy(&snapshot, ringBuffer)
4784 err = &smithy.DeserializationError{
4785 Err: fmt.Errorf("failed to decode response body, %w", err),
4786 Snapshot: snapshot.Bytes(),
4787 }
4788 return out, metadata, err
4789 }
4790
4791 err = awsAwsjson11_deserializeOpDocumentUntagResourceOutput(&output, shape)
4792 if err != nil {
4793 var snapshot bytes.Buffer
4794 io.Copy(&snapshot, ringBuffer)
4795 err = &smithy.DeserializationError{
4796 Err: fmt.Errorf("failed to decode response body, %w", err),
4797 Snapshot: snapshot.Bytes(),
4798 }
4799 return out, metadata, err
4800 }
4801
4802 return out, metadata, err
4803 }
4804
4805 func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4806 var errorBuffer bytes.Buffer
4807 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4808 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4809 }
4810 errorBody := bytes.NewReader(errorBuffer.Bytes())
4811
4812 errorCode := "UnknownError"
4813 errorMessage := errorCode
4814
4815 headerCode := response.Header.Get("X-Amzn-ErrorType")
4816 if len(headerCode) != 0 {
4817 errorCode = restjson.SanitizeErrorCode(headerCode)
4818 }
4819
4820 var buff [1024]byte
4821 ringBuffer := smithyio.NewRingBuffer(buff[:])
4822
4823 body := io.TeeReader(errorBody, ringBuffer)
4824 decoder := json.NewDecoder(body)
4825 decoder.UseNumber()
4826 jsonCode, message, err := restjson.GetErrorInfo(decoder)
4827 if err != nil {
4828 var snapshot bytes.Buffer
4829 io.Copy(&snapshot, ringBuffer)
4830 err = &smithy.DeserializationError{
4831 Err: fmt.Errorf("failed to decode response body, %w", err),
4832 Snapshot: snapshot.Bytes(),
4833 }
4834 return err
4835 }
4836
4837 errorBody.Seek(0, io.SeekStart)
4838 if len(headerCode) == 0 && len(jsonCode) != 0 {
4839 errorCode = restjson.SanitizeErrorCode(jsonCode)
4840 }
4841 if len(message) != 0 {
4842 errorMessage = message
4843 }
4844
4845 switch {
4846 case strings.EqualFold("InvalidParameterException", errorCode):
4847 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
4848
4849 case strings.EqualFold("InvalidTagParameterException", errorCode):
4850 return awsAwsjson11_deserializeErrorInvalidTagParameterException(response, errorBody)
4851
4852 case strings.EqualFold("RepositoryNotFoundException", errorCode):
4853 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
4854
4855 case strings.EqualFold("ServerException", errorCode):
4856 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
4857
4858 case strings.EqualFold("TooManyTagsException", errorCode):
4859 return awsAwsjson11_deserializeErrorTooManyTagsException(response, errorBody)
4860
4861 default:
4862 genericError := &smithy.GenericAPIError{
4863 Code: errorCode,
4864 Message: errorMessage,
4865 }
4866 return genericError
4867
4868 }
4869 }
4870
4871 type awsAwsjson11_deserializeOpUploadLayerPart struct {
4872 }
4873
4874 func (*awsAwsjson11_deserializeOpUploadLayerPart) ID() string {
4875 return "OperationDeserializer"
4876 }
4877
4878 func (m *awsAwsjson11_deserializeOpUploadLayerPart) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4879 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4880 ) {
4881 out, metadata, err = next.HandleDeserialize(ctx, in)
4882 if err != nil {
4883 return out, metadata, err
4884 }
4885
4886 response, ok := out.RawResponse.(*smithyhttp.Response)
4887 if !ok {
4888 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4889 }
4890
4891 if response.StatusCode < 200 || response.StatusCode >= 300 {
4892 return out, metadata, awsAwsjson11_deserializeOpErrorUploadLayerPart(response, &metadata)
4893 }
4894 output := &UploadLayerPartOutput{}
4895 out.Result = output
4896
4897 var buff [1024]byte
4898 ringBuffer := smithyio.NewRingBuffer(buff[:])
4899
4900 body := io.TeeReader(response.Body, ringBuffer)
4901 decoder := json.NewDecoder(body)
4902 decoder.UseNumber()
4903 var shape interface{}
4904 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
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 out, metadata, err
4912 }
4913
4914 err = awsAwsjson11_deserializeOpDocumentUploadLayerPartOutput(&output, shape)
4915 if err != nil {
4916 var snapshot bytes.Buffer
4917 io.Copy(&snapshot, ringBuffer)
4918 err = &smithy.DeserializationError{
4919 Err: fmt.Errorf("failed to decode response body, %w", err),
4920 Snapshot: snapshot.Bytes(),
4921 }
4922 return out, metadata, err
4923 }
4924
4925 return out, metadata, err
4926 }
4927
4928 func awsAwsjson11_deserializeOpErrorUploadLayerPart(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4929 var errorBuffer bytes.Buffer
4930 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4931 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4932 }
4933 errorBody := bytes.NewReader(errorBuffer.Bytes())
4934
4935 errorCode := "UnknownError"
4936 errorMessage := errorCode
4937
4938 headerCode := response.Header.Get("X-Amzn-ErrorType")
4939 if len(headerCode) != 0 {
4940 errorCode = restjson.SanitizeErrorCode(headerCode)
4941 }
4942
4943 var buff [1024]byte
4944 ringBuffer := smithyio.NewRingBuffer(buff[:])
4945
4946 body := io.TeeReader(errorBody, ringBuffer)
4947 decoder := json.NewDecoder(body)
4948 decoder.UseNumber()
4949 jsonCode, message, err := restjson.GetErrorInfo(decoder)
4950 if err != nil {
4951 var snapshot bytes.Buffer
4952 io.Copy(&snapshot, ringBuffer)
4953 err = &smithy.DeserializationError{
4954 Err: fmt.Errorf("failed to decode response body, %w", err),
4955 Snapshot: snapshot.Bytes(),
4956 }
4957 return err
4958 }
4959
4960 errorBody.Seek(0, io.SeekStart)
4961 if len(headerCode) == 0 && len(jsonCode) != 0 {
4962 errorCode = restjson.SanitizeErrorCode(jsonCode)
4963 }
4964 if len(message) != 0 {
4965 errorMessage = message
4966 }
4967
4968 switch {
4969 case strings.EqualFold("InvalidLayerPartException", errorCode):
4970 return awsAwsjson11_deserializeErrorInvalidLayerPartException(response, errorBody)
4971
4972 case strings.EqualFold("InvalidParameterException", errorCode):
4973 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
4974
4975 case strings.EqualFold("KmsException", errorCode):
4976 return awsAwsjson11_deserializeErrorKmsException(response, errorBody)
4977
4978 case strings.EqualFold("LimitExceededException", errorCode):
4979 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
4980
4981 case strings.EqualFold("RepositoryNotFoundException", errorCode):
4982 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
4983
4984 case strings.EqualFold("ServerException", errorCode):
4985 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
4986
4987 case strings.EqualFold("UploadNotFoundException", errorCode):
4988 return awsAwsjson11_deserializeErrorUploadNotFoundException(response, errorBody)
4989
4990 default:
4991 genericError := &smithy.GenericAPIError{
4992 Code: errorCode,
4993 Message: errorMessage,
4994 }
4995 return genericError
4996
4997 }
4998 }
4999
5000 func awsAwsjson11_deserializeErrorEmptyUploadException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5001 var buff [1024]byte
5002 ringBuffer := smithyio.NewRingBuffer(buff[:])
5003
5004 body := io.TeeReader(errorBody, ringBuffer)
5005 decoder := json.NewDecoder(body)
5006 decoder.UseNumber()
5007 var shape interface{}
5008 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5009 var snapshot bytes.Buffer
5010 io.Copy(&snapshot, ringBuffer)
5011 err = &smithy.DeserializationError{
5012 Err: fmt.Errorf("failed to decode response body, %w", err),
5013 Snapshot: snapshot.Bytes(),
5014 }
5015 return err
5016 }
5017
5018 output := &types.EmptyUploadException{}
5019 err := awsAwsjson11_deserializeDocumentEmptyUploadException(&output, shape)
5020
5021 if err != nil {
5022 var snapshot bytes.Buffer
5023 io.Copy(&snapshot, ringBuffer)
5024 err = &smithy.DeserializationError{
5025 Err: fmt.Errorf("failed to decode response body, %w", err),
5026 Snapshot: snapshot.Bytes(),
5027 }
5028 return err
5029 }
5030
5031 errorBody.Seek(0, io.SeekStart)
5032 return output
5033 }
5034
5035 func awsAwsjson11_deserializeErrorImageAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5036 var buff [1024]byte
5037 ringBuffer := smithyio.NewRingBuffer(buff[:])
5038
5039 body := io.TeeReader(errorBody, ringBuffer)
5040 decoder := json.NewDecoder(body)
5041 decoder.UseNumber()
5042 var shape interface{}
5043 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5044 var snapshot bytes.Buffer
5045 io.Copy(&snapshot, ringBuffer)
5046 err = &smithy.DeserializationError{
5047 Err: fmt.Errorf("failed to decode response body, %w", err),
5048 Snapshot: snapshot.Bytes(),
5049 }
5050 return err
5051 }
5052
5053 output := &types.ImageAlreadyExistsException{}
5054 err := awsAwsjson11_deserializeDocumentImageAlreadyExistsException(&output, shape)
5055
5056 if err != nil {
5057 var snapshot bytes.Buffer
5058 io.Copy(&snapshot, ringBuffer)
5059 err = &smithy.DeserializationError{
5060 Err: fmt.Errorf("failed to decode response body, %w", err),
5061 Snapshot: snapshot.Bytes(),
5062 }
5063 return err
5064 }
5065
5066 errorBody.Seek(0, io.SeekStart)
5067 return output
5068 }
5069
5070 func awsAwsjson11_deserializeErrorImageDigestDoesNotMatchException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5071 var buff [1024]byte
5072 ringBuffer := smithyio.NewRingBuffer(buff[:])
5073
5074 body := io.TeeReader(errorBody, ringBuffer)
5075 decoder := json.NewDecoder(body)
5076 decoder.UseNumber()
5077 var shape interface{}
5078 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5079 var snapshot bytes.Buffer
5080 io.Copy(&snapshot, ringBuffer)
5081 err = &smithy.DeserializationError{
5082 Err: fmt.Errorf("failed to decode response body, %w", err),
5083 Snapshot: snapshot.Bytes(),
5084 }
5085 return err
5086 }
5087
5088 output := &types.ImageDigestDoesNotMatchException{}
5089 err := awsAwsjson11_deserializeDocumentImageDigestDoesNotMatchException(&output, shape)
5090
5091 if err != nil {
5092 var snapshot bytes.Buffer
5093 io.Copy(&snapshot, ringBuffer)
5094 err = &smithy.DeserializationError{
5095 Err: fmt.Errorf("failed to decode response body, %w", err),
5096 Snapshot: snapshot.Bytes(),
5097 }
5098 return err
5099 }
5100
5101 errorBody.Seek(0, io.SeekStart)
5102 return output
5103 }
5104
5105 func awsAwsjson11_deserializeErrorImageNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5106 var buff [1024]byte
5107 ringBuffer := smithyio.NewRingBuffer(buff[:])
5108
5109 body := io.TeeReader(errorBody, ringBuffer)
5110 decoder := json.NewDecoder(body)
5111 decoder.UseNumber()
5112 var shape interface{}
5113 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5114 var snapshot bytes.Buffer
5115 io.Copy(&snapshot, ringBuffer)
5116 err = &smithy.DeserializationError{
5117 Err: fmt.Errorf("failed to decode response body, %w", err),
5118 Snapshot: snapshot.Bytes(),
5119 }
5120 return err
5121 }
5122
5123 output := &types.ImageNotFoundException{}
5124 err := awsAwsjson11_deserializeDocumentImageNotFoundException(&output, shape)
5125
5126 if err != nil {
5127 var snapshot bytes.Buffer
5128 io.Copy(&snapshot, ringBuffer)
5129 err = &smithy.DeserializationError{
5130 Err: fmt.Errorf("failed to decode response body, %w", err),
5131 Snapshot: snapshot.Bytes(),
5132 }
5133 return err
5134 }
5135
5136 errorBody.Seek(0, io.SeekStart)
5137 return output
5138 }
5139
5140 func awsAwsjson11_deserializeErrorImageTagAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5141 var buff [1024]byte
5142 ringBuffer := smithyio.NewRingBuffer(buff[:])
5143
5144 body := io.TeeReader(errorBody, ringBuffer)
5145 decoder := json.NewDecoder(body)
5146 decoder.UseNumber()
5147 var shape interface{}
5148 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5149 var snapshot bytes.Buffer
5150 io.Copy(&snapshot, ringBuffer)
5151 err = &smithy.DeserializationError{
5152 Err: fmt.Errorf("failed to decode response body, %w", err),
5153 Snapshot: snapshot.Bytes(),
5154 }
5155 return err
5156 }
5157
5158 output := &types.ImageTagAlreadyExistsException{}
5159 err := awsAwsjson11_deserializeDocumentImageTagAlreadyExistsException(&output, shape)
5160
5161 if err != nil {
5162 var snapshot bytes.Buffer
5163 io.Copy(&snapshot, ringBuffer)
5164 err = &smithy.DeserializationError{
5165 Err: fmt.Errorf("failed to decode response body, %w", err),
5166 Snapshot: snapshot.Bytes(),
5167 }
5168 return err
5169 }
5170
5171 errorBody.Seek(0, io.SeekStart)
5172 return output
5173 }
5174
5175 func awsAwsjson11_deserializeErrorInvalidLayerException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5176 var buff [1024]byte
5177 ringBuffer := smithyio.NewRingBuffer(buff[:])
5178
5179 body := io.TeeReader(errorBody, ringBuffer)
5180 decoder := json.NewDecoder(body)
5181 decoder.UseNumber()
5182 var shape interface{}
5183 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5184 var snapshot bytes.Buffer
5185 io.Copy(&snapshot, ringBuffer)
5186 err = &smithy.DeserializationError{
5187 Err: fmt.Errorf("failed to decode response body, %w", err),
5188 Snapshot: snapshot.Bytes(),
5189 }
5190 return err
5191 }
5192
5193 output := &types.InvalidLayerException{}
5194 err := awsAwsjson11_deserializeDocumentInvalidLayerException(&output, shape)
5195
5196 if err != nil {
5197 var snapshot bytes.Buffer
5198 io.Copy(&snapshot, ringBuffer)
5199 err = &smithy.DeserializationError{
5200 Err: fmt.Errorf("failed to decode response body, %w", err),
5201 Snapshot: snapshot.Bytes(),
5202 }
5203 return err
5204 }
5205
5206 errorBody.Seek(0, io.SeekStart)
5207 return output
5208 }
5209
5210 func awsAwsjson11_deserializeErrorInvalidLayerPartException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5211 var buff [1024]byte
5212 ringBuffer := smithyio.NewRingBuffer(buff[:])
5213
5214 body := io.TeeReader(errorBody, ringBuffer)
5215 decoder := json.NewDecoder(body)
5216 decoder.UseNumber()
5217 var shape interface{}
5218 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5219 var snapshot bytes.Buffer
5220 io.Copy(&snapshot, ringBuffer)
5221 err = &smithy.DeserializationError{
5222 Err: fmt.Errorf("failed to decode response body, %w", err),
5223 Snapshot: snapshot.Bytes(),
5224 }
5225 return err
5226 }
5227
5228 output := &types.InvalidLayerPartException{}
5229 err := awsAwsjson11_deserializeDocumentInvalidLayerPartException(&output, shape)
5230
5231 if err != nil {
5232 var snapshot bytes.Buffer
5233 io.Copy(&snapshot, ringBuffer)
5234 err = &smithy.DeserializationError{
5235 Err: fmt.Errorf("failed to decode response body, %w", err),
5236 Snapshot: snapshot.Bytes(),
5237 }
5238 return err
5239 }
5240
5241 errorBody.Seek(0, io.SeekStart)
5242 return output
5243 }
5244
5245 func awsAwsjson11_deserializeErrorInvalidParameterException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5246 var buff [1024]byte
5247 ringBuffer := smithyio.NewRingBuffer(buff[:])
5248
5249 body := io.TeeReader(errorBody, ringBuffer)
5250 decoder := json.NewDecoder(body)
5251 decoder.UseNumber()
5252 var shape interface{}
5253 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
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 err
5261 }
5262
5263 output := &types.InvalidParameterException{}
5264 err := awsAwsjson11_deserializeDocumentInvalidParameterException(&output, shape)
5265
5266 if err != nil {
5267 var snapshot bytes.Buffer
5268 io.Copy(&snapshot, ringBuffer)
5269 err = &smithy.DeserializationError{
5270 Err: fmt.Errorf("failed to decode response body, %w", err),
5271 Snapshot: snapshot.Bytes(),
5272 }
5273 return err
5274 }
5275
5276 errorBody.Seek(0, io.SeekStart)
5277 return output
5278 }
5279
5280 func awsAwsjson11_deserializeErrorInvalidTagParameterException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5281 var buff [1024]byte
5282 ringBuffer := smithyio.NewRingBuffer(buff[:])
5283
5284 body := io.TeeReader(errorBody, ringBuffer)
5285 decoder := json.NewDecoder(body)
5286 decoder.UseNumber()
5287 var shape interface{}
5288 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5289 var snapshot bytes.Buffer
5290 io.Copy(&snapshot, ringBuffer)
5291 err = &smithy.DeserializationError{
5292 Err: fmt.Errorf("failed to decode response body, %w", err),
5293 Snapshot: snapshot.Bytes(),
5294 }
5295 return err
5296 }
5297
5298 output := &types.InvalidTagParameterException{}
5299 err := awsAwsjson11_deserializeDocumentInvalidTagParameterException(&output, shape)
5300
5301 if err != nil {
5302 var snapshot bytes.Buffer
5303 io.Copy(&snapshot, ringBuffer)
5304 err = &smithy.DeserializationError{
5305 Err: fmt.Errorf("failed to decode response body, %w", err),
5306 Snapshot: snapshot.Bytes(),
5307 }
5308 return err
5309 }
5310
5311 errorBody.Seek(0, io.SeekStart)
5312 return output
5313 }
5314
5315 func awsAwsjson11_deserializeErrorKmsException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5316 var buff [1024]byte
5317 ringBuffer := smithyio.NewRingBuffer(buff[:])
5318
5319 body := io.TeeReader(errorBody, ringBuffer)
5320 decoder := json.NewDecoder(body)
5321 decoder.UseNumber()
5322 var shape interface{}
5323 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5324 var snapshot bytes.Buffer
5325 io.Copy(&snapshot, ringBuffer)
5326 err = &smithy.DeserializationError{
5327 Err: fmt.Errorf("failed to decode response body, %w", err),
5328 Snapshot: snapshot.Bytes(),
5329 }
5330 return err
5331 }
5332
5333 output := &types.KmsException{}
5334 err := awsAwsjson11_deserializeDocumentKmsException(&output, shape)
5335
5336 if err != nil {
5337 var snapshot bytes.Buffer
5338 io.Copy(&snapshot, ringBuffer)
5339 err = &smithy.DeserializationError{
5340 Err: fmt.Errorf("failed to decode response body, %w", err),
5341 Snapshot: snapshot.Bytes(),
5342 }
5343 return err
5344 }
5345
5346 errorBody.Seek(0, io.SeekStart)
5347 return output
5348 }
5349
5350 func awsAwsjson11_deserializeErrorLayerAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5351 var buff [1024]byte
5352 ringBuffer := smithyio.NewRingBuffer(buff[:])
5353
5354 body := io.TeeReader(errorBody, ringBuffer)
5355 decoder := json.NewDecoder(body)
5356 decoder.UseNumber()
5357 var shape interface{}
5358 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5359 var snapshot bytes.Buffer
5360 io.Copy(&snapshot, ringBuffer)
5361 err = &smithy.DeserializationError{
5362 Err: fmt.Errorf("failed to decode response body, %w", err),
5363 Snapshot: snapshot.Bytes(),
5364 }
5365 return err
5366 }
5367
5368 output := &types.LayerAlreadyExistsException{}
5369 err := awsAwsjson11_deserializeDocumentLayerAlreadyExistsException(&output, shape)
5370
5371 if err != nil {
5372 var snapshot bytes.Buffer
5373 io.Copy(&snapshot, ringBuffer)
5374 err = &smithy.DeserializationError{
5375 Err: fmt.Errorf("failed to decode response body, %w", err),
5376 Snapshot: snapshot.Bytes(),
5377 }
5378 return err
5379 }
5380
5381 errorBody.Seek(0, io.SeekStart)
5382 return output
5383 }
5384
5385 func awsAwsjson11_deserializeErrorLayerInaccessibleException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5386 var buff [1024]byte
5387 ringBuffer := smithyio.NewRingBuffer(buff[:])
5388
5389 body := io.TeeReader(errorBody, ringBuffer)
5390 decoder := json.NewDecoder(body)
5391 decoder.UseNumber()
5392 var shape interface{}
5393 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5394 var snapshot bytes.Buffer
5395 io.Copy(&snapshot, ringBuffer)
5396 err = &smithy.DeserializationError{
5397 Err: fmt.Errorf("failed to decode response body, %w", err),
5398 Snapshot: snapshot.Bytes(),
5399 }
5400 return err
5401 }
5402
5403 output := &types.LayerInaccessibleException{}
5404 err := awsAwsjson11_deserializeDocumentLayerInaccessibleException(&output, shape)
5405
5406 if err != nil {
5407 var snapshot bytes.Buffer
5408 io.Copy(&snapshot, ringBuffer)
5409 err = &smithy.DeserializationError{
5410 Err: fmt.Errorf("failed to decode response body, %w", err),
5411 Snapshot: snapshot.Bytes(),
5412 }
5413 return err
5414 }
5415
5416 errorBody.Seek(0, io.SeekStart)
5417 return output
5418 }
5419
5420 func awsAwsjson11_deserializeErrorLayerPartTooSmallException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5421 var buff [1024]byte
5422 ringBuffer := smithyio.NewRingBuffer(buff[:])
5423
5424 body := io.TeeReader(errorBody, ringBuffer)
5425 decoder := json.NewDecoder(body)
5426 decoder.UseNumber()
5427 var shape interface{}
5428 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5429 var snapshot bytes.Buffer
5430 io.Copy(&snapshot, ringBuffer)
5431 err = &smithy.DeserializationError{
5432 Err: fmt.Errorf("failed to decode response body, %w", err),
5433 Snapshot: snapshot.Bytes(),
5434 }
5435 return err
5436 }
5437
5438 output := &types.LayerPartTooSmallException{}
5439 err := awsAwsjson11_deserializeDocumentLayerPartTooSmallException(&output, shape)
5440
5441 if err != nil {
5442 var snapshot bytes.Buffer
5443 io.Copy(&snapshot, ringBuffer)
5444 err = &smithy.DeserializationError{
5445 Err: fmt.Errorf("failed to decode response body, %w", err),
5446 Snapshot: snapshot.Bytes(),
5447 }
5448 return err
5449 }
5450
5451 errorBody.Seek(0, io.SeekStart)
5452 return output
5453 }
5454
5455 func awsAwsjson11_deserializeErrorLayersNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5456 var buff [1024]byte
5457 ringBuffer := smithyio.NewRingBuffer(buff[:])
5458
5459 body := io.TeeReader(errorBody, ringBuffer)
5460 decoder := json.NewDecoder(body)
5461 decoder.UseNumber()
5462 var shape interface{}
5463 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5464 var snapshot bytes.Buffer
5465 io.Copy(&snapshot, ringBuffer)
5466 err = &smithy.DeserializationError{
5467 Err: fmt.Errorf("failed to decode response body, %w", err),
5468 Snapshot: snapshot.Bytes(),
5469 }
5470 return err
5471 }
5472
5473 output := &types.LayersNotFoundException{}
5474 err := awsAwsjson11_deserializeDocumentLayersNotFoundException(&output, shape)
5475
5476 if err != nil {
5477 var snapshot bytes.Buffer
5478 io.Copy(&snapshot, ringBuffer)
5479 err = &smithy.DeserializationError{
5480 Err: fmt.Errorf("failed to decode response body, %w", err),
5481 Snapshot: snapshot.Bytes(),
5482 }
5483 return err
5484 }
5485
5486 errorBody.Seek(0, io.SeekStart)
5487 return output
5488 }
5489
5490 func awsAwsjson11_deserializeErrorLifecyclePolicyNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5491 var buff [1024]byte
5492 ringBuffer := smithyio.NewRingBuffer(buff[:])
5493
5494 body := io.TeeReader(errorBody, ringBuffer)
5495 decoder := json.NewDecoder(body)
5496 decoder.UseNumber()
5497 var shape interface{}
5498 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5499 var snapshot bytes.Buffer
5500 io.Copy(&snapshot, ringBuffer)
5501 err = &smithy.DeserializationError{
5502 Err: fmt.Errorf("failed to decode response body, %w", err),
5503 Snapshot: snapshot.Bytes(),
5504 }
5505 return err
5506 }
5507
5508 output := &types.LifecyclePolicyNotFoundException{}
5509 err := awsAwsjson11_deserializeDocumentLifecyclePolicyNotFoundException(&output, shape)
5510
5511 if err != nil {
5512 var snapshot bytes.Buffer
5513 io.Copy(&snapshot, ringBuffer)
5514 err = &smithy.DeserializationError{
5515 Err: fmt.Errorf("failed to decode response body, %w", err),
5516 Snapshot: snapshot.Bytes(),
5517 }
5518 return err
5519 }
5520
5521 errorBody.Seek(0, io.SeekStart)
5522 return output
5523 }
5524
5525 func awsAwsjson11_deserializeErrorLifecyclePolicyPreviewInProgressException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5526 var buff [1024]byte
5527 ringBuffer := smithyio.NewRingBuffer(buff[:])
5528
5529 body := io.TeeReader(errorBody, ringBuffer)
5530 decoder := json.NewDecoder(body)
5531 decoder.UseNumber()
5532 var shape interface{}
5533 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5534 var snapshot bytes.Buffer
5535 io.Copy(&snapshot, ringBuffer)
5536 err = &smithy.DeserializationError{
5537 Err: fmt.Errorf("failed to decode response body, %w", err),
5538 Snapshot: snapshot.Bytes(),
5539 }
5540 return err
5541 }
5542
5543 output := &types.LifecyclePolicyPreviewInProgressException{}
5544 err := awsAwsjson11_deserializeDocumentLifecyclePolicyPreviewInProgressException(&output, shape)
5545
5546 if err != nil {
5547 var snapshot bytes.Buffer
5548 io.Copy(&snapshot, ringBuffer)
5549 err = &smithy.DeserializationError{
5550 Err: fmt.Errorf("failed to decode response body, %w", err),
5551 Snapshot: snapshot.Bytes(),
5552 }
5553 return err
5554 }
5555
5556 errorBody.Seek(0, io.SeekStart)
5557 return output
5558 }
5559
5560 func awsAwsjson11_deserializeErrorLifecyclePolicyPreviewNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5561 var buff [1024]byte
5562 ringBuffer := smithyio.NewRingBuffer(buff[:])
5563
5564 body := io.TeeReader(errorBody, ringBuffer)
5565 decoder := json.NewDecoder(body)
5566 decoder.UseNumber()
5567 var shape interface{}
5568 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5569 var snapshot bytes.Buffer
5570 io.Copy(&snapshot, ringBuffer)
5571 err = &smithy.DeserializationError{
5572 Err: fmt.Errorf("failed to decode response body, %w", err),
5573 Snapshot: snapshot.Bytes(),
5574 }
5575 return err
5576 }
5577
5578 output := &types.LifecyclePolicyPreviewNotFoundException{}
5579 err := awsAwsjson11_deserializeDocumentLifecyclePolicyPreviewNotFoundException(&output, shape)
5580
5581 if err != nil {
5582 var snapshot bytes.Buffer
5583 io.Copy(&snapshot, ringBuffer)
5584 err = &smithy.DeserializationError{
5585 Err: fmt.Errorf("failed to decode response body, %w", err),
5586 Snapshot: snapshot.Bytes(),
5587 }
5588 return err
5589 }
5590
5591 errorBody.Seek(0, io.SeekStart)
5592 return output
5593 }
5594
5595 func awsAwsjson11_deserializeErrorLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5596 var buff [1024]byte
5597 ringBuffer := smithyio.NewRingBuffer(buff[:])
5598
5599 body := io.TeeReader(errorBody, ringBuffer)
5600 decoder := json.NewDecoder(body)
5601 decoder.UseNumber()
5602 var shape interface{}
5603 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5604 var snapshot bytes.Buffer
5605 io.Copy(&snapshot, ringBuffer)
5606 err = &smithy.DeserializationError{
5607 Err: fmt.Errorf("failed to decode response body, %w", err),
5608 Snapshot: snapshot.Bytes(),
5609 }
5610 return err
5611 }
5612
5613 output := &types.LimitExceededException{}
5614 err := awsAwsjson11_deserializeDocumentLimitExceededException(&output, shape)
5615
5616 if err != nil {
5617 var snapshot bytes.Buffer
5618 io.Copy(&snapshot, ringBuffer)
5619 err = &smithy.DeserializationError{
5620 Err: fmt.Errorf("failed to decode response body, %w", err),
5621 Snapshot: snapshot.Bytes(),
5622 }
5623 return err
5624 }
5625
5626 errorBody.Seek(0, io.SeekStart)
5627 return output
5628 }
5629
5630 func awsAwsjson11_deserializeErrorPullThroughCacheRuleAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5631 var buff [1024]byte
5632 ringBuffer := smithyio.NewRingBuffer(buff[:])
5633
5634 body := io.TeeReader(errorBody, ringBuffer)
5635 decoder := json.NewDecoder(body)
5636 decoder.UseNumber()
5637 var shape interface{}
5638 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5639 var snapshot bytes.Buffer
5640 io.Copy(&snapshot, ringBuffer)
5641 err = &smithy.DeserializationError{
5642 Err: fmt.Errorf("failed to decode response body, %w", err),
5643 Snapshot: snapshot.Bytes(),
5644 }
5645 return err
5646 }
5647
5648 output := &types.PullThroughCacheRuleAlreadyExistsException{}
5649 err := awsAwsjson11_deserializeDocumentPullThroughCacheRuleAlreadyExistsException(&output, shape)
5650
5651 if err != nil {
5652 var snapshot bytes.Buffer
5653 io.Copy(&snapshot, ringBuffer)
5654 err = &smithy.DeserializationError{
5655 Err: fmt.Errorf("failed to decode response body, %w", err),
5656 Snapshot: snapshot.Bytes(),
5657 }
5658 return err
5659 }
5660
5661 errorBody.Seek(0, io.SeekStart)
5662 return output
5663 }
5664
5665 func awsAwsjson11_deserializeErrorPullThroughCacheRuleNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5666 var buff [1024]byte
5667 ringBuffer := smithyio.NewRingBuffer(buff[:])
5668
5669 body := io.TeeReader(errorBody, ringBuffer)
5670 decoder := json.NewDecoder(body)
5671 decoder.UseNumber()
5672 var shape interface{}
5673 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5674 var snapshot bytes.Buffer
5675 io.Copy(&snapshot, ringBuffer)
5676 err = &smithy.DeserializationError{
5677 Err: fmt.Errorf("failed to decode response body, %w", err),
5678 Snapshot: snapshot.Bytes(),
5679 }
5680 return err
5681 }
5682
5683 output := &types.PullThroughCacheRuleNotFoundException{}
5684 err := awsAwsjson11_deserializeDocumentPullThroughCacheRuleNotFoundException(&output, shape)
5685
5686 if err != nil {
5687 var snapshot bytes.Buffer
5688 io.Copy(&snapshot, ringBuffer)
5689 err = &smithy.DeserializationError{
5690 Err: fmt.Errorf("failed to decode response body, %w", err),
5691 Snapshot: snapshot.Bytes(),
5692 }
5693 return err
5694 }
5695
5696 errorBody.Seek(0, io.SeekStart)
5697 return output
5698 }
5699
5700 func awsAwsjson11_deserializeErrorReferencedImagesNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5701 var buff [1024]byte
5702 ringBuffer := smithyio.NewRingBuffer(buff[:])
5703
5704 body := io.TeeReader(errorBody, ringBuffer)
5705 decoder := json.NewDecoder(body)
5706 decoder.UseNumber()
5707 var shape interface{}
5708 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5709 var snapshot bytes.Buffer
5710 io.Copy(&snapshot, ringBuffer)
5711 err = &smithy.DeserializationError{
5712 Err: fmt.Errorf("failed to decode response body, %w", err),
5713 Snapshot: snapshot.Bytes(),
5714 }
5715 return err
5716 }
5717
5718 output := &types.ReferencedImagesNotFoundException{}
5719 err := awsAwsjson11_deserializeDocumentReferencedImagesNotFoundException(&output, shape)
5720
5721 if err != nil {
5722 var snapshot bytes.Buffer
5723 io.Copy(&snapshot, ringBuffer)
5724 err = &smithy.DeserializationError{
5725 Err: fmt.Errorf("failed to decode response body, %w", err),
5726 Snapshot: snapshot.Bytes(),
5727 }
5728 return err
5729 }
5730
5731 errorBody.Seek(0, io.SeekStart)
5732 return output
5733 }
5734
5735 func awsAwsjson11_deserializeErrorRegistryPolicyNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5736 var buff [1024]byte
5737 ringBuffer := smithyio.NewRingBuffer(buff[:])
5738
5739 body := io.TeeReader(errorBody, ringBuffer)
5740 decoder := json.NewDecoder(body)
5741 decoder.UseNumber()
5742 var shape interface{}
5743 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5744 var snapshot bytes.Buffer
5745 io.Copy(&snapshot, ringBuffer)
5746 err = &smithy.DeserializationError{
5747 Err: fmt.Errorf("failed to decode response body, %w", err),
5748 Snapshot: snapshot.Bytes(),
5749 }
5750 return err
5751 }
5752
5753 output := &types.RegistryPolicyNotFoundException{}
5754 err := awsAwsjson11_deserializeDocumentRegistryPolicyNotFoundException(&output, shape)
5755
5756 if err != nil {
5757 var snapshot bytes.Buffer
5758 io.Copy(&snapshot, ringBuffer)
5759 err = &smithy.DeserializationError{
5760 Err: fmt.Errorf("failed to decode response body, %w", err),
5761 Snapshot: snapshot.Bytes(),
5762 }
5763 return err
5764 }
5765
5766 errorBody.Seek(0, io.SeekStart)
5767 return output
5768 }
5769
5770 func awsAwsjson11_deserializeErrorRepositoryAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5771 var buff [1024]byte
5772 ringBuffer := smithyio.NewRingBuffer(buff[:])
5773
5774 body := io.TeeReader(errorBody, ringBuffer)
5775 decoder := json.NewDecoder(body)
5776 decoder.UseNumber()
5777 var shape interface{}
5778 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5779 var snapshot bytes.Buffer
5780 io.Copy(&snapshot, ringBuffer)
5781 err = &smithy.DeserializationError{
5782 Err: fmt.Errorf("failed to decode response body, %w", err),
5783 Snapshot: snapshot.Bytes(),
5784 }
5785 return err
5786 }
5787
5788 output := &types.RepositoryAlreadyExistsException{}
5789 err := awsAwsjson11_deserializeDocumentRepositoryAlreadyExistsException(&output, shape)
5790
5791 if err != nil {
5792 var snapshot bytes.Buffer
5793 io.Copy(&snapshot, ringBuffer)
5794 err = &smithy.DeserializationError{
5795 Err: fmt.Errorf("failed to decode response body, %w", err),
5796 Snapshot: snapshot.Bytes(),
5797 }
5798 return err
5799 }
5800
5801 errorBody.Seek(0, io.SeekStart)
5802 return output
5803 }
5804
5805 func awsAwsjson11_deserializeErrorRepositoryNotEmptyException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5806 var buff [1024]byte
5807 ringBuffer := smithyio.NewRingBuffer(buff[:])
5808
5809 body := io.TeeReader(errorBody, ringBuffer)
5810 decoder := json.NewDecoder(body)
5811 decoder.UseNumber()
5812 var shape interface{}
5813 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5814 var snapshot bytes.Buffer
5815 io.Copy(&snapshot, ringBuffer)
5816 err = &smithy.DeserializationError{
5817 Err: fmt.Errorf("failed to decode response body, %w", err),
5818 Snapshot: snapshot.Bytes(),
5819 }
5820 return err
5821 }
5822
5823 output := &types.RepositoryNotEmptyException{}
5824 err := awsAwsjson11_deserializeDocumentRepositoryNotEmptyException(&output, shape)
5825
5826 if err != nil {
5827 var snapshot bytes.Buffer
5828 io.Copy(&snapshot, ringBuffer)
5829 err = &smithy.DeserializationError{
5830 Err: fmt.Errorf("failed to decode response body, %w", err),
5831 Snapshot: snapshot.Bytes(),
5832 }
5833 return err
5834 }
5835
5836 errorBody.Seek(0, io.SeekStart)
5837 return output
5838 }
5839
5840 func awsAwsjson11_deserializeErrorRepositoryNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5841 var buff [1024]byte
5842 ringBuffer := smithyio.NewRingBuffer(buff[:])
5843
5844 body := io.TeeReader(errorBody, ringBuffer)
5845 decoder := json.NewDecoder(body)
5846 decoder.UseNumber()
5847 var shape interface{}
5848 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5849 var snapshot bytes.Buffer
5850 io.Copy(&snapshot, ringBuffer)
5851 err = &smithy.DeserializationError{
5852 Err: fmt.Errorf("failed to decode response body, %w", err),
5853 Snapshot: snapshot.Bytes(),
5854 }
5855 return err
5856 }
5857
5858 output := &types.RepositoryNotFoundException{}
5859 err := awsAwsjson11_deserializeDocumentRepositoryNotFoundException(&output, shape)
5860
5861 if err != nil {
5862 var snapshot bytes.Buffer
5863 io.Copy(&snapshot, ringBuffer)
5864 err = &smithy.DeserializationError{
5865 Err: fmt.Errorf("failed to decode response body, %w", err),
5866 Snapshot: snapshot.Bytes(),
5867 }
5868 return err
5869 }
5870
5871 errorBody.Seek(0, io.SeekStart)
5872 return output
5873 }
5874
5875 func awsAwsjson11_deserializeErrorRepositoryPolicyNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5876 var buff [1024]byte
5877 ringBuffer := smithyio.NewRingBuffer(buff[:])
5878
5879 body := io.TeeReader(errorBody, ringBuffer)
5880 decoder := json.NewDecoder(body)
5881 decoder.UseNumber()
5882 var shape interface{}
5883 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5884 var snapshot bytes.Buffer
5885 io.Copy(&snapshot, ringBuffer)
5886 err = &smithy.DeserializationError{
5887 Err: fmt.Errorf("failed to decode response body, %w", err),
5888 Snapshot: snapshot.Bytes(),
5889 }
5890 return err
5891 }
5892
5893 output := &types.RepositoryPolicyNotFoundException{}
5894 err := awsAwsjson11_deserializeDocumentRepositoryPolicyNotFoundException(&output, shape)
5895
5896 if err != nil {
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 err
5904 }
5905
5906 errorBody.Seek(0, io.SeekStart)
5907 return output
5908 }
5909
5910 func awsAwsjson11_deserializeErrorScanNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5911 var buff [1024]byte
5912 ringBuffer := smithyio.NewRingBuffer(buff[:])
5913
5914 body := io.TeeReader(errorBody, ringBuffer)
5915 decoder := json.NewDecoder(body)
5916 decoder.UseNumber()
5917 var shape interface{}
5918 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5919 var snapshot bytes.Buffer
5920 io.Copy(&snapshot, ringBuffer)
5921 err = &smithy.DeserializationError{
5922 Err: fmt.Errorf("failed to decode response body, %w", err),
5923 Snapshot: snapshot.Bytes(),
5924 }
5925 return err
5926 }
5927
5928 output := &types.ScanNotFoundException{}
5929 err := awsAwsjson11_deserializeDocumentScanNotFoundException(&output, shape)
5930
5931 if err != nil {
5932 var snapshot bytes.Buffer
5933 io.Copy(&snapshot, ringBuffer)
5934 err = &smithy.DeserializationError{
5935 Err: fmt.Errorf("failed to decode response body, %w", err),
5936 Snapshot: snapshot.Bytes(),
5937 }
5938 return err
5939 }
5940
5941 errorBody.Seek(0, io.SeekStart)
5942 return output
5943 }
5944
5945 func awsAwsjson11_deserializeErrorServerException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5946 var buff [1024]byte
5947 ringBuffer := smithyio.NewRingBuffer(buff[:])
5948
5949 body := io.TeeReader(errorBody, ringBuffer)
5950 decoder := json.NewDecoder(body)
5951 decoder.UseNumber()
5952 var shape interface{}
5953 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5954 var snapshot bytes.Buffer
5955 io.Copy(&snapshot, ringBuffer)
5956 err = &smithy.DeserializationError{
5957 Err: fmt.Errorf("failed to decode response body, %w", err),
5958 Snapshot: snapshot.Bytes(),
5959 }
5960 return err
5961 }
5962
5963 output := &types.ServerException{}
5964 err := awsAwsjson11_deserializeDocumentServerException(&output, shape)
5965
5966 if err != nil {
5967 var snapshot bytes.Buffer
5968 io.Copy(&snapshot, ringBuffer)
5969 err = &smithy.DeserializationError{
5970 Err: fmt.Errorf("failed to decode response body, %w", err),
5971 Snapshot: snapshot.Bytes(),
5972 }
5973 return err
5974 }
5975
5976 errorBody.Seek(0, io.SeekStart)
5977 return output
5978 }
5979
5980 func awsAwsjson11_deserializeErrorTooManyTagsException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5981 var buff [1024]byte
5982 ringBuffer := smithyio.NewRingBuffer(buff[:])
5983
5984 body := io.TeeReader(errorBody, ringBuffer)
5985 decoder := json.NewDecoder(body)
5986 decoder.UseNumber()
5987 var shape interface{}
5988 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5989 var snapshot bytes.Buffer
5990 io.Copy(&snapshot, ringBuffer)
5991 err = &smithy.DeserializationError{
5992 Err: fmt.Errorf("failed to decode response body, %w", err),
5993 Snapshot: snapshot.Bytes(),
5994 }
5995 return err
5996 }
5997
5998 output := &types.TooManyTagsException{}
5999 err := awsAwsjson11_deserializeDocumentTooManyTagsException(&output, shape)
6000
6001 if err != nil {
6002 var snapshot bytes.Buffer
6003 io.Copy(&snapshot, ringBuffer)
6004 err = &smithy.DeserializationError{
6005 Err: fmt.Errorf("failed to decode response body, %w", err),
6006 Snapshot: snapshot.Bytes(),
6007 }
6008 return err
6009 }
6010
6011 errorBody.Seek(0, io.SeekStart)
6012 return output
6013 }
6014
6015 func awsAwsjson11_deserializeErrorUnsupportedImageTypeException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6016 var buff [1024]byte
6017 ringBuffer := smithyio.NewRingBuffer(buff[:])
6018
6019 body := io.TeeReader(errorBody, ringBuffer)
6020 decoder := json.NewDecoder(body)
6021 decoder.UseNumber()
6022 var shape interface{}
6023 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6024 var snapshot bytes.Buffer
6025 io.Copy(&snapshot, ringBuffer)
6026 err = &smithy.DeserializationError{
6027 Err: fmt.Errorf("failed to decode response body, %w", err),
6028 Snapshot: snapshot.Bytes(),
6029 }
6030 return err
6031 }
6032
6033 output := &types.UnsupportedImageTypeException{}
6034 err := awsAwsjson11_deserializeDocumentUnsupportedImageTypeException(&output, shape)
6035
6036 if err != nil {
6037 var snapshot bytes.Buffer
6038 io.Copy(&snapshot, ringBuffer)
6039 err = &smithy.DeserializationError{
6040 Err: fmt.Errorf("failed to decode response body, %w", err),
6041 Snapshot: snapshot.Bytes(),
6042 }
6043 return err
6044 }
6045
6046 errorBody.Seek(0, io.SeekStart)
6047 return output
6048 }
6049
6050 func awsAwsjson11_deserializeErrorUnsupportedUpstreamRegistryException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6051 var buff [1024]byte
6052 ringBuffer := smithyio.NewRingBuffer(buff[:])
6053
6054 body := io.TeeReader(errorBody, ringBuffer)
6055 decoder := json.NewDecoder(body)
6056 decoder.UseNumber()
6057 var shape interface{}
6058 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6059 var snapshot bytes.Buffer
6060 io.Copy(&snapshot, ringBuffer)
6061 err = &smithy.DeserializationError{
6062 Err: fmt.Errorf("failed to decode response body, %w", err),
6063 Snapshot: snapshot.Bytes(),
6064 }
6065 return err
6066 }
6067
6068 output := &types.UnsupportedUpstreamRegistryException{}
6069 err := awsAwsjson11_deserializeDocumentUnsupportedUpstreamRegistryException(&output, shape)
6070
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 return output
6083 }
6084
6085 func awsAwsjson11_deserializeErrorUploadNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6086 var buff [1024]byte
6087 ringBuffer := smithyio.NewRingBuffer(buff[:])
6088
6089 body := io.TeeReader(errorBody, ringBuffer)
6090 decoder := json.NewDecoder(body)
6091 decoder.UseNumber()
6092 var shape interface{}
6093 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6094 var snapshot bytes.Buffer
6095 io.Copy(&snapshot, ringBuffer)
6096 err = &smithy.DeserializationError{
6097 Err: fmt.Errorf("failed to decode response body, %w", err),
6098 Snapshot: snapshot.Bytes(),
6099 }
6100 return err
6101 }
6102
6103 output := &types.UploadNotFoundException{}
6104 err := awsAwsjson11_deserializeDocumentUploadNotFoundException(&output, shape)
6105
6106 if err != nil {
6107 var snapshot bytes.Buffer
6108 io.Copy(&snapshot, ringBuffer)
6109 err = &smithy.DeserializationError{
6110 Err: fmt.Errorf("failed to decode response body, %w", err),
6111 Snapshot: snapshot.Bytes(),
6112 }
6113 return err
6114 }
6115
6116 errorBody.Seek(0, io.SeekStart)
6117 return output
6118 }
6119
6120 func awsAwsjson11_deserializeErrorValidationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6121 var buff [1024]byte
6122 ringBuffer := smithyio.NewRingBuffer(buff[:])
6123
6124 body := io.TeeReader(errorBody, ringBuffer)
6125 decoder := json.NewDecoder(body)
6126 decoder.UseNumber()
6127 var shape interface{}
6128 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6129 var snapshot bytes.Buffer
6130 io.Copy(&snapshot, ringBuffer)
6131 err = &smithy.DeserializationError{
6132 Err: fmt.Errorf("failed to decode response body, %w", err),
6133 Snapshot: snapshot.Bytes(),
6134 }
6135 return err
6136 }
6137
6138 output := &types.ValidationException{}
6139 err := awsAwsjson11_deserializeDocumentValidationException(&output, shape)
6140
6141 if err != nil {
6142 var snapshot bytes.Buffer
6143 io.Copy(&snapshot, ringBuffer)
6144 err = &smithy.DeserializationError{
6145 Err: fmt.Errorf("failed to decode response body, %w", err),
6146 Snapshot: snapshot.Bytes(),
6147 }
6148 return err
6149 }
6150
6151 errorBody.Seek(0, io.SeekStart)
6152 return output
6153 }
6154
6155 func awsAwsjson11_deserializeDocumentAttribute(v **types.Attribute, value interface{}) error {
6156 if v == nil {
6157 return fmt.Errorf("unexpected nil of type %T", v)
6158 }
6159 if value == nil {
6160 return nil
6161 }
6162
6163 shape, ok := value.(map[string]interface{})
6164 if !ok {
6165 return fmt.Errorf("unexpected JSON type %v", value)
6166 }
6167
6168 var sv *types.Attribute
6169 if *v == nil {
6170 sv = &types.Attribute{}
6171 } else {
6172 sv = *v
6173 }
6174
6175 for key, value := range shape {
6176 switch key {
6177 case "key":
6178 if value != nil {
6179 jtv, ok := value.(string)
6180 if !ok {
6181 return fmt.Errorf("expected AttributeKey to be of type string, got %T instead", value)
6182 }
6183 sv.Key = ptr.String(jtv)
6184 }
6185
6186 case "value":
6187 if value != nil {
6188 jtv, ok := value.(string)
6189 if !ok {
6190 return fmt.Errorf("expected AttributeValue to be of type string, got %T instead", value)
6191 }
6192 sv.Value = ptr.String(jtv)
6193 }
6194
6195 default:
6196 _, _ = key, value
6197
6198 }
6199 }
6200 *v = sv
6201 return nil
6202 }
6203
6204 func awsAwsjson11_deserializeDocumentAttributeList(v *[]types.Attribute, value interface{}) error {
6205 if v == nil {
6206 return fmt.Errorf("unexpected nil of type %T", v)
6207 }
6208 if value == nil {
6209 return nil
6210 }
6211
6212 shape, ok := value.([]interface{})
6213 if !ok {
6214 return fmt.Errorf("unexpected JSON type %v", value)
6215 }
6216
6217 var cv []types.Attribute
6218 if *v == nil {
6219 cv = []types.Attribute{}
6220 } else {
6221 cv = *v
6222 }
6223
6224 for _, value := range shape {
6225 var col types.Attribute
6226 destAddr := &col
6227 if err := awsAwsjson11_deserializeDocumentAttribute(&destAddr, value); err != nil {
6228 return err
6229 }
6230 col = *destAddr
6231 cv = append(cv, col)
6232
6233 }
6234 *v = cv
6235 return nil
6236 }
6237
6238 func awsAwsjson11_deserializeDocumentAuthorizationData(v **types.AuthorizationData, value interface{}) error {
6239 if v == nil {
6240 return fmt.Errorf("unexpected nil of type %T", v)
6241 }
6242 if value == nil {
6243 return nil
6244 }
6245
6246 shape, ok := value.(map[string]interface{})
6247 if !ok {
6248 return fmt.Errorf("unexpected JSON type %v", value)
6249 }
6250
6251 var sv *types.AuthorizationData
6252 if *v == nil {
6253 sv = &types.AuthorizationData{}
6254 } else {
6255 sv = *v
6256 }
6257
6258 for key, value := range shape {
6259 switch key {
6260 case "authorizationToken":
6261 if value != nil {
6262 jtv, ok := value.(string)
6263 if !ok {
6264 return fmt.Errorf("expected Base64 to be of type string, got %T instead", value)
6265 }
6266 sv.AuthorizationToken = ptr.String(jtv)
6267 }
6268
6269 case "expiresAt":
6270 if value != nil {
6271 switch jtv := value.(type) {
6272 case json.Number:
6273 f64, err := jtv.Float64()
6274 if err != nil {
6275 return err
6276 }
6277 sv.ExpiresAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
6278
6279 default:
6280 return fmt.Errorf("expected ExpirationTimestamp to be a JSON Number, got %T instead", value)
6281
6282 }
6283 }
6284
6285 case "proxyEndpoint":
6286 if value != nil {
6287 jtv, ok := value.(string)
6288 if !ok {
6289 return fmt.Errorf("expected ProxyEndpoint to be of type string, got %T instead", value)
6290 }
6291 sv.ProxyEndpoint = ptr.String(jtv)
6292 }
6293
6294 default:
6295 _, _ = key, value
6296
6297 }
6298 }
6299 *v = sv
6300 return nil
6301 }
6302
6303 func awsAwsjson11_deserializeDocumentAuthorizationDataList(v *[]types.AuthorizationData, value interface{}) error {
6304 if v == nil {
6305 return fmt.Errorf("unexpected nil of type %T", v)
6306 }
6307 if value == nil {
6308 return nil
6309 }
6310
6311 shape, ok := value.([]interface{})
6312 if !ok {
6313 return fmt.Errorf("unexpected JSON type %v", value)
6314 }
6315
6316 var cv []types.AuthorizationData
6317 if *v == nil {
6318 cv = []types.AuthorizationData{}
6319 } else {
6320 cv = *v
6321 }
6322
6323 for _, value := range shape {
6324 var col types.AuthorizationData
6325 destAddr := &col
6326 if err := awsAwsjson11_deserializeDocumentAuthorizationData(&destAddr, value); err != nil {
6327 return err
6328 }
6329 col = *destAddr
6330 cv = append(cv, col)
6331
6332 }
6333 *v = cv
6334 return nil
6335 }
6336
6337 func awsAwsjson11_deserializeDocumentAwsEcrContainerImageDetails(v **types.AwsEcrContainerImageDetails, value interface{}) error {
6338 if v == nil {
6339 return fmt.Errorf("unexpected nil of type %T", v)
6340 }
6341 if value == nil {
6342 return nil
6343 }
6344
6345 shape, ok := value.(map[string]interface{})
6346 if !ok {
6347 return fmt.Errorf("unexpected JSON type %v", value)
6348 }
6349
6350 var sv *types.AwsEcrContainerImageDetails
6351 if *v == nil {
6352 sv = &types.AwsEcrContainerImageDetails{}
6353 } else {
6354 sv = *v
6355 }
6356
6357 for key, value := range shape {
6358 switch key {
6359 case "architecture":
6360 if value != nil {
6361 jtv, ok := value.(string)
6362 if !ok {
6363 return fmt.Errorf("expected Arch to be of type string, got %T instead", value)
6364 }
6365 sv.Architecture = ptr.String(jtv)
6366 }
6367
6368 case "author":
6369 if value != nil {
6370 jtv, ok := value.(string)
6371 if !ok {
6372 return fmt.Errorf("expected Author to be of type string, got %T instead", value)
6373 }
6374 sv.Author = ptr.String(jtv)
6375 }
6376
6377 case "imageHash":
6378 if value != nil {
6379 jtv, ok := value.(string)
6380 if !ok {
6381 return fmt.Errorf("expected ImageDigest to be of type string, got %T instead", value)
6382 }
6383 sv.ImageHash = ptr.String(jtv)
6384 }
6385
6386 case "imageTags":
6387 if err := awsAwsjson11_deserializeDocumentImageTagsList(&sv.ImageTags, value); err != nil {
6388 return err
6389 }
6390
6391 case "platform":
6392 if value != nil {
6393 jtv, ok := value.(string)
6394 if !ok {
6395 return fmt.Errorf("expected Platform to be of type string, got %T instead", value)
6396 }
6397 sv.Platform = ptr.String(jtv)
6398 }
6399
6400 case "pushedAt":
6401 if value != nil {
6402 switch jtv := value.(type) {
6403 case json.Number:
6404 f64, err := jtv.Float64()
6405 if err != nil {
6406 return err
6407 }
6408 sv.PushedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
6409
6410 default:
6411 return fmt.Errorf("expected Date to be a JSON Number, got %T instead", value)
6412
6413 }
6414 }
6415
6416 case "registry":
6417 if value != nil {
6418 jtv, ok := value.(string)
6419 if !ok {
6420 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
6421 }
6422 sv.Registry = ptr.String(jtv)
6423 }
6424
6425 case "repositoryName":
6426 if value != nil {
6427 jtv, ok := value.(string)
6428 if !ok {
6429 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
6430 }
6431 sv.RepositoryName = ptr.String(jtv)
6432 }
6433
6434 default:
6435 _, _ = key, value
6436
6437 }
6438 }
6439 *v = sv
6440 return nil
6441 }
6442
6443 func awsAwsjson11_deserializeDocumentCvssScore(v **types.CvssScore, value interface{}) error {
6444 if v == nil {
6445 return fmt.Errorf("unexpected nil of type %T", v)
6446 }
6447 if value == nil {
6448 return nil
6449 }
6450
6451 shape, ok := value.(map[string]interface{})
6452 if !ok {
6453 return fmt.Errorf("unexpected JSON type %v", value)
6454 }
6455
6456 var sv *types.CvssScore
6457 if *v == nil {
6458 sv = &types.CvssScore{}
6459 } else {
6460 sv = *v
6461 }
6462
6463 for key, value := range shape {
6464 switch key {
6465 case "baseScore":
6466 if value != nil {
6467 switch jtv := value.(type) {
6468 case json.Number:
6469 f64, err := jtv.Float64()
6470 if err != nil {
6471 return err
6472 }
6473 sv.BaseScore = f64
6474
6475 case string:
6476 var f64 float64
6477 switch {
6478 case strings.EqualFold(jtv, "NaN"):
6479 f64 = math.NaN()
6480
6481 case strings.EqualFold(jtv, "Infinity"):
6482 f64 = math.Inf(1)
6483
6484 case strings.EqualFold(jtv, "-Infinity"):
6485 f64 = math.Inf(-1)
6486
6487 default:
6488 return fmt.Errorf("unknown JSON number value: %s", jtv)
6489
6490 }
6491 sv.BaseScore = f64
6492
6493 default:
6494 return fmt.Errorf("expected BaseScore to be a JSON Number, got %T instead", value)
6495
6496 }
6497 }
6498
6499 case "scoringVector":
6500 if value != nil {
6501 jtv, ok := value.(string)
6502 if !ok {
6503 return fmt.Errorf("expected ScoringVector to be of type string, got %T instead", value)
6504 }
6505 sv.ScoringVector = ptr.String(jtv)
6506 }
6507
6508 case "source":
6509 if value != nil {
6510 jtv, ok := value.(string)
6511 if !ok {
6512 return fmt.Errorf("expected Source to be of type string, got %T instead", value)
6513 }
6514 sv.Source = ptr.String(jtv)
6515 }
6516
6517 case "version":
6518 if value != nil {
6519 jtv, ok := value.(string)
6520 if !ok {
6521 return fmt.Errorf("expected Version to be of type string, got %T instead", value)
6522 }
6523 sv.Version = ptr.String(jtv)
6524 }
6525
6526 default:
6527 _, _ = key, value
6528
6529 }
6530 }
6531 *v = sv
6532 return nil
6533 }
6534
6535 func awsAwsjson11_deserializeDocumentCvssScoreAdjustment(v **types.CvssScoreAdjustment, value interface{}) error {
6536 if v == nil {
6537 return fmt.Errorf("unexpected nil of type %T", v)
6538 }
6539 if value == nil {
6540 return nil
6541 }
6542
6543 shape, ok := value.(map[string]interface{})
6544 if !ok {
6545 return fmt.Errorf("unexpected JSON type %v", value)
6546 }
6547
6548 var sv *types.CvssScoreAdjustment
6549 if *v == nil {
6550 sv = &types.CvssScoreAdjustment{}
6551 } else {
6552 sv = *v
6553 }
6554
6555 for key, value := range shape {
6556 switch key {
6557 case "metric":
6558 if value != nil {
6559 jtv, ok := value.(string)
6560 if !ok {
6561 return fmt.Errorf("expected Metric to be of type string, got %T instead", value)
6562 }
6563 sv.Metric = ptr.String(jtv)
6564 }
6565
6566 case "reason":
6567 if value != nil {
6568 jtv, ok := value.(string)
6569 if !ok {
6570 return fmt.Errorf("expected Reason to be of type string, got %T instead", value)
6571 }
6572 sv.Reason = ptr.String(jtv)
6573 }
6574
6575 default:
6576 _, _ = key, value
6577
6578 }
6579 }
6580 *v = sv
6581 return nil
6582 }
6583
6584 func awsAwsjson11_deserializeDocumentCvssScoreAdjustmentList(v *[]types.CvssScoreAdjustment, value interface{}) error {
6585 if v == nil {
6586 return fmt.Errorf("unexpected nil of type %T", v)
6587 }
6588 if value == nil {
6589 return nil
6590 }
6591
6592 shape, ok := value.([]interface{})
6593 if !ok {
6594 return fmt.Errorf("unexpected JSON type %v", value)
6595 }
6596
6597 var cv []types.CvssScoreAdjustment
6598 if *v == nil {
6599 cv = []types.CvssScoreAdjustment{}
6600 } else {
6601 cv = *v
6602 }
6603
6604 for _, value := range shape {
6605 var col types.CvssScoreAdjustment
6606 destAddr := &col
6607 if err := awsAwsjson11_deserializeDocumentCvssScoreAdjustment(&destAddr, value); err != nil {
6608 return err
6609 }
6610 col = *destAddr
6611 cv = append(cv, col)
6612
6613 }
6614 *v = cv
6615 return nil
6616 }
6617
6618 func awsAwsjson11_deserializeDocumentCvssScoreDetails(v **types.CvssScoreDetails, value interface{}) error {
6619 if v == nil {
6620 return fmt.Errorf("unexpected nil of type %T", v)
6621 }
6622 if value == nil {
6623 return nil
6624 }
6625
6626 shape, ok := value.(map[string]interface{})
6627 if !ok {
6628 return fmt.Errorf("unexpected JSON type %v", value)
6629 }
6630
6631 var sv *types.CvssScoreDetails
6632 if *v == nil {
6633 sv = &types.CvssScoreDetails{}
6634 } else {
6635 sv = *v
6636 }
6637
6638 for key, value := range shape {
6639 switch key {
6640 case "adjustments":
6641 if err := awsAwsjson11_deserializeDocumentCvssScoreAdjustmentList(&sv.Adjustments, value); err != nil {
6642 return err
6643 }
6644
6645 case "score":
6646 if value != nil {
6647 switch jtv := value.(type) {
6648 case json.Number:
6649 f64, err := jtv.Float64()
6650 if err != nil {
6651 return err
6652 }
6653 sv.Score = f64
6654
6655 case string:
6656 var f64 float64
6657 switch {
6658 case strings.EqualFold(jtv, "NaN"):
6659 f64 = math.NaN()
6660
6661 case strings.EqualFold(jtv, "Infinity"):
6662 f64 = math.Inf(1)
6663
6664 case strings.EqualFold(jtv, "-Infinity"):
6665 f64 = math.Inf(-1)
6666
6667 default:
6668 return fmt.Errorf("unknown JSON number value: %s", jtv)
6669
6670 }
6671 sv.Score = f64
6672
6673 default:
6674 return fmt.Errorf("expected Score to be a JSON Number, got %T instead", value)
6675
6676 }
6677 }
6678
6679 case "scoreSource":
6680 if value != nil {
6681 jtv, ok := value.(string)
6682 if !ok {
6683 return fmt.Errorf("expected Source to be of type string, got %T instead", value)
6684 }
6685 sv.ScoreSource = ptr.String(jtv)
6686 }
6687
6688 case "scoringVector":
6689 if value != nil {
6690 jtv, ok := value.(string)
6691 if !ok {
6692 return fmt.Errorf("expected ScoringVector to be of type string, got %T instead", value)
6693 }
6694 sv.ScoringVector = ptr.String(jtv)
6695 }
6696
6697 case "version":
6698 if value != nil {
6699 jtv, ok := value.(string)
6700 if !ok {
6701 return fmt.Errorf("expected Version to be of type string, got %T instead", value)
6702 }
6703 sv.Version = ptr.String(jtv)
6704 }
6705
6706 default:
6707 _, _ = key, value
6708
6709 }
6710 }
6711 *v = sv
6712 return nil
6713 }
6714
6715 func awsAwsjson11_deserializeDocumentCvssScoreList(v *[]types.CvssScore, value interface{}) error {
6716 if v == nil {
6717 return fmt.Errorf("unexpected nil of type %T", v)
6718 }
6719 if value == nil {
6720 return nil
6721 }
6722
6723 shape, ok := value.([]interface{})
6724 if !ok {
6725 return fmt.Errorf("unexpected JSON type %v", value)
6726 }
6727
6728 var cv []types.CvssScore
6729 if *v == nil {
6730 cv = []types.CvssScore{}
6731 } else {
6732 cv = *v
6733 }
6734
6735 for _, value := range shape {
6736 var col types.CvssScore
6737 destAddr := &col
6738 if err := awsAwsjson11_deserializeDocumentCvssScore(&destAddr, value); err != nil {
6739 return err
6740 }
6741 col = *destAddr
6742 cv = append(cv, col)
6743
6744 }
6745 *v = cv
6746 return nil
6747 }
6748
6749 func awsAwsjson11_deserializeDocumentEmptyUploadException(v **types.EmptyUploadException, value interface{}) error {
6750 if v == nil {
6751 return fmt.Errorf("unexpected nil of type %T", v)
6752 }
6753 if value == nil {
6754 return nil
6755 }
6756
6757 shape, ok := value.(map[string]interface{})
6758 if !ok {
6759 return fmt.Errorf("unexpected JSON type %v", value)
6760 }
6761
6762 var sv *types.EmptyUploadException
6763 if *v == nil {
6764 sv = &types.EmptyUploadException{}
6765 } else {
6766 sv = *v
6767 }
6768
6769 for key, value := range shape {
6770 switch key {
6771 case "message":
6772 if value != nil {
6773 jtv, ok := value.(string)
6774 if !ok {
6775 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
6776 }
6777 sv.Message = ptr.String(jtv)
6778 }
6779
6780 default:
6781 _, _ = key, value
6782
6783 }
6784 }
6785 *v = sv
6786 return nil
6787 }
6788
6789 func awsAwsjson11_deserializeDocumentEncryptionConfiguration(v **types.EncryptionConfiguration, value interface{}) error {
6790 if v == nil {
6791 return fmt.Errorf("unexpected nil of type %T", v)
6792 }
6793 if value == nil {
6794 return nil
6795 }
6796
6797 shape, ok := value.(map[string]interface{})
6798 if !ok {
6799 return fmt.Errorf("unexpected JSON type %v", value)
6800 }
6801
6802 var sv *types.EncryptionConfiguration
6803 if *v == nil {
6804 sv = &types.EncryptionConfiguration{}
6805 } else {
6806 sv = *v
6807 }
6808
6809 for key, value := range shape {
6810 switch key {
6811 case "encryptionType":
6812 if value != nil {
6813 jtv, ok := value.(string)
6814 if !ok {
6815 return fmt.Errorf("expected EncryptionType to be of type string, got %T instead", value)
6816 }
6817 sv.EncryptionType = types.EncryptionType(jtv)
6818 }
6819
6820 case "kmsKey":
6821 if value != nil {
6822 jtv, ok := value.(string)
6823 if !ok {
6824 return fmt.Errorf("expected KmsKey to be of type string, got %T instead", value)
6825 }
6826 sv.KmsKey = ptr.String(jtv)
6827 }
6828
6829 default:
6830 _, _ = key, value
6831
6832 }
6833 }
6834 *v = sv
6835 return nil
6836 }
6837
6838 func awsAwsjson11_deserializeDocumentEnhancedImageScanFinding(v **types.EnhancedImageScanFinding, value interface{}) error {
6839 if v == nil {
6840 return fmt.Errorf("unexpected nil of type %T", v)
6841 }
6842 if value == nil {
6843 return nil
6844 }
6845
6846 shape, ok := value.(map[string]interface{})
6847 if !ok {
6848 return fmt.Errorf("unexpected JSON type %v", value)
6849 }
6850
6851 var sv *types.EnhancedImageScanFinding
6852 if *v == nil {
6853 sv = &types.EnhancedImageScanFinding{}
6854 } else {
6855 sv = *v
6856 }
6857
6858 for key, value := range shape {
6859 switch key {
6860 case "awsAccountId":
6861 if value != nil {
6862 jtv, ok := value.(string)
6863 if !ok {
6864 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
6865 }
6866 sv.AwsAccountId = ptr.String(jtv)
6867 }
6868
6869 case "description":
6870 if value != nil {
6871 jtv, ok := value.(string)
6872 if !ok {
6873 return fmt.Errorf("expected FindingDescription to be of type string, got %T instead", value)
6874 }
6875 sv.Description = ptr.String(jtv)
6876 }
6877
6878 case "findingArn":
6879 if value != nil {
6880 jtv, ok := value.(string)
6881 if !ok {
6882 return fmt.Errorf("expected FindingArn to be of type string, got %T instead", value)
6883 }
6884 sv.FindingArn = ptr.String(jtv)
6885 }
6886
6887 case "firstObservedAt":
6888 if value != nil {
6889 switch jtv := value.(type) {
6890 case json.Number:
6891 f64, err := jtv.Float64()
6892 if err != nil {
6893 return err
6894 }
6895 sv.FirstObservedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
6896
6897 default:
6898 return fmt.Errorf("expected Date to be a JSON Number, got %T instead", value)
6899
6900 }
6901 }
6902
6903 case "lastObservedAt":
6904 if value != nil {
6905 switch jtv := value.(type) {
6906 case json.Number:
6907 f64, err := jtv.Float64()
6908 if err != nil {
6909 return err
6910 }
6911 sv.LastObservedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
6912
6913 default:
6914 return fmt.Errorf("expected Date to be a JSON Number, got %T instead", value)
6915
6916 }
6917 }
6918
6919 case "packageVulnerabilityDetails":
6920 if err := awsAwsjson11_deserializeDocumentPackageVulnerabilityDetails(&sv.PackageVulnerabilityDetails, value); err != nil {
6921 return err
6922 }
6923
6924 case "remediation":
6925 if err := awsAwsjson11_deserializeDocumentRemediation(&sv.Remediation, value); err != nil {
6926 return err
6927 }
6928
6929 case "resources":
6930 if err := awsAwsjson11_deserializeDocumentResourceList(&sv.Resources, value); err != nil {
6931 return err
6932 }
6933
6934 case "score":
6935 if value != nil {
6936 switch jtv := value.(type) {
6937 case json.Number:
6938 f64, err := jtv.Float64()
6939 if err != nil {
6940 return err
6941 }
6942 sv.Score = f64
6943
6944 case string:
6945 var f64 float64
6946 switch {
6947 case strings.EqualFold(jtv, "NaN"):
6948 f64 = math.NaN()
6949
6950 case strings.EqualFold(jtv, "Infinity"):
6951 f64 = math.Inf(1)
6952
6953 case strings.EqualFold(jtv, "-Infinity"):
6954 f64 = math.Inf(-1)
6955
6956 default:
6957 return fmt.Errorf("unknown JSON number value: %s", jtv)
6958
6959 }
6960 sv.Score = f64
6961
6962 default:
6963 return fmt.Errorf("expected Score to be a JSON Number, got %T instead", value)
6964
6965 }
6966 }
6967
6968 case "scoreDetails":
6969 if err := awsAwsjson11_deserializeDocumentScoreDetails(&sv.ScoreDetails, value); err != nil {
6970 return err
6971 }
6972
6973 case "severity":
6974 if value != nil {
6975 jtv, ok := value.(string)
6976 if !ok {
6977 return fmt.Errorf("expected Severity to be of type string, got %T instead", value)
6978 }
6979 sv.Severity = ptr.String(jtv)
6980 }
6981
6982 case "status":
6983 if value != nil {
6984 jtv, ok := value.(string)
6985 if !ok {
6986 return fmt.Errorf("expected Status to be of type string, got %T instead", value)
6987 }
6988 sv.Status = ptr.String(jtv)
6989 }
6990
6991 case "title":
6992 if value != nil {
6993 jtv, ok := value.(string)
6994 if !ok {
6995 return fmt.Errorf("expected Title to be of type string, got %T instead", value)
6996 }
6997 sv.Title = ptr.String(jtv)
6998 }
6999
7000 case "type":
7001 if value != nil {
7002 jtv, ok := value.(string)
7003 if !ok {
7004 return fmt.Errorf("expected Type to be of type string, got %T instead", value)
7005 }
7006 sv.Type = ptr.String(jtv)
7007 }
7008
7009 case "updatedAt":
7010 if value != nil {
7011 switch jtv := value.(type) {
7012 case json.Number:
7013 f64, err := jtv.Float64()
7014 if err != nil {
7015 return err
7016 }
7017 sv.UpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
7018
7019 default:
7020 return fmt.Errorf("expected Date to be a JSON Number, got %T instead", value)
7021
7022 }
7023 }
7024
7025 default:
7026 _, _ = key, value
7027
7028 }
7029 }
7030 *v = sv
7031 return nil
7032 }
7033
7034 func awsAwsjson11_deserializeDocumentEnhancedImageScanFindingList(v *[]types.EnhancedImageScanFinding, value interface{}) error {
7035 if v == nil {
7036 return fmt.Errorf("unexpected nil of type %T", v)
7037 }
7038 if value == nil {
7039 return nil
7040 }
7041
7042 shape, ok := value.([]interface{})
7043 if !ok {
7044 return fmt.Errorf("unexpected JSON type %v", value)
7045 }
7046
7047 var cv []types.EnhancedImageScanFinding
7048 if *v == nil {
7049 cv = []types.EnhancedImageScanFinding{}
7050 } else {
7051 cv = *v
7052 }
7053
7054 for _, value := range shape {
7055 var col types.EnhancedImageScanFinding
7056 destAddr := &col
7057 if err := awsAwsjson11_deserializeDocumentEnhancedImageScanFinding(&destAddr, value); err != nil {
7058 return err
7059 }
7060 col = *destAddr
7061 cv = append(cv, col)
7062
7063 }
7064 *v = cv
7065 return nil
7066 }
7067
7068 func awsAwsjson11_deserializeDocumentFindingSeverityCounts(v *map[string]int32, value interface{}) error {
7069 if v == nil {
7070 return fmt.Errorf("unexpected nil of type %T", v)
7071 }
7072 if value == nil {
7073 return nil
7074 }
7075
7076 shape, ok := value.(map[string]interface{})
7077 if !ok {
7078 return fmt.Errorf("unexpected JSON type %v", value)
7079 }
7080
7081 var mv map[string]int32
7082 if *v == nil {
7083 mv = map[string]int32{}
7084 } else {
7085 mv = *v
7086 }
7087
7088 for key, value := range shape {
7089 var parsedVal int32
7090 if value != nil {
7091 jtv, ok := value.(json.Number)
7092 if !ok {
7093 return fmt.Errorf("expected SeverityCount to be json.Number, got %T instead", value)
7094 }
7095 i64, err := jtv.Int64()
7096 if err != nil {
7097 return err
7098 }
7099 parsedVal = int32(i64)
7100 }
7101 mv[key] = parsedVal
7102
7103 }
7104 *v = mv
7105 return nil
7106 }
7107
7108 func awsAwsjson11_deserializeDocumentImage(v **types.Image, value interface{}) error {
7109 if v == nil {
7110 return fmt.Errorf("unexpected nil of type %T", v)
7111 }
7112 if value == nil {
7113 return nil
7114 }
7115
7116 shape, ok := value.(map[string]interface{})
7117 if !ok {
7118 return fmt.Errorf("unexpected JSON type %v", value)
7119 }
7120
7121 var sv *types.Image
7122 if *v == nil {
7123 sv = &types.Image{}
7124 } else {
7125 sv = *v
7126 }
7127
7128 for key, value := range shape {
7129 switch key {
7130 case "imageId":
7131 if err := awsAwsjson11_deserializeDocumentImageIdentifier(&sv.ImageId, value); err != nil {
7132 return err
7133 }
7134
7135 case "imageManifest":
7136 if value != nil {
7137 jtv, ok := value.(string)
7138 if !ok {
7139 return fmt.Errorf("expected ImageManifest to be of type string, got %T instead", value)
7140 }
7141 sv.ImageManifest = ptr.String(jtv)
7142 }
7143
7144 case "imageManifestMediaType":
7145 if value != nil {
7146 jtv, ok := value.(string)
7147 if !ok {
7148 return fmt.Errorf("expected MediaType to be of type string, got %T instead", value)
7149 }
7150 sv.ImageManifestMediaType = ptr.String(jtv)
7151 }
7152
7153 case "registryId":
7154 if value != nil {
7155 jtv, ok := value.(string)
7156 if !ok {
7157 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
7158 }
7159 sv.RegistryId = ptr.String(jtv)
7160 }
7161
7162 case "repositoryName":
7163 if value != nil {
7164 jtv, ok := value.(string)
7165 if !ok {
7166 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
7167 }
7168 sv.RepositoryName = ptr.String(jtv)
7169 }
7170
7171 default:
7172 _, _ = key, value
7173
7174 }
7175 }
7176 *v = sv
7177 return nil
7178 }
7179
7180 func awsAwsjson11_deserializeDocumentImageAlreadyExistsException(v **types.ImageAlreadyExistsException, value interface{}) error {
7181 if v == nil {
7182 return fmt.Errorf("unexpected nil of type %T", v)
7183 }
7184 if value == nil {
7185 return nil
7186 }
7187
7188 shape, ok := value.(map[string]interface{})
7189 if !ok {
7190 return fmt.Errorf("unexpected JSON type %v", value)
7191 }
7192
7193 var sv *types.ImageAlreadyExistsException
7194 if *v == nil {
7195 sv = &types.ImageAlreadyExistsException{}
7196 } else {
7197 sv = *v
7198 }
7199
7200 for key, value := range shape {
7201 switch key {
7202 case "message":
7203 if value != nil {
7204 jtv, ok := value.(string)
7205 if !ok {
7206 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
7207 }
7208 sv.Message = ptr.String(jtv)
7209 }
7210
7211 default:
7212 _, _ = key, value
7213
7214 }
7215 }
7216 *v = sv
7217 return nil
7218 }
7219
7220 func awsAwsjson11_deserializeDocumentImageDetail(v **types.ImageDetail, value interface{}) error {
7221 if v == nil {
7222 return fmt.Errorf("unexpected nil of type %T", v)
7223 }
7224 if value == nil {
7225 return nil
7226 }
7227
7228 shape, ok := value.(map[string]interface{})
7229 if !ok {
7230 return fmt.Errorf("unexpected JSON type %v", value)
7231 }
7232
7233 var sv *types.ImageDetail
7234 if *v == nil {
7235 sv = &types.ImageDetail{}
7236 } else {
7237 sv = *v
7238 }
7239
7240 for key, value := range shape {
7241 switch key {
7242 case "artifactMediaType":
7243 if value != nil {
7244 jtv, ok := value.(string)
7245 if !ok {
7246 return fmt.Errorf("expected MediaType to be of type string, got %T instead", value)
7247 }
7248 sv.ArtifactMediaType = ptr.String(jtv)
7249 }
7250
7251 case "imageDigest":
7252 if value != nil {
7253 jtv, ok := value.(string)
7254 if !ok {
7255 return fmt.Errorf("expected ImageDigest to be of type string, got %T instead", value)
7256 }
7257 sv.ImageDigest = ptr.String(jtv)
7258 }
7259
7260 case "imageManifestMediaType":
7261 if value != nil {
7262 jtv, ok := value.(string)
7263 if !ok {
7264 return fmt.Errorf("expected MediaType to be of type string, got %T instead", value)
7265 }
7266 sv.ImageManifestMediaType = ptr.String(jtv)
7267 }
7268
7269 case "imagePushedAt":
7270 if value != nil {
7271 switch jtv := value.(type) {
7272 case json.Number:
7273 f64, err := jtv.Float64()
7274 if err != nil {
7275 return err
7276 }
7277 sv.ImagePushedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
7278
7279 default:
7280 return fmt.Errorf("expected PushTimestamp to be a JSON Number, got %T instead", value)
7281
7282 }
7283 }
7284
7285 case "imageScanFindingsSummary":
7286 if err := awsAwsjson11_deserializeDocumentImageScanFindingsSummary(&sv.ImageScanFindingsSummary, value); err != nil {
7287 return err
7288 }
7289
7290 case "imageScanStatus":
7291 if err := awsAwsjson11_deserializeDocumentImageScanStatus(&sv.ImageScanStatus, value); err != nil {
7292 return err
7293 }
7294
7295 case "imageSizeInBytes":
7296 if value != nil {
7297 jtv, ok := value.(json.Number)
7298 if !ok {
7299 return fmt.Errorf("expected ImageSizeInBytes to be json.Number, got %T instead", value)
7300 }
7301 i64, err := jtv.Int64()
7302 if err != nil {
7303 return err
7304 }
7305 sv.ImageSizeInBytes = ptr.Int64(i64)
7306 }
7307
7308 case "imageTags":
7309 if err := awsAwsjson11_deserializeDocumentImageTagList(&sv.ImageTags, value); err != nil {
7310 return err
7311 }
7312
7313 case "lastRecordedPullTime":
7314 if value != nil {
7315 switch jtv := value.(type) {
7316 case json.Number:
7317 f64, err := jtv.Float64()
7318 if err != nil {
7319 return err
7320 }
7321 sv.LastRecordedPullTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
7322
7323 default:
7324 return fmt.Errorf("expected RecordedPullTimestamp to be a JSON Number, got %T instead", value)
7325
7326 }
7327 }
7328
7329 case "registryId":
7330 if value != nil {
7331 jtv, ok := value.(string)
7332 if !ok {
7333 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
7334 }
7335 sv.RegistryId = ptr.String(jtv)
7336 }
7337
7338 case "repositoryName":
7339 if value != nil {
7340 jtv, ok := value.(string)
7341 if !ok {
7342 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
7343 }
7344 sv.RepositoryName = ptr.String(jtv)
7345 }
7346
7347 default:
7348 _, _ = key, value
7349
7350 }
7351 }
7352 *v = sv
7353 return nil
7354 }
7355
7356 func awsAwsjson11_deserializeDocumentImageDetailList(v *[]types.ImageDetail, value interface{}) error {
7357 if v == nil {
7358 return fmt.Errorf("unexpected nil of type %T", v)
7359 }
7360 if value == nil {
7361 return nil
7362 }
7363
7364 shape, ok := value.([]interface{})
7365 if !ok {
7366 return fmt.Errorf("unexpected JSON type %v", value)
7367 }
7368
7369 var cv []types.ImageDetail
7370 if *v == nil {
7371 cv = []types.ImageDetail{}
7372 } else {
7373 cv = *v
7374 }
7375
7376 for _, value := range shape {
7377 var col types.ImageDetail
7378 destAddr := &col
7379 if err := awsAwsjson11_deserializeDocumentImageDetail(&destAddr, value); err != nil {
7380 return err
7381 }
7382 col = *destAddr
7383 cv = append(cv, col)
7384
7385 }
7386 *v = cv
7387 return nil
7388 }
7389
7390 func awsAwsjson11_deserializeDocumentImageDigestDoesNotMatchException(v **types.ImageDigestDoesNotMatchException, value interface{}) error {
7391 if v == nil {
7392 return fmt.Errorf("unexpected nil of type %T", v)
7393 }
7394 if value == nil {
7395 return nil
7396 }
7397
7398 shape, ok := value.(map[string]interface{})
7399 if !ok {
7400 return fmt.Errorf("unexpected JSON type %v", value)
7401 }
7402
7403 var sv *types.ImageDigestDoesNotMatchException
7404 if *v == nil {
7405 sv = &types.ImageDigestDoesNotMatchException{}
7406 } else {
7407 sv = *v
7408 }
7409
7410 for key, value := range shape {
7411 switch key {
7412 case "message":
7413 if value != nil {
7414 jtv, ok := value.(string)
7415 if !ok {
7416 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
7417 }
7418 sv.Message = ptr.String(jtv)
7419 }
7420
7421 default:
7422 _, _ = key, value
7423
7424 }
7425 }
7426 *v = sv
7427 return nil
7428 }
7429
7430 func awsAwsjson11_deserializeDocumentImageFailure(v **types.ImageFailure, value interface{}) error {
7431 if v == nil {
7432 return fmt.Errorf("unexpected nil of type %T", v)
7433 }
7434 if value == nil {
7435 return nil
7436 }
7437
7438 shape, ok := value.(map[string]interface{})
7439 if !ok {
7440 return fmt.Errorf("unexpected JSON type %v", value)
7441 }
7442
7443 var sv *types.ImageFailure
7444 if *v == nil {
7445 sv = &types.ImageFailure{}
7446 } else {
7447 sv = *v
7448 }
7449
7450 for key, value := range shape {
7451 switch key {
7452 case "failureCode":
7453 if value != nil {
7454 jtv, ok := value.(string)
7455 if !ok {
7456 return fmt.Errorf("expected ImageFailureCode to be of type string, got %T instead", value)
7457 }
7458 sv.FailureCode = types.ImageFailureCode(jtv)
7459 }
7460
7461 case "failureReason":
7462 if value != nil {
7463 jtv, ok := value.(string)
7464 if !ok {
7465 return fmt.Errorf("expected ImageFailureReason to be of type string, got %T instead", value)
7466 }
7467 sv.FailureReason = ptr.String(jtv)
7468 }
7469
7470 case "imageId":
7471 if err := awsAwsjson11_deserializeDocumentImageIdentifier(&sv.ImageId, value); err != nil {
7472 return err
7473 }
7474
7475 default:
7476 _, _ = key, value
7477
7478 }
7479 }
7480 *v = sv
7481 return nil
7482 }
7483
7484 func awsAwsjson11_deserializeDocumentImageFailureList(v *[]types.ImageFailure, value interface{}) error {
7485 if v == nil {
7486 return fmt.Errorf("unexpected nil of type %T", v)
7487 }
7488 if value == nil {
7489 return nil
7490 }
7491
7492 shape, ok := value.([]interface{})
7493 if !ok {
7494 return fmt.Errorf("unexpected JSON type %v", value)
7495 }
7496
7497 var cv []types.ImageFailure
7498 if *v == nil {
7499 cv = []types.ImageFailure{}
7500 } else {
7501 cv = *v
7502 }
7503
7504 for _, value := range shape {
7505 var col types.ImageFailure
7506 destAddr := &col
7507 if err := awsAwsjson11_deserializeDocumentImageFailure(&destAddr, value); err != nil {
7508 return err
7509 }
7510 col = *destAddr
7511 cv = append(cv, col)
7512
7513 }
7514 *v = cv
7515 return nil
7516 }
7517
7518 func awsAwsjson11_deserializeDocumentImageIdentifier(v **types.ImageIdentifier, value interface{}) error {
7519 if v == nil {
7520 return fmt.Errorf("unexpected nil of type %T", v)
7521 }
7522 if value == nil {
7523 return nil
7524 }
7525
7526 shape, ok := value.(map[string]interface{})
7527 if !ok {
7528 return fmt.Errorf("unexpected JSON type %v", value)
7529 }
7530
7531 var sv *types.ImageIdentifier
7532 if *v == nil {
7533 sv = &types.ImageIdentifier{}
7534 } else {
7535 sv = *v
7536 }
7537
7538 for key, value := range shape {
7539 switch key {
7540 case "imageDigest":
7541 if value != nil {
7542 jtv, ok := value.(string)
7543 if !ok {
7544 return fmt.Errorf("expected ImageDigest to be of type string, got %T instead", value)
7545 }
7546 sv.ImageDigest = ptr.String(jtv)
7547 }
7548
7549 case "imageTag":
7550 if value != nil {
7551 jtv, ok := value.(string)
7552 if !ok {
7553 return fmt.Errorf("expected ImageTag to be of type string, got %T instead", value)
7554 }
7555 sv.ImageTag = ptr.String(jtv)
7556 }
7557
7558 default:
7559 _, _ = key, value
7560
7561 }
7562 }
7563 *v = sv
7564 return nil
7565 }
7566
7567 func awsAwsjson11_deserializeDocumentImageIdentifierList(v *[]types.ImageIdentifier, value interface{}) error {
7568 if v == nil {
7569 return fmt.Errorf("unexpected nil of type %T", v)
7570 }
7571 if value == nil {
7572 return nil
7573 }
7574
7575 shape, ok := value.([]interface{})
7576 if !ok {
7577 return fmt.Errorf("unexpected JSON type %v", value)
7578 }
7579
7580 var cv []types.ImageIdentifier
7581 if *v == nil {
7582 cv = []types.ImageIdentifier{}
7583 } else {
7584 cv = *v
7585 }
7586
7587 for _, value := range shape {
7588 var col types.ImageIdentifier
7589 destAddr := &col
7590 if err := awsAwsjson11_deserializeDocumentImageIdentifier(&destAddr, value); err != nil {
7591 return err
7592 }
7593 col = *destAddr
7594 cv = append(cv, col)
7595
7596 }
7597 *v = cv
7598 return nil
7599 }
7600
7601 func awsAwsjson11_deserializeDocumentImageList(v *[]types.Image, value interface{}) error {
7602 if v == nil {
7603 return fmt.Errorf("unexpected nil of type %T", v)
7604 }
7605 if value == nil {
7606 return nil
7607 }
7608
7609 shape, ok := value.([]interface{})
7610 if !ok {
7611 return fmt.Errorf("unexpected JSON type %v", value)
7612 }
7613
7614 var cv []types.Image
7615 if *v == nil {
7616 cv = []types.Image{}
7617 } else {
7618 cv = *v
7619 }
7620
7621 for _, value := range shape {
7622 var col types.Image
7623 destAddr := &col
7624 if err := awsAwsjson11_deserializeDocumentImage(&destAddr, value); err != nil {
7625 return err
7626 }
7627 col = *destAddr
7628 cv = append(cv, col)
7629
7630 }
7631 *v = cv
7632 return nil
7633 }
7634
7635 func awsAwsjson11_deserializeDocumentImageNotFoundException(v **types.ImageNotFoundException, value interface{}) error {
7636 if v == nil {
7637 return fmt.Errorf("unexpected nil of type %T", v)
7638 }
7639 if value == nil {
7640 return nil
7641 }
7642
7643 shape, ok := value.(map[string]interface{})
7644 if !ok {
7645 return fmt.Errorf("unexpected JSON type %v", value)
7646 }
7647
7648 var sv *types.ImageNotFoundException
7649 if *v == nil {
7650 sv = &types.ImageNotFoundException{}
7651 } else {
7652 sv = *v
7653 }
7654
7655 for key, value := range shape {
7656 switch key {
7657 case "message":
7658 if value != nil {
7659 jtv, ok := value.(string)
7660 if !ok {
7661 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
7662 }
7663 sv.Message = ptr.String(jtv)
7664 }
7665
7666 default:
7667 _, _ = key, value
7668
7669 }
7670 }
7671 *v = sv
7672 return nil
7673 }
7674
7675 func awsAwsjson11_deserializeDocumentImageReplicationStatus(v **types.ImageReplicationStatus, value interface{}) error {
7676 if v == nil {
7677 return fmt.Errorf("unexpected nil of type %T", v)
7678 }
7679 if value == nil {
7680 return nil
7681 }
7682
7683 shape, ok := value.(map[string]interface{})
7684 if !ok {
7685 return fmt.Errorf("unexpected JSON type %v", value)
7686 }
7687
7688 var sv *types.ImageReplicationStatus
7689 if *v == nil {
7690 sv = &types.ImageReplicationStatus{}
7691 } else {
7692 sv = *v
7693 }
7694
7695 for key, value := range shape {
7696 switch key {
7697 case "failureCode":
7698 if value != nil {
7699 jtv, ok := value.(string)
7700 if !ok {
7701 return fmt.Errorf("expected ReplicationError to be of type string, got %T instead", value)
7702 }
7703 sv.FailureCode = ptr.String(jtv)
7704 }
7705
7706 case "region":
7707 if value != nil {
7708 jtv, ok := value.(string)
7709 if !ok {
7710 return fmt.Errorf("expected Region to be of type string, got %T instead", value)
7711 }
7712 sv.Region = ptr.String(jtv)
7713 }
7714
7715 case "registryId":
7716 if value != nil {
7717 jtv, ok := value.(string)
7718 if !ok {
7719 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
7720 }
7721 sv.RegistryId = ptr.String(jtv)
7722 }
7723
7724 case "status":
7725 if value != nil {
7726 jtv, ok := value.(string)
7727 if !ok {
7728 return fmt.Errorf("expected ReplicationStatus to be of type string, got %T instead", value)
7729 }
7730 sv.Status = types.ReplicationStatus(jtv)
7731 }
7732
7733 default:
7734 _, _ = key, value
7735
7736 }
7737 }
7738 *v = sv
7739 return nil
7740 }
7741
7742 func awsAwsjson11_deserializeDocumentImageReplicationStatusList(v *[]types.ImageReplicationStatus, value interface{}) error {
7743 if v == nil {
7744 return fmt.Errorf("unexpected nil of type %T", v)
7745 }
7746 if value == nil {
7747 return nil
7748 }
7749
7750 shape, ok := value.([]interface{})
7751 if !ok {
7752 return fmt.Errorf("unexpected JSON type %v", value)
7753 }
7754
7755 var cv []types.ImageReplicationStatus
7756 if *v == nil {
7757 cv = []types.ImageReplicationStatus{}
7758 } else {
7759 cv = *v
7760 }
7761
7762 for _, value := range shape {
7763 var col types.ImageReplicationStatus
7764 destAddr := &col
7765 if err := awsAwsjson11_deserializeDocumentImageReplicationStatus(&destAddr, value); err != nil {
7766 return err
7767 }
7768 col = *destAddr
7769 cv = append(cv, col)
7770
7771 }
7772 *v = cv
7773 return nil
7774 }
7775
7776 func awsAwsjson11_deserializeDocumentImageScanFinding(v **types.ImageScanFinding, value interface{}) error {
7777 if v == nil {
7778 return fmt.Errorf("unexpected nil of type %T", v)
7779 }
7780 if value == nil {
7781 return nil
7782 }
7783
7784 shape, ok := value.(map[string]interface{})
7785 if !ok {
7786 return fmt.Errorf("unexpected JSON type %v", value)
7787 }
7788
7789 var sv *types.ImageScanFinding
7790 if *v == nil {
7791 sv = &types.ImageScanFinding{}
7792 } else {
7793 sv = *v
7794 }
7795
7796 for key, value := range shape {
7797 switch key {
7798 case "attributes":
7799 if err := awsAwsjson11_deserializeDocumentAttributeList(&sv.Attributes, value); err != nil {
7800 return err
7801 }
7802
7803 case "description":
7804 if value != nil {
7805 jtv, ok := value.(string)
7806 if !ok {
7807 return fmt.Errorf("expected FindingDescription to be of type string, got %T instead", value)
7808 }
7809 sv.Description = ptr.String(jtv)
7810 }
7811
7812 case "name":
7813 if value != nil {
7814 jtv, ok := value.(string)
7815 if !ok {
7816 return fmt.Errorf("expected FindingName to be of type string, got %T instead", value)
7817 }
7818 sv.Name = ptr.String(jtv)
7819 }
7820
7821 case "severity":
7822 if value != nil {
7823 jtv, ok := value.(string)
7824 if !ok {
7825 return fmt.Errorf("expected FindingSeverity to be of type string, got %T instead", value)
7826 }
7827 sv.Severity = types.FindingSeverity(jtv)
7828 }
7829
7830 case "uri":
7831 if value != nil {
7832 jtv, ok := value.(string)
7833 if !ok {
7834 return fmt.Errorf("expected Url to be of type string, got %T instead", value)
7835 }
7836 sv.Uri = ptr.String(jtv)
7837 }
7838
7839 default:
7840 _, _ = key, value
7841
7842 }
7843 }
7844 *v = sv
7845 return nil
7846 }
7847
7848 func awsAwsjson11_deserializeDocumentImageScanFindingList(v *[]types.ImageScanFinding, value interface{}) error {
7849 if v == nil {
7850 return fmt.Errorf("unexpected nil of type %T", v)
7851 }
7852 if value == nil {
7853 return nil
7854 }
7855
7856 shape, ok := value.([]interface{})
7857 if !ok {
7858 return fmt.Errorf("unexpected JSON type %v", value)
7859 }
7860
7861 var cv []types.ImageScanFinding
7862 if *v == nil {
7863 cv = []types.ImageScanFinding{}
7864 } else {
7865 cv = *v
7866 }
7867
7868 for _, value := range shape {
7869 var col types.ImageScanFinding
7870 destAddr := &col
7871 if err := awsAwsjson11_deserializeDocumentImageScanFinding(&destAddr, value); err != nil {
7872 return err
7873 }
7874 col = *destAddr
7875 cv = append(cv, col)
7876
7877 }
7878 *v = cv
7879 return nil
7880 }
7881
7882 func awsAwsjson11_deserializeDocumentImageScanFindings(v **types.ImageScanFindings, value interface{}) error {
7883 if v == nil {
7884 return fmt.Errorf("unexpected nil of type %T", v)
7885 }
7886 if value == nil {
7887 return nil
7888 }
7889
7890 shape, ok := value.(map[string]interface{})
7891 if !ok {
7892 return fmt.Errorf("unexpected JSON type %v", value)
7893 }
7894
7895 var sv *types.ImageScanFindings
7896 if *v == nil {
7897 sv = &types.ImageScanFindings{}
7898 } else {
7899 sv = *v
7900 }
7901
7902 for key, value := range shape {
7903 switch key {
7904 case "enhancedFindings":
7905 if err := awsAwsjson11_deserializeDocumentEnhancedImageScanFindingList(&sv.EnhancedFindings, value); err != nil {
7906 return err
7907 }
7908
7909 case "findings":
7910 if err := awsAwsjson11_deserializeDocumentImageScanFindingList(&sv.Findings, value); err != nil {
7911 return err
7912 }
7913
7914 case "findingSeverityCounts":
7915 if err := awsAwsjson11_deserializeDocumentFindingSeverityCounts(&sv.FindingSeverityCounts, value); err != nil {
7916 return err
7917 }
7918
7919 case "imageScanCompletedAt":
7920 if value != nil {
7921 switch jtv := value.(type) {
7922 case json.Number:
7923 f64, err := jtv.Float64()
7924 if err != nil {
7925 return err
7926 }
7927 sv.ImageScanCompletedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
7928
7929 default:
7930 return fmt.Errorf("expected ScanTimestamp to be a JSON Number, got %T instead", value)
7931
7932 }
7933 }
7934
7935 case "vulnerabilitySourceUpdatedAt":
7936 if value != nil {
7937 switch jtv := value.(type) {
7938 case json.Number:
7939 f64, err := jtv.Float64()
7940 if err != nil {
7941 return err
7942 }
7943 sv.VulnerabilitySourceUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
7944
7945 default:
7946 return fmt.Errorf("expected VulnerabilitySourceUpdateTimestamp to be a JSON Number, got %T instead", value)
7947
7948 }
7949 }
7950
7951 default:
7952 _, _ = key, value
7953
7954 }
7955 }
7956 *v = sv
7957 return nil
7958 }
7959
7960 func awsAwsjson11_deserializeDocumentImageScanFindingsSummary(v **types.ImageScanFindingsSummary, value interface{}) error {
7961 if v == nil {
7962 return fmt.Errorf("unexpected nil of type %T", v)
7963 }
7964 if value == nil {
7965 return nil
7966 }
7967
7968 shape, ok := value.(map[string]interface{})
7969 if !ok {
7970 return fmt.Errorf("unexpected JSON type %v", value)
7971 }
7972
7973 var sv *types.ImageScanFindingsSummary
7974 if *v == nil {
7975 sv = &types.ImageScanFindingsSummary{}
7976 } else {
7977 sv = *v
7978 }
7979
7980 for key, value := range shape {
7981 switch key {
7982 case "findingSeverityCounts":
7983 if err := awsAwsjson11_deserializeDocumentFindingSeverityCounts(&sv.FindingSeverityCounts, value); err != nil {
7984 return err
7985 }
7986
7987 case "imageScanCompletedAt":
7988 if value != nil {
7989 switch jtv := value.(type) {
7990 case json.Number:
7991 f64, err := jtv.Float64()
7992 if err != nil {
7993 return err
7994 }
7995 sv.ImageScanCompletedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
7996
7997 default:
7998 return fmt.Errorf("expected ScanTimestamp to be a JSON Number, got %T instead", value)
7999
8000 }
8001 }
8002
8003 case "vulnerabilitySourceUpdatedAt":
8004 if value != nil {
8005 switch jtv := value.(type) {
8006 case json.Number:
8007 f64, err := jtv.Float64()
8008 if err != nil {
8009 return err
8010 }
8011 sv.VulnerabilitySourceUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
8012
8013 default:
8014 return fmt.Errorf("expected VulnerabilitySourceUpdateTimestamp to be a JSON Number, got %T instead", value)
8015
8016 }
8017 }
8018
8019 default:
8020 _, _ = key, value
8021
8022 }
8023 }
8024 *v = sv
8025 return nil
8026 }
8027
8028 func awsAwsjson11_deserializeDocumentImageScanningConfiguration(v **types.ImageScanningConfiguration, value interface{}) error {
8029 if v == nil {
8030 return fmt.Errorf("unexpected nil of type %T", v)
8031 }
8032 if value == nil {
8033 return nil
8034 }
8035
8036 shape, ok := value.(map[string]interface{})
8037 if !ok {
8038 return fmt.Errorf("unexpected JSON type %v", value)
8039 }
8040
8041 var sv *types.ImageScanningConfiguration
8042 if *v == nil {
8043 sv = &types.ImageScanningConfiguration{}
8044 } else {
8045 sv = *v
8046 }
8047
8048 for key, value := range shape {
8049 switch key {
8050 case "scanOnPush":
8051 if value != nil {
8052 jtv, ok := value.(bool)
8053 if !ok {
8054 return fmt.Errorf("expected ScanOnPushFlag to be of type *bool, got %T instead", value)
8055 }
8056 sv.ScanOnPush = jtv
8057 }
8058
8059 default:
8060 _, _ = key, value
8061
8062 }
8063 }
8064 *v = sv
8065 return nil
8066 }
8067
8068 func awsAwsjson11_deserializeDocumentImageScanStatus(v **types.ImageScanStatus, value interface{}) error {
8069 if v == nil {
8070 return fmt.Errorf("unexpected nil of type %T", v)
8071 }
8072 if value == nil {
8073 return nil
8074 }
8075
8076 shape, ok := value.(map[string]interface{})
8077 if !ok {
8078 return fmt.Errorf("unexpected JSON type %v", value)
8079 }
8080
8081 var sv *types.ImageScanStatus
8082 if *v == nil {
8083 sv = &types.ImageScanStatus{}
8084 } else {
8085 sv = *v
8086 }
8087
8088 for key, value := range shape {
8089 switch key {
8090 case "description":
8091 if value != nil {
8092 jtv, ok := value.(string)
8093 if !ok {
8094 return fmt.Errorf("expected ScanStatusDescription to be of type string, got %T instead", value)
8095 }
8096 sv.Description = ptr.String(jtv)
8097 }
8098
8099 case "status":
8100 if value != nil {
8101 jtv, ok := value.(string)
8102 if !ok {
8103 return fmt.Errorf("expected ScanStatus to be of type string, got %T instead", value)
8104 }
8105 sv.Status = types.ScanStatus(jtv)
8106 }
8107
8108 default:
8109 _, _ = key, value
8110
8111 }
8112 }
8113 *v = sv
8114 return nil
8115 }
8116
8117 func awsAwsjson11_deserializeDocumentImageTagAlreadyExistsException(v **types.ImageTagAlreadyExistsException, value interface{}) error {
8118 if v == nil {
8119 return fmt.Errorf("unexpected nil of type %T", v)
8120 }
8121 if value == nil {
8122 return nil
8123 }
8124
8125 shape, ok := value.(map[string]interface{})
8126 if !ok {
8127 return fmt.Errorf("unexpected JSON type %v", value)
8128 }
8129
8130 var sv *types.ImageTagAlreadyExistsException
8131 if *v == nil {
8132 sv = &types.ImageTagAlreadyExistsException{}
8133 } else {
8134 sv = *v
8135 }
8136
8137 for key, value := range shape {
8138 switch key {
8139 case "message":
8140 if value != nil {
8141 jtv, ok := value.(string)
8142 if !ok {
8143 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8144 }
8145 sv.Message = ptr.String(jtv)
8146 }
8147
8148 default:
8149 _, _ = key, value
8150
8151 }
8152 }
8153 *v = sv
8154 return nil
8155 }
8156
8157 func awsAwsjson11_deserializeDocumentImageTagList(v *[]string, value interface{}) error {
8158 if v == nil {
8159 return fmt.Errorf("unexpected nil of type %T", v)
8160 }
8161 if value == nil {
8162 return nil
8163 }
8164
8165 shape, ok := value.([]interface{})
8166 if !ok {
8167 return fmt.Errorf("unexpected JSON type %v", value)
8168 }
8169
8170 var cv []string
8171 if *v == nil {
8172 cv = []string{}
8173 } else {
8174 cv = *v
8175 }
8176
8177 for _, value := range shape {
8178 var col string
8179 if value != nil {
8180 jtv, ok := value.(string)
8181 if !ok {
8182 return fmt.Errorf("expected ImageTag to be of type string, got %T instead", value)
8183 }
8184 col = jtv
8185 }
8186 cv = append(cv, col)
8187
8188 }
8189 *v = cv
8190 return nil
8191 }
8192
8193 func awsAwsjson11_deserializeDocumentImageTagsList(v *[]string, value interface{}) error {
8194 if v == nil {
8195 return fmt.Errorf("unexpected nil of type %T", v)
8196 }
8197 if value == nil {
8198 return nil
8199 }
8200
8201 shape, ok := value.([]interface{})
8202 if !ok {
8203 return fmt.Errorf("unexpected JSON type %v", value)
8204 }
8205
8206 var cv []string
8207 if *v == nil {
8208 cv = []string{}
8209 } else {
8210 cv = *v
8211 }
8212
8213 for _, value := range shape {
8214 var col string
8215 if value != nil {
8216 jtv, ok := value.(string)
8217 if !ok {
8218 return fmt.Errorf("expected ImageTag to be of type string, got %T instead", value)
8219 }
8220 col = jtv
8221 }
8222 cv = append(cv, col)
8223
8224 }
8225 *v = cv
8226 return nil
8227 }
8228
8229 func awsAwsjson11_deserializeDocumentInvalidLayerException(v **types.InvalidLayerException, value interface{}) error {
8230 if v == nil {
8231 return fmt.Errorf("unexpected nil of type %T", v)
8232 }
8233 if value == nil {
8234 return nil
8235 }
8236
8237 shape, ok := value.(map[string]interface{})
8238 if !ok {
8239 return fmt.Errorf("unexpected JSON type %v", value)
8240 }
8241
8242 var sv *types.InvalidLayerException
8243 if *v == nil {
8244 sv = &types.InvalidLayerException{}
8245 } else {
8246 sv = *v
8247 }
8248
8249 for key, value := range shape {
8250 switch key {
8251 case "message":
8252 if value != nil {
8253 jtv, ok := value.(string)
8254 if !ok {
8255 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8256 }
8257 sv.Message = ptr.String(jtv)
8258 }
8259
8260 default:
8261 _, _ = key, value
8262
8263 }
8264 }
8265 *v = sv
8266 return nil
8267 }
8268
8269 func awsAwsjson11_deserializeDocumentInvalidLayerPartException(v **types.InvalidLayerPartException, value interface{}) error {
8270 if v == nil {
8271 return fmt.Errorf("unexpected nil of type %T", v)
8272 }
8273 if value == nil {
8274 return nil
8275 }
8276
8277 shape, ok := value.(map[string]interface{})
8278 if !ok {
8279 return fmt.Errorf("unexpected JSON type %v", value)
8280 }
8281
8282 var sv *types.InvalidLayerPartException
8283 if *v == nil {
8284 sv = &types.InvalidLayerPartException{}
8285 } else {
8286 sv = *v
8287 }
8288
8289 for key, value := range shape {
8290 switch key {
8291 case "lastValidByteReceived":
8292 if value != nil {
8293 jtv, ok := value.(json.Number)
8294 if !ok {
8295 return fmt.Errorf("expected PartSize to be json.Number, got %T instead", value)
8296 }
8297 i64, err := jtv.Int64()
8298 if err != nil {
8299 return err
8300 }
8301 sv.LastValidByteReceived = ptr.Int64(i64)
8302 }
8303
8304 case "message":
8305 if value != nil {
8306 jtv, ok := value.(string)
8307 if !ok {
8308 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8309 }
8310 sv.Message = ptr.String(jtv)
8311 }
8312
8313 case "registryId":
8314 if value != nil {
8315 jtv, ok := value.(string)
8316 if !ok {
8317 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
8318 }
8319 sv.RegistryId = ptr.String(jtv)
8320 }
8321
8322 case "repositoryName":
8323 if value != nil {
8324 jtv, ok := value.(string)
8325 if !ok {
8326 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
8327 }
8328 sv.RepositoryName = ptr.String(jtv)
8329 }
8330
8331 case "uploadId":
8332 if value != nil {
8333 jtv, ok := value.(string)
8334 if !ok {
8335 return fmt.Errorf("expected UploadId to be of type string, got %T instead", value)
8336 }
8337 sv.UploadId = ptr.String(jtv)
8338 }
8339
8340 default:
8341 _, _ = key, value
8342
8343 }
8344 }
8345 *v = sv
8346 return nil
8347 }
8348
8349 func awsAwsjson11_deserializeDocumentInvalidParameterException(v **types.InvalidParameterException, value interface{}) error {
8350 if v == nil {
8351 return fmt.Errorf("unexpected nil of type %T", v)
8352 }
8353 if value == nil {
8354 return nil
8355 }
8356
8357 shape, ok := value.(map[string]interface{})
8358 if !ok {
8359 return fmt.Errorf("unexpected JSON type %v", value)
8360 }
8361
8362 var sv *types.InvalidParameterException
8363 if *v == nil {
8364 sv = &types.InvalidParameterException{}
8365 } else {
8366 sv = *v
8367 }
8368
8369 for key, value := range shape {
8370 switch key {
8371 case "message":
8372 if value != nil {
8373 jtv, ok := value.(string)
8374 if !ok {
8375 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8376 }
8377 sv.Message = ptr.String(jtv)
8378 }
8379
8380 default:
8381 _, _ = key, value
8382
8383 }
8384 }
8385 *v = sv
8386 return nil
8387 }
8388
8389 func awsAwsjson11_deserializeDocumentInvalidTagParameterException(v **types.InvalidTagParameterException, value interface{}) error {
8390 if v == nil {
8391 return fmt.Errorf("unexpected nil of type %T", v)
8392 }
8393 if value == nil {
8394 return nil
8395 }
8396
8397 shape, ok := value.(map[string]interface{})
8398 if !ok {
8399 return fmt.Errorf("unexpected JSON type %v", value)
8400 }
8401
8402 var sv *types.InvalidTagParameterException
8403 if *v == nil {
8404 sv = &types.InvalidTagParameterException{}
8405 } else {
8406 sv = *v
8407 }
8408
8409 for key, value := range shape {
8410 switch key {
8411 case "message":
8412 if value != nil {
8413 jtv, ok := value.(string)
8414 if !ok {
8415 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8416 }
8417 sv.Message = ptr.String(jtv)
8418 }
8419
8420 default:
8421 _, _ = key, value
8422
8423 }
8424 }
8425 *v = sv
8426 return nil
8427 }
8428
8429 func awsAwsjson11_deserializeDocumentKmsException(v **types.KmsException, value interface{}) error {
8430 if v == nil {
8431 return fmt.Errorf("unexpected nil of type %T", v)
8432 }
8433 if value == nil {
8434 return nil
8435 }
8436
8437 shape, ok := value.(map[string]interface{})
8438 if !ok {
8439 return fmt.Errorf("unexpected JSON type %v", value)
8440 }
8441
8442 var sv *types.KmsException
8443 if *v == nil {
8444 sv = &types.KmsException{}
8445 } else {
8446 sv = *v
8447 }
8448
8449 for key, value := range shape {
8450 switch key {
8451 case "kmsError":
8452 if value != nil {
8453 jtv, ok := value.(string)
8454 if !ok {
8455 return fmt.Errorf("expected KmsError to be of type string, got %T instead", value)
8456 }
8457 sv.KmsError = ptr.String(jtv)
8458 }
8459
8460 case "message":
8461 if value != nil {
8462 jtv, ok := value.(string)
8463 if !ok {
8464 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8465 }
8466 sv.Message = ptr.String(jtv)
8467 }
8468
8469 default:
8470 _, _ = key, value
8471
8472 }
8473 }
8474 *v = sv
8475 return nil
8476 }
8477
8478 func awsAwsjson11_deserializeDocumentLayer(v **types.Layer, value interface{}) error {
8479 if v == nil {
8480 return fmt.Errorf("unexpected nil of type %T", v)
8481 }
8482 if value == nil {
8483 return nil
8484 }
8485
8486 shape, ok := value.(map[string]interface{})
8487 if !ok {
8488 return fmt.Errorf("unexpected JSON type %v", value)
8489 }
8490
8491 var sv *types.Layer
8492 if *v == nil {
8493 sv = &types.Layer{}
8494 } else {
8495 sv = *v
8496 }
8497
8498 for key, value := range shape {
8499 switch key {
8500 case "layerAvailability":
8501 if value != nil {
8502 jtv, ok := value.(string)
8503 if !ok {
8504 return fmt.Errorf("expected LayerAvailability to be of type string, got %T instead", value)
8505 }
8506 sv.LayerAvailability = types.LayerAvailability(jtv)
8507 }
8508
8509 case "layerDigest":
8510 if value != nil {
8511 jtv, ok := value.(string)
8512 if !ok {
8513 return fmt.Errorf("expected LayerDigest to be of type string, got %T instead", value)
8514 }
8515 sv.LayerDigest = ptr.String(jtv)
8516 }
8517
8518 case "layerSize":
8519 if value != nil {
8520 jtv, ok := value.(json.Number)
8521 if !ok {
8522 return fmt.Errorf("expected LayerSizeInBytes to be json.Number, got %T instead", value)
8523 }
8524 i64, err := jtv.Int64()
8525 if err != nil {
8526 return err
8527 }
8528 sv.LayerSize = ptr.Int64(i64)
8529 }
8530
8531 case "mediaType":
8532 if value != nil {
8533 jtv, ok := value.(string)
8534 if !ok {
8535 return fmt.Errorf("expected MediaType to be of type string, got %T instead", value)
8536 }
8537 sv.MediaType = ptr.String(jtv)
8538 }
8539
8540 default:
8541 _, _ = key, value
8542
8543 }
8544 }
8545 *v = sv
8546 return nil
8547 }
8548
8549 func awsAwsjson11_deserializeDocumentLayerAlreadyExistsException(v **types.LayerAlreadyExistsException, value interface{}) error {
8550 if v == nil {
8551 return fmt.Errorf("unexpected nil of type %T", v)
8552 }
8553 if value == nil {
8554 return nil
8555 }
8556
8557 shape, ok := value.(map[string]interface{})
8558 if !ok {
8559 return fmt.Errorf("unexpected JSON type %v", value)
8560 }
8561
8562 var sv *types.LayerAlreadyExistsException
8563 if *v == nil {
8564 sv = &types.LayerAlreadyExistsException{}
8565 } else {
8566 sv = *v
8567 }
8568
8569 for key, value := range shape {
8570 switch key {
8571 case "message":
8572 if value != nil {
8573 jtv, ok := value.(string)
8574 if !ok {
8575 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8576 }
8577 sv.Message = ptr.String(jtv)
8578 }
8579
8580 default:
8581 _, _ = key, value
8582
8583 }
8584 }
8585 *v = sv
8586 return nil
8587 }
8588
8589 func awsAwsjson11_deserializeDocumentLayerFailure(v **types.LayerFailure, value interface{}) error {
8590 if v == nil {
8591 return fmt.Errorf("unexpected nil of type %T", v)
8592 }
8593 if value == nil {
8594 return nil
8595 }
8596
8597 shape, ok := value.(map[string]interface{})
8598 if !ok {
8599 return fmt.Errorf("unexpected JSON type %v", value)
8600 }
8601
8602 var sv *types.LayerFailure
8603 if *v == nil {
8604 sv = &types.LayerFailure{}
8605 } else {
8606 sv = *v
8607 }
8608
8609 for key, value := range shape {
8610 switch key {
8611 case "failureCode":
8612 if value != nil {
8613 jtv, ok := value.(string)
8614 if !ok {
8615 return fmt.Errorf("expected LayerFailureCode to be of type string, got %T instead", value)
8616 }
8617 sv.FailureCode = types.LayerFailureCode(jtv)
8618 }
8619
8620 case "failureReason":
8621 if value != nil {
8622 jtv, ok := value.(string)
8623 if !ok {
8624 return fmt.Errorf("expected LayerFailureReason to be of type string, got %T instead", value)
8625 }
8626 sv.FailureReason = ptr.String(jtv)
8627 }
8628
8629 case "layerDigest":
8630 if value != nil {
8631 jtv, ok := value.(string)
8632 if !ok {
8633 return fmt.Errorf("expected BatchedOperationLayerDigest to be of type string, got %T instead", value)
8634 }
8635 sv.LayerDigest = ptr.String(jtv)
8636 }
8637
8638 default:
8639 _, _ = key, value
8640
8641 }
8642 }
8643 *v = sv
8644 return nil
8645 }
8646
8647 func awsAwsjson11_deserializeDocumentLayerFailureList(v *[]types.LayerFailure, value interface{}) error {
8648 if v == nil {
8649 return fmt.Errorf("unexpected nil of type %T", v)
8650 }
8651 if value == nil {
8652 return nil
8653 }
8654
8655 shape, ok := value.([]interface{})
8656 if !ok {
8657 return fmt.Errorf("unexpected JSON type %v", value)
8658 }
8659
8660 var cv []types.LayerFailure
8661 if *v == nil {
8662 cv = []types.LayerFailure{}
8663 } else {
8664 cv = *v
8665 }
8666
8667 for _, value := range shape {
8668 var col types.LayerFailure
8669 destAddr := &col
8670 if err := awsAwsjson11_deserializeDocumentLayerFailure(&destAddr, value); err != nil {
8671 return err
8672 }
8673 col = *destAddr
8674 cv = append(cv, col)
8675
8676 }
8677 *v = cv
8678 return nil
8679 }
8680
8681 func awsAwsjson11_deserializeDocumentLayerInaccessibleException(v **types.LayerInaccessibleException, value interface{}) error {
8682 if v == nil {
8683 return fmt.Errorf("unexpected nil of type %T", v)
8684 }
8685 if value == nil {
8686 return nil
8687 }
8688
8689 shape, ok := value.(map[string]interface{})
8690 if !ok {
8691 return fmt.Errorf("unexpected JSON type %v", value)
8692 }
8693
8694 var sv *types.LayerInaccessibleException
8695 if *v == nil {
8696 sv = &types.LayerInaccessibleException{}
8697 } else {
8698 sv = *v
8699 }
8700
8701 for key, value := range shape {
8702 switch key {
8703 case "message":
8704 if value != nil {
8705 jtv, ok := value.(string)
8706 if !ok {
8707 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8708 }
8709 sv.Message = ptr.String(jtv)
8710 }
8711
8712 default:
8713 _, _ = key, value
8714
8715 }
8716 }
8717 *v = sv
8718 return nil
8719 }
8720
8721 func awsAwsjson11_deserializeDocumentLayerList(v *[]types.Layer, value interface{}) error {
8722 if v == nil {
8723 return fmt.Errorf("unexpected nil of type %T", v)
8724 }
8725 if value == nil {
8726 return nil
8727 }
8728
8729 shape, ok := value.([]interface{})
8730 if !ok {
8731 return fmt.Errorf("unexpected JSON type %v", value)
8732 }
8733
8734 var cv []types.Layer
8735 if *v == nil {
8736 cv = []types.Layer{}
8737 } else {
8738 cv = *v
8739 }
8740
8741 for _, value := range shape {
8742 var col types.Layer
8743 destAddr := &col
8744 if err := awsAwsjson11_deserializeDocumentLayer(&destAddr, value); err != nil {
8745 return err
8746 }
8747 col = *destAddr
8748 cv = append(cv, col)
8749
8750 }
8751 *v = cv
8752 return nil
8753 }
8754
8755 func awsAwsjson11_deserializeDocumentLayerPartTooSmallException(v **types.LayerPartTooSmallException, value interface{}) error {
8756 if v == nil {
8757 return fmt.Errorf("unexpected nil of type %T", v)
8758 }
8759 if value == nil {
8760 return nil
8761 }
8762
8763 shape, ok := value.(map[string]interface{})
8764 if !ok {
8765 return fmt.Errorf("unexpected JSON type %v", value)
8766 }
8767
8768 var sv *types.LayerPartTooSmallException
8769 if *v == nil {
8770 sv = &types.LayerPartTooSmallException{}
8771 } else {
8772 sv = *v
8773 }
8774
8775 for key, value := range shape {
8776 switch key {
8777 case "message":
8778 if value != nil {
8779 jtv, ok := value.(string)
8780 if !ok {
8781 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8782 }
8783 sv.Message = ptr.String(jtv)
8784 }
8785
8786 default:
8787 _, _ = key, value
8788
8789 }
8790 }
8791 *v = sv
8792 return nil
8793 }
8794
8795 func awsAwsjson11_deserializeDocumentLayersNotFoundException(v **types.LayersNotFoundException, value interface{}) error {
8796 if v == nil {
8797 return fmt.Errorf("unexpected nil of type %T", v)
8798 }
8799 if value == nil {
8800 return nil
8801 }
8802
8803 shape, ok := value.(map[string]interface{})
8804 if !ok {
8805 return fmt.Errorf("unexpected JSON type %v", value)
8806 }
8807
8808 var sv *types.LayersNotFoundException
8809 if *v == nil {
8810 sv = &types.LayersNotFoundException{}
8811 } else {
8812 sv = *v
8813 }
8814
8815 for key, value := range shape {
8816 switch key {
8817 case "message":
8818 if value != nil {
8819 jtv, ok := value.(string)
8820 if !ok {
8821 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8822 }
8823 sv.Message = ptr.String(jtv)
8824 }
8825
8826 default:
8827 _, _ = key, value
8828
8829 }
8830 }
8831 *v = sv
8832 return nil
8833 }
8834
8835 func awsAwsjson11_deserializeDocumentLifecyclePolicyNotFoundException(v **types.LifecyclePolicyNotFoundException, value interface{}) error {
8836 if v == nil {
8837 return fmt.Errorf("unexpected nil of type %T", v)
8838 }
8839 if value == nil {
8840 return nil
8841 }
8842
8843 shape, ok := value.(map[string]interface{})
8844 if !ok {
8845 return fmt.Errorf("unexpected JSON type %v", value)
8846 }
8847
8848 var sv *types.LifecyclePolicyNotFoundException
8849 if *v == nil {
8850 sv = &types.LifecyclePolicyNotFoundException{}
8851 } else {
8852 sv = *v
8853 }
8854
8855 for key, value := range shape {
8856 switch key {
8857 case "message":
8858 if value != nil {
8859 jtv, ok := value.(string)
8860 if !ok {
8861 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8862 }
8863 sv.Message = ptr.String(jtv)
8864 }
8865
8866 default:
8867 _, _ = key, value
8868
8869 }
8870 }
8871 *v = sv
8872 return nil
8873 }
8874
8875 func awsAwsjson11_deserializeDocumentLifecyclePolicyPreviewInProgressException(v **types.LifecyclePolicyPreviewInProgressException, value interface{}) error {
8876 if v == nil {
8877 return fmt.Errorf("unexpected nil of type %T", v)
8878 }
8879 if value == nil {
8880 return nil
8881 }
8882
8883 shape, ok := value.(map[string]interface{})
8884 if !ok {
8885 return fmt.Errorf("unexpected JSON type %v", value)
8886 }
8887
8888 var sv *types.LifecyclePolicyPreviewInProgressException
8889 if *v == nil {
8890 sv = &types.LifecyclePolicyPreviewInProgressException{}
8891 } else {
8892 sv = *v
8893 }
8894
8895 for key, value := range shape {
8896 switch key {
8897 case "message":
8898 if value != nil {
8899 jtv, ok := value.(string)
8900 if !ok {
8901 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8902 }
8903 sv.Message = ptr.String(jtv)
8904 }
8905
8906 default:
8907 _, _ = key, value
8908
8909 }
8910 }
8911 *v = sv
8912 return nil
8913 }
8914
8915 func awsAwsjson11_deserializeDocumentLifecyclePolicyPreviewNotFoundException(v **types.LifecyclePolicyPreviewNotFoundException, value interface{}) error {
8916 if v == nil {
8917 return fmt.Errorf("unexpected nil of type %T", v)
8918 }
8919 if value == nil {
8920 return nil
8921 }
8922
8923 shape, ok := value.(map[string]interface{})
8924 if !ok {
8925 return fmt.Errorf("unexpected JSON type %v", value)
8926 }
8927
8928 var sv *types.LifecyclePolicyPreviewNotFoundException
8929 if *v == nil {
8930 sv = &types.LifecyclePolicyPreviewNotFoundException{}
8931 } else {
8932 sv = *v
8933 }
8934
8935 for key, value := range shape {
8936 switch key {
8937 case "message":
8938 if value != nil {
8939 jtv, ok := value.(string)
8940 if !ok {
8941 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8942 }
8943 sv.Message = ptr.String(jtv)
8944 }
8945
8946 default:
8947 _, _ = key, value
8948
8949 }
8950 }
8951 *v = sv
8952 return nil
8953 }
8954
8955 func awsAwsjson11_deserializeDocumentLifecyclePolicyPreviewResult(v **types.LifecyclePolicyPreviewResult, value interface{}) error {
8956 if v == nil {
8957 return fmt.Errorf("unexpected nil of type %T", v)
8958 }
8959 if value == nil {
8960 return nil
8961 }
8962
8963 shape, ok := value.(map[string]interface{})
8964 if !ok {
8965 return fmt.Errorf("unexpected JSON type %v", value)
8966 }
8967
8968 var sv *types.LifecyclePolicyPreviewResult
8969 if *v == nil {
8970 sv = &types.LifecyclePolicyPreviewResult{}
8971 } else {
8972 sv = *v
8973 }
8974
8975 for key, value := range shape {
8976 switch key {
8977 case "action":
8978 if err := awsAwsjson11_deserializeDocumentLifecyclePolicyRuleAction(&sv.Action, value); err != nil {
8979 return err
8980 }
8981
8982 case "appliedRulePriority":
8983 if value != nil {
8984 jtv, ok := value.(json.Number)
8985 if !ok {
8986 return fmt.Errorf("expected LifecyclePolicyRulePriority to be json.Number, got %T instead", value)
8987 }
8988 i64, err := jtv.Int64()
8989 if err != nil {
8990 return err
8991 }
8992 sv.AppliedRulePriority = ptr.Int32(int32(i64))
8993 }
8994
8995 case "imageDigest":
8996 if value != nil {
8997 jtv, ok := value.(string)
8998 if !ok {
8999 return fmt.Errorf("expected ImageDigest to be of type string, got %T instead", value)
9000 }
9001 sv.ImageDigest = ptr.String(jtv)
9002 }
9003
9004 case "imagePushedAt":
9005 if value != nil {
9006 switch jtv := value.(type) {
9007 case json.Number:
9008 f64, err := jtv.Float64()
9009 if err != nil {
9010 return err
9011 }
9012 sv.ImagePushedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
9013
9014 default:
9015 return fmt.Errorf("expected PushTimestamp to be a JSON Number, got %T instead", value)
9016
9017 }
9018 }
9019
9020 case "imageTags":
9021 if err := awsAwsjson11_deserializeDocumentImageTagList(&sv.ImageTags, value); err != nil {
9022 return err
9023 }
9024
9025 default:
9026 _, _ = key, value
9027
9028 }
9029 }
9030 *v = sv
9031 return nil
9032 }
9033
9034 func awsAwsjson11_deserializeDocumentLifecyclePolicyPreviewResultList(v *[]types.LifecyclePolicyPreviewResult, value interface{}) error {
9035 if v == nil {
9036 return fmt.Errorf("unexpected nil of type %T", v)
9037 }
9038 if value == nil {
9039 return nil
9040 }
9041
9042 shape, ok := value.([]interface{})
9043 if !ok {
9044 return fmt.Errorf("unexpected JSON type %v", value)
9045 }
9046
9047 var cv []types.LifecyclePolicyPreviewResult
9048 if *v == nil {
9049 cv = []types.LifecyclePolicyPreviewResult{}
9050 } else {
9051 cv = *v
9052 }
9053
9054 for _, value := range shape {
9055 var col types.LifecyclePolicyPreviewResult
9056 destAddr := &col
9057 if err := awsAwsjson11_deserializeDocumentLifecyclePolicyPreviewResult(&destAddr, value); err != nil {
9058 return err
9059 }
9060 col = *destAddr
9061 cv = append(cv, col)
9062
9063 }
9064 *v = cv
9065 return nil
9066 }
9067
9068 func awsAwsjson11_deserializeDocumentLifecyclePolicyPreviewSummary(v **types.LifecyclePolicyPreviewSummary, value interface{}) error {
9069 if v == nil {
9070 return fmt.Errorf("unexpected nil of type %T", v)
9071 }
9072 if value == nil {
9073 return nil
9074 }
9075
9076 shape, ok := value.(map[string]interface{})
9077 if !ok {
9078 return fmt.Errorf("unexpected JSON type %v", value)
9079 }
9080
9081 var sv *types.LifecyclePolicyPreviewSummary
9082 if *v == nil {
9083 sv = &types.LifecyclePolicyPreviewSummary{}
9084 } else {
9085 sv = *v
9086 }
9087
9088 for key, value := range shape {
9089 switch key {
9090 case "expiringImageTotalCount":
9091 if value != nil {
9092 jtv, ok := value.(json.Number)
9093 if !ok {
9094 return fmt.Errorf("expected ImageCount to be json.Number, got %T instead", value)
9095 }
9096 i64, err := jtv.Int64()
9097 if err != nil {
9098 return err
9099 }
9100 sv.ExpiringImageTotalCount = ptr.Int32(int32(i64))
9101 }
9102
9103 default:
9104 _, _ = key, value
9105
9106 }
9107 }
9108 *v = sv
9109 return nil
9110 }
9111
9112 func awsAwsjson11_deserializeDocumentLifecyclePolicyRuleAction(v **types.LifecyclePolicyRuleAction, value interface{}) error {
9113 if v == nil {
9114 return fmt.Errorf("unexpected nil of type %T", v)
9115 }
9116 if value == nil {
9117 return nil
9118 }
9119
9120 shape, ok := value.(map[string]interface{})
9121 if !ok {
9122 return fmt.Errorf("unexpected JSON type %v", value)
9123 }
9124
9125 var sv *types.LifecyclePolicyRuleAction
9126 if *v == nil {
9127 sv = &types.LifecyclePolicyRuleAction{}
9128 } else {
9129 sv = *v
9130 }
9131
9132 for key, value := range shape {
9133 switch key {
9134 case "type":
9135 if value != nil {
9136 jtv, ok := value.(string)
9137 if !ok {
9138 return fmt.Errorf("expected ImageActionType to be of type string, got %T instead", value)
9139 }
9140 sv.Type = types.ImageActionType(jtv)
9141 }
9142
9143 default:
9144 _, _ = key, value
9145
9146 }
9147 }
9148 *v = sv
9149 return nil
9150 }
9151
9152 func awsAwsjson11_deserializeDocumentLimitExceededException(v **types.LimitExceededException, value interface{}) error {
9153 if v == nil {
9154 return fmt.Errorf("unexpected nil of type %T", v)
9155 }
9156 if value == nil {
9157 return nil
9158 }
9159
9160 shape, ok := value.(map[string]interface{})
9161 if !ok {
9162 return fmt.Errorf("unexpected JSON type %v", value)
9163 }
9164
9165 var sv *types.LimitExceededException
9166 if *v == nil {
9167 sv = &types.LimitExceededException{}
9168 } else {
9169 sv = *v
9170 }
9171
9172 for key, value := range shape {
9173 switch key {
9174 case "message":
9175 if value != nil {
9176 jtv, ok := value.(string)
9177 if !ok {
9178 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
9179 }
9180 sv.Message = ptr.String(jtv)
9181 }
9182
9183 default:
9184 _, _ = key, value
9185
9186 }
9187 }
9188 *v = sv
9189 return nil
9190 }
9191
9192 func awsAwsjson11_deserializeDocumentPackageVulnerabilityDetails(v **types.PackageVulnerabilityDetails, value interface{}) error {
9193 if v == nil {
9194 return fmt.Errorf("unexpected nil of type %T", v)
9195 }
9196 if value == nil {
9197 return nil
9198 }
9199
9200 shape, ok := value.(map[string]interface{})
9201 if !ok {
9202 return fmt.Errorf("unexpected JSON type %v", value)
9203 }
9204
9205 var sv *types.PackageVulnerabilityDetails
9206 if *v == nil {
9207 sv = &types.PackageVulnerabilityDetails{}
9208 } else {
9209 sv = *v
9210 }
9211
9212 for key, value := range shape {
9213 switch key {
9214 case "cvss":
9215 if err := awsAwsjson11_deserializeDocumentCvssScoreList(&sv.Cvss, value); err != nil {
9216 return err
9217 }
9218
9219 case "referenceUrls":
9220 if err := awsAwsjson11_deserializeDocumentReferenceUrlsList(&sv.ReferenceUrls, value); err != nil {
9221 return err
9222 }
9223
9224 case "relatedVulnerabilities":
9225 if err := awsAwsjson11_deserializeDocumentRelatedVulnerabilitiesList(&sv.RelatedVulnerabilities, value); err != nil {
9226 return err
9227 }
9228
9229 case "source":
9230 if value != nil {
9231 jtv, ok := value.(string)
9232 if !ok {
9233 return fmt.Errorf("expected Source to be of type string, got %T instead", value)
9234 }
9235 sv.Source = ptr.String(jtv)
9236 }
9237
9238 case "sourceUrl":
9239 if value != nil {
9240 jtv, ok := value.(string)
9241 if !ok {
9242 return fmt.Errorf("expected Url to be of type string, got %T instead", value)
9243 }
9244 sv.SourceUrl = ptr.String(jtv)
9245 }
9246
9247 case "vendorCreatedAt":
9248 if value != nil {
9249 switch jtv := value.(type) {
9250 case json.Number:
9251 f64, err := jtv.Float64()
9252 if err != nil {
9253 return err
9254 }
9255 sv.VendorCreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
9256
9257 default:
9258 return fmt.Errorf("expected Date to be a JSON Number, got %T instead", value)
9259
9260 }
9261 }
9262
9263 case "vendorSeverity":
9264 if value != nil {
9265 jtv, ok := value.(string)
9266 if !ok {
9267 return fmt.Errorf("expected Severity to be of type string, got %T instead", value)
9268 }
9269 sv.VendorSeverity = ptr.String(jtv)
9270 }
9271
9272 case "vendorUpdatedAt":
9273 if value != nil {
9274 switch jtv := value.(type) {
9275 case json.Number:
9276 f64, err := jtv.Float64()
9277 if err != nil {
9278 return err
9279 }
9280 sv.VendorUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
9281
9282 default:
9283 return fmt.Errorf("expected Date to be a JSON Number, got %T instead", value)
9284
9285 }
9286 }
9287
9288 case "vulnerabilityId":
9289 if value != nil {
9290 jtv, ok := value.(string)
9291 if !ok {
9292 return fmt.Errorf("expected VulnerabilityId to be of type string, got %T instead", value)
9293 }
9294 sv.VulnerabilityId = ptr.String(jtv)
9295 }
9296
9297 case "vulnerablePackages":
9298 if err := awsAwsjson11_deserializeDocumentVulnerablePackagesList(&sv.VulnerablePackages, value); err != nil {
9299 return err
9300 }
9301
9302 default:
9303 _, _ = key, value
9304
9305 }
9306 }
9307 *v = sv
9308 return nil
9309 }
9310
9311 func awsAwsjson11_deserializeDocumentPullThroughCacheRule(v **types.PullThroughCacheRule, value interface{}) error {
9312 if v == nil {
9313 return fmt.Errorf("unexpected nil of type %T", v)
9314 }
9315 if value == nil {
9316 return nil
9317 }
9318
9319 shape, ok := value.(map[string]interface{})
9320 if !ok {
9321 return fmt.Errorf("unexpected JSON type %v", value)
9322 }
9323
9324 var sv *types.PullThroughCacheRule
9325 if *v == nil {
9326 sv = &types.PullThroughCacheRule{}
9327 } else {
9328 sv = *v
9329 }
9330
9331 for key, value := range shape {
9332 switch key {
9333 case "createdAt":
9334 if value != nil {
9335 switch jtv := value.(type) {
9336 case json.Number:
9337 f64, err := jtv.Float64()
9338 if err != nil {
9339 return err
9340 }
9341 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
9342
9343 default:
9344 return fmt.Errorf("expected CreationTimestamp to be a JSON Number, got %T instead", value)
9345
9346 }
9347 }
9348
9349 case "ecrRepositoryPrefix":
9350 if value != nil {
9351 jtv, ok := value.(string)
9352 if !ok {
9353 return fmt.Errorf("expected PullThroughCacheRuleRepositoryPrefix to be of type string, got %T instead", value)
9354 }
9355 sv.EcrRepositoryPrefix = ptr.String(jtv)
9356 }
9357
9358 case "registryId":
9359 if value != nil {
9360 jtv, ok := value.(string)
9361 if !ok {
9362 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
9363 }
9364 sv.RegistryId = ptr.String(jtv)
9365 }
9366
9367 case "upstreamRegistryUrl":
9368 if value != nil {
9369 jtv, ok := value.(string)
9370 if !ok {
9371 return fmt.Errorf("expected Url to be of type string, got %T instead", value)
9372 }
9373 sv.UpstreamRegistryUrl = ptr.String(jtv)
9374 }
9375
9376 default:
9377 _, _ = key, value
9378
9379 }
9380 }
9381 *v = sv
9382 return nil
9383 }
9384
9385 func awsAwsjson11_deserializeDocumentPullThroughCacheRuleAlreadyExistsException(v **types.PullThroughCacheRuleAlreadyExistsException, value interface{}) error {
9386 if v == nil {
9387 return fmt.Errorf("unexpected nil of type %T", v)
9388 }
9389 if value == nil {
9390 return nil
9391 }
9392
9393 shape, ok := value.(map[string]interface{})
9394 if !ok {
9395 return fmt.Errorf("unexpected JSON type %v", value)
9396 }
9397
9398 var sv *types.PullThroughCacheRuleAlreadyExistsException
9399 if *v == nil {
9400 sv = &types.PullThroughCacheRuleAlreadyExistsException{}
9401 } else {
9402 sv = *v
9403 }
9404
9405 for key, value := range shape {
9406 switch key {
9407 case "message":
9408 if value != nil {
9409 jtv, ok := value.(string)
9410 if !ok {
9411 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
9412 }
9413 sv.Message = ptr.String(jtv)
9414 }
9415
9416 default:
9417 _, _ = key, value
9418
9419 }
9420 }
9421 *v = sv
9422 return nil
9423 }
9424
9425 func awsAwsjson11_deserializeDocumentPullThroughCacheRuleList(v *[]types.PullThroughCacheRule, value interface{}) error {
9426 if v == nil {
9427 return fmt.Errorf("unexpected nil of type %T", v)
9428 }
9429 if value == nil {
9430 return nil
9431 }
9432
9433 shape, ok := value.([]interface{})
9434 if !ok {
9435 return fmt.Errorf("unexpected JSON type %v", value)
9436 }
9437
9438 var cv []types.PullThroughCacheRule
9439 if *v == nil {
9440 cv = []types.PullThroughCacheRule{}
9441 } else {
9442 cv = *v
9443 }
9444
9445 for _, value := range shape {
9446 var col types.PullThroughCacheRule
9447 destAddr := &col
9448 if err := awsAwsjson11_deserializeDocumentPullThroughCacheRule(&destAddr, value); err != nil {
9449 return err
9450 }
9451 col = *destAddr
9452 cv = append(cv, col)
9453
9454 }
9455 *v = cv
9456 return nil
9457 }
9458
9459 func awsAwsjson11_deserializeDocumentPullThroughCacheRuleNotFoundException(v **types.PullThroughCacheRuleNotFoundException, value interface{}) error {
9460 if v == nil {
9461 return fmt.Errorf("unexpected nil of type %T", v)
9462 }
9463 if value == nil {
9464 return nil
9465 }
9466
9467 shape, ok := value.(map[string]interface{})
9468 if !ok {
9469 return fmt.Errorf("unexpected JSON type %v", value)
9470 }
9471
9472 var sv *types.PullThroughCacheRuleNotFoundException
9473 if *v == nil {
9474 sv = &types.PullThroughCacheRuleNotFoundException{}
9475 } else {
9476 sv = *v
9477 }
9478
9479 for key, value := range shape {
9480 switch key {
9481 case "message":
9482 if value != nil {
9483 jtv, ok := value.(string)
9484 if !ok {
9485 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
9486 }
9487 sv.Message = ptr.String(jtv)
9488 }
9489
9490 default:
9491 _, _ = key, value
9492
9493 }
9494 }
9495 *v = sv
9496 return nil
9497 }
9498
9499 func awsAwsjson11_deserializeDocumentRecommendation(v **types.Recommendation, value interface{}) error {
9500 if v == nil {
9501 return fmt.Errorf("unexpected nil of type %T", v)
9502 }
9503 if value == nil {
9504 return nil
9505 }
9506
9507 shape, ok := value.(map[string]interface{})
9508 if !ok {
9509 return fmt.Errorf("unexpected JSON type %v", value)
9510 }
9511
9512 var sv *types.Recommendation
9513 if *v == nil {
9514 sv = &types.Recommendation{}
9515 } else {
9516 sv = *v
9517 }
9518
9519 for key, value := range shape {
9520 switch key {
9521 case "text":
9522 if value != nil {
9523 jtv, ok := value.(string)
9524 if !ok {
9525 return fmt.Errorf("expected RecommendationText to be of type string, got %T instead", value)
9526 }
9527 sv.Text = ptr.String(jtv)
9528 }
9529
9530 case "url":
9531 if value != nil {
9532 jtv, ok := value.(string)
9533 if !ok {
9534 return fmt.Errorf("expected Url to be of type string, got %T instead", value)
9535 }
9536 sv.Url = ptr.String(jtv)
9537 }
9538
9539 default:
9540 _, _ = key, value
9541
9542 }
9543 }
9544 *v = sv
9545 return nil
9546 }
9547
9548 func awsAwsjson11_deserializeDocumentReferencedImagesNotFoundException(v **types.ReferencedImagesNotFoundException, value interface{}) error {
9549 if v == nil {
9550 return fmt.Errorf("unexpected nil of type %T", v)
9551 }
9552 if value == nil {
9553 return nil
9554 }
9555
9556 shape, ok := value.(map[string]interface{})
9557 if !ok {
9558 return fmt.Errorf("unexpected JSON type %v", value)
9559 }
9560
9561 var sv *types.ReferencedImagesNotFoundException
9562 if *v == nil {
9563 sv = &types.ReferencedImagesNotFoundException{}
9564 } else {
9565 sv = *v
9566 }
9567
9568 for key, value := range shape {
9569 switch key {
9570 case "message":
9571 if value != nil {
9572 jtv, ok := value.(string)
9573 if !ok {
9574 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
9575 }
9576 sv.Message = ptr.String(jtv)
9577 }
9578
9579 default:
9580 _, _ = key, value
9581
9582 }
9583 }
9584 *v = sv
9585 return nil
9586 }
9587
9588 func awsAwsjson11_deserializeDocumentReferenceUrlsList(v *[]string, value interface{}) error {
9589 if v == nil {
9590 return fmt.Errorf("unexpected nil of type %T", v)
9591 }
9592 if value == nil {
9593 return nil
9594 }
9595
9596 shape, ok := value.([]interface{})
9597 if !ok {
9598 return fmt.Errorf("unexpected JSON type %v", value)
9599 }
9600
9601 var cv []string
9602 if *v == nil {
9603 cv = []string{}
9604 } else {
9605 cv = *v
9606 }
9607
9608 for _, value := range shape {
9609 var col string
9610 if value != nil {
9611 jtv, ok := value.(string)
9612 if !ok {
9613 return fmt.Errorf("expected Url to be of type string, got %T instead", value)
9614 }
9615 col = jtv
9616 }
9617 cv = append(cv, col)
9618
9619 }
9620 *v = cv
9621 return nil
9622 }
9623
9624 func awsAwsjson11_deserializeDocumentRegistryPolicyNotFoundException(v **types.RegistryPolicyNotFoundException, value interface{}) error {
9625 if v == nil {
9626 return fmt.Errorf("unexpected nil of type %T", v)
9627 }
9628 if value == nil {
9629 return nil
9630 }
9631
9632 shape, ok := value.(map[string]interface{})
9633 if !ok {
9634 return fmt.Errorf("unexpected JSON type %v", value)
9635 }
9636
9637 var sv *types.RegistryPolicyNotFoundException
9638 if *v == nil {
9639 sv = &types.RegistryPolicyNotFoundException{}
9640 } else {
9641 sv = *v
9642 }
9643
9644 for key, value := range shape {
9645 switch key {
9646 case "message":
9647 if value != nil {
9648 jtv, ok := value.(string)
9649 if !ok {
9650 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
9651 }
9652 sv.Message = ptr.String(jtv)
9653 }
9654
9655 default:
9656 _, _ = key, value
9657
9658 }
9659 }
9660 *v = sv
9661 return nil
9662 }
9663
9664 func awsAwsjson11_deserializeDocumentRegistryScanningConfiguration(v **types.RegistryScanningConfiguration, value interface{}) error {
9665 if v == nil {
9666 return fmt.Errorf("unexpected nil of type %T", v)
9667 }
9668 if value == nil {
9669 return nil
9670 }
9671
9672 shape, ok := value.(map[string]interface{})
9673 if !ok {
9674 return fmt.Errorf("unexpected JSON type %v", value)
9675 }
9676
9677 var sv *types.RegistryScanningConfiguration
9678 if *v == nil {
9679 sv = &types.RegistryScanningConfiguration{}
9680 } else {
9681 sv = *v
9682 }
9683
9684 for key, value := range shape {
9685 switch key {
9686 case "rules":
9687 if err := awsAwsjson11_deserializeDocumentRegistryScanningRuleList(&sv.Rules, value); err != nil {
9688 return err
9689 }
9690
9691 case "scanType":
9692 if value != nil {
9693 jtv, ok := value.(string)
9694 if !ok {
9695 return fmt.Errorf("expected ScanType to be of type string, got %T instead", value)
9696 }
9697 sv.ScanType = types.ScanType(jtv)
9698 }
9699
9700 default:
9701 _, _ = key, value
9702
9703 }
9704 }
9705 *v = sv
9706 return nil
9707 }
9708
9709 func awsAwsjson11_deserializeDocumentRegistryScanningRule(v **types.RegistryScanningRule, value interface{}) error {
9710 if v == nil {
9711 return fmt.Errorf("unexpected nil of type %T", v)
9712 }
9713 if value == nil {
9714 return nil
9715 }
9716
9717 shape, ok := value.(map[string]interface{})
9718 if !ok {
9719 return fmt.Errorf("unexpected JSON type %v", value)
9720 }
9721
9722 var sv *types.RegistryScanningRule
9723 if *v == nil {
9724 sv = &types.RegistryScanningRule{}
9725 } else {
9726 sv = *v
9727 }
9728
9729 for key, value := range shape {
9730 switch key {
9731 case "repositoryFilters":
9732 if err := awsAwsjson11_deserializeDocumentScanningRepositoryFilterList(&sv.RepositoryFilters, value); err != nil {
9733 return err
9734 }
9735
9736 case "scanFrequency":
9737 if value != nil {
9738 jtv, ok := value.(string)
9739 if !ok {
9740 return fmt.Errorf("expected ScanFrequency to be of type string, got %T instead", value)
9741 }
9742 sv.ScanFrequency = types.ScanFrequency(jtv)
9743 }
9744
9745 default:
9746 _, _ = key, value
9747
9748 }
9749 }
9750 *v = sv
9751 return nil
9752 }
9753
9754 func awsAwsjson11_deserializeDocumentRegistryScanningRuleList(v *[]types.RegistryScanningRule, value interface{}) error {
9755 if v == nil {
9756 return fmt.Errorf("unexpected nil of type %T", v)
9757 }
9758 if value == nil {
9759 return nil
9760 }
9761
9762 shape, ok := value.([]interface{})
9763 if !ok {
9764 return fmt.Errorf("unexpected JSON type %v", value)
9765 }
9766
9767 var cv []types.RegistryScanningRule
9768 if *v == nil {
9769 cv = []types.RegistryScanningRule{}
9770 } else {
9771 cv = *v
9772 }
9773
9774 for _, value := range shape {
9775 var col types.RegistryScanningRule
9776 destAddr := &col
9777 if err := awsAwsjson11_deserializeDocumentRegistryScanningRule(&destAddr, value); err != nil {
9778 return err
9779 }
9780 col = *destAddr
9781 cv = append(cv, col)
9782
9783 }
9784 *v = cv
9785 return nil
9786 }
9787
9788 func awsAwsjson11_deserializeDocumentRelatedVulnerabilitiesList(v *[]string, value interface{}) error {
9789 if v == nil {
9790 return fmt.Errorf("unexpected nil of type %T", v)
9791 }
9792 if value == nil {
9793 return nil
9794 }
9795
9796 shape, ok := value.([]interface{})
9797 if !ok {
9798 return fmt.Errorf("unexpected JSON type %v", value)
9799 }
9800
9801 var cv []string
9802 if *v == nil {
9803 cv = []string{}
9804 } else {
9805 cv = *v
9806 }
9807
9808 for _, value := range shape {
9809 var col string
9810 if value != nil {
9811 jtv, ok := value.(string)
9812 if !ok {
9813 return fmt.Errorf("expected RelatedVulnerability to be of type string, got %T instead", value)
9814 }
9815 col = jtv
9816 }
9817 cv = append(cv, col)
9818
9819 }
9820 *v = cv
9821 return nil
9822 }
9823
9824 func awsAwsjson11_deserializeDocumentRemediation(v **types.Remediation, value interface{}) error {
9825 if v == nil {
9826 return fmt.Errorf("unexpected nil of type %T", v)
9827 }
9828 if value == nil {
9829 return nil
9830 }
9831
9832 shape, ok := value.(map[string]interface{})
9833 if !ok {
9834 return fmt.Errorf("unexpected JSON type %v", value)
9835 }
9836
9837 var sv *types.Remediation
9838 if *v == nil {
9839 sv = &types.Remediation{}
9840 } else {
9841 sv = *v
9842 }
9843
9844 for key, value := range shape {
9845 switch key {
9846 case "recommendation":
9847 if err := awsAwsjson11_deserializeDocumentRecommendation(&sv.Recommendation, value); err != nil {
9848 return err
9849 }
9850
9851 default:
9852 _, _ = key, value
9853
9854 }
9855 }
9856 *v = sv
9857 return nil
9858 }
9859
9860 func awsAwsjson11_deserializeDocumentReplicationConfiguration(v **types.ReplicationConfiguration, value interface{}) error {
9861 if v == nil {
9862 return fmt.Errorf("unexpected nil of type %T", v)
9863 }
9864 if value == nil {
9865 return nil
9866 }
9867
9868 shape, ok := value.(map[string]interface{})
9869 if !ok {
9870 return fmt.Errorf("unexpected JSON type %v", value)
9871 }
9872
9873 var sv *types.ReplicationConfiguration
9874 if *v == nil {
9875 sv = &types.ReplicationConfiguration{}
9876 } else {
9877 sv = *v
9878 }
9879
9880 for key, value := range shape {
9881 switch key {
9882 case "rules":
9883 if err := awsAwsjson11_deserializeDocumentReplicationRuleList(&sv.Rules, value); err != nil {
9884 return err
9885 }
9886
9887 default:
9888 _, _ = key, value
9889
9890 }
9891 }
9892 *v = sv
9893 return nil
9894 }
9895
9896 func awsAwsjson11_deserializeDocumentReplicationDestination(v **types.ReplicationDestination, value interface{}) error {
9897 if v == nil {
9898 return fmt.Errorf("unexpected nil of type %T", v)
9899 }
9900 if value == nil {
9901 return nil
9902 }
9903
9904 shape, ok := value.(map[string]interface{})
9905 if !ok {
9906 return fmt.Errorf("unexpected JSON type %v", value)
9907 }
9908
9909 var sv *types.ReplicationDestination
9910 if *v == nil {
9911 sv = &types.ReplicationDestination{}
9912 } else {
9913 sv = *v
9914 }
9915
9916 for key, value := range shape {
9917 switch key {
9918 case "region":
9919 if value != nil {
9920 jtv, ok := value.(string)
9921 if !ok {
9922 return fmt.Errorf("expected Region to be of type string, got %T instead", value)
9923 }
9924 sv.Region = ptr.String(jtv)
9925 }
9926
9927 case "registryId":
9928 if value != nil {
9929 jtv, ok := value.(string)
9930 if !ok {
9931 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
9932 }
9933 sv.RegistryId = ptr.String(jtv)
9934 }
9935
9936 default:
9937 _, _ = key, value
9938
9939 }
9940 }
9941 *v = sv
9942 return nil
9943 }
9944
9945 func awsAwsjson11_deserializeDocumentReplicationDestinationList(v *[]types.ReplicationDestination, value interface{}) error {
9946 if v == nil {
9947 return fmt.Errorf("unexpected nil of type %T", v)
9948 }
9949 if value == nil {
9950 return nil
9951 }
9952
9953 shape, ok := value.([]interface{})
9954 if !ok {
9955 return fmt.Errorf("unexpected JSON type %v", value)
9956 }
9957
9958 var cv []types.ReplicationDestination
9959 if *v == nil {
9960 cv = []types.ReplicationDestination{}
9961 } else {
9962 cv = *v
9963 }
9964
9965 for _, value := range shape {
9966 var col types.ReplicationDestination
9967 destAddr := &col
9968 if err := awsAwsjson11_deserializeDocumentReplicationDestination(&destAddr, value); err != nil {
9969 return err
9970 }
9971 col = *destAddr
9972 cv = append(cv, col)
9973
9974 }
9975 *v = cv
9976 return nil
9977 }
9978
9979 func awsAwsjson11_deserializeDocumentReplicationRule(v **types.ReplicationRule, value interface{}) error {
9980 if v == nil {
9981 return fmt.Errorf("unexpected nil of type %T", v)
9982 }
9983 if value == nil {
9984 return nil
9985 }
9986
9987 shape, ok := value.(map[string]interface{})
9988 if !ok {
9989 return fmt.Errorf("unexpected JSON type %v", value)
9990 }
9991
9992 var sv *types.ReplicationRule
9993 if *v == nil {
9994 sv = &types.ReplicationRule{}
9995 } else {
9996 sv = *v
9997 }
9998
9999 for key, value := range shape {
10000 switch key {
10001 case "destinations":
10002 if err := awsAwsjson11_deserializeDocumentReplicationDestinationList(&sv.Destinations, value); err != nil {
10003 return err
10004 }
10005
10006 case "repositoryFilters":
10007 if err := awsAwsjson11_deserializeDocumentRepositoryFilterList(&sv.RepositoryFilters, value); err != nil {
10008 return err
10009 }
10010
10011 default:
10012 _, _ = key, value
10013
10014 }
10015 }
10016 *v = sv
10017 return nil
10018 }
10019
10020 func awsAwsjson11_deserializeDocumentReplicationRuleList(v *[]types.ReplicationRule, value interface{}) error {
10021 if v == nil {
10022 return fmt.Errorf("unexpected nil of type %T", v)
10023 }
10024 if value == nil {
10025 return nil
10026 }
10027
10028 shape, ok := value.([]interface{})
10029 if !ok {
10030 return fmt.Errorf("unexpected JSON type %v", value)
10031 }
10032
10033 var cv []types.ReplicationRule
10034 if *v == nil {
10035 cv = []types.ReplicationRule{}
10036 } else {
10037 cv = *v
10038 }
10039
10040 for _, value := range shape {
10041 var col types.ReplicationRule
10042 destAddr := &col
10043 if err := awsAwsjson11_deserializeDocumentReplicationRule(&destAddr, value); err != nil {
10044 return err
10045 }
10046 col = *destAddr
10047 cv = append(cv, col)
10048
10049 }
10050 *v = cv
10051 return nil
10052 }
10053
10054 func awsAwsjson11_deserializeDocumentRepository(v **types.Repository, value interface{}) error {
10055 if v == nil {
10056 return fmt.Errorf("unexpected nil of type %T", v)
10057 }
10058 if value == nil {
10059 return nil
10060 }
10061
10062 shape, ok := value.(map[string]interface{})
10063 if !ok {
10064 return fmt.Errorf("unexpected JSON type %v", value)
10065 }
10066
10067 var sv *types.Repository
10068 if *v == nil {
10069 sv = &types.Repository{}
10070 } else {
10071 sv = *v
10072 }
10073
10074 for key, value := range shape {
10075 switch key {
10076 case "createdAt":
10077 if value != nil {
10078 switch jtv := value.(type) {
10079 case json.Number:
10080 f64, err := jtv.Float64()
10081 if err != nil {
10082 return err
10083 }
10084 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
10085
10086 default:
10087 return fmt.Errorf("expected CreationTimestamp to be a JSON Number, got %T instead", value)
10088
10089 }
10090 }
10091
10092 case "encryptionConfiguration":
10093 if err := awsAwsjson11_deserializeDocumentEncryptionConfiguration(&sv.EncryptionConfiguration, value); err != nil {
10094 return err
10095 }
10096
10097 case "imageScanningConfiguration":
10098 if err := awsAwsjson11_deserializeDocumentImageScanningConfiguration(&sv.ImageScanningConfiguration, value); err != nil {
10099 return err
10100 }
10101
10102 case "imageTagMutability":
10103 if value != nil {
10104 jtv, ok := value.(string)
10105 if !ok {
10106 return fmt.Errorf("expected ImageTagMutability to be of type string, got %T instead", value)
10107 }
10108 sv.ImageTagMutability = types.ImageTagMutability(jtv)
10109 }
10110
10111 case "registryId":
10112 if value != nil {
10113 jtv, ok := value.(string)
10114 if !ok {
10115 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
10116 }
10117 sv.RegistryId = ptr.String(jtv)
10118 }
10119
10120 case "repositoryArn":
10121 if value != nil {
10122 jtv, ok := value.(string)
10123 if !ok {
10124 return fmt.Errorf("expected Arn to be of type string, got %T instead", value)
10125 }
10126 sv.RepositoryArn = ptr.String(jtv)
10127 }
10128
10129 case "repositoryName":
10130 if value != nil {
10131 jtv, ok := value.(string)
10132 if !ok {
10133 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
10134 }
10135 sv.RepositoryName = ptr.String(jtv)
10136 }
10137
10138 case "repositoryUri":
10139 if value != nil {
10140 jtv, ok := value.(string)
10141 if !ok {
10142 return fmt.Errorf("expected Url to be of type string, got %T instead", value)
10143 }
10144 sv.RepositoryUri = ptr.String(jtv)
10145 }
10146
10147 default:
10148 _, _ = key, value
10149
10150 }
10151 }
10152 *v = sv
10153 return nil
10154 }
10155
10156 func awsAwsjson11_deserializeDocumentRepositoryAlreadyExistsException(v **types.RepositoryAlreadyExistsException, value interface{}) error {
10157 if v == nil {
10158 return fmt.Errorf("unexpected nil of type %T", v)
10159 }
10160 if value == nil {
10161 return nil
10162 }
10163
10164 shape, ok := value.(map[string]interface{})
10165 if !ok {
10166 return fmt.Errorf("unexpected JSON type %v", value)
10167 }
10168
10169 var sv *types.RepositoryAlreadyExistsException
10170 if *v == nil {
10171 sv = &types.RepositoryAlreadyExistsException{}
10172 } else {
10173 sv = *v
10174 }
10175
10176 for key, value := range shape {
10177 switch key {
10178 case "message":
10179 if value != nil {
10180 jtv, ok := value.(string)
10181 if !ok {
10182 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
10183 }
10184 sv.Message = ptr.String(jtv)
10185 }
10186
10187 default:
10188 _, _ = key, value
10189
10190 }
10191 }
10192 *v = sv
10193 return nil
10194 }
10195
10196 func awsAwsjson11_deserializeDocumentRepositoryFilter(v **types.RepositoryFilter, value interface{}) error {
10197 if v == nil {
10198 return fmt.Errorf("unexpected nil of type %T", v)
10199 }
10200 if value == nil {
10201 return nil
10202 }
10203
10204 shape, ok := value.(map[string]interface{})
10205 if !ok {
10206 return fmt.Errorf("unexpected JSON type %v", value)
10207 }
10208
10209 var sv *types.RepositoryFilter
10210 if *v == nil {
10211 sv = &types.RepositoryFilter{}
10212 } else {
10213 sv = *v
10214 }
10215
10216 for key, value := range shape {
10217 switch key {
10218 case "filter":
10219 if value != nil {
10220 jtv, ok := value.(string)
10221 if !ok {
10222 return fmt.Errorf("expected RepositoryFilterValue to be of type string, got %T instead", value)
10223 }
10224 sv.Filter = ptr.String(jtv)
10225 }
10226
10227 case "filterType":
10228 if value != nil {
10229 jtv, ok := value.(string)
10230 if !ok {
10231 return fmt.Errorf("expected RepositoryFilterType to be of type string, got %T instead", value)
10232 }
10233 sv.FilterType = types.RepositoryFilterType(jtv)
10234 }
10235
10236 default:
10237 _, _ = key, value
10238
10239 }
10240 }
10241 *v = sv
10242 return nil
10243 }
10244
10245 func awsAwsjson11_deserializeDocumentRepositoryFilterList(v *[]types.RepositoryFilter, value interface{}) error {
10246 if v == nil {
10247 return fmt.Errorf("unexpected nil of type %T", v)
10248 }
10249 if value == nil {
10250 return nil
10251 }
10252
10253 shape, ok := value.([]interface{})
10254 if !ok {
10255 return fmt.Errorf("unexpected JSON type %v", value)
10256 }
10257
10258 var cv []types.RepositoryFilter
10259 if *v == nil {
10260 cv = []types.RepositoryFilter{}
10261 } else {
10262 cv = *v
10263 }
10264
10265 for _, value := range shape {
10266 var col types.RepositoryFilter
10267 destAddr := &col
10268 if err := awsAwsjson11_deserializeDocumentRepositoryFilter(&destAddr, value); err != nil {
10269 return err
10270 }
10271 col = *destAddr
10272 cv = append(cv, col)
10273
10274 }
10275 *v = cv
10276 return nil
10277 }
10278
10279 func awsAwsjson11_deserializeDocumentRepositoryList(v *[]types.Repository, value interface{}) error {
10280 if v == nil {
10281 return fmt.Errorf("unexpected nil of type %T", v)
10282 }
10283 if value == nil {
10284 return nil
10285 }
10286
10287 shape, ok := value.([]interface{})
10288 if !ok {
10289 return fmt.Errorf("unexpected JSON type %v", value)
10290 }
10291
10292 var cv []types.Repository
10293 if *v == nil {
10294 cv = []types.Repository{}
10295 } else {
10296 cv = *v
10297 }
10298
10299 for _, value := range shape {
10300 var col types.Repository
10301 destAddr := &col
10302 if err := awsAwsjson11_deserializeDocumentRepository(&destAddr, value); err != nil {
10303 return err
10304 }
10305 col = *destAddr
10306 cv = append(cv, col)
10307
10308 }
10309 *v = cv
10310 return nil
10311 }
10312
10313 func awsAwsjson11_deserializeDocumentRepositoryNotEmptyException(v **types.RepositoryNotEmptyException, value interface{}) error {
10314 if v == nil {
10315 return fmt.Errorf("unexpected nil of type %T", v)
10316 }
10317 if value == nil {
10318 return nil
10319 }
10320
10321 shape, ok := value.(map[string]interface{})
10322 if !ok {
10323 return fmt.Errorf("unexpected JSON type %v", value)
10324 }
10325
10326 var sv *types.RepositoryNotEmptyException
10327 if *v == nil {
10328 sv = &types.RepositoryNotEmptyException{}
10329 } else {
10330 sv = *v
10331 }
10332
10333 for key, value := range shape {
10334 switch key {
10335 case "message":
10336 if value != nil {
10337 jtv, ok := value.(string)
10338 if !ok {
10339 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
10340 }
10341 sv.Message = ptr.String(jtv)
10342 }
10343
10344 default:
10345 _, _ = key, value
10346
10347 }
10348 }
10349 *v = sv
10350 return nil
10351 }
10352
10353 func awsAwsjson11_deserializeDocumentRepositoryNotFoundException(v **types.RepositoryNotFoundException, value interface{}) error {
10354 if v == nil {
10355 return fmt.Errorf("unexpected nil of type %T", v)
10356 }
10357 if value == nil {
10358 return nil
10359 }
10360
10361 shape, ok := value.(map[string]interface{})
10362 if !ok {
10363 return fmt.Errorf("unexpected JSON type %v", value)
10364 }
10365
10366 var sv *types.RepositoryNotFoundException
10367 if *v == nil {
10368 sv = &types.RepositoryNotFoundException{}
10369 } else {
10370 sv = *v
10371 }
10372
10373 for key, value := range shape {
10374 switch key {
10375 case "message":
10376 if value != nil {
10377 jtv, ok := value.(string)
10378 if !ok {
10379 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
10380 }
10381 sv.Message = ptr.String(jtv)
10382 }
10383
10384 default:
10385 _, _ = key, value
10386
10387 }
10388 }
10389 *v = sv
10390 return nil
10391 }
10392
10393 func awsAwsjson11_deserializeDocumentRepositoryPolicyNotFoundException(v **types.RepositoryPolicyNotFoundException, value interface{}) error {
10394 if v == nil {
10395 return fmt.Errorf("unexpected nil of type %T", v)
10396 }
10397 if value == nil {
10398 return nil
10399 }
10400
10401 shape, ok := value.(map[string]interface{})
10402 if !ok {
10403 return fmt.Errorf("unexpected JSON type %v", value)
10404 }
10405
10406 var sv *types.RepositoryPolicyNotFoundException
10407 if *v == nil {
10408 sv = &types.RepositoryPolicyNotFoundException{}
10409 } else {
10410 sv = *v
10411 }
10412
10413 for key, value := range shape {
10414 switch key {
10415 case "message":
10416 if value != nil {
10417 jtv, ok := value.(string)
10418 if !ok {
10419 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
10420 }
10421 sv.Message = ptr.String(jtv)
10422 }
10423
10424 default:
10425 _, _ = key, value
10426
10427 }
10428 }
10429 *v = sv
10430 return nil
10431 }
10432
10433 func awsAwsjson11_deserializeDocumentRepositoryScanningConfiguration(v **types.RepositoryScanningConfiguration, value interface{}) error {
10434 if v == nil {
10435 return fmt.Errorf("unexpected nil of type %T", v)
10436 }
10437 if value == nil {
10438 return nil
10439 }
10440
10441 shape, ok := value.(map[string]interface{})
10442 if !ok {
10443 return fmt.Errorf("unexpected JSON type %v", value)
10444 }
10445
10446 var sv *types.RepositoryScanningConfiguration
10447 if *v == nil {
10448 sv = &types.RepositoryScanningConfiguration{}
10449 } else {
10450 sv = *v
10451 }
10452
10453 for key, value := range shape {
10454 switch key {
10455 case "appliedScanFilters":
10456 if err := awsAwsjson11_deserializeDocumentScanningRepositoryFilterList(&sv.AppliedScanFilters, value); err != nil {
10457 return err
10458 }
10459
10460 case "repositoryArn":
10461 if value != nil {
10462 jtv, ok := value.(string)
10463 if !ok {
10464 return fmt.Errorf("expected Arn to be of type string, got %T instead", value)
10465 }
10466 sv.RepositoryArn = ptr.String(jtv)
10467 }
10468
10469 case "repositoryName":
10470 if value != nil {
10471 jtv, ok := value.(string)
10472 if !ok {
10473 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
10474 }
10475 sv.RepositoryName = ptr.String(jtv)
10476 }
10477
10478 case "scanFrequency":
10479 if value != nil {
10480 jtv, ok := value.(string)
10481 if !ok {
10482 return fmt.Errorf("expected ScanFrequency to be of type string, got %T instead", value)
10483 }
10484 sv.ScanFrequency = types.ScanFrequency(jtv)
10485 }
10486
10487 case "scanOnPush":
10488 if value != nil {
10489 jtv, ok := value.(bool)
10490 if !ok {
10491 return fmt.Errorf("expected ScanOnPushFlag to be of type *bool, got %T instead", value)
10492 }
10493 sv.ScanOnPush = jtv
10494 }
10495
10496 default:
10497 _, _ = key, value
10498
10499 }
10500 }
10501 *v = sv
10502 return nil
10503 }
10504
10505 func awsAwsjson11_deserializeDocumentRepositoryScanningConfigurationFailure(v **types.RepositoryScanningConfigurationFailure, value interface{}) error {
10506 if v == nil {
10507 return fmt.Errorf("unexpected nil of type %T", v)
10508 }
10509 if value == nil {
10510 return nil
10511 }
10512
10513 shape, ok := value.(map[string]interface{})
10514 if !ok {
10515 return fmt.Errorf("unexpected JSON type %v", value)
10516 }
10517
10518 var sv *types.RepositoryScanningConfigurationFailure
10519 if *v == nil {
10520 sv = &types.RepositoryScanningConfigurationFailure{}
10521 } else {
10522 sv = *v
10523 }
10524
10525 for key, value := range shape {
10526 switch key {
10527 case "failureCode":
10528 if value != nil {
10529 jtv, ok := value.(string)
10530 if !ok {
10531 return fmt.Errorf("expected ScanningConfigurationFailureCode to be of type string, got %T instead", value)
10532 }
10533 sv.FailureCode = types.ScanningConfigurationFailureCode(jtv)
10534 }
10535
10536 case "failureReason":
10537 if value != nil {
10538 jtv, ok := value.(string)
10539 if !ok {
10540 return fmt.Errorf("expected ScanningConfigurationFailureReason to be of type string, got %T instead", value)
10541 }
10542 sv.FailureReason = ptr.String(jtv)
10543 }
10544
10545 case "repositoryName":
10546 if value != nil {
10547 jtv, ok := value.(string)
10548 if !ok {
10549 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
10550 }
10551 sv.RepositoryName = ptr.String(jtv)
10552 }
10553
10554 default:
10555 _, _ = key, value
10556
10557 }
10558 }
10559 *v = sv
10560 return nil
10561 }
10562
10563 func awsAwsjson11_deserializeDocumentRepositoryScanningConfigurationFailureList(v *[]types.RepositoryScanningConfigurationFailure, value interface{}) error {
10564 if v == nil {
10565 return fmt.Errorf("unexpected nil of type %T", v)
10566 }
10567 if value == nil {
10568 return nil
10569 }
10570
10571 shape, ok := value.([]interface{})
10572 if !ok {
10573 return fmt.Errorf("unexpected JSON type %v", value)
10574 }
10575
10576 var cv []types.RepositoryScanningConfigurationFailure
10577 if *v == nil {
10578 cv = []types.RepositoryScanningConfigurationFailure{}
10579 } else {
10580 cv = *v
10581 }
10582
10583 for _, value := range shape {
10584 var col types.RepositoryScanningConfigurationFailure
10585 destAddr := &col
10586 if err := awsAwsjson11_deserializeDocumentRepositoryScanningConfigurationFailure(&destAddr, value); err != nil {
10587 return err
10588 }
10589 col = *destAddr
10590 cv = append(cv, col)
10591
10592 }
10593 *v = cv
10594 return nil
10595 }
10596
10597 func awsAwsjson11_deserializeDocumentRepositoryScanningConfigurationList(v *[]types.RepositoryScanningConfiguration, value interface{}) error {
10598 if v == nil {
10599 return fmt.Errorf("unexpected nil of type %T", v)
10600 }
10601 if value == nil {
10602 return nil
10603 }
10604
10605 shape, ok := value.([]interface{})
10606 if !ok {
10607 return fmt.Errorf("unexpected JSON type %v", value)
10608 }
10609
10610 var cv []types.RepositoryScanningConfiguration
10611 if *v == nil {
10612 cv = []types.RepositoryScanningConfiguration{}
10613 } else {
10614 cv = *v
10615 }
10616
10617 for _, value := range shape {
10618 var col types.RepositoryScanningConfiguration
10619 destAddr := &col
10620 if err := awsAwsjson11_deserializeDocumentRepositoryScanningConfiguration(&destAddr, value); err != nil {
10621 return err
10622 }
10623 col = *destAddr
10624 cv = append(cv, col)
10625
10626 }
10627 *v = cv
10628 return nil
10629 }
10630
10631 func awsAwsjson11_deserializeDocumentResource(v **types.Resource, value interface{}) error {
10632 if v == nil {
10633 return fmt.Errorf("unexpected nil of type %T", v)
10634 }
10635 if value == nil {
10636 return nil
10637 }
10638
10639 shape, ok := value.(map[string]interface{})
10640 if !ok {
10641 return fmt.Errorf("unexpected JSON type %v", value)
10642 }
10643
10644 var sv *types.Resource
10645 if *v == nil {
10646 sv = &types.Resource{}
10647 } else {
10648 sv = *v
10649 }
10650
10651 for key, value := range shape {
10652 switch key {
10653 case "details":
10654 if err := awsAwsjson11_deserializeDocumentResourceDetails(&sv.Details, value); err != nil {
10655 return err
10656 }
10657
10658 case "id":
10659 if value != nil {
10660 jtv, ok := value.(string)
10661 if !ok {
10662 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
10663 }
10664 sv.Id = ptr.String(jtv)
10665 }
10666
10667 case "tags":
10668 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
10669 return err
10670 }
10671
10672 case "type":
10673 if value != nil {
10674 jtv, ok := value.(string)
10675 if !ok {
10676 return fmt.Errorf("expected Type to be of type string, got %T instead", value)
10677 }
10678 sv.Type = ptr.String(jtv)
10679 }
10680
10681 default:
10682 _, _ = key, value
10683
10684 }
10685 }
10686 *v = sv
10687 return nil
10688 }
10689
10690 func awsAwsjson11_deserializeDocumentResourceDetails(v **types.ResourceDetails, value interface{}) error {
10691 if v == nil {
10692 return fmt.Errorf("unexpected nil of type %T", v)
10693 }
10694 if value == nil {
10695 return nil
10696 }
10697
10698 shape, ok := value.(map[string]interface{})
10699 if !ok {
10700 return fmt.Errorf("unexpected JSON type %v", value)
10701 }
10702
10703 var sv *types.ResourceDetails
10704 if *v == nil {
10705 sv = &types.ResourceDetails{}
10706 } else {
10707 sv = *v
10708 }
10709
10710 for key, value := range shape {
10711 switch key {
10712 case "awsEcrContainerImage":
10713 if err := awsAwsjson11_deserializeDocumentAwsEcrContainerImageDetails(&sv.AwsEcrContainerImage, value); err != nil {
10714 return err
10715 }
10716
10717 default:
10718 _, _ = key, value
10719
10720 }
10721 }
10722 *v = sv
10723 return nil
10724 }
10725
10726 func awsAwsjson11_deserializeDocumentResourceList(v *[]types.Resource, value interface{}) error {
10727 if v == nil {
10728 return fmt.Errorf("unexpected nil of type %T", v)
10729 }
10730 if value == nil {
10731 return nil
10732 }
10733
10734 shape, ok := value.([]interface{})
10735 if !ok {
10736 return fmt.Errorf("unexpected JSON type %v", value)
10737 }
10738
10739 var cv []types.Resource
10740 if *v == nil {
10741 cv = []types.Resource{}
10742 } else {
10743 cv = *v
10744 }
10745
10746 for _, value := range shape {
10747 var col types.Resource
10748 destAddr := &col
10749 if err := awsAwsjson11_deserializeDocumentResource(&destAddr, value); err != nil {
10750 return err
10751 }
10752 col = *destAddr
10753 cv = append(cv, col)
10754
10755 }
10756 *v = cv
10757 return nil
10758 }
10759
10760 func awsAwsjson11_deserializeDocumentScanningRepositoryFilter(v **types.ScanningRepositoryFilter, value interface{}) error {
10761 if v == nil {
10762 return fmt.Errorf("unexpected nil of type %T", v)
10763 }
10764 if value == nil {
10765 return nil
10766 }
10767
10768 shape, ok := value.(map[string]interface{})
10769 if !ok {
10770 return fmt.Errorf("unexpected JSON type %v", value)
10771 }
10772
10773 var sv *types.ScanningRepositoryFilter
10774 if *v == nil {
10775 sv = &types.ScanningRepositoryFilter{}
10776 } else {
10777 sv = *v
10778 }
10779
10780 for key, value := range shape {
10781 switch key {
10782 case "filter":
10783 if value != nil {
10784 jtv, ok := value.(string)
10785 if !ok {
10786 return fmt.Errorf("expected ScanningRepositoryFilterValue to be of type string, got %T instead", value)
10787 }
10788 sv.Filter = ptr.String(jtv)
10789 }
10790
10791 case "filterType":
10792 if value != nil {
10793 jtv, ok := value.(string)
10794 if !ok {
10795 return fmt.Errorf("expected ScanningRepositoryFilterType to be of type string, got %T instead", value)
10796 }
10797 sv.FilterType = types.ScanningRepositoryFilterType(jtv)
10798 }
10799
10800 default:
10801 _, _ = key, value
10802
10803 }
10804 }
10805 *v = sv
10806 return nil
10807 }
10808
10809 func awsAwsjson11_deserializeDocumentScanningRepositoryFilterList(v *[]types.ScanningRepositoryFilter, value interface{}) error {
10810 if v == nil {
10811 return fmt.Errorf("unexpected nil of type %T", v)
10812 }
10813 if value == nil {
10814 return nil
10815 }
10816
10817 shape, ok := value.([]interface{})
10818 if !ok {
10819 return fmt.Errorf("unexpected JSON type %v", value)
10820 }
10821
10822 var cv []types.ScanningRepositoryFilter
10823 if *v == nil {
10824 cv = []types.ScanningRepositoryFilter{}
10825 } else {
10826 cv = *v
10827 }
10828
10829 for _, value := range shape {
10830 var col types.ScanningRepositoryFilter
10831 destAddr := &col
10832 if err := awsAwsjson11_deserializeDocumentScanningRepositoryFilter(&destAddr, value); err != nil {
10833 return err
10834 }
10835 col = *destAddr
10836 cv = append(cv, col)
10837
10838 }
10839 *v = cv
10840 return nil
10841 }
10842
10843 func awsAwsjson11_deserializeDocumentScanNotFoundException(v **types.ScanNotFoundException, value interface{}) error {
10844 if v == nil {
10845 return fmt.Errorf("unexpected nil of type %T", v)
10846 }
10847 if value == nil {
10848 return nil
10849 }
10850
10851 shape, ok := value.(map[string]interface{})
10852 if !ok {
10853 return fmt.Errorf("unexpected JSON type %v", value)
10854 }
10855
10856 var sv *types.ScanNotFoundException
10857 if *v == nil {
10858 sv = &types.ScanNotFoundException{}
10859 } else {
10860 sv = *v
10861 }
10862
10863 for key, value := range shape {
10864 switch key {
10865 case "message":
10866 if value != nil {
10867 jtv, ok := value.(string)
10868 if !ok {
10869 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
10870 }
10871 sv.Message = ptr.String(jtv)
10872 }
10873
10874 default:
10875 _, _ = key, value
10876
10877 }
10878 }
10879 *v = sv
10880 return nil
10881 }
10882
10883 func awsAwsjson11_deserializeDocumentScoreDetails(v **types.ScoreDetails, value interface{}) error {
10884 if v == nil {
10885 return fmt.Errorf("unexpected nil of type %T", v)
10886 }
10887 if value == nil {
10888 return nil
10889 }
10890
10891 shape, ok := value.(map[string]interface{})
10892 if !ok {
10893 return fmt.Errorf("unexpected JSON type %v", value)
10894 }
10895
10896 var sv *types.ScoreDetails
10897 if *v == nil {
10898 sv = &types.ScoreDetails{}
10899 } else {
10900 sv = *v
10901 }
10902
10903 for key, value := range shape {
10904 switch key {
10905 case "cvss":
10906 if err := awsAwsjson11_deserializeDocumentCvssScoreDetails(&sv.Cvss, value); err != nil {
10907 return err
10908 }
10909
10910 default:
10911 _, _ = key, value
10912
10913 }
10914 }
10915 *v = sv
10916 return nil
10917 }
10918
10919 func awsAwsjson11_deserializeDocumentServerException(v **types.ServerException, value interface{}) error {
10920 if v == nil {
10921 return fmt.Errorf("unexpected nil of type %T", v)
10922 }
10923 if value == nil {
10924 return nil
10925 }
10926
10927 shape, ok := value.(map[string]interface{})
10928 if !ok {
10929 return fmt.Errorf("unexpected JSON type %v", value)
10930 }
10931
10932 var sv *types.ServerException
10933 if *v == nil {
10934 sv = &types.ServerException{}
10935 } else {
10936 sv = *v
10937 }
10938
10939 for key, value := range shape {
10940 switch key {
10941 case "message":
10942 if value != nil {
10943 jtv, ok := value.(string)
10944 if !ok {
10945 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
10946 }
10947 sv.Message = ptr.String(jtv)
10948 }
10949
10950 default:
10951 _, _ = key, value
10952
10953 }
10954 }
10955 *v = sv
10956 return nil
10957 }
10958
10959 func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error {
10960 if v == nil {
10961 return fmt.Errorf("unexpected nil of type %T", v)
10962 }
10963 if value == nil {
10964 return nil
10965 }
10966
10967 shape, ok := value.(map[string]interface{})
10968 if !ok {
10969 return fmt.Errorf("unexpected JSON type %v", value)
10970 }
10971
10972 var sv *types.Tag
10973 if *v == nil {
10974 sv = &types.Tag{}
10975 } else {
10976 sv = *v
10977 }
10978
10979 for key, value := range shape {
10980 switch key {
10981 case "Key":
10982 if value != nil {
10983 jtv, ok := value.(string)
10984 if !ok {
10985 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value)
10986 }
10987 sv.Key = ptr.String(jtv)
10988 }
10989
10990 case "Value":
10991 if value != nil {
10992 jtv, ok := value.(string)
10993 if !ok {
10994 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value)
10995 }
10996 sv.Value = ptr.String(jtv)
10997 }
10998
10999 default:
11000 _, _ = key, value
11001
11002 }
11003 }
11004 *v = sv
11005 return nil
11006 }
11007
11008 func awsAwsjson11_deserializeDocumentTagList(v *[]types.Tag, value interface{}) error {
11009 if v == nil {
11010 return fmt.Errorf("unexpected nil of type %T", v)
11011 }
11012 if value == nil {
11013 return nil
11014 }
11015
11016 shape, ok := value.([]interface{})
11017 if !ok {
11018 return fmt.Errorf("unexpected JSON type %v", value)
11019 }
11020
11021 var cv []types.Tag
11022 if *v == nil {
11023 cv = []types.Tag{}
11024 } else {
11025 cv = *v
11026 }
11027
11028 for _, value := range shape {
11029 var col types.Tag
11030 destAddr := &col
11031 if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil {
11032 return err
11033 }
11034 col = *destAddr
11035 cv = append(cv, col)
11036
11037 }
11038 *v = cv
11039 return nil
11040 }
11041
11042 func awsAwsjson11_deserializeDocumentTags(v *map[string]string, value interface{}) error {
11043 if v == nil {
11044 return fmt.Errorf("unexpected nil of type %T", v)
11045 }
11046 if value == nil {
11047 return nil
11048 }
11049
11050 shape, ok := value.(map[string]interface{})
11051 if !ok {
11052 return fmt.Errorf("unexpected JSON type %v", value)
11053 }
11054
11055 var mv map[string]string
11056 if *v == nil {
11057 mv = map[string]string{}
11058 } else {
11059 mv = *v
11060 }
11061
11062 for key, value := range shape {
11063 var parsedVal string
11064 if value != nil {
11065 jtv, ok := value.(string)
11066 if !ok {
11067 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value)
11068 }
11069 parsedVal = jtv
11070 }
11071 mv[key] = parsedVal
11072
11073 }
11074 *v = mv
11075 return nil
11076 }
11077
11078 func awsAwsjson11_deserializeDocumentTooManyTagsException(v **types.TooManyTagsException, value interface{}) error {
11079 if v == nil {
11080 return fmt.Errorf("unexpected nil of type %T", v)
11081 }
11082 if value == nil {
11083 return nil
11084 }
11085
11086 shape, ok := value.(map[string]interface{})
11087 if !ok {
11088 return fmt.Errorf("unexpected JSON type %v", value)
11089 }
11090
11091 var sv *types.TooManyTagsException
11092 if *v == nil {
11093 sv = &types.TooManyTagsException{}
11094 } else {
11095 sv = *v
11096 }
11097
11098 for key, value := range shape {
11099 switch key {
11100 case "message":
11101 if value != nil {
11102 jtv, ok := value.(string)
11103 if !ok {
11104 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
11105 }
11106 sv.Message = ptr.String(jtv)
11107 }
11108
11109 default:
11110 _, _ = key, value
11111
11112 }
11113 }
11114 *v = sv
11115 return nil
11116 }
11117
11118 func awsAwsjson11_deserializeDocumentUnsupportedImageTypeException(v **types.UnsupportedImageTypeException, value interface{}) error {
11119 if v == nil {
11120 return fmt.Errorf("unexpected nil of type %T", v)
11121 }
11122 if value == nil {
11123 return nil
11124 }
11125
11126 shape, ok := value.(map[string]interface{})
11127 if !ok {
11128 return fmt.Errorf("unexpected JSON type %v", value)
11129 }
11130
11131 var sv *types.UnsupportedImageTypeException
11132 if *v == nil {
11133 sv = &types.UnsupportedImageTypeException{}
11134 } else {
11135 sv = *v
11136 }
11137
11138 for key, value := range shape {
11139 switch key {
11140 case "message":
11141 if value != nil {
11142 jtv, ok := value.(string)
11143 if !ok {
11144 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
11145 }
11146 sv.Message = ptr.String(jtv)
11147 }
11148
11149 default:
11150 _, _ = key, value
11151
11152 }
11153 }
11154 *v = sv
11155 return nil
11156 }
11157
11158 func awsAwsjson11_deserializeDocumentUnsupportedUpstreamRegistryException(v **types.UnsupportedUpstreamRegistryException, value interface{}) error {
11159 if v == nil {
11160 return fmt.Errorf("unexpected nil of type %T", v)
11161 }
11162 if value == nil {
11163 return nil
11164 }
11165
11166 shape, ok := value.(map[string]interface{})
11167 if !ok {
11168 return fmt.Errorf("unexpected JSON type %v", value)
11169 }
11170
11171 var sv *types.UnsupportedUpstreamRegistryException
11172 if *v == nil {
11173 sv = &types.UnsupportedUpstreamRegistryException{}
11174 } else {
11175 sv = *v
11176 }
11177
11178 for key, value := range shape {
11179 switch key {
11180 case "message":
11181 if value != nil {
11182 jtv, ok := value.(string)
11183 if !ok {
11184 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
11185 }
11186 sv.Message = ptr.String(jtv)
11187 }
11188
11189 default:
11190 _, _ = key, value
11191
11192 }
11193 }
11194 *v = sv
11195 return nil
11196 }
11197
11198 func awsAwsjson11_deserializeDocumentUploadNotFoundException(v **types.UploadNotFoundException, value interface{}) error {
11199 if v == nil {
11200 return fmt.Errorf("unexpected nil of type %T", v)
11201 }
11202 if value == nil {
11203 return nil
11204 }
11205
11206 shape, ok := value.(map[string]interface{})
11207 if !ok {
11208 return fmt.Errorf("unexpected JSON type %v", value)
11209 }
11210
11211 var sv *types.UploadNotFoundException
11212 if *v == nil {
11213 sv = &types.UploadNotFoundException{}
11214 } else {
11215 sv = *v
11216 }
11217
11218 for key, value := range shape {
11219 switch key {
11220 case "message":
11221 if value != nil {
11222 jtv, ok := value.(string)
11223 if !ok {
11224 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
11225 }
11226 sv.Message = ptr.String(jtv)
11227 }
11228
11229 default:
11230 _, _ = key, value
11231
11232 }
11233 }
11234 *v = sv
11235 return nil
11236 }
11237
11238 func awsAwsjson11_deserializeDocumentValidationException(v **types.ValidationException, value interface{}) error {
11239 if v == nil {
11240 return fmt.Errorf("unexpected nil of type %T", v)
11241 }
11242 if value == nil {
11243 return nil
11244 }
11245
11246 shape, ok := value.(map[string]interface{})
11247 if !ok {
11248 return fmt.Errorf("unexpected JSON type %v", value)
11249 }
11250
11251 var sv *types.ValidationException
11252 if *v == nil {
11253 sv = &types.ValidationException{}
11254 } else {
11255 sv = *v
11256 }
11257
11258 for key, value := range shape {
11259 switch key {
11260 case "message":
11261 if value != nil {
11262 jtv, ok := value.(string)
11263 if !ok {
11264 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
11265 }
11266 sv.Message = ptr.String(jtv)
11267 }
11268
11269 default:
11270 _, _ = key, value
11271
11272 }
11273 }
11274 *v = sv
11275 return nil
11276 }
11277
11278 func awsAwsjson11_deserializeDocumentVulnerablePackage(v **types.VulnerablePackage, value interface{}) error {
11279 if v == nil {
11280 return fmt.Errorf("unexpected nil of type %T", v)
11281 }
11282 if value == nil {
11283 return nil
11284 }
11285
11286 shape, ok := value.(map[string]interface{})
11287 if !ok {
11288 return fmt.Errorf("unexpected JSON type %v", value)
11289 }
11290
11291 var sv *types.VulnerablePackage
11292 if *v == nil {
11293 sv = &types.VulnerablePackage{}
11294 } else {
11295 sv = *v
11296 }
11297
11298 for key, value := range shape {
11299 switch key {
11300 case "arch":
11301 if value != nil {
11302 jtv, ok := value.(string)
11303 if !ok {
11304 return fmt.Errorf("expected Arch to be of type string, got %T instead", value)
11305 }
11306 sv.Arch = ptr.String(jtv)
11307 }
11308
11309 case "epoch":
11310 if value != nil {
11311 jtv, ok := value.(json.Number)
11312 if !ok {
11313 return fmt.Errorf("expected Epoch to be json.Number, got %T instead", value)
11314 }
11315 i64, err := jtv.Int64()
11316 if err != nil {
11317 return err
11318 }
11319 sv.Epoch = ptr.Int32(int32(i64))
11320 }
11321
11322 case "filePath":
11323 if value != nil {
11324 jtv, ok := value.(string)
11325 if !ok {
11326 return fmt.Errorf("expected FilePath to be of type string, got %T instead", value)
11327 }
11328 sv.FilePath = ptr.String(jtv)
11329 }
11330
11331 case "name":
11332 if value != nil {
11333 jtv, ok := value.(string)
11334 if !ok {
11335 return fmt.Errorf("expected VulnerablePackageName to be of type string, got %T instead", value)
11336 }
11337 sv.Name = ptr.String(jtv)
11338 }
11339
11340 case "packageManager":
11341 if value != nil {
11342 jtv, ok := value.(string)
11343 if !ok {
11344 return fmt.Errorf("expected PackageManager to be of type string, got %T instead", value)
11345 }
11346 sv.PackageManager = ptr.String(jtv)
11347 }
11348
11349 case "release":
11350 if value != nil {
11351 jtv, ok := value.(string)
11352 if !ok {
11353 return fmt.Errorf("expected Release to be of type string, got %T instead", value)
11354 }
11355 sv.Release = ptr.String(jtv)
11356 }
11357
11358 case "sourceLayerHash":
11359 if value != nil {
11360 jtv, ok := value.(string)
11361 if !ok {
11362 return fmt.Errorf("expected SourceLayerHash to be of type string, got %T instead", value)
11363 }
11364 sv.SourceLayerHash = ptr.String(jtv)
11365 }
11366
11367 case "version":
11368 if value != nil {
11369 jtv, ok := value.(string)
11370 if !ok {
11371 return fmt.Errorf("expected Version to be of type string, got %T instead", value)
11372 }
11373 sv.Version = ptr.String(jtv)
11374 }
11375
11376 default:
11377 _, _ = key, value
11378
11379 }
11380 }
11381 *v = sv
11382 return nil
11383 }
11384
11385 func awsAwsjson11_deserializeDocumentVulnerablePackagesList(v *[]types.VulnerablePackage, value interface{}) error {
11386 if v == nil {
11387 return fmt.Errorf("unexpected nil of type %T", v)
11388 }
11389 if value == nil {
11390 return nil
11391 }
11392
11393 shape, ok := value.([]interface{})
11394 if !ok {
11395 return fmt.Errorf("unexpected JSON type %v", value)
11396 }
11397
11398 var cv []types.VulnerablePackage
11399 if *v == nil {
11400 cv = []types.VulnerablePackage{}
11401 } else {
11402 cv = *v
11403 }
11404
11405 for _, value := range shape {
11406 var col types.VulnerablePackage
11407 destAddr := &col
11408 if err := awsAwsjson11_deserializeDocumentVulnerablePackage(&destAddr, value); err != nil {
11409 return err
11410 }
11411 col = *destAddr
11412 cv = append(cv, col)
11413
11414 }
11415 *v = cv
11416 return nil
11417 }
11418
11419 func awsAwsjson11_deserializeOpDocumentBatchCheckLayerAvailabilityOutput(v **BatchCheckLayerAvailabilityOutput, value interface{}) error {
11420 if v == nil {
11421 return fmt.Errorf("unexpected nil of type %T", v)
11422 }
11423 if value == nil {
11424 return nil
11425 }
11426
11427 shape, ok := value.(map[string]interface{})
11428 if !ok {
11429 return fmt.Errorf("unexpected JSON type %v", value)
11430 }
11431
11432 var sv *BatchCheckLayerAvailabilityOutput
11433 if *v == nil {
11434 sv = &BatchCheckLayerAvailabilityOutput{}
11435 } else {
11436 sv = *v
11437 }
11438
11439 for key, value := range shape {
11440 switch key {
11441 case "failures":
11442 if err := awsAwsjson11_deserializeDocumentLayerFailureList(&sv.Failures, value); err != nil {
11443 return err
11444 }
11445
11446 case "layers":
11447 if err := awsAwsjson11_deserializeDocumentLayerList(&sv.Layers, value); err != nil {
11448 return err
11449 }
11450
11451 default:
11452 _, _ = key, value
11453
11454 }
11455 }
11456 *v = sv
11457 return nil
11458 }
11459
11460 func awsAwsjson11_deserializeOpDocumentBatchDeleteImageOutput(v **BatchDeleteImageOutput, value interface{}) error {
11461 if v == nil {
11462 return fmt.Errorf("unexpected nil of type %T", v)
11463 }
11464 if value == nil {
11465 return nil
11466 }
11467
11468 shape, ok := value.(map[string]interface{})
11469 if !ok {
11470 return fmt.Errorf("unexpected JSON type %v", value)
11471 }
11472
11473 var sv *BatchDeleteImageOutput
11474 if *v == nil {
11475 sv = &BatchDeleteImageOutput{}
11476 } else {
11477 sv = *v
11478 }
11479
11480 for key, value := range shape {
11481 switch key {
11482 case "failures":
11483 if err := awsAwsjson11_deserializeDocumentImageFailureList(&sv.Failures, value); err != nil {
11484 return err
11485 }
11486
11487 case "imageIds":
11488 if err := awsAwsjson11_deserializeDocumentImageIdentifierList(&sv.ImageIds, value); err != nil {
11489 return err
11490 }
11491
11492 default:
11493 _, _ = key, value
11494
11495 }
11496 }
11497 *v = sv
11498 return nil
11499 }
11500
11501 func awsAwsjson11_deserializeOpDocumentBatchGetImageOutput(v **BatchGetImageOutput, value interface{}) error {
11502 if v == nil {
11503 return fmt.Errorf("unexpected nil of type %T", v)
11504 }
11505 if value == nil {
11506 return nil
11507 }
11508
11509 shape, ok := value.(map[string]interface{})
11510 if !ok {
11511 return fmt.Errorf("unexpected JSON type %v", value)
11512 }
11513
11514 var sv *BatchGetImageOutput
11515 if *v == nil {
11516 sv = &BatchGetImageOutput{}
11517 } else {
11518 sv = *v
11519 }
11520
11521 for key, value := range shape {
11522 switch key {
11523 case "failures":
11524 if err := awsAwsjson11_deserializeDocumentImageFailureList(&sv.Failures, value); err != nil {
11525 return err
11526 }
11527
11528 case "images":
11529 if err := awsAwsjson11_deserializeDocumentImageList(&sv.Images, value); err != nil {
11530 return err
11531 }
11532
11533 default:
11534 _, _ = key, value
11535
11536 }
11537 }
11538 *v = sv
11539 return nil
11540 }
11541
11542 func awsAwsjson11_deserializeOpDocumentBatchGetRepositoryScanningConfigurationOutput(v **BatchGetRepositoryScanningConfigurationOutput, value interface{}) error {
11543 if v == nil {
11544 return fmt.Errorf("unexpected nil of type %T", v)
11545 }
11546 if value == nil {
11547 return nil
11548 }
11549
11550 shape, ok := value.(map[string]interface{})
11551 if !ok {
11552 return fmt.Errorf("unexpected JSON type %v", value)
11553 }
11554
11555 var sv *BatchGetRepositoryScanningConfigurationOutput
11556 if *v == nil {
11557 sv = &BatchGetRepositoryScanningConfigurationOutput{}
11558 } else {
11559 sv = *v
11560 }
11561
11562 for key, value := range shape {
11563 switch key {
11564 case "failures":
11565 if err := awsAwsjson11_deserializeDocumentRepositoryScanningConfigurationFailureList(&sv.Failures, value); err != nil {
11566 return err
11567 }
11568
11569 case "scanningConfigurations":
11570 if err := awsAwsjson11_deserializeDocumentRepositoryScanningConfigurationList(&sv.ScanningConfigurations, value); err != nil {
11571 return err
11572 }
11573
11574 default:
11575 _, _ = key, value
11576
11577 }
11578 }
11579 *v = sv
11580 return nil
11581 }
11582
11583 func awsAwsjson11_deserializeOpDocumentCompleteLayerUploadOutput(v **CompleteLayerUploadOutput, value interface{}) error {
11584 if v == nil {
11585 return fmt.Errorf("unexpected nil of type %T", v)
11586 }
11587 if value == nil {
11588 return nil
11589 }
11590
11591 shape, ok := value.(map[string]interface{})
11592 if !ok {
11593 return fmt.Errorf("unexpected JSON type %v", value)
11594 }
11595
11596 var sv *CompleteLayerUploadOutput
11597 if *v == nil {
11598 sv = &CompleteLayerUploadOutput{}
11599 } else {
11600 sv = *v
11601 }
11602
11603 for key, value := range shape {
11604 switch key {
11605 case "layerDigest":
11606 if value != nil {
11607 jtv, ok := value.(string)
11608 if !ok {
11609 return fmt.Errorf("expected LayerDigest to be of type string, got %T instead", value)
11610 }
11611 sv.LayerDigest = ptr.String(jtv)
11612 }
11613
11614 case "registryId":
11615 if value != nil {
11616 jtv, ok := value.(string)
11617 if !ok {
11618 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
11619 }
11620 sv.RegistryId = ptr.String(jtv)
11621 }
11622
11623 case "repositoryName":
11624 if value != nil {
11625 jtv, ok := value.(string)
11626 if !ok {
11627 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
11628 }
11629 sv.RepositoryName = ptr.String(jtv)
11630 }
11631
11632 case "uploadId":
11633 if value != nil {
11634 jtv, ok := value.(string)
11635 if !ok {
11636 return fmt.Errorf("expected UploadId to be of type string, got %T instead", value)
11637 }
11638 sv.UploadId = ptr.String(jtv)
11639 }
11640
11641 default:
11642 _, _ = key, value
11643
11644 }
11645 }
11646 *v = sv
11647 return nil
11648 }
11649
11650 func awsAwsjson11_deserializeOpDocumentCreatePullThroughCacheRuleOutput(v **CreatePullThroughCacheRuleOutput, value interface{}) error {
11651 if v == nil {
11652 return fmt.Errorf("unexpected nil of type %T", v)
11653 }
11654 if value == nil {
11655 return nil
11656 }
11657
11658 shape, ok := value.(map[string]interface{})
11659 if !ok {
11660 return fmt.Errorf("unexpected JSON type %v", value)
11661 }
11662
11663 var sv *CreatePullThroughCacheRuleOutput
11664 if *v == nil {
11665 sv = &CreatePullThroughCacheRuleOutput{}
11666 } else {
11667 sv = *v
11668 }
11669
11670 for key, value := range shape {
11671 switch key {
11672 case "createdAt":
11673 if value != nil {
11674 switch jtv := value.(type) {
11675 case json.Number:
11676 f64, err := jtv.Float64()
11677 if err != nil {
11678 return err
11679 }
11680 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
11681
11682 default:
11683 return fmt.Errorf("expected CreationTimestamp to be a JSON Number, got %T instead", value)
11684
11685 }
11686 }
11687
11688 case "ecrRepositoryPrefix":
11689 if value != nil {
11690 jtv, ok := value.(string)
11691 if !ok {
11692 return fmt.Errorf("expected PullThroughCacheRuleRepositoryPrefix to be of type string, got %T instead", value)
11693 }
11694 sv.EcrRepositoryPrefix = ptr.String(jtv)
11695 }
11696
11697 case "registryId":
11698 if value != nil {
11699 jtv, ok := value.(string)
11700 if !ok {
11701 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
11702 }
11703 sv.RegistryId = ptr.String(jtv)
11704 }
11705
11706 case "upstreamRegistryUrl":
11707 if value != nil {
11708 jtv, ok := value.(string)
11709 if !ok {
11710 return fmt.Errorf("expected Url to be of type string, got %T instead", value)
11711 }
11712 sv.UpstreamRegistryUrl = ptr.String(jtv)
11713 }
11714
11715 default:
11716 _, _ = key, value
11717
11718 }
11719 }
11720 *v = sv
11721 return nil
11722 }
11723
11724 func awsAwsjson11_deserializeOpDocumentCreateRepositoryOutput(v **CreateRepositoryOutput, value interface{}) error {
11725 if v == nil {
11726 return fmt.Errorf("unexpected nil of type %T", v)
11727 }
11728 if value == nil {
11729 return nil
11730 }
11731
11732 shape, ok := value.(map[string]interface{})
11733 if !ok {
11734 return fmt.Errorf("unexpected JSON type %v", value)
11735 }
11736
11737 var sv *CreateRepositoryOutput
11738 if *v == nil {
11739 sv = &CreateRepositoryOutput{}
11740 } else {
11741 sv = *v
11742 }
11743
11744 for key, value := range shape {
11745 switch key {
11746 case "repository":
11747 if err := awsAwsjson11_deserializeDocumentRepository(&sv.Repository, value); err != nil {
11748 return err
11749 }
11750
11751 default:
11752 _, _ = key, value
11753
11754 }
11755 }
11756 *v = sv
11757 return nil
11758 }
11759
11760 func awsAwsjson11_deserializeOpDocumentDeleteLifecyclePolicyOutput(v **DeleteLifecyclePolicyOutput, value interface{}) error {
11761 if v == nil {
11762 return fmt.Errorf("unexpected nil of type %T", v)
11763 }
11764 if value == nil {
11765 return nil
11766 }
11767
11768 shape, ok := value.(map[string]interface{})
11769 if !ok {
11770 return fmt.Errorf("unexpected JSON type %v", value)
11771 }
11772
11773 var sv *DeleteLifecyclePolicyOutput
11774 if *v == nil {
11775 sv = &DeleteLifecyclePolicyOutput{}
11776 } else {
11777 sv = *v
11778 }
11779
11780 for key, value := range shape {
11781 switch key {
11782 case "lastEvaluatedAt":
11783 if value != nil {
11784 switch jtv := value.(type) {
11785 case json.Number:
11786 f64, err := jtv.Float64()
11787 if err != nil {
11788 return err
11789 }
11790 sv.LastEvaluatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
11791
11792 default:
11793 return fmt.Errorf("expected EvaluationTimestamp to be a JSON Number, got %T instead", value)
11794
11795 }
11796 }
11797
11798 case "lifecyclePolicyText":
11799 if value != nil {
11800 jtv, ok := value.(string)
11801 if !ok {
11802 return fmt.Errorf("expected LifecyclePolicyText to be of type string, got %T instead", value)
11803 }
11804 sv.LifecyclePolicyText = ptr.String(jtv)
11805 }
11806
11807 case "registryId":
11808 if value != nil {
11809 jtv, ok := value.(string)
11810 if !ok {
11811 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
11812 }
11813 sv.RegistryId = ptr.String(jtv)
11814 }
11815
11816 case "repositoryName":
11817 if value != nil {
11818 jtv, ok := value.(string)
11819 if !ok {
11820 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
11821 }
11822 sv.RepositoryName = ptr.String(jtv)
11823 }
11824
11825 default:
11826 _, _ = key, value
11827
11828 }
11829 }
11830 *v = sv
11831 return nil
11832 }
11833
11834 func awsAwsjson11_deserializeOpDocumentDeletePullThroughCacheRuleOutput(v **DeletePullThroughCacheRuleOutput, value interface{}) error {
11835 if v == nil {
11836 return fmt.Errorf("unexpected nil of type %T", v)
11837 }
11838 if value == nil {
11839 return nil
11840 }
11841
11842 shape, ok := value.(map[string]interface{})
11843 if !ok {
11844 return fmt.Errorf("unexpected JSON type %v", value)
11845 }
11846
11847 var sv *DeletePullThroughCacheRuleOutput
11848 if *v == nil {
11849 sv = &DeletePullThroughCacheRuleOutput{}
11850 } else {
11851 sv = *v
11852 }
11853
11854 for key, value := range shape {
11855 switch key {
11856 case "createdAt":
11857 if value != nil {
11858 switch jtv := value.(type) {
11859 case json.Number:
11860 f64, err := jtv.Float64()
11861 if err != nil {
11862 return err
11863 }
11864 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
11865
11866 default:
11867 return fmt.Errorf("expected CreationTimestamp to be a JSON Number, got %T instead", value)
11868
11869 }
11870 }
11871
11872 case "ecrRepositoryPrefix":
11873 if value != nil {
11874 jtv, ok := value.(string)
11875 if !ok {
11876 return fmt.Errorf("expected PullThroughCacheRuleRepositoryPrefix to be of type string, got %T instead", value)
11877 }
11878 sv.EcrRepositoryPrefix = ptr.String(jtv)
11879 }
11880
11881 case "registryId":
11882 if value != nil {
11883 jtv, ok := value.(string)
11884 if !ok {
11885 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
11886 }
11887 sv.RegistryId = ptr.String(jtv)
11888 }
11889
11890 case "upstreamRegistryUrl":
11891 if value != nil {
11892 jtv, ok := value.(string)
11893 if !ok {
11894 return fmt.Errorf("expected Url to be of type string, got %T instead", value)
11895 }
11896 sv.UpstreamRegistryUrl = ptr.String(jtv)
11897 }
11898
11899 default:
11900 _, _ = key, value
11901
11902 }
11903 }
11904 *v = sv
11905 return nil
11906 }
11907
11908 func awsAwsjson11_deserializeOpDocumentDeleteRegistryPolicyOutput(v **DeleteRegistryPolicyOutput, value interface{}) error {
11909 if v == nil {
11910 return fmt.Errorf("unexpected nil of type %T", v)
11911 }
11912 if value == nil {
11913 return nil
11914 }
11915
11916 shape, ok := value.(map[string]interface{})
11917 if !ok {
11918 return fmt.Errorf("unexpected JSON type %v", value)
11919 }
11920
11921 var sv *DeleteRegistryPolicyOutput
11922 if *v == nil {
11923 sv = &DeleteRegistryPolicyOutput{}
11924 } else {
11925 sv = *v
11926 }
11927
11928 for key, value := range shape {
11929 switch key {
11930 case "policyText":
11931 if value != nil {
11932 jtv, ok := value.(string)
11933 if !ok {
11934 return fmt.Errorf("expected RegistryPolicyText to be of type string, got %T instead", value)
11935 }
11936 sv.PolicyText = ptr.String(jtv)
11937 }
11938
11939 case "registryId":
11940 if value != nil {
11941 jtv, ok := value.(string)
11942 if !ok {
11943 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
11944 }
11945 sv.RegistryId = ptr.String(jtv)
11946 }
11947
11948 default:
11949 _, _ = key, value
11950
11951 }
11952 }
11953 *v = sv
11954 return nil
11955 }
11956
11957 func awsAwsjson11_deserializeOpDocumentDeleteRepositoryOutput(v **DeleteRepositoryOutput, value interface{}) error {
11958 if v == nil {
11959 return fmt.Errorf("unexpected nil of type %T", v)
11960 }
11961 if value == nil {
11962 return nil
11963 }
11964
11965 shape, ok := value.(map[string]interface{})
11966 if !ok {
11967 return fmt.Errorf("unexpected JSON type %v", value)
11968 }
11969
11970 var sv *DeleteRepositoryOutput
11971 if *v == nil {
11972 sv = &DeleteRepositoryOutput{}
11973 } else {
11974 sv = *v
11975 }
11976
11977 for key, value := range shape {
11978 switch key {
11979 case "repository":
11980 if err := awsAwsjson11_deserializeDocumentRepository(&sv.Repository, value); err != nil {
11981 return err
11982 }
11983
11984 default:
11985 _, _ = key, value
11986
11987 }
11988 }
11989 *v = sv
11990 return nil
11991 }
11992
11993 func awsAwsjson11_deserializeOpDocumentDeleteRepositoryPolicyOutput(v **DeleteRepositoryPolicyOutput, value interface{}) error {
11994 if v == nil {
11995 return fmt.Errorf("unexpected nil of type %T", v)
11996 }
11997 if value == nil {
11998 return nil
11999 }
12000
12001 shape, ok := value.(map[string]interface{})
12002 if !ok {
12003 return fmt.Errorf("unexpected JSON type %v", value)
12004 }
12005
12006 var sv *DeleteRepositoryPolicyOutput
12007 if *v == nil {
12008 sv = &DeleteRepositoryPolicyOutput{}
12009 } else {
12010 sv = *v
12011 }
12012
12013 for key, value := range shape {
12014 switch key {
12015 case "policyText":
12016 if value != nil {
12017 jtv, ok := value.(string)
12018 if !ok {
12019 return fmt.Errorf("expected RepositoryPolicyText to be of type string, got %T instead", value)
12020 }
12021 sv.PolicyText = ptr.String(jtv)
12022 }
12023
12024 case "registryId":
12025 if value != nil {
12026 jtv, ok := value.(string)
12027 if !ok {
12028 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
12029 }
12030 sv.RegistryId = ptr.String(jtv)
12031 }
12032
12033 case "repositoryName":
12034 if value != nil {
12035 jtv, ok := value.(string)
12036 if !ok {
12037 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
12038 }
12039 sv.RepositoryName = ptr.String(jtv)
12040 }
12041
12042 default:
12043 _, _ = key, value
12044
12045 }
12046 }
12047 *v = sv
12048 return nil
12049 }
12050
12051 func awsAwsjson11_deserializeOpDocumentDescribeImageReplicationStatusOutput(v **DescribeImageReplicationStatusOutput, value interface{}) error {
12052 if v == nil {
12053 return fmt.Errorf("unexpected nil of type %T", v)
12054 }
12055 if value == nil {
12056 return nil
12057 }
12058
12059 shape, ok := value.(map[string]interface{})
12060 if !ok {
12061 return fmt.Errorf("unexpected JSON type %v", value)
12062 }
12063
12064 var sv *DescribeImageReplicationStatusOutput
12065 if *v == nil {
12066 sv = &DescribeImageReplicationStatusOutput{}
12067 } else {
12068 sv = *v
12069 }
12070
12071 for key, value := range shape {
12072 switch key {
12073 case "imageId":
12074 if err := awsAwsjson11_deserializeDocumentImageIdentifier(&sv.ImageId, value); err != nil {
12075 return err
12076 }
12077
12078 case "replicationStatuses":
12079 if err := awsAwsjson11_deserializeDocumentImageReplicationStatusList(&sv.ReplicationStatuses, value); err != nil {
12080 return err
12081 }
12082
12083 case "repositoryName":
12084 if value != nil {
12085 jtv, ok := value.(string)
12086 if !ok {
12087 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
12088 }
12089 sv.RepositoryName = ptr.String(jtv)
12090 }
12091
12092 default:
12093 _, _ = key, value
12094
12095 }
12096 }
12097 *v = sv
12098 return nil
12099 }
12100
12101 func awsAwsjson11_deserializeOpDocumentDescribeImageScanFindingsOutput(v **DescribeImageScanFindingsOutput, value interface{}) error {
12102 if v == nil {
12103 return fmt.Errorf("unexpected nil of type %T", v)
12104 }
12105 if value == nil {
12106 return nil
12107 }
12108
12109 shape, ok := value.(map[string]interface{})
12110 if !ok {
12111 return fmt.Errorf("unexpected JSON type %v", value)
12112 }
12113
12114 var sv *DescribeImageScanFindingsOutput
12115 if *v == nil {
12116 sv = &DescribeImageScanFindingsOutput{}
12117 } else {
12118 sv = *v
12119 }
12120
12121 for key, value := range shape {
12122 switch key {
12123 case "imageId":
12124 if err := awsAwsjson11_deserializeDocumentImageIdentifier(&sv.ImageId, value); err != nil {
12125 return err
12126 }
12127
12128 case "imageScanFindings":
12129 if err := awsAwsjson11_deserializeDocumentImageScanFindings(&sv.ImageScanFindings, value); err != nil {
12130 return err
12131 }
12132
12133 case "imageScanStatus":
12134 if err := awsAwsjson11_deserializeDocumentImageScanStatus(&sv.ImageScanStatus, value); err != nil {
12135 return err
12136 }
12137
12138 case "nextToken":
12139 if value != nil {
12140 jtv, ok := value.(string)
12141 if !ok {
12142 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12143 }
12144 sv.NextToken = ptr.String(jtv)
12145 }
12146
12147 case "registryId":
12148 if value != nil {
12149 jtv, ok := value.(string)
12150 if !ok {
12151 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
12152 }
12153 sv.RegistryId = ptr.String(jtv)
12154 }
12155
12156 case "repositoryName":
12157 if value != nil {
12158 jtv, ok := value.(string)
12159 if !ok {
12160 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
12161 }
12162 sv.RepositoryName = ptr.String(jtv)
12163 }
12164
12165 default:
12166 _, _ = key, value
12167
12168 }
12169 }
12170 *v = sv
12171 return nil
12172 }
12173
12174 func awsAwsjson11_deserializeOpDocumentDescribeImagesOutput(v **DescribeImagesOutput, value interface{}) error {
12175 if v == nil {
12176 return fmt.Errorf("unexpected nil of type %T", v)
12177 }
12178 if value == nil {
12179 return nil
12180 }
12181
12182 shape, ok := value.(map[string]interface{})
12183 if !ok {
12184 return fmt.Errorf("unexpected JSON type %v", value)
12185 }
12186
12187 var sv *DescribeImagesOutput
12188 if *v == nil {
12189 sv = &DescribeImagesOutput{}
12190 } else {
12191 sv = *v
12192 }
12193
12194 for key, value := range shape {
12195 switch key {
12196 case "imageDetails":
12197 if err := awsAwsjson11_deserializeDocumentImageDetailList(&sv.ImageDetails, value); err != nil {
12198 return err
12199 }
12200
12201 case "nextToken":
12202 if value != nil {
12203 jtv, ok := value.(string)
12204 if !ok {
12205 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12206 }
12207 sv.NextToken = ptr.String(jtv)
12208 }
12209
12210 default:
12211 _, _ = key, value
12212
12213 }
12214 }
12215 *v = sv
12216 return nil
12217 }
12218
12219 func awsAwsjson11_deserializeOpDocumentDescribePullThroughCacheRulesOutput(v **DescribePullThroughCacheRulesOutput, value interface{}) error {
12220 if v == nil {
12221 return fmt.Errorf("unexpected nil of type %T", v)
12222 }
12223 if value == nil {
12224 return nil
12225 }
12226
12227 shape, ok := value.(map[string]interface{})
12228 if !ok {
12229 return fmt.Errorf("unexpected JSON type %v", value)
12230 }
12231
12232 var sv *DescribePullThroughCacheRulesOutput
12233 if *v == nil {
12234 sv = &DescribePullThroughCacheRulesOutput{}
12235 } else {
12236 sv = *v
12237 }
12238
12239 for key, value := range shape {
12240 switch key {
12241 case "nextToken":
12242 if value != nil {
12243 jtv, ok := value.(string)
12244 if !ok {
12245 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12246 }
12247 sv.NextToken = ptr.String(jtv)
12248 }
12249
12250 case "pullThroughCacheRules":
12251 if err := awsAwsjson11_deserializeDocumentPullThroughCacheRuleList(&sv.PullThroughCacheRules, value); err != nil {
12252 return err
12253 }
12254
12255 default:
12256 _, _ = key, value
12257
12258 }
12259 }
12260 *v = sv
12261 return nil
12262 }
12263
12264 func awsAwsjson11_deserializeOpDocumentDescribeRegistryOutput(v **DescribeRegistryOutput, value interface{}) error {
12265 if v == nil {
12266 return fmt.Errorf("unexpected nil of type %T", v)
12267 }
12268 if value == nil {
12269 return nil
12270 }
12271
12272 shape, ok := value.(map[string]interface{})
12273 if !ok {
12274 return fmt.Errorf("unexpected JSON type %v", value)
12275 }
12276
12277 var sv *DescribeRegistryOutput
12278 if *v == nil {
12279 sv = &DescribeRegistryOutput{}
12280 } else {
12281 sv = *v
12282 }
12283
12284 for key, value := range shape {
12285 switch key {
12286 case "registryId":
12287 if value != nil {
12288 jtv, ok := value.(string)
12289 if !ok {
12290 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
12291 }
12292 sv.RegistryId = ptr.String(jtv)
12293 }
12294
12295 case "replicationConfiguration":
12296 if err := awsAwsjson11_deserializeDocumentReplicationConfiguration(&sv.ReplicationConfiguration, value); err != nil {
12297 return err
12298 }
12299
12300 default:
12301 _, _ = key, value
12302
12303 }
12304 }
12305 *v = sv
12306 return nil
12307 }
12308
12309 func awsAwsjson11_deserializeOpDocumentDescribeRepositoriesOutput(v **DescribeRepositoriesOutput, value interface{}) error {
12310 if v == nil {
12311 return fmt.Errorf("unexpected nil of type %T", v)
12312 }
12313 if value == nil {
12314 return nil
12315 }
12316
12317 shape, ok := value.(map[string]interface{})
12318 if !ok {
12319 return fmt.Errorf("unexpected JSON type %v", value)
12320 }
12321
12322 var sv *DescribeRepositoriesOutput
12323 if *v == nil {
12324 sv = &DescribeRepositoriesOutput{}
12325 } else {
12326 sv = *v
12327 }
12328
12329 for key, value := range shape {
12330 switch key {
12331 case "nextToken":
12332 if value != nil {
12333 jtv, ok := value.(string)
12334 if !ok {
12335 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12336 }
12337 sv.NextToken = ptr.String(jtv)
12338 }
12339
12340 case "repositories":
12341 if err := awsAwsjson11_deserializeDocumentRepositoryList(&sv.Repositories, value); err != nil {
12342 return err
12343 }
12344
12345 default:
12346 _, _ = key, value
12347
12348 }
12349 }
12350 *v = sv
12351 return nil
12352 }
12353
12354 func awsAwsjson11_deserializeOpDocumentGetAuthorizationTokenOutput(v **GetAuthorizationTokenOutput, value interface{}) error {
12355 if v == nil {
12356 return fmt.Errorf("unexpected nil of type %T", v)
12357 }
12358 if value == nil {
12359 return nil
12360 }
12361
12362 shape, ok := value.(map[string]interface{})
12363 if !ok {
12364 return fmt.Errorf("unexpected JSON type %v", value)
12365 }
12366
12367 var sv *GetAuthorizationTokenOutput
12368 if *v == nil {
12369 sv = &GetAuthorizationTokenOutput{}
12370 } else {
12371 sv = *v
12372 }
12373
12374 for key, value := range shape {
12375 switch key {
12376 case "authorizationData":
12377 if err := awsAwsjson11_deserializeDocumentAuthorizationDataList(&sv.AuthorizationData, value); err != nil {
12378 return err
12379 }
12380
12381 default:
12382 _, _ = key, value
12383
12384 }
12385 }
12386 *v = sv
12387 return nil
12388 }
12389
12390 func awsAwsjson11_deserializeOpDocumentGetDownloadUrlForLayerOutput(v **GetDownloadUrlForLayerOutput, value interface{}) error {
12391 if v == nil {
12392 return fmt.Errorf("unexpected nil of type %T", v)
12393 }
12394 if value == nil {
12395 return nil
12396 }
12397
12398 shape, ok := value.(map[string]interface{})
12399 if !ok {
12400 return fmt.Errorf("unexpected JSON type %v", value)
12401 }
12402
12403 var sv *GetDownloadUrlForLayerOutput
12404 if *v == nil {
12405 sv = &GetDownloadUrlForLayerOutput{}
12406 } else {
12407 sv = *v
12408 }
12409
12410 for key, value := range shape {
12411 switch key {
12412 case "downloadUrl":
12413 if value != nil {
12414 jtv, ok := value.(string)
12415 if !ok {
12416 return fmt.Errorf("expected Url to be of type string, got %T instead", value)
12417 }
12418 sv.DownloadUrl = ptr.String(jtv)
12419 }
12420
12421 case "layerDigest":
12422 if value != nil {
12423 jtv, ok := value.(string)
12424 if !ok {
12425 return fmt.Errorf("expected LayerDigest to be of type string, got %T instead", value)
12426 }
12427 sv.LayerDigest = ptr.String(jtv)
12428 }
12429
12430 default:
12431 _, _ = key, value
12432
12433 }
12434 }
12435 *v = sv
12436 return nil
12437 }
12438
12439 func awsAwsjson11_deserializeOpDocumentGetLifecyclePolicyOutput(v **GetLifecyclePolicyOutput, value interface{}) error {
12440 if v == nil {
12441 return fmt.Errorf("unexpected nil of type %T", v)
12442 }
12443 if value == nil {
12444 return nil
12445 }
12446
12447 shape, ok := value.(map[string]interface{})
12448 if !ok {
12449 return fmt.Errorf("unexpected JSON type %v", value)
12450 }
12451
12452 var sv *GetLifecyclePolicyOutput
12453 if *v == nil {
12454 sv = &GetLifecyclePolicyOutput{}
12455 } else {
12456 sv = *v
12457 }
12458
12459 for key, value := range shape {
12460 switch key {
12461 case "lastEvaluatedAt":
12462 if value != nil {
12463 switch jtv := value.(type) {
12464 case json.Number:
12465 f64, err := jtv.Float64()
12466 if err != nil {
12467 return err
12468 }
12469 sv.LastEvaluatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
12470
12471 default:
12472 return fmt.Errorf("expected EvaluationTimestamp to be a JSON Number, got %T instead", value)
12473
12474 }
12475 }
12476
12477 case "lifecyclePolicyText":
12478 if value != nil {
12479 jtv, ok := value.(string)
12480 if !ok {
12481 return fmt.Errorf("expected LifecyclePolicyText to be of type string, got %T instead", value)
12482 }
12483 sv.LifecyclePolicyText = ptr.String(jtv)
12484 }
12485
12486 case "registryId":
12487 if value != nil {
12488 jtv, ok := value.(string)
12489 if !ok {
12490 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
12491 }
12492 sv.RegistryId = ptr.String(jtv)
12493 }
12494
12495 case "repositoryName":
12496 if value != nil {
12497 jtv, ok := value.(string)
12498 if !ok {
12499 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
12500 }
12501 sv.RepositoryName = ptr.String(jtv)
12502 }
12503
12504 default:
12505 _, _ = key, value
12506
12507 }
12508 }
12509 *v = sv
12510 return nil
12511 }
12512
12513 func awsAwsjson11_deserializeOpDocumentGetLifecyclePolicyPreviewOutput(v **GetLifecyclePolicyPreviewOutput, value interface{}) error {
12514 if v == nil {
12515 return fmt.Errorf("unexpected nil of type %T", v)
12516 }
12517 if value == nil {
12518 return nil
12519 }
12520
12521 shape, ok := value.(map[string]interface{})
12522 if !ok {
12523 return fmt.Errorf("unexpected JSON type %v", value)
12524 }
12525
12526 var sv *GetLifecyclePolicyPreviewOutput
12527 if *v == nil {
12528 sv = &GetLifecyclePolicyPreviewOutput{}
12529 } else {
12530 sv = *v
12531 }
12532
12533 for key, value := range shape {
12534 switch key {
12535 case "lifecyclePolicyText":
12536 if value != nil {
12537 jtv, ok := value.(string)
12538 if !ok {
12539 return fmt.Errorf("expected LifecyclePolicyText to be of type string, got %T instead", value)
12540 }
12541 sv.LifecyclePolicyText = ptr.String(jtv)
12542 }
12543
12544 case "nextToken":
12545 if value != nil {
12546 jtv, ok := value.(string)
12547 if !ok {
12548 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12549 }
12550 sv.NextToken = ptr.String(jtv)
12551 }
12552
12553 case "previewResults":
12554 if err := awsAwsjson11_deserializeDocumentLifecyclePolicyPreviewResultList(&sv.PreviewResults, value); err != nil {
12555 return err
12556 }
12557
12558 case "registryId":
12559 if value != nil {
12560 jtv, ok := value.(string)
12561 if !ok {
12562 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
12563 }
12564 sv.RegistryId = ptr.String(jtv)
12565 }
12566
12567 case "repositoryName":
12568 if value != nil {
12569 jtv, ok := value.(string)
12570 if !ok {
12571 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
12572 }
12573 sv.RepositoryName = ptr.String(jtv)
12574 }
12575
12576 case "status":
12577 if value != nil {
12578 jtv, ok := value.(string)
12579 if !ok {
12580 return fmt.Errorf("expected LifecyclePolicyPreviewStatus to be of type string, got %T instead", value)
12581 }
12582 sv.Status = types.LifecyclePolicyPreviewStatus(jtv)
12583 }
12584
12585 case "summary":
12586 if err := awsAwsjson11_deserializeDocumentLifecyclePolicyPreviewSummary(&sv.Summary, value); err != nil {
12587 return err
12588 }
12589
12590 default:
12591 _, _ = key, value
12592
12593 }
12594 }
12595 *v = sv
12596 return nil
12597 }
12598
12599 func awsAwsjson11_deserializeOpDocumentGetRegistryPolicyOutput(v **GetRegistryPolicyOutput, value interface{}) error {
12600 if v == nil {
12601 return fmt.Errorf("unexpected nil of type %T", v)
12602 }
12603 if value == nil {
12604 return nil
12605 }
12606
12607 shape, ok := value.(map[string]interface{})
12608 if !ok {
12609 return fmt.Errorf("unexpected JSON type %v", value)
12610 }
12611
12612 var sv *GetRegistryPolicyOutput
12613 if *v == nil {
12614 sv = &GetRegistryPolicyOutput{}
12615 } else {
12616 sv = *v
12617 }
12618
12619 for key, value := range shape {
12620 switch key {
12621 case "policyText":
12622 if value != nil {
12623 jtv, ok := value.(string)
12624 if !ok {
12625 return fmt.Errorf("expected RegistryPolicyText to be of type string, got %T instead", value)
12626 }
12627 sv.PolicyText = ptr.String(jtv)
12628 }
12629
12630 case "registryId":
12631 if value != nil {
12632 jtv, ok := value.(string)
12633 if !ok {
12634 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
12635 }
12636 sv.RegistryId = ptr.String(jtv)
12637 }
12638
12639 default:
12640 _, _ = key, value
12641
12642 }
12643 }
12644 *v = sv
12645 return nil
12646 }
12647
12648 func awsAwsjson11_deserializeOpDocumentGetRegistryScanningConfigurationOutput(v **GetRegistryScanningConfigurationOutput, value interface{}) error {
12649 if v == nil {
12650 return fmt.Errorf("unexpected nil of type %T", v)
12651 }
12652 if value == nil {
12653 return nil
12654 }
12655
12656 shape, ok := value.(map[string]interface{})
12657 if !ok {
12658 return fmt.Errorf("unexpected JSON type %v", value)
12659 }
12660
12661 var sv *GetRegistryScanningConfigurationOutput
12662 if *v == nil {
12663 sv = &GetRegistryScanningConfigurationOutput{}
12664 } else {
12665 sv = *v
12666 }
12667
12668 for key, value := range shape {
12669 switch key {
12670 case "registryId":
12671 if value != nil {
12672 jtv, ok := value.(string)
12673 if !ok {
12674 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
12675 }
12676 sv.RegistryId = ptr.String(jtv)
12677 }
12678
12679 case "scanningConfiguration":
12680 if err := awsAwsjson11_deserializeDocumentRegistryScanningConfiguration(&sv.ScanningConfiguration, value); err != nil {
12681 return err
12682 }
12683
12684 default:
12685 _, _ = key, value
12686
12687 }
12688 }
12689 *v = sv
12690 return nil
12691 }
12692
12693 func awsAwsjson11_deserializeOpDocumentGetRepositoryPolicyOutput(v **GetRepositoryPolicyOutput, value interface{}) error {
12694 if v == nil {
12695 return fmt.Errorf("unexpected nil of type %T", v)
12696 }
12697 if value == nil {
12698 return nil
12699 }
12700
12701 shape, ok := value.(map[string]interface{})
12702 if !ok {
12703 return fmt.Errorf("unexpected JSON type %v", value)
12704 }
12705
12706 var sv *GetRepositoryPolicyOutput
12707 if *v == nil {
12708 sv = &GetRepositoryPolicyOutput{}
12709 } else {
12710 sv = *v
12711 }
12712
12713 for key, value := range shape {
12714 switch key {
12715 case "policyText":
12716 if value != nil {
12717 jtv, ok := value.(string)
12718 if !ok {
12719 return fmt.Errorf("expected RepositoryPolicyText to be of type string, got %T instead", value)
12720 }
12721 sv.PolicyText = ptr.String(jtv)
12722 }
12723
12724 case "registryId":
12725 if value != nil {
12726 jtv, ok := value.(string)
12727 if !ok {
12728 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
12729 }
12730 sv.RegistryId = ptr.String(jtv)
12731 }
12732
12733 case "repositoryName":
12734 if value != nil {
12735 jtv, ok := value.(string)
12736 if !ok {
12737 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
12738 }
12739 sv.RepositoryName = ptr.String(jtv)
12740 }
12741
12742 default:
12743 _, _ = key, value
12744
12745 }
12746 }
12747 *v = sv
12748 return nil
12749 }
12750
12751 func awsAwsjson11_deserializeOpDocumentInitiateLayerUploadOutput(v **InitiateLayerUploadOutput, value interface{}) error {
12752 if v == nil {
12753 return fmt.Errorf("unexpected nil of type %T", v)
12754 }
12755 if value == nil {
12756 return nil
12757 }
12758
12759 shape, ok := value.(map[string]interface{})
12760 if !ok {
12761 return fmt.Errorf("unexpected JSON type %v", value)
12762 }
12763
12764 var sv *InitiateLayerUploadOutput
12765 if *v == nil {
12766 sv = &InitiateLayerUploadOutput{}
12767 } else {
12768 sv = *v
12769 }
12770
12771 for key, value := range shape {
12772 switch key {
12773 case "partSize":
12774 if value != nil {
12775 jtv, ok := value.(json.Number)
12776 if !ok {
12777 return fmt.Errorf("expected PartSize to be json.Number, got %T instead", value)
12778 }
12779 i64, err := jtv.Int64()
12780 if err != nil {
12781 return err
12782 }
12783 sv.PartSize = ptr.Int64(i64)
12784 }
12785
12786 case "uploadId":
12787 if value != nil {
12788 jtv, ok := value.(string)
12789 if !ok {
12790 return fmt.Errorf("expected UploadId to be of type string, got %T instead", value)
12791 }
12792 sv.UploadId = ptr.String(jtv)
12793 }
12794
12795 default:
12796 _, _ = key, value
12797
12798 }
12799 }
12800 *v = sv
12801 return nil
12802 }
12803
12804 func awsAwsjson11_deserializeOpDocumentListImagesOutput(v **ListImagesOutput, value interface{}) error {
12805 if v == nil {
12806 return fmt.Errorf("unexpected nil of type %T", v)
12807 }
12808 if value == nil {
12809 return nil
12810 }
12811
12812 shape, ok := value.(map[string]interface{})
12813 if !ok {
12814 return fmt.Errorf("unexpected JSON type %v", value)
12815 }
12816
12817 var sv *ListImagesOutput
12818 if *v == nil {
12819 sv = &ListImagesOutput{}
12820 } else {
12821 sv = *v
12822 }
12823
12824 for key, value := range shape {
12825 switch key {
12826 case "imageIds":
12827 if err := awsAwsjson11_deserializeDocumentImageIdentifierList(&sv.ImageIds, value); err != nil {
12828 return err
12829 }
12830
12831 case "nextToken":
12832 if value != nil {
12833 jtv, ok := value.(string)
12834 if !ok {
12835 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12836 }
12837 sv.NextToken = ptr.String(jtv)
12838 }
12839
12840 default:
12841 _, _ = key, value
12842
12843 }
12844 }
12845 *v = sv
12846 return nil
12847 }
12848
12849 func awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error {
12850 if v == nil {
12851 return fmt.Errorf("unexpected nil of type %T", v)
12852 }
12853 if value == nil {
12854 return nil
12855 }
12856
12857 shape, ok := value.(map[string]interface{})
12858 if !ok {
12859 return fmt.Errorf("unexpected JSON type %v", value)
12860 }
12861
12862 var sv *ListTagsForResourceOutput
12863 if *v == nil {
12864 sv = &ListTagsForResourceOutput{}
12865 } else {
12866 sv = *v
12867 }
12868
12869 for key, value := range shape {
12870 switch key {
12871 case "tags":
12872 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
12873 return err
12874 }
12875
12876 default:
12877 _, _ = key, value
12878
12879 }
12880 }
12881 *v = sv
12882 return nil
12883 }
12884
12885 func awsAwsjson11_deserializeOpDocumentPutImageOutput(v **PutImageOutput, value interface{}) error {
12886 if v == nil {
12887 return fmt.Errorf("unexpected nil of type %T", v)
12888 }
12889 if value == nil {
12890 return nil
12891 }
12892
12893 shape, ok := value.(map[string]interface{})
12894 if !ok {
12895 return fmt.Errorf("unexpected JSON type %v", value)
12896 }
12897
12898 var sv *PutImageOutput
12899 if *v == nil {
12900 sv = &PutImageOutput{}
12901 } else {
12902 sv = *v
12903 }
12904
12905 for key, value := range shape {
12906 switch key {
12907 case "image":
12908 if err := awsAwsjson11_deserializeDocumentImage(&sv.Image, value); err != nil {
12909 return err
12910 }
12911
12912 default:
12913 _, _ = key, value
12914
12915 }
12916 }
12917 *v = sv
12918 return nil
12919 }
12920
12921 func awsAwsjson11_deserializeOpDocumentPutImageScanningConfigurationOutput(v **PutImageScanningConfigurationOutput, value interface{}) error {
12922 if v == nil {
12923 return fmt.Errorf("unexpected nil of type %T", v)
12924 }
12925 if value == nil {
12926 return nil
12927 }
12928
12929 shape, ok := value.(map[string]interface{})
12930 if !ok {
12931 return fmt.Errorf("unexpected JSON type %v", value)
12932 }
12933
12934 var sv *PutImageScanningConfigurationOutput
12935 if *v == nil {
12936 sv = &PutImageScanningConfigurationOutput{}
12937 } else {
12938 sv = *v
12939 }
12940
12941 for key, value := range shape {
12942 switch key {
12943 case "imageScanningConfiguration":
12944 if err := awsAwsjson11_deserializeDocumentImageScanningConfiguration(&sv.ImageScanningConfiguration, value); err != nil {
12945 return err
12946 }
12947
12948 case "registryId":
12949 if value != nil {
12950 jtv, ok := value.(string)
12951 if !ok {
12952 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
12953 }
12954 sv.RegistryId = ptr.String(jtv)
12955 }
12956
12957 case "repositoryName":
12958 if value != nil {
12959 jtv, ok := value.(string)
12960 if !ok {
12961 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
12962 }
12963 sv.RepositoryName = ptr.String(jtv)
12964 }
12965
12966 default:
12967 _, _ = key, value
12968
12969 }
12970 }
12971 *v = sv
12972 return nil
12973 }
12974
12975 func awsAwsjson11_deserializeOpDocumentPutImageTagMutabilityOutput(v **PutImageTagMutabilityOutput, value interface{}) error {
12976 if v == nil {
12977 return fmt.Errorf("unexpected nil of type %T", v)
12978 }
12979 if value == nil {
12980 return nil
12981 }
12982
12983 shape, ok := value.(map[string]interface{})
12984 if !ok {
12985 return fmt.Errorf("unexpected JSON type %v", value)
12986 }
12987
12988 var sv *PutImageTagMutabilityOutput
12989 if *v == nil {
12990 sv = &PutImageTagMutabilityOutput{}
12991 } else {
12992 sv = *v
12993 }
12994
12995 for key, value := range shape {
12996 switch key {
12997 case "imageTagMutability":
12998 if value != nil {
12999 jtv, ok := value.(string)
13000 if !ok {
13001 return fmt.Errorf("expected ImageTagMutability to be of type string, got %T instead", value)
13002 }
13003 sv.ImageTagMutability = types.ImageTagMutability(jtv)
13004 }
13005
13006 case "registryId":
13007 if value != nil {
13008 jtv, ok := value.(string)
13009 if !ok {
13010 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
13011 }
13012 sv.RegistryId = ptr.String(jtv)
13013 }
13014
13015 case "repositoryName":
13016 if value != nil {
13017 jtv, ok := value.(string)
13018 if !ok {
13019 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
13020 }
13021 sv.RepositoryName = ptr.String(jtv)
13022 }
13023
13024 default:
13025 _, _ = key, value
13026
13027 }
13028 }
13029 *v = sv
13030 return nil
13031 }
13032
13033 func awsAwsjson11_deserializeOpDocumentPutLifecyclePolicyOutput(v **PutLifecyclePolicyOutput, value interface{}) error {
13034 if v == nil {
13035 return fmt.Errorf("unexpected nil of type %T", v)
13036 }
13037 if value == nil {
13038 return nil
13039 }
13040
13041 shape, ok := value.(map[string]interface{})
13042 if !ok {
13043 return fmt.Errorf("unexpected JSON type %v", value)
13044 }
13045
13046 var sv *PutLifecyclePolicyOutput
13047 if *v == nil {
13048 sv = &PutLifecyclePolicyOutput{}
13049 } else {
13050 sv = *v
13051 }
13052
13053 for key, value := range shape {
13054 switch key {
13055 case "lifecyclePolicyText":
13056 if value != nil {
13057 jtv, ok := value.(string)
13058 if !ok {
13059 return fmt.Errorf("expected LifecyclePolicyText to be of type string, got %T instead", value)
13060 }
13061 sv.LifecyclePolicyText = ptr.String(jtv)
13062 }
13063
13064 case "registryId":
13065 if value != nil {
13066 jtv, ok := value.(string)
13067 if !ok {
13068 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
13069 }
13070 sv.RegistryId = ptr.String(jtv)
13071 }
13072
13073 case "repositoryName":
13074 if value != nil {
13075 jtv, ok := value.(string)
13076 if !ok {
13077 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
13078 }
13079 sv.RepositoryName = ptr.String(jtv)
13080 }
13081
13082 default:
13083 _, _ = key, value
13084
13085 }
13086 }
13087 *v = sv
13088 return nil
13089 }
13090
13091 func awsAwsjson11_deserializeOpDocumentPutRegistryPolicyOutput(v **PutRegistryPolicyOutput, value interface{}) error {
13092 if v == nil {
13093 return fmt.Errorf("unexpected nil of type %T", v)
13094 }
13095 if value == nil {
13096 return nil
13097 }
13098
13099 shape, ok := value.(map[string]interface{})
13100 if !ok {
13101 return fmt.Errorf("unexpected JSON type %v", value)
13102 }
13103
13104 var sv *PutRegistryPolicyOutput
13105 if *v == nil {
13106 sv = &PutRegistryPolicyOutput{}
13107 } else {
13108 sv = *v
13109 }
13110
13111 for key, value := range shape {
13112 switch key {
13113 case "policyText":
13114 if value != nil {
13115 jtv, ok := value.(string)
13116 if !ok {
13117 return fmt.Errorf("expected RegistryPolicyText to be of type string, got %T instead", value)
13118 }
13119 sv.PolicyText = ptr.String(jtv)
13120 }
13121
13122 case "registryId":
13123 if value != nil {
13124 jtv, ok := value.(string)
13125 if !ok {
13126 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
13127 }
13128 sv.RegistryId = ptr.String(jtv)
13129 }
13130
13131 default:
13132 _, _ = key, value
13133
13134 }
13135 }
13136 *v = sv
13137 return nil
13138 }
13139
13140 func awsAwsjson11_deserializeOpDocumentPutRegistryScanningConfigurationOutput(v **PutRegistryScanningConfigurationOutput, value interface{}) error {
13141 if v == nil {
13142 return fmt.Errorf("unexpected nil of type %T", v)
13143 }
13144 if value == nil {
13145 return nil
13146 }
13147
13148 shape, ok := value.(map[string]interface{})
13149 if !ok {
13150 return fmt.Errorf("unexpected JSON type %v", value)
13151 }
13152
13153 var sv *PutRegistryScanningConfigurationOutput
13154 if *v == nil {
13155 sv = &PutRegistryScanningConfigurationOutput{}
13156 } else {
13157 sv = *v
13158 }
13159
13160 for key, value := range shape {
13161 switch key {
13162 case "registryScanningConfiguration":
13163 if err := awsAwsjson11_deserializeDocumentRegistryScanningConfiguration(&sv.RegistryScanningConfiguration, value); err != nil {
13164 return err
13165 }
13166
13167 default:
13168 _, _ = key, value
13169
13170 }
13171 }
13172 *v = sv
13173 return nil
13174 }
13175
13176 func awsAwsjson11_deserializeOpDocumentPutReplicationConfigurationOutput(v **PutReplicationConfigurationOutput, value interface{}) error {
13177 if v == nil {
13178 return fmt.Errorf("unexpected nil of type %T", v)
13179 }
13180 if value == nil {
13181 return nil
13182 }
13183
13184 shape, ok := value.(map[string]interface{})
13185 if !ok {
13186 return fmt.Errorf("unexpected JSON type %v", value)
13187 }
13188
13189 var sv *PutReplicationConfigurationOutput
13190 if *v == nil {
13191 sv = &PutReplicationConfigurationOutput{}
13192 } else {
13193 sv = *v
13194 }
13195
13196 for key, value := range shape {
13197 switch key {
13198 case "replicationConfiguration":
13199 if err := awsAwsjson11_deserializeDocumentReplicationConfiguration(&sv.ReplicationConfiguration, value); err != nil {
13200 return err
13201 }
13202
13203 default:
13204 _, _ = key, value
13205
13206 }
13207 }
13208 *v = sv
13209 return nil
13210 }
13211
13212 func awsAwsjson11_deserializeOpDocumentSetRepositoryPolicyOutput(v **SetRepositoryPolicyOutput, value interface{}) error {
13213 if v == nil {
13214 return fmt.Errorf("unexpected nil of type %T", v)
13215 }
13216 if value == nil {
13217 return nil
13218 }
13219
13220 shape, ok := value.(map[string]interface{})
13221 if !ok {
13222 return fmt.Errorf("unexpected JSON type %v", value)
13223 }
13224
13225 var sv *SetRepositoryPolicyOutput
13226 if *v == nil {
13227 sv = &SetRepositoryPolicyOutput{}
13228 } else {
13229 sv = *v
13230 }
13231
13232 for key, value := range shape {
13233 switch key {
13234 case "policyText":
13235 if value != nil {
13236 jtv, ok := value.(string)
13237 if !ok {
13238 return fmt.Errorf("expected RepositoryPolicyText to be of type string, got %T instead", value)
13239 }
13240 sv.PolicyText = ptr.String(jtv)
13241 }
13242
13243 case "registryId":
13244 if value != nil {
13245 jtv, ok := value.(string)
13246 if !ok {
13247 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
13248 }
13249 sv.RegistryId = ptr.String(jtv)
13250 }
13251
13252 case "repositoryName":
13253 if value != nil {
13254 jtv, ok := value.(string)
13255 if !ok {
13256 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
13257 }
13258 sv.RepositoryName = ptr.String(jtv)
13259 }
13260
13261 default:
13262 _, _ = key, value
13263
13264 }
13265 }
13266 *v = sv
13267 return nil
13268 }
13269
13270 func awsAwsjson11_deserializeOpDocumentStartImageScanOutput(v **StartImageScanOutput, value interface{}) error {
13271 if v == nil {
13272 return fmt.Errorf("unexpected nil of type %T", v)
13273 }
13274 if value == nil {
13275 return nil
13276 }
13277
13278 shape, ok := value.(map[string]interface{})
13279 if !ok {
13280 return fmt.Errorf("unexpected JSON type %v", value)
13281 }
13282
13283 var sv *StartImageScanOutput
13284 if *v == nil {
13285 sv = &StartImageScanOutput{}
13286 } else {
13287 sv = *v
13288 }
13289
13290 for key, value := range shape {
13291 switch key {
13292 case "imageId":
13293 if err := awsAwsjson11_deserializeDocumentImageIdentifier(&sv.ImageId, value); err != nil {
13294 return err
13295 }
13296
13297 case "imageScanStatus":
13298 if err := awsAwsjson11_deserializeDocumentImageScanStatus(&sv.ImageScanStatus, value); err != nil {
13299 return err
13300 }
13301
13302 case "registryId":
13303 if value != nil {
13304 jtv, ok := value.(string)
13305 if !ok {
13306 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
13307 }
13308 sv.RegistryId = ptr.String(jtv)
13309 }
13310
13311 case "repositoryName":
13312 if value != nil {
13313 jtv, ok := value.(string)
13314 if !ok {
13315 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
13316 }
13317 sv.RepositoryName = ptr.String(jtv)
13318 }
13319
13320 default:
13321 _, _ = key, value
13322
13323 }
13324 }
13325 *v = sv
13326 return nil
13327 }
13328
13329 func awsAwsjson11_deserializeOpDocumentStartLifecyclePolicyPreviewOutput(v **StartLifecyclePolicyPreviewOutput, value interface{}) error {
13330 if v == nil {
13331 return fmt.Errorf("unexpected nil of type %T", v)
13332 }
13333 if value == nil {
13334 return nil
13335 }
13336
13337 shape, ok := value.(map[string]interface{})
13338 if !ok {
13339 return fmt.Errorf("unexpected JSON type %v", value)
13340 }
13341
13342 var sv *StartLifecyclePolicyPreviewOutput
13343 if *v == nil {
13344 sv = &StartLifecyclePolicyPreviewOutput{}
13345 } else {
13346 sv = *v
13347 }
13348
13349 for key, value := range shape {
13350 switch key {
13351 case "lifecyclePolicyText":
13352 if value != nil {
13353 jtv, ok := value.(string)
13354 if !ok {
13355 return fmt.Errorf("expected LifecyclePolicyText to be of type string, got %T instead", value)
13356 }
13357 sv.LifecyclePolicyText = ptr.String(jtv)
13358 }
13359
13360 case "registryId":
13361 if value != nil {
13362 jtv, ok := value.(string)
13363 if !ok {
13364 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
13365 }
13366 sv.RegistryId = ptr.String(jtv)
13367 }
13368
13369 case "repositoryName":
13370 if value != nil {
13371 jtv, ok := value.(string)
13372 if !ok {
13373 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
13374 }
13375 sv.RepositoryName = ptr.String(jtv)
13376 }
13377
13378 case "status":
13379 if value != nil {
13380 jtv, ok := value.(string)
13381 if !ok {
13382 return fmt.Errorf("expected LifecyclePolicyPreviewStatus to be of type string, got %T instead", value)
13383 }
13384 sv.Status = types.LifecyclePolicyPreviewStatus(jtv)
13385 }
13386
13387 default:
13388 _, _ = key, value
13389
13390 }
13391 }
13392 *v = sv
13393 return nil
13394 }
13395
13396 func awsAwsjson11_deserializeOpDocumentTagResourceOutput(v **TagResourceOutput, value interface{}) error {
13397 if v == nil {
13398 return fmt.Errorf("unexpected nil of type %T", v)
13399 }
13400 if value == nil {
13401 return nil
13402 }
13403
13404 shape, ok := value.(map[string]interface{})
13405 if !ok {
13406 return fmt.Errorf("unexpected JSON type %v", value)
13407 }
13408
13409 var sv *TagResourceOutput
13410 if *v == nil {
13411 sv = &TagResourceOutput{}
13412 } else {
13413 sv = *v
13414 }
13415
13416 for key, value := range shape {
13417 switch key {
13418 default:
13419 _, _ = key, value
13420
13421 }
13422 }
13423 *v = sv
13424 return nil
13425 }
13426
13427 func awsAwsjson11_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutput, value interface{}) error {
13428 if v == nil {
13429 return fmt.Errorf("unexpected nil of type %T", v)
13430 }
13431 if value == nil {
13432 return nil
13433 }
13434
13435 shape, ok := value.(map[string]interface{})
13436 if !ok {
13437 return fmt.Errorf("unexpected JSON type %v", value)
13438 }
13439
13440 var sv *UntagResourceOutput
13441 if *v == nil {
13442 sv = &UntagResourceOutput{}
13443 } else {
13444 sv = *v
13445 }
13446
13447 for key, value := range shape {
13448 switch key {
13449 default:
13450 _, _ = key, value
13451
13452 }
13453 }
13454 *v = sv
13455 return nil
13456 }
13457
13458 func awsAwsjson11_deserializeOpDocumentUploadLayerPartOutput(v **UploadLayerPartOutput, value interface{}) error {
13459 if v == nil {
13460 return fmt.Errorf("unexpected nil of type %T", v)
13461 }
13462 if value == nil {
13463 return nil
13464 }
13465
13466 shape, ok := value.(map[string]interface{})
13467 if !ok {
13468 return fmt.Errorf("unexpected JSON type %v", value)
13469 }
13470
13471 var sv *UploadLayerPartOutput
13472 if *v == nil {
13473 sv = &UploadLayerPartOutput{}
13474 } else {
13475 sv = *v
13476 }
13477
13478 for key, value := range shape {
13479 switch key {
13480 case "lastByteReceived":
13481 if value != nil {
13482 jtv, ok := value.(json.Number)
13483 if !ok {
13484 return fmt.Errorf("expected PartSize to be json.Number, got %T instead", value)
13485 }
13486 i64, err := jtv.Int64()
13487 if err != nil {
13488 return err
13489 }
13490 sv.LastByteReceived = ptr.Int64(i64)
13491 }
13492
13493 case "registryId":
13494 if value != nil {
13495 jtv, ok := value.(string)
13496 if !ok {
13497 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
13498 }
13499 sv.RegistryId = ptr.String(jtv)
13500 }
13501
13502 case "repositoryName":
13503 if value != nil {
13504 jtv, ok := value.(string)
13505 if !ok {
13506 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
13507 }
13508 sv.RepositoryName = ptr.String(jtv)
13509 }
13510
13511 case "uploadId":
13512 if value != nil {
13513 jtv, ok := value.(string)
13514 if !ok {
13515 return fmt.Errorf("expected UploadId to be of type string, got %T instead", value)
13516 }
13517 sv.UploadId = ptr.String(jtv)
13518 }
13519
13520 default:
13521 _, _ = key, value
13522
13523 }
13524 }
13525 *v = sv
13526 return nil
13527 }
13528
View as plain text