1
2
3 package ecrpublic
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/ecrpublic/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 "strings"
20 )
21
22 type awsAwsjson11_deserializeOpBatchCheckLayerAvailability struct {
23 }
24
25 func (*awsAwsjson11_deserializeOpBatchCheckLayerAvailability) ID() string {
26 return "OperationDeserializer"
27 }
28
29 func (m *awsAwsjson11_deserializeOpBatchCheckLayerAvailability) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
30 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
31 ) {
32 out, metadata, err = next.HandleDeserialize(ctx, in)
33 if err != nil {
34 return out, metadata, err
35 }
36
37 response, ok := out.RawResponse.(*smithyhttp.Response)
38 if !ok {
39 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
40 }
41
42 if response.StatusCode < 200 || response.StatusCode >= 300 {
43 return out, metadata, awsAwsjson11_deserializeOpErrorBatchCheckLayerAvailability(response, &metadata)
44 }
45 output := &BatchCheckLayerAvailabilityOutput{}
46 out.Result = output
47
48 var buff [1024]byte
49 ringBuffer := smithyio.NewRingBuffer(buff[:])
50
51 body := io.TeeReader(response.Body, ringBuffer)
52 decoder := json.NewDecoder(body)
53 decoder.UseNumber()
54 var shape interface{}
55 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
56 var snapshot bytes.Buffer
57 io.Copy(&snapshot, ringBuffer)
58 err = &smithy.DeserializationError{
59 Err: fmt.Errorf("failed to decode response body, %w", err),
60 Snapshot: snapshot.Bytes(),
61 }
62 return out, metadata, err
63 }
64
65 err = awsAwsjson11_deserializeOpDocumentBatchCheckLayerAvailabilityOutput(&output, shape)
66 if err != nil {
67 var snapshot bytes.Buffer
68 io.Copy(&snapshot, ringBuffer)
69 err = &smithy.DeserializationError{
70 Err: fmt.Errorf("failed to decode response body, %w", err),
71 Snapshot: snapshot.Bytes(),
72 }
73 return out, metadata, err
74 }
75
76 return out, metadata, err
77 }
78
79 func awsAwsjson11_deserializeOpErrorBatchCheckLayerAvailability(response *smithyhttp.Response, metadata *middleware.Metadata) error {
80 var errorBuffer bytes.Buffer
81 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
82 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
83 }
84 errorBody := bytes.NewReader(errorBuffer.Bytes())
85
86 errorCode := "UnknownError"
87 errorMessage := errorCode
88
89 headerCode := response.Header.Get("X-Amzn-ErrorType")
90 if len(headerCode) != 0 {
91 errorCode = restjson.SanitizeErrorCode(headerCode)
92 }
93
94 var buff [1024]byte
95 ringBuffer := smithyio.NewRingBuffer(buff[:])
96
97 body := io.TeeReader(errorBody, ringBuffer)
98 decoder := json.NewDecoder(body)
99 decoder.UseNumber()
100 jsonCode, message, err := restjson.GetErrorInfo(decoder)
101 if err != nil {
102 var snapshot bytes.Buffer
103 io.Copy(&snapshot, ringBuffer)
104 err = &smithy.DeserializationError{
105 Err: fmt.Errorf("failed to decode response body, %w", err),
106 Snapshot: snapshot.Bytes(),
107 }
108 return err
109 }
110
111 errorBody.Seek(0, io.SeekStart)
112 if len(headerCode) == 0 && len(jsonCode) != 0 {
113 errorCode = restjson.SanitizeErrorCode(jsonCode)
114 }
115 if len(message) != 0 {
116 errorMessage = message
117 }
118
119 switch {
120 case strings.EqualFold("InvalidParameterException", errorCode):
121 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
122
123 case strings.EqualFold("RegistryNotFoundException", errorCode):
124 return awsAwsjson11_deserializeErrorRegistryNotFoundException(response, errorBody)
125
126 case strings.EqualFold("RepositoryNotFoundException", errorCode):
127 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
128
129 case strings.EqualFold("ServerException", errorCode):
130 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
131
132 case strings.EqualFold("UnsupportedCommandException", errorCode):
133 return awsAwsjson11_deserializeErrorUnsupportedCommandException(response, errorBody)
134
135 default:
136 genericError := &smithy.GenericAPIError{
137 Code: errorCode,
138 Message: errorMessage,
139 }
140 return genericError
141
142 }
143 }
144
145 type awsAwsjson11_deserializeOpBatchDeleteImage struct {
146 }
147
148 func (*awsAwsjson11_deserializeOpBatchDeleteImage) ID() string {
149 return "OperationDeserializer"
150 }
151
152 func (m *awsAwsjson11_deserializeOpBatchDeleteImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
153 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
154 ) {
155 out, metadata, err = next.HandleDeserialize(ctx, in)
156 if err != nil {
157 return out, metadata, err
158 }
159
160 response, ok := out.RawResponse.(*smithyhttp.Response)
161 if !ok {
162 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
163 }
164
165 if response.StatusCode < 200 || response.StatusCode >= 300 {
166 return out, metadata, awsAwsjson11_deserializeOpErrorBatchDeleteImage(response, &metadata)
167 }
168 output := &BatchDeleteImageOutput{}
169 out.Result = output
170
171 var buff [1024]byte
172 ringBuffer := smithyio.NewRingBuffer(buff[:])
173
174 body := io.TeeReader(response.Body, ringBuffer)
175 decoder := json.NewDecoder(body)
176 decoder.UseNumber()
177 var shape interface{}
178 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
179 var snapshot bytes.Buffer
180 io.Copy(&snapshot, ringBuffer)
181 err = &smithy.DeserializationError{
182 Err: fmt.Errorf("failed to decode response body, %w", err),
183 Snapshot: snapshot.Bytes(),
184 }
185 return out, metadata, err
186 }
187
188 err = awsAwsjson11_deserializeOpDocumentBatchDeleteImageOutput(&output, shape)
189 if err != nil {
190 var snapshot bytes.Buffer
191 io.Copy(&snapshot, ringBuffer)
192 err = &smithy.DeserializationError{
193 Err: fmt.Errorf("failed to decode response body, %w", err),
194 Snapshot: snapshot.Bytes(),
195 }
196 return out, metadata, err
197 }
198
199 return out, metadata, err
200 }
201
202 func awsAwsjson11_deserializeOpErrorBatchDeleteImage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
203 var errorBuffer bytes.Buffer
204 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
205 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
206 }
207 errorBody := bytes.NewReader(errorBuffer.Bytes())
208
209 errorCode := "UnknownError"
210 errorMessage := errorCode
211
212 headerCode := response.Header.Get("X-Amzn-ErrorType")
213 if len(headerCode) != 0 {
214 errorCode = restjson.SanitizeErrorCode(headerCode)
215 }
216
217 var buff [1024]byte
218 ringBuffer := smithyio.NewRingBuffer(buff[:])
219
220 body := io.TeeReader(errorBody, ringBuffer)
221 decoder := json.NewDecoder(body)
222 decoder.UseNumber()
223 jsonCode, message, err := restjson.GetErrorInfo(decoder)
224 if err != nil {
225 var snapshot bytes.Buffer
226 io.Copy(&snapshot, ringBuffer)
227 err = &smithy.DeserializationError{
228 Err: fmt.Errorf("failed to decode response body, %w", err),
229 Snapshot: snapshot.Bytes(),
230 }
231 return err
232 }
233
234 errorBody.Seek(0, io.SeekStart)
235 if len(headerCode) == 0 && len(jsonCode) != 0 {
236 errorCode = restjson.SanitizeErrorCode(jsonCode)
237 }
238 if len(message) != 0 {
239 errorMessage = message
240 }
241
242 switch {
243 case strings.EqualFold("InvalidParameterException", errorCode):
244 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
245
246 case strings.EqualFold("RepositoryNotFoundException", errorCode):
247 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
248
249 case strings.EqualFold("ServerException", errorCode):
250 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
251
252 case strings.EqualFold("UnsupportedCommandException", errorCode):
253 return awsAwsjson11_deserializeErrorUnsupportedCommandException(response, errorBody)
254
255 default:
256 genericError := &smithy.GenericAPIError{
257 Code: errorCode,
258 Message: errorMessage,
259 }
260 return genericError
261
262 }
263 }
264
265 type awsAwsjson11_deserializeOpCompleteLayerUpload struct {
266 }
267
268 func (*awsAwsjson11_deserializeOpCompleteLayerUpload) ID() string {
269 return "OperationDeserializer"
270 }
271
272 func (m *awsAwsjson11_deserializeOpCompleteLayerUpload) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
273 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
274 ) {
275 out, metadata, err = next.HandleDeserialize(ctx, in)
276 if err != nil {
277 return out, metadata, err
278 }
279
280 response, ok := out.RawResponse.(*smithyhttp.Response)
281 if !ok {
282 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
283 }
284
285 if response.StatusCode < 200 || response.StatusCode >= 300 {
286 return out, metadata, awsAwsjson11_deserializeOpErrorCompleteLayerUpload(response, &metadata)
287 }
288 output := &CompleteLayerUploadOutput{}
289 out.Result = output
290
291 var buff [1024]byte
292 ringBuffer := smithyio.NewRingBuffer(buff[:])
293
294 body := io.TeeReader(response.Body, ringBuffer)
295 decoder := json.NewDecoder(body)
296 decoder.UseNumber()
297 var shape interface{}
298 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
299 var snapshot bytes.Buffer
300 io.Copy(&snapshot, ringBuffer)
301 err = &smithy.DeserializationError{
302 Err: fmt.Errorf("failed to decode response body, %w", err),
303 Snapshot: snapshot.Bytes(),
304 }
305 return out, metadata, err
306 }
307
308 err = awsAwsjson11_deserializeOpDocumentCompleteLayerUploadOutput(&output, shape)
309 if err != nil {
310 var snapshot bytes.Buffer
311 io.Copy(&snapshot, ringBuffer)
312 err = &smithy.DeserializationError{
313 Err: fmt.Errorf("failed to decode response body, %w", err),
314 Snapshot: snapshot.Bytes(),
315 }
316 return out, metadata, err
317 }
318
319 return out, metadata, err
320 }
321
322 func awsAwsjson11_deserializeOpErrorCompleteLayerUpload(response *smithyhttp.Response, metadata *middleware.Metadata) error {
323 var errorBuffer bytes.Buffer
324 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
325 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
326 }
327 errorBody := bytes.NewReader(errorBuffer.Bytes())
328
329 errorCode := "UnknownError"
330 errorMessage := errorCode
331
332 headerCode := response.Header.Get("X-Amzn-ErrorType")
333 if len(headerCode) != 0 {
334 errorCode = restjson.SanitizeErrorCode(headerCode)
335 }
336
337 var buff [1024]byte
338 ringBuffer := smithyio.NewRingBuffer(buff[:])
339
340 body := io.TeeReader(errorBody, ringBuffer)
341 decoder := json.NewDecoder(body)
342 decoder.UseNumber()
343 jsonCode, message, err := restjson.GetErrorInfo(decoder)
344 if err != nil {
345 var snapshot bytes.Buffer
346 io.Copy(&snapshot, ringBuffer)
347 err = &smithy.DeserializationError{
348 Err: fmt.Errorf("failed to decode response body, %w", err),
349 Snapshot: snapshot.Bytes(),
350 }
351 return err
352 }
353
354 errorBody.Seek(0, io.SeekStart)
355 if len(headerCode) == 0 && len(jsonCode) != 0 {
356 errorCode = restjson.SanitizeErrorCode(jsonCode)
357 }
358 if len(message) != 0 {
359 errorMessage = message
360 }
361
362 switch {
363 case strings.EqualFold("EmptyUploadException", errorCode):
364 return awsAwsjson11_deserializeErrorEmptyUploadException(response, errorBody)
365
366 case strings.EqualFold("InvalidLayerException", errorCode):
367 return awsAwsjson11_deserializeErrorInvalidLayerException(response, errorBody)
368
369 case strings.EqualFold("InvalidParameterException", errorCode):
370 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
371
372 case strings.EqualFold("LayerAlreadyExistsException", errorCode):
373 return awsAwsjson11_deserializeErrorLayerAlreadyExistsException(response, errorBody)
374
375 case strings.EqualFold("LayerPartTooSmallException", errorCode):
376 return awsAwsjson11_deserializeErrorLayerPartTooSmallException(response, errorBody)
377
378 case strings.EqualFold("RegistryNotFoundException", errorCode):
379 return awsAwsjson11_deserializeErrorRegistryNotFoundException(response, errorBody)
380
381 case strings.EqualFold("RepositoryNotFoundException", errorCode):
382 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
383
384 case strings.EqualFold("ServerException", errorCode):
385 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
386
387 case strings.EqualFold("UnsupportedCommandException", errorCode):
388 return awsAwsjson11_deserializeErrorUnsupportedCommandException(response, errorBody)
389
390 case strings.EqualFold("UploadNotFoundException", errorCode):
391 return awsAwsjson11_deserializeErrorUploadNotFoundException(response, errorBody)
392
393 default:
394 genericError := &smithy.GenericAPIError{
395 Code: errorCode,
396 Message: errorMessage,
397 }
398 return genericError
399
400 }
401 }
402
403 type awsAwsjson11_deserializeOpCreateRepository struct {
404 }
405
406 func (*awsAwsjson11_deserializeOpCreateRepository) ID() string {
407 return "OperationDeserializer"
408 }
409
410 func (m *awsAwsjson11_deserializeOpCreateRepository) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
411 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
412 ) {
413 out, metadata, err = next.HandleDeserialize(ctx, in)
414 if err != nil {
415 return out, metadata, err
416 }
417
418 response, ok := out.RawResponse.(*smithyhttp.Response)
419 if !ok {
420 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
421 }
422
423 if response.StatusCode < 200 || response.StatusCode >= 300 {
424 return out, metadata, awsAwsjson11_deserializeOpErrorCreateRepository(response, &metadata)
425 }
426 output := &CreateRepositoryOutput{}
427 out.Result = output
428
429 var buff [1024]byte
430 ringBuffer := smithyio.NewRingBuffer(buff[:])
431
432 body := io.TeeReader(response.Body, ringBuffer)
433 decoder := json.NewDecoder(body)
434 decoder.UseNumber()
435 var shape interface{}
436 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
437 var snapshot bytes.Buffer
438 io.Copy(&snapshot, ringBuffer)
439 err = &smithy.DeserializationError{
440 Err: fmt.Errorf("failed to decode response body, %w", err),
441 Snapshot: snapshot.Bytes(),
442 }
443 return out, metadata, err
444 }
445
446 err = awsAwsjson11_deserializeOpDocumentCreateRepositoryOutput(&output, shape)
447 if err != nil {
448 var snapshot bytes.Buffer
449 io.Copy(&snapshot, ringBuffer)
450 err = &smithy.DeserializationError{
451 Err: fmt.Errorf("failed to decode response body, %w", err),
452 Snapshot: snapshot.Bytes(),
453 }
454 return out, metadata, err
455 }
456
457 return out, metadata, err
458 }
459
460 func awsAwsjson11_deserializeOpErrorCreateRepository(response *smithyhttp.Response, metadata *middleware.Metadata) error {
461 var errorBuffer bytes.Buffer
462 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
463 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
464 }
465 errorBody := bytes.NewReader(errorBuffer.Bytes())
466
467 errorCode := "UnknownError"
468 errorMessage := errorCode
469
470 headerCode := response.Header.Get("X-Amzn-ErrorType")
471 if len(headerCode) != 0 {
472 errorCode = restjson.SanitizeErrorCode(headerCode)
473 }
474
475 var buff [1024]byte
476 ringBuffer := smithyio.NewRingBuffer(buff[:])
477
478 body := io.TeeReader(errorBody, ringBuffer)
479 decoder := json.NewDecoder(body)
480 decoder.UseNumber()
481 jsonCode, message, err := restjson.GetErrorInfo(decoder)
482 if err != nil {
483 var snapshot bytes.Buffer
484 io.Copy(&snapshot, ringBuffer)
485 err = &smithy.DeserializationError{
486 Err: fmt.Errorf("failed to decode response body, %w", err),
487 Snapshot: snapshot.Bytes(),
488 }
489 return err
490 }
491
492 errorBody.Seek(0, io.SeekStart)
493 if len(headerCode) == 0 && len(jsonCode) != 0 {
494 errorCode = restjson.SanitizeErrorCode(jsonCode)
495 }
496 if len(message) != 0 {
497 errorMessage = message
498 }
499
500 switch {
501 case strings.EqualFold("InvalidParameterException", errorCode):
502 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
503
504 case strings.EqualFold("InvalidTagParameterException", errorCode):
505 return awsAwsjson11_deserializeErrorInvalidTagParameterException(response, errorBody)
506
507 case strings.EqualFold("LimitExceededException", errorCode):
508 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
509
510 case strings.EqualFold("RepositoryAlreadyExistsException", errorCode):
511 return awsAwsjson11_deserializeErrorRepositoryAlreadyExistsException(response, errorBody)
512
513 case strings.EqualFold("ServerException", errorCode):
514 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
515
516 case strings.EqualFold("TooManyTagsException", errorCode):
517 return awsAwsjson11_deserializeErrorTooManyTagsException(response, errorBody)
518
519 case strings.EqualFold("UnsupportedCommandException", errorCode):
520 return awsAwsjson11_deserializeErrorUnsupportedCommandException(response, errorBody)
521
522 default:
523 genericError := &smithy.GenericAPIError{
524 Code: errorCode,
525 Message: errorMessage,
526 }
527 return genericError
528
529 }
530 }
531
532 type awsAwsjson11_deserializeOpDeleteRepository struct {
533 }
534
535 func (*awsAwsjson11_deserializeOpDeleteRepository) ID() string {
536 return "OperationDeserializer"
537 }
538
539 func (m *awsAwsjson11_deserializeOpDeleteRepository) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
540 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
541 ) {
542 out, metadata, err = next.HandleDeserialize(ctx, in)
543 if err != nil {
544 return out, metadata, err
545 }
546
547 response, ok := out.RawResponse.(*smithyhttp.Response)
548 if !ok {
549 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
550 }
551
552 if response.StatusCode < 200 || response.StatusCode >= 300 {
553 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteRepository(response, &metadata)
554 }
555 output := &DeleteRepositoryOutput{}
556 out.Result = output
557
558 var buff [1024]byte
559 ringBuffer := smithyio.NewRingBuffer(buff[:])
560
561 body := io.TeeReader(response.Body, ringBuffer)
562 decoder := json.NewDecoder(body)
563 decoder.UseNumber()
564 var shape interface{}
565 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
566 var snapshot bytes.Buffer
567 io.Copy(&snapshot, ringBuffer)
568 err = &smithy.DeserializationError{
569 Err: fmt.Errorf("failed to decode response body, %w", err),
570 Snapshot: snapshot.Bytes(),
571 }
572 return out, metadata, err
573 }
574
575 err = awsAwsjson11_deserializeOpDocumentDeleteRepositoryOutput(&output, shape)
576 if err != nil {
577 var snapshot bytes.Buffer
578 io.Copy(&snapshot, ringBuffer)
579 err = &smithy.DeserializationError{
580 Err: fmt.Errorf("failed to decode response body, %w", err),
581 Snapshot: snapshot.Bytes(),
582 }
583 return out, metadata, err
584 }
585
586 return out, metadata, err
587 }
588
589 func awsAwsjson11_deserializeOpErrorDeleteRepository(response *smithyhttp.Response, metadata *middleware.Metadata) error {
590 var errorBuffer bytes.Buffer
591 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
592 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
593 }
594 errorBody := bytes.NewReader(errorBuffer.Bytes())
595
596 errorCode := "UnknownError"
597 errorMessage := errorCode
598
599 headerCode := response.Header.Get("X-Amzn-ErrorType")
600 if len(headerCode) != 0 {
601 errorCode = restjson.SanitizeErrorCode(headerCode)
602 }
603
604 var buff [1024]byte
605 ringBuffer := smithyio.NewRingBuffer(buff[:])
606
607 body := io.TeeReader(errorBody, ringBuffer)
608 decoder := json.NewDecoder(body)
609 decoder.UseNumber()
610 jsonCode, message, err := restjson.GetErrorInfo(decoder)
611 if err != nil {
612 var snapshot bytes.Buffer
613 io.Copy(&snapshot, ringBuffer)
614 err = &smithy.DeserializationError{
615 Err: fmt.Errorf("failed to decode response body, %w", err),
616 Snapshot: snapshot.Bytes(),
617 }
618 return err
619 }
620
621 errorBody.Seek(0, io.SeekStart)
622 if len(headerCode) == 0 && len(jsonCode) != 0 {
623 errorCode = restjson.SanitizeErrorCode(jsonCode)
624 }
625 if len(message) != 0 {
626 errorMessage = message
627 }
628
629 switch {
630 case strings.EqualFold("InvalidParameterException", errorCode):
631 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
632
633 case strings.EqualFold("RepositoryNotEmptyException", errorCode):
634 return awsAwsjson11_deserializeErrorRepositoryNotEmptyException(response, errorBody)
635
636 case strings.EqualFold("RepositoryNotFoundException", errorCode):
637 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
638
639 case strings.EqualFold("ServerException", errorCode):
640 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
641
642 case strings.EqualFold("UnsupportedCommandException", errorCode):
643 return awsAwsjson11_deserializeErrorUnsupportedCommandException(response, errorBody)
644
645 default:
646 genericError := &smithy.GenericAPIError{
647 Code: errorCode,
648 Message: errorMessage,
649 }
650 return genericError
651
652 }
653 }
654
655 type awsAwsjson11_deserializeOpDeleteRepositoryPolicy struct {
656 }
657
658 func (*awsAwsjson11_deserializeOpDeleteRepositoryPolicy) ID() string {
659 return "OperationDeserializer"
660 }
661
662 func (m *awsAwsjson11_deserializeOpDeleteRepositoryPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
663 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
664 ) {
665 out, metadata, err = next.HandleDeserialize(ctx, in)
666 if err != nil {
667 return out, metadata, err
668 }
669
670 response, ok := out.RawResponse.(*smithyhttp.Response)
671 if !ok {
672 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
673 }
674
675 if response.StatusCode < 200 || response.StatusCode >= 300 {
676 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteRepositoryPolicy(response, &metadata)
677 }
678 output := &DeleteRepositoryPolicyOutput{}
679 out.Result = output
680
681 var buff [1024]byte
682 ringBuffer := smithyio.NewRingBuffer(buff[:])
683
684 body := io.TeeReader(response.Body, ringBuffer)
685 decoder := json.NewDecoder(body)
686 decoder.UseNumber()
687 var shape interface{}
688 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
689 var snapshot bytes.Buffer
690 io.Copy(&snapshot, ringBuffer)
691 err = &smithy.DeserializationError{
692 Err: fmt.Errorf("failed to decode response body, %w", err),
693 Snapshot: snapshot.Bytes(),
694 }
695 return out, metadata, err
696 }
697
698 err = awsAwsjson11_deserializeOpDocumentDeleteRepositoryPolicyOutput(&output, shape)
699 if err != nil {
700 var snapshot bytes.Buffer
701 io.Copy(&snapshot, ringBuffer)
702 err = &smithy.DeserializationError{
703 Err: fmt.Errorf("failed to decode response body, %w", err),
704 Snapshot: snapshot.Bytes(),
705 }
706 return out, metadata, err
707 }
708
709 return out, metadata, err
710 }
711
712 func awsAwsjson11_deserializeOpErrorDeleteRepositoryPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
713 var errorBuffer bytes.Buffer
714 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
715 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
716 }
717 errorBody := bytes.NewReader(errorBuffer.Bytes())
718
719 errorCode := "UnknownError"
720 errorMessage := errorCode
721
722 headerCode := response.Header.Get("X-Amzn-ErrorType")
723 if len(headerCode) != 0 {
724 errorCode = restjson.SanitizeErrorCode(headerCode)
725 }
726
727 var buff [1024]byte
728 ringBuffer := smithyio.NewRingBuffer(buff[:])
729
730 body := io.TeeReader(errorBody, ringBuffer)
731 decoder := json.NewDecoder(body)
732 decoder.UseNumber()
733 jsonCode, message, err := restjson.GetErrorInfo(decoder)
734 if err != nil {
735 var snapshot bytes.Buffer
736 io.Copy(&snapshot, ringBuffer)
737 err = &smithy.DeserializationError{
738 Err: fmt.Errorf("failed to decode response body, %w", err),
739 Snapshot: snapshot.Bytes(),
740 }
741 return err
742 }
743
744 errorBody.Seek(0, io.SeekStart)
745 if len(headerCode) == 0 && len(jsonCode) != 0 {
746 errorCode = restjson.SanitizeErrorCode(jsonCode)
747 }
748 if len(message) != 0 {
749 errorMessage = message
750 }
751
752 switch {
753 case strings.EqualFold("InvalidParameterException", errorCode):
754 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
755
756 case strings.EqualFold("RepositoryNotFoundException", errorCode):
757 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
758
759 case strings.EqualFold("RepositoryPolicyNotFoundException", errorCode):
760 return awsAwsjson11_deserializeErrorRepositoryPolicyNotFoundException(response, errorBody)
761
762 case strings.EqualFold("ServerException", errorCode):
763 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
764
765 case strings.EqualFold("UnsupportedCommandException", errorCode):
766 return awsAwsjson11_deserializeErrorUnsupportedCommandException(response, errorBody)
767
768 default:
769 genericError := &smithy.GenericAPIError{
770 Code: errorCode,
771 Message: errorMessage,
772 }
773 return genericError
774
775 }
776 }
777
778 type awsAwsjson11_deserializeOpDescribeImages struct {
779 }
780
781 func (*awsAwsjson11_deserializeOpDescribeImages) ID() string {
782 return "OperationDeserializer"
783 }
784
785 func (m *awsAwsjson11_deserializeOpDescribeImages) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
786 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
787 ) {
788 out, metadata, err = next.HandleDeserialize(ctx, in)
789 if err != nil {
790 return out, metadata, err
791 }
792
793 response, ok := out.RawResponse.(*smithyhttp.Response)
794 if !ok {
795 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
796 }
797
798 if response.StatusCode < 200 || response.StatusCode >= 300 {
799 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeImages(response, &metadata)
800 }
801 output := &DescribeImagesOutput{}
802 out.Result = output
803
804 var buff [1024]byte
805 ringBuffer := smithyio.NewRingBuffer(buff[:])
806
807 body := io.TeeReader(response.Body, ringBuffer)
808 decoder := json.NewDecoder(body)
809 decoder.UseNumber()
810 var shape interface{}
811 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
812 var snapshot bytes.Buffer
813 io.Copy(&snapshot, ringBuffer)
814 err = &smithy.DeserializationError{
815 Err: fmt.Errorf("failed to decode response body, %w", err),
816 Snapshot: snapshot.Bytes(),
817 }
818 return out, metadata, err
819 }
820
821 err = awsAwsjson11_deserializeOpDocumentDescribeImagesOutput(&output, shape)
822 if err != nil {
823 var snapshot bytes.Buffer
824 io.Copy(&snapshot, ringBuffer)
825 err = &smithy.DeserializationError{
826 Err: fmt.Errorf("failed to decode response body, %w", err),
827 Snapshot: snapshot.Bytes(),
828 }
829 return out, metadata, err
830 }
831
832 return out, metadata, err
833 }
834
835 func awsAwsjson11_deserializeOpErrorDescribeImages(response *smithyhttp.Response, metadata *middleware.Metadata) error {
836 var errorBuffer bytes.Buffer
837 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
838 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
839 }
840 errorBody := bytes.NewReader(errorBuffer.Bytes())
841
842 errorCode := "UnknownError"
843 errorMessage := errorCode
844
845 headerCode := response.Header.Get("X-Amzn-ErrorType")
846 if len(headerCode) != 0 {
847 errorCode = restjson.SanitizeErrorCode(headerCode)
848 }
849
850 var buff [1024]byte
851 ringBuffer := smithyio.NewRingBuffer(buff[:])
852
853 body := io.TeeReader(errorBody, ringBuffer)
854 decoder := json.NewDecoder(body)
855 decoder.UseNumber()
856 jsonCode, message, err := restjson.GetErrorInfo(decoder)
857 if err != nil {
858 var snapshot bytes.Buffer
859 io.Copy(&snapshot, ringBuffer)
860 err = &smithy.DeserializationError{
861 Err: fmt.Errorf("failed to decode response body, %w", err),
862 Snapshot: snapshot.Bytes(),
863 }
864 return err
865 }
866
867 errorBody.Seek(0, io.SeekStart)
868 if len(headerCode) == 0 && len(jsonCode) != 0 {
869 errorCode = restjson.SanitizeErrorCode(jsonCode)
870 }
871 if len(message) != 0 {
872 errorMessage = message
873 }
874
875 switch {
876 case strings.EqualFold("ImageNotFoundException", errorCode):
877 return awsAwsjson11_deserializeErrorImageNotFoundException(response, errorBody)
878
879 case strings.EqualFold("InvalidParameterException", errorCode):
880 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
881
882 case strings.EqualFold("RepositoryNotFoundException", errorCode):
883 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
884
885 case strings.EqualFold("ServerException", errorCode):
886 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
887
888 case strings.EqualFold("UnsupportedCommandException", errorCode):
889 return awsAwsjson11_deserializeErrorUnsupportedCommandException(response, errorBody)
890
891 default:
892 genericError := &smithy.GenericAPIError{
893 Code: errorCode,
894 Message: errorMessage,
895 }
896 return genericError
897
898 }
899 }
900
901 type awsAwsjson11_deserializeOpDescribeImageTags struct {
902 }
903
904 func (*awsAwsjson11_deserializeOpDescribeImageTags) ID() string {
905 return "OperationDeserializer"
906 }
907
908 func (m *awsAwsjson11_deserializeOpDescribeImageTags) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
909 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
910 ) {
911 out, metadata, err = next.HandleDeserialize(ctx, in)
912 if err != nil {
913 return out, metadata, err
914 }
915
916 response, ok := out.RawResponse.(*smithyhttp.Response)
917 if !ok {
918 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
919 }
920
921 if response.StatusCode < 200 || response.StatusCode >= 300 {
922 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeImageTags(response, &metadata)
923 }
924 output := &DescribeImageTagsOutput{}
925 out.Result = output
926
927 var buff [1024]byte
928 ringBuffer := smithyio.NewRingBuffer(buff[:])
929
930 body := io.TeeReader(response.Body, ringBuffer)
931 decoder := json.NewDecoder(body)
932 decoder.UseNumber()
933 var shape interface{}
934 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
935 var snapshot bytes.Buffer
936 io.Copy(&snapshot, ringBuffer)
937 err = &smithy.DeserializationError{
938 Err: fmt.Errorf("failed to decode response body, %w", err),
939 Snapshot: snapshot.Bytes(),
940 }
941 return out, metadata, err
942 }
943
944 err = awsAwsjson11_deserializeOpDocumentDescribeImageTagsOutput(&output, shape)
945 if err != nil {
946 var snapshot bytes.Buffer
947 io.Copy(&snapshot, ringBuffer)
948 err = &smithy.DeserializationError{
949 Err: fmt.Errorf("failed to decode response body, %w", err),
950 Snapshot: snapshot.Bytes(),
951 }
952 return out, metadata, err
953 }
954
955 return out, metadata, err
956 }
957
958 func awsAwsjson11_deserializeOpErrorDescribeImageTags(response *smithyhttp.Response, metadata *middleware.Metadata) error {
959 var errorBuffer bytes.Buffer
960 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
961 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
962 }
963 errorBody := bytes.NewReader(errorBuffer.Bytes())
964
965 errorCode := "UnknownError"
966 errorMessage := errorCode
967
968 headerCode := response.Header.Get("X-Amzn-ErrorType")
969 if len(headerCode) != 0 {
970 errorCode = restjson.SanitizeErrorCode(headerCode)
971 }
972
973 var buff [1024]byte
974 ringBuffer := smithyio.NewRingBuffer(buff[:])
975
976 body := io.TeeReader(errorBody, ringBuffer)
977 decoder := json.NewDecoder(body)
978 decoder.UseNumber()
979 jsonCode, message, err := restjson.GetErrorInfo(decoder)
980 if err != nil {
981 var snapshot bytes.Buffer
982 io.Copy(&snapshot, ringBuffer)
983 err = &smithy.DeserializationError{
984 Err: fmt.Errorf("failed to decode response body, %w", err),
985 Snapshot: snapshot.Bytes(),
986 }
987 return err
988 }
989
990 errorBody.Seek(0, io.SeekStart)
991 if len(headerCode) == 0 && len(jsonCode) != 0 {
992 errorCode = restjson.SanitizeErrorCode(jsonCode)
993 }
994 if len(message) != 0 {
995 errorMessage = message
996 }
997
998 switch {
999 case strings.EqualFold("InvalidParameterException", errorCode):
1000 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1001
1002 case strings.EqualFold("RepositoryNotFoundException", errorCode):
1003 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
1004
1005 case strings.EqualFold("ServerException", errorCode):
1006 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
1007
1008 case strings.EqualFold("UnsupportedCommandException", errorCode):
1009 return awsAwsjson11_deserializeErrorUnsupportedCommandException(response, errorBody)
1010
1011 default:
1012 genericError := &smithy.GenericAPIError{
1013 Code: errorCode,
1014 Message: errorMessage,
1015 }
1016 return genericError
1017
1018 }
1019 }
1020
1021 type awsAwsjson11_deserializeOpDescribeRegistries struct {
1022 }
1023
1024 func (*awsAwsjson11_deserializeOpDescribeRegistries) ID() string {
1025 return "OperationDeserializer"
1026 }
1027
1028 func (m *awsAwsjson11_deserializeOpDescribeRegistries) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1029 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1030 ) {
1031 out, metadata, err = next.HandleDeserialize(ctx, in)
1032 if err != nil {
1033 return out, metadata, err
1034 }
1035
1036 response, ok := out.RawResponse.(*smithyhttp.Response)
1037 if !ok {
1038 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1039 }
1040
1041 if response.StatusCode < 200 || response.StatusCode >= 300 {
1042 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeRegistries(response, &metadata)
1043 }
1044 output := &DescribeRegistriesOutput{}
1045 out.Result = output
1046
1047 var buff [1024]byte
1048 ringBuffer := smithyio.NewRingBuffer(buff[:])
1049
1050 body := io.TeeReader(response.Body, ringBuffer)
1051 decoder := json.NewDecoder(body)
1052 decoder.UseNumber()
1053 var shape interface{}
1054 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1055 var snapshot bytes.Buffer
1056 io.Copy(&snapshot, ringBuffer)
1057 err = &smithy.DeserializationError{
1058 Err: fmt.Errorf("failed to decode response body, %w", err),
1059 Snapshot: snapshot.Bytes(),
1060 }
1061 return out, metadata, err
1062 }
1063
1064 err = awsAwsjson11_deserializeOpDocumentDescribeRegistriesOutput(&output, shape)
1065 if err != nil {
1066 var snapshot bytes.Buffer
1067 io.Copy(&snapshot, ringBuffer)
1068 err = &smithy.DeserializationError{
1069 Err: fmt.Errorf("failed to decode response body, %w", err),
1070 Snapshot: snapshot.Bytes(),
1071 }
1072 return out, metadata, err
1073 }
1074
1075 return out, metadata, err
1076 }
1077
1078 func awsAwsjson11_deserializeOpErrorDescribeRegistries(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1079 var errorBuffer bytes.Buffer
1080 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1081 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1082 }
1083 errorBody := bytes.NewReader(errorBuffer.Bytes())
1084
1085 errorCode := "UnknownError"
1086 errorMessage := errorCode
1087
1088 headerCode := response.Header.Get("X-Amzn-ErrorType")
1089 if len(headerCode) != 0 {
1090 errorCode = restjson.SanitizeErrorCode(headerCode)
1091 }
1092
1093 var buff [1024]byte
1094 ringBuffer := smithyio.NewRingBuffer(buff[:])
1095
1096 body := io.TeeReader(errorBody, ringBuffer)
1097 decoder := json.NewDecoder(body)
1098 decoder.UseNumber()
1099 jsonCode, message, err := restjson.GetErrorInfo(decoder)
1100 if err != nil {
1101 var snapshot bytes.Buffer
1102 io.Copy(&snapshot, ringBuffer)
1103 err = &smithy.DeserializationError{
1104 Err: fmt.Errorf("failed to decode response body, %w", err),
1105 Snapshot: snapshot.Bytes(),
1106 }
1107 return err
1108 }
1109
1110 errorBody.Seek(0, io.SeekStart)
1111 if len(headerCode) == 0 && len(jsonCode) != 0 {
1112 errorCode = restjson.SanitizeErrorCode(jsonCode)
1113 }
1114 if len(message) != 0 {
1115 errorMessage = message
1116 }
1117
1118 switch {
1119 case strings.EqualFold("InvalidParameterException", errorCode):
1120 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1121
1122 case strings.EqualFold("ServerException", errorCode):
1123 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
1124
1125 case strings.EqualFold("UnsupportedCommandException", errorCode):
1126 return awsAwsjson11_deserializeErrorUnsupportedCommandException(response, errorBody)
1127
1128 default:
1129 genericError := &smithy.GenericAPIError{
1130 Code: errorCode,
1131 Message: errorMessage,
1132 }
1133 return genericError
1134
1135 }
1136 }
1137
1138 type awsAwsjson11_deserializeOpDescribeRepositories struct {
1139 }
1140
1141 func (*awsAwsjson11_deserializeOpDescribeRepositories) ID() string {
1142 return "OperationDeserializer"
1143 }
1144
1145 func (m *awsAwsjson11_deserializeOpDescribeRepositories) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1146 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1147 ) {
1148 out, metadata, err = next.HandleDeserialize(ctx, in)
1149 if err != nil {
1150 return out, metadata, err
1151 }
1152
1153 response, ok := out.RawResponse.(*smithyhttp.Response)
1154 if !ok {
1155 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1156 }
1157
1158 if response.StatusCode < 200 || response.StatusCode >= 300 {
1159 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeRepositories(response, &metadata)
1160 }
1161 output := &DescribeRepositoriesOutput{}
1162 out.Result = output
1163
1164 var buff [1024]byte
1165 ringBuffer := smithyio.NewRingBuffer(buff[:])
1166
1167 body := io.TeeReader(response.Body, ringBuffer)
1168 decoder := json.NewDecoder(body)
1169 decoder.UseNumber()
1170 var shape interface{}
1171 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
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 err = awsAwsjson11_deserializeOpDocumentDescribeRepositoriesOutput(&output, shape)
1182 if err != nil {
1183 var snapshot bytes.Buffer
1184 io.Copy(&snapshot, ringBuffer)
1185 err = &smithy.DeserializationError{
1186 Err: fmt.Errorf("failed to decode response body, %w", err),
1187 Snapshot: snapshot.Bytes(),
1188 }
1189 return out, metadata, err
1190 }
1191
1192 return out, metadata, err
1193 }
1194
1195 func awsAwsjson11_deserializeOpErrorDescribeRepositories(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1196 var errorBuffer bytes.Buffer
1197 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1198 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1199 }
1200 errorBody := bytes.NewReader(errorBuffer.Bytes())
1201
1202 errorCode := "UnknownError"
1203 errorMessage := errorCode
1204
1205 headerCode := response.Header.Get("X-Amzn-ErrorType")
1206 if len(headerCode) != 0 {
1207 errorCode = restjson.SanitizeErrorCode(headerCode)
1208 }
1209
1210 var buff [1024]byte
1211 ringBuffer := smithyio.NewRingBuffer(buff[:])
1212
1213 body := io.TeeReader(errorBody, ringBuffer)
1214 decoder := json.NewDecoder(body)
1215 decoder.UseNumber()
1216 jsonCode, message, err := restjson.GetErrorInfo(decoder)
1217 if err != nil {
1218 var snapshot bytes.Buffer
1219 io.Copy(&snapshot, ringBuffer)
1220 err = &smithy.DeserializationError{
1221 Err: fmt.Errorf("failed to decode response body, %w", err),
1222 Snapshot: snapshot.Bytes(),
1223 }
1224 return err
1225 }
1226
1227 errorBody.Seek(0, io.SeekStart)
1228 if len(headerCode) == 0 && len(jsonCode) != 0 {
1229 errorCode = restjson.SanitizeErrorCode(jsonCode)
1230 }
1231 if len(message) != 0 {
1232 errorMessage = message
1233 }
1234
1235 switch {
1236 case strings.EqualFold("InvalidParameterException", errorCode):
1237 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1238
1239 case strings.EqualFold("RepositoryNotFoundException", errorCode):
1240 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
1241
1242 case strings.EqualFold("ServerException", errorCode):
1243 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
1244
1245 case strings.EqualFold("UnsupportedCommandException", errorCode):
1246 return awsAwsjson11_deserializeErrorUnsupportedCommandException(response, errorBody)
1247
1248 default:
1249 genericError := &smithy.GenericAPIError{
1250 Code: errorCode,
1251 Message: errorMessage,
1252 }
1253 return genericError
1254
1255 }
1256 }
1257
1258 type awsAwsjson11_deserializeOpGetAuthorizationToken struct {
1259 }
1260
1261 func (*awsAwsjson11_deserializeOpGetAuthorizationToken) ID() string {
1262 return "OperationDeserializer"
1263 }
1264
1265 func (m *awsAwsjson11_deserializeOpGetAuthorizationToken) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1266 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1267 ) {
1268 out, metadata, err = next.HandleDeserialize(ctx, in)
1269 if err != nil {
1270 return out, metadata, err
1271 }
1272
1273 response, ok := out.RawResponse.(*smithyhttp.Response)
1274 if !ok {
1275 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1276 }
1277
1278 if response.StatusCode < 200 || response.StatusCode >= 300 {
1279 return out, metadata, awsAwsjson11_deserializeOpErrorGetAuthorizationToken(response, &metadata)
1280 }
1281 output := &GetAuthorizationTokenOutput{}
1282 out.Result = output
1283
1284 var buff [1024]byte
1285 ringBuffer := smithyio.NewRingBuffer(buff[:])
1286
1287 body := io.TeeReader(response.Body, ringBuffer)
1288 decoder := json.NewDecoder(body)
1289 decoder.UseNumber()
1290 var shape interface{}
1291 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
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 err = awsAwsjson11_deserializeOpDocumentGetAuthorizationTokenOutput(&output, shape)
1302 if err != nil {
1303 var snapshot bytes.Buffer
1304 io.Copy(&snapshot, ringBuffer)
1305 err = &smithy.DeserializationError{
1306 Err: fmt.Errorf("failed to decode response body, %w", err),
1307 Snapshot: snapshot.Bytes(),
1308 }
1309 return out, metadata, err
1310 }
1311
1312 return out, metadata, err
1313 }
1314
1315 func awsAwsjson11_deserializeOpErrorGetAuthorizationToken(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1316 var errorBuffer bytes.Buffer
1317 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1318 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1319 }
1320 errorBody := bytes.NewReader(errorBuffer.Bytes())
1321
1322 errorCode := "UnknownError"
1323 errorMessage := errorCode
1324
1325 headerCode := response.Header.Get("X-Amzn-ErrorType")
1326 if len(headerCode) != 0 {
1327 errorCode = restjson.SanitizeErrorCode(headerCode)
1328 }
1329
1330 var buff [1024]byte
1331 ringBuffer := smithyio.NewRingBuffer(buff[:])
1332
1333 body := io.TeeReader(errorBody, ringBuffer)
1334 decoder := json.NewDecoder(body)
1335 decoder.UseNumber()
1336 jsonCode, message, err := restjson.GetErrorInfo(decoder)
1337 if err != nil {
1338 var snapshot bytes.Buffer
1339 io.Copy(&snapshot, ringBuffer)
1340 err = &smithy.DeserializationError{
1341 Err: fmt.Errorf("failed to decode response body, %w", err),
1342 Snapshot: snapshot.Bytes(),
1343 }
1344 return err
1345 }
1346
1347 errorBody.Seek(0, io.SeekStart)
1348 if len(headerCode) == 0 && len(jsonCode) != 0 {
1349 errorCode = restjson.SanitizeErrorCode(jsonCode)
1350 }
1351 if len(message) != 0 {
1352 errorMessage = message
1353 }
1354
1355 switch {
1356 case strings.EqualFold("InvalidParameterException", errorCode):
1357 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1358
1359 case strings.EqualFold("ServerException", errorCode):
1360 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
1361
1362 case strings.EqualFold("UnsupportedCommandException", errorCode):
1363 return awsAwsjson11_deserializeErrorUnsupportedCommandException(response, errorBody)
1364
1365 default:
1366 genericError := &smithy.GenericAPIError{
1367 Code: errorCode,
1368 Message: errorMessage,
1369 }
1370 return genericError
1371
1372 }
1373 }
1374
1375 type awsAwsjson11_deserializeOpGetRegistryCatalogData struct {
1376 }
1377
1378 func (*awsAwsjson11_deserializeOpGetRegistryCatalogData) ID() string {
1379 return "OperationDeserializer"
1380 }
1381
1382 func (m *awsAwsjson11_deserializeOpGetRegistryCatalogData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1383 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1384 ) {
1385 out, metadata, err = next.HandleDeserialize(ctx, in)
1386 if err != nil {
1387 return out, metadata, err
1388 }
1389
1390 response, ok := out.RawResponse.(*smithyhttp.Response)
1391 if !ok {
1392 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1393 }
1394
1395 if response.StatusCode < 200 || response.StatusCode >= 300 {
1396 return out, metadata, awsAwsjson11_deserializeOpErrorGetRegistryCatalogData(response, &metadata)
1397 }
1398 output := &GetRegistryCatalogDataOutput{}
1399 out.Result = output
1400
1401 var buff [1024]byte
1402 ringBuffer := smithyio.NewRingBuffer(buff[:])
1403
1404 body := io.TeeReader(response.Body, ringBuffer)
1405 decoder := json.NewDecoder(body)
1406 decoder.UseNumber()
1407 var shape interface{}
1408 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1409 var snapshot bytes.Buffer
1410 io.Copy(&snapshot, ringBuffer)
1411 err = &smithy.DeserializationError{
1412 Err: fmt.Errorf("failed to decode response body, %w", err),
1413 Snapshot: snapshot.Bytes(),
1414 }
1415 return out, metadata, err
1416 }
1417
1418 err = awsAwsjson11_deserializeOpDocumentGetRegistryCatalogDataOutput(&output, shape)
1419 if err != nil {
1420 var snapshot bytes.Buffer
1421 io.Copy(&snapshot, ringBuffer)
1422 err = &smithy.DeserializationError{
1423 Err: fmt.Errorf("failed to decode response body, %w", err),
1424 Snapshot: snapshot.Bytes(),
1425 }
1426 return out, metadata, err
1427 }
1428
1429 return out, metadata, err
1430 }
1431
1432 func awsAwsjson11_deserializeOpErrorGetRegistryCatalogData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1433 var errorBuffer bytes.Buffer
1434 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1435 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1436 }
1437 errorBody := bytes.NewReader(errorBuffer.Bytes())
1438
1439 errorCode := "UnknownError"
1440 errorMessage := errorCode
1441
1442 headerCode := response.Header.Get("X-Amzn-ErrorType")
1443 if len(headerCode) != 0 {
1444 errorCode = restjson.SanitizeErrorCode(headerCode)
1445 }
1446
1447 var buff [1024]byte
1448 ringBuffer := smithyio.NewRingBuffer(buff[:])
1449
1450 body := io.TeeReader(errorBody, ringBuffer)
1451 decoder := json.NewDecoder(body)
1452 decoder.UseNumber()
1453 jsonCode, message, err := restjson.GetErrorInfo(decoder)
1454 if err != nil {
1455 var snapshot bytes.Buffer
1456 io.Copy(&snapshot, ringBuffer)
1457 err = &smithy.DeserializationError{
1458 Err: fmt.Errorf("failed to decode response body, %w", err),
1459 Snapshot: snapshot.Bytes(),
1460 }
1461 return err
1462 }
1463
1464 errorBody.Seek(0, io.SeekStart)
1465 if len(headerCode) == 0 && len(jsonCode) != 0 {
1466 errorCode = restjson.SanitizeErrorCode(jsonCode)
1467 }
1468 if len(message) != 0 {
1469 errorMessage = message
1470 }
1471
1472 switch {
1473 case strings.EqualFold("ServerException", errorCode):
1474 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
1475
1476 case strings.EqualFold("UnsupportedCommandException", errorCode):
1477 return awsAwsjson11_deserializeErrorUnsupportedCommandException(response, errorBody)
1478
1479 default:
1480 genericError := &smithy.GenericAPIError{
1481 Code: errorCode,
1482 Message: errorMessage,
1483 }
1484 return genericError
1485
1486 }
1487 }
1488
1489 type awsAwsjson11_deserializeOpGetRepositoryCatalogData struct {
1490 }
1491
1492 func (*awsAwsjson11_deserializeOpGetRepositoryCatalogData) ID() string {
1493 return "OperationDeserializer"
1494 }
1495
1496 func (m *awsAwsjson11_deserializeOpGetRepositoryCatalogData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1497 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1498 ) {
1499 out, metadata, err = next.HandleDeserialize(ctx, in)
1500 if err != nil {
1501 return out, metadata, err
1502 }
1503
1504 response, ok := out.RawResponse.(*smithyhttp.Response)
1505 if !ok {
1506 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1507 }
1508
1509 if response.StatusCode < 200 || response.StatusCode >= 300 {
1510 return out, metadata, awsAwsjson11_deserializeOpErrorGetRepositoryCatalogData(response, &metadata)
1511 }
1512 output := &GetRepositoryCatalogDataOutput{}
1513 out.Result = output
1514
1515 var buff [1024]byte
1516 ringBuffer := smithyio.NewRingBuffer(buff[:])
1517
1518 body := io.TeeReader(response.Body, ringBuffer)
1519 decoder := json.NewDecoder(body)
1520 decoder.UseNumber()
1521 var shape interface{}
1522 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1523 var snapshot bytes.Buffer
1524 io.Copy(&snapshot, ringBuffer)
1525 err = &smithy.DeserializationError{
1526 Err: fmt.Errorf("failed to decode response body, %w", err),
1527 Snapshot: snapshot.Bytes(),
1528 }
1529 return out, metadata, err
1530 }
1531
1532 err = awsAwsjson11_deserializeOpDocumentGetRepositoryCatalogDataOutput(&output, shape)
1533 if err != nil {
1534 var snapshot bytes.Buffer
1535 io.Copy(&snapshot, ringBuffer)
1536 err = &smithy.DeserializationError{
1537 Err: fmt.Errorf("failed to decode response body, %w", err),
1538 Snapshot: snapshot.Bytes(),
1539 }
1540 return out, metadata, err
1541 }
1542
1543 return out, metadata, err
1544 }
1545
1546 func awsAwsjson11_deserializeOpErrorGetRepositoryCatalogData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1547 var errorBuffer bytes.Buffer
1548 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1549 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1550 }
1551 errorBody := bytes.NewReader(errorBuffer.Bytes())
1552
1553 errorCode := "UnknownError"
1554 errorMessage := errorCode
1555
1556 headerCode := response.Header.Get("X-Amzn-ErrorType")
1557 if len(headerCode) != 0 {
1558 errorCode = restjson.SanitizeErrorCode(headerCode)
1559 }
1560
1561 var buff [1024]byte
1562 ringBuffer := smithyio.NewRingBuffer(buff[:])
1563
1564 body := io.TeeReader(errorBody, ringBuffer)
1565 decoder := json.NewDecoder(body)
1566 decoder.UseNumber()
1567 jsonCode, message, err := restjson.GetErrorInfo(decoder)
1568 if err != nil {
1569 var snapshot bytes.Buffer
1570 io.Copy(&snapshot, ringBuffer)
1571 err = &smithy.DeserializationError{
1572 Err: fmt.Errorf("failed to decode response body, %w", err),
1573 Snapshot: snapshot.Bytes(),
1574 }
1575 return err
1576 }
1577
1578 errorBody.Seek(0, io.SeekStart)
1579 if len(headerCode) == 0 && len(jsonCode) != 0 {
1580 errorCode = restjson.SanitizeErrorCode(jsonCode)
1581 }
1582 if len(message) != 0 {
1583 errorMessage = message
1584 }
1585
1586 switch {
1587 case strings.EqualFold("InvalidParameterException", errorCode):
1588 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1589
1590 case strings.EqualFold("RepositoryCatalogDataNotFoundException", errorCode):
1591 return awsAwsjson11_deserializeErrorRepositoryCatalogDataNotFoundException(response, errorBody)
1592
1593 case strings.EqualFold("RepositoryNotFoundException", errorCode):
1594 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
1595
1596 case strings.EqualFold("ServerException", errorCode):
1597 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
1598
1599 case strings.EqualFold("UnsupportedCommandException", errorCode):
1600 return awsAwsjson11_deserializeErrorUnsupportedCommandException(response, errorBody)
1601
1602 default:
1603 genericError := &smithy.GenericAPIError{
1604 Code: errorCode,
1605 Message: errorMessage,
1606 }
1607 return genericError
1608
1609 }
1610 }
1611
1612 type awsAwsjson11_deserializeOpGetRepositoryPolicy struct {
1613 }
1614
1615 func (*awsAwsjson11_deserializeOpGetRepositoryPolicy) ID() string {
1616 return "OperationDeserializer"
1617 }
1618
1619 func (m *awsAwsjson11_deserializeOpGetRepositoryPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1620 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1621 ) {
1622 out, metadata, err = next.HandleDeserialize(ctx, in)
1623 if err != nil {
1624 return out, metadata, err
1625 }
1626
1627 response, ok := out.RawResponse.(*smithyhttp.Response)
1628 if !ok {
1629 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1630 }
1631
1632 if response.StatusCode < 200 || response.StatusCode >= 300 {
1633 return out, metadata, awsAwsjson11_deserializeOpErrorGetRepositoryPolicy(response, &metadata)
1634 }
1635 output := &GetRepositoryPolicyOutput{}
1636 out.Result = output
1637
1638 var buff [1024]byte
1639 ringBuffer := smithyio.NewRingBuffer(buff[:])
1640
1641 body := io.TeeReader(response.Body, ringBuffer)
1642 decoder := json.NewDecoder(body)
1643 decoder.UseNumber()
1644 var shape interface{}
1645 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1646 var snapshot bytes.Buffer
1647 io.Copy(&snapshot, ringBuffer)
1648 err = &smithy.DeserializationError{
1649 Err: fmt.Errorf("failed to decode response body, %w", err),
1650 Snapshot: snapshot.Bytes(),
1651 }
1652 return out, metadata, err
1653 }
1654
1655 err = awsAwsjson11_deserializeOpDocumentGetRepositoryPolicyOutput(&output, shape)
1656 if err != nil {
1657 var snapshot bytes.Buffer
1658 io.Copy(&snapshot, ringBuffer)
1659 err = &smithy.DeserializationError{
1660 Err: fmt.Errorf("failed to decode response body, %w", err),
1661 Snapshot: snapshot.Bytes(),
1662 }
1663 return out, metadata, err
1664 }
1665
1666 return out, metadata, err
1667 }
1668
1669 func awsAwsjson11_deserializeOpErrorGetRepositoryPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1670 var errorBuffer bytes.Buffer
1671 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1672 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1673 }
1674 errorBody := bytes.NewReader(errorBuffer.Bytes())
1675
1676 errorCode := "UnknownError"
1677 errorMessage := errorCode
1678
1679 headerCode := response.Header.Get("X-Amzn-ErrorType")
1680 if len(headerCode) != 0 {
1681 errorCode = restjson.SanitizeErrorCode(headerCode)
1682 }
1683
1684 var buff [1024]byte
1685 ringBuffer := smithyio.NewRingBuffer(buff[:])
1686
1687 body := io.TeeReader(errorBody, ringBuffer)
1688 decoder := json.NewDecoder(body)
1689 decoder.UseNumber()
1690 jsonCode, message, err := restjson.GetErrorInfo(decoder)
1691 if err != nil {
1692 var snapshot bytes.Buffer
1693 io.Copy(&snapshot, ringBuffer)
1694 err = &smithy.DeserializationError{
1695 Err: fmt.Errorf("failed to decode response body, %w", err),
1696 Snapshot: snapshot.Bytes(),
1697 }
1698 return err
1699 }
1700
1701 errorBody.Seek(0, io.SeekStart)
1702 if len(headerCode) == 0 && len(jsonCode) != 0 {
1703 errorCode = restjson.SanitizeErrorCode(jsonCode)
1704 }
1705 if len(message) != 0 {
1706 errorMessage = message
1707 }
1708
1709 switch {
1710 case strings.EqualFold("InvalidParameterException", errorCode):
1711 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1712
1713 case strings.EqualFold("RepositoryNotFoundException", errorCode):
1714 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
1715
1716 case strings.EqualFold("RepositoryPolicyNotFoundException", errorCode):
1717 return awsAwsjson11_deserializeErrorRepositoryPolicyNotFoundException(response, errorBody)
1718
1719 case strings.EqualFold("ServerException", errorCode):
1720 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
1721
1722 case strings.EqualFold("UnsupportedCommandException", errorCode):
1723 return awsAwsjson11_deserializeErrorUnsupportedCommandException(response, errorBody)
1724
1725 default:
1726 genericError := &smithy.GenericAPIError{
1727 Code: errorCode,
1728 Message: errorMessage,
1729 }
1730 return genericError
1731
1732 }
1733 }
1734
1735 type awsAwsjson11_deserializeOpInitiateLayerUpload struct {
1736 }
1737
1738 func (*awsAwsjson11_deserializeOpInitiateLayerUpload) ID() string {
1739 return "OperationDeserializer"
1740 }
1741
1742 func (m *awsAwsjson11_deserializeOpInitiateLayerUpload) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1743 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1744 ) {
1745 out, metadata, err = next.HandleDeserialize(ctx, in)
1746 if err != nil {
1747 return out, metadata, err
1748 }
1749
1750 response, ok := out.RawResponse.(*smithyhttp.Response)
1751 if !ok {
1752 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1753 }
1754
1755 if response.StatusCode < 200 || response.StatusCode >= 300 {
1756 return out, metadata, awsAwsjson11_deserializeOpErrorInitiateLayerUpload(response, &metadata)
1757 }
1758 output := &InitiateLayerUploadOutput{}
1759 out.Result = output
1760
1761 var buff [1024]byte
1762 ringBuffer := smithyio.NewRingBuffer(buff[:])
1763
1764 body := io.TeeReader(response.Body, ringBuffer)
1765 decoder := json.NewDecoder(body)
1766 decoder.UseNumber()
1767 var shape interface{}
1768 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1769 var snapshot bytes.Buffer
1770 io.Copy(&snapshot, ringBuffer)
1771 err = &smithy.DeserializationError{
1772 Err: fmt.Errorf("failed to decode response body, %w", err),
1773 Snapshot: snapshot.Bytes(),
1774 }
1775 return out, metadata, err
1776 }
1777
1778 err = awsAwsjson11_deserializeOpDocumentInitiateLayerUploadOutput(&output, shape)
1779 if err != nil {
1780 var snapshot bytes.Buffer
1781 io.Copy(&snapshot, ringBuffer)
1782 err = &smithy.DeserializationError{
1783 Err: fmt.Errorf("failed to decode response body, %w", err),
1784 Snapshot: snapshot.Bytes(),
1785 }
1786 return out, metadata, err
1787 }
1788
1789 return out, metadata, err
1790 }
1791
1792 func awsAwsjson11_deserializeOpErrorInitiateLayerUpload(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1793 var errorBuffer bytes.Buffer
1794 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1795 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1796 }
1797 errorBody := bytes.NewReader(errorBuffer.Bytes())
1798
1799 errorCode := "UnknownError"
1800 errorMessage := errorCode
1801
1802 headerCode := response.Header.Get("X-Amzn-ErrorType")
1803 if len(headerCode) != 0 {
1804 errorCode = restjson.SanitizeErrorCode(headerCode)
1805 }
1806
1807 var buff [1024]byte
1808 ringBuffer := smithyio.NewRingBuffer(buff[:])
1809
1810 body := io.TeeReader(errorBody, ringBuffer)
1811 decoder := json.NewDecoder(body)
1812 decoder.UseNumber()
1813 jsonCode, message, err := restjson.GetErrorInfo(decoder)
1814 if err != nil {
1815 var snapshot bytes.Buffer
1816 io.Copy(&snapshot, ringBuffer)
1817 err = &smithy.DeserializationError{
1818 Err: fmt.Errorf("failed to decode response body, %w", err),
1819 Snapshot: snapshot.Bytes(),
1820 }
1821 return err
1822 }
1823
1824 errorBody.Seek(0, io.SeekStart)
1825 if len(headerCode) == 0 && len(jsonCode) != 0 {
1826 errorCode = restjson.SanitizeErrorCode(jsonCode)
1827 }
1828 if len(message) != 0 {
1829 errorMessage = message
1830 }
1831
1832 switch {
1833 case strings.EqualFold("InvalidParameterException", errorCode):
1834 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1835
1836 case strings.EqualFold("RegistryNotFoundException", errorCode):
1837 return awsAwsjson11_deserializeErrorRegistryNotFoundException(response, errorBody)
1838
1839 case strings.EqualFold("RepositoryNotFoundException", errorCode):
1840 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
1841
1842 case strings.EqualFold("ServerException", errorCode):
1843 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
1844
1845 case strings.EqualFold("UnsupportedCommandException", errorCode):
1846 return awsAwsjson11_deserializeErrorUnsupportedCommandException(response, errorBody)
1847
1848 default:
1849 genericError := &smithy.GenericAPIError{
1850 Code: errorCode,
1851 Message: errorMessage,
1852 }
1853 return genericError
1854
1855 }
1856 }
1857
1858 type awsAwsjson11_deserializeOpListTagsForResource struct {
1859 }
1860
1861 func (*awsAwsjson11_deserializeOpListTagsForResource) ID() string {
1862 return "OperationDeserializer"
1863 }
1864
1865 func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1866 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1867 ) {
1868 out, metadata, err = next.HandleDeserialize(ctx, in)
1869 if err != nil {
1870 return out, metadata, err
1871 }
1872
1873 response, ok := out.RawResponse.(*smithyhttp.Response)
1874 if !ok {
1875 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1876 }
1877
1878 if response.StatusCode < 200 || response.StatusCode >= 300 {
1879 return out, metadata, awsAwsjson11_deserializeOpErrorListTagsForResource(response, &metadata)
1880 }
1881 output := &ListTagsForResourceOutput{}
1882 out.Result = output
1883
1884 var buff [1024]byte
1885 ringBuffer := smithyio.NewRingBuffer(buff[:])
1886
1887 body := io.TeeReader(response.Body, ringBuffer)
1888 decoder := json.NewDecoder(body)
1889 decoder.UseNumber()
1890 var shape interface{}
1891 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1892 var snapshot bytes.Buffer
1893 io.Copy(&snapshot, ringBuffer)
1894 err = &smithy.DeserializationError{
1895 Err: fmt.Errorf("failed to decode response body, %w", err),
1896 Snapshot: snapshot.Bytes(),
1897 }
1898 return out, metadata, err
1899 }
1900
1901 err = awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(&output, shape)
1902 if err != nil {
1903 var snapshot bytes.Buffer
1904 io.Copy(&snapshot, ringBuffer)
1905 err = &smithy.DeserializationError{
1906 Err: fmt.Errorf("failed to decode response body, %w", err),
1907 Snapshot: snapshot.Bytes(),
1908 }
1909 return out, metadata, err
1910 }
1911
1912 return out, metadata, err
1913 }
1914
1915 func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1916 var errorBuffer bytes.Buffer
1917 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1918 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1919 }
1920 errorBody := bytes.NewReader(errorBuffer.Bytes())
1921
1922 errorCode := "UnknownError"
1923 errorMessage := errorCode
1924
1925 headerCode := response.Header.Get("X-Amzn-ErrorType")
1926 if len(headerCode) != 0 {
1927 errorCode = restjson.SanitizeErrorCode(headerCode)
1928 }
1929
1930 var buff [1024]byte
1931 ringBuffer := smithyio.NewRingBuffer(buff[:])
1932
1933 body := io.TeeReader(errorBody, ringBuffer)
1934 decoder := json.NewDecoder(body)
1935 decoder.UseNumber()
1936 jsonCode, message, err := restjson.GetErrorInfo(decoder)
1937 if err != nil {
1938 var snapshot bytes.Buffer
1939 io.Copy(&snapshot, ringBuffer)
1940 err = &smithy.DeserializationError{
1941 Err: fmt.Errorf("failed to decode response body, %w", err),
1942 Snapshot: snapshot.Bytes(),
1943 }
1944 return err
1945 }
1946
1947 errorBody.Seek(0, io.SeekStart)
1948 if len(headerCode) == 0 && len(jsonCode) != 0 {
1949 errorCode = restjson.SanitizeErrorCode(jsonCode)
1950 }
1951 if len(message) != 0 {
1952 errorMessage = message
1953 }
1954
1955 switch {
1956 case strings.EqualFold("InvalidParameterException", errorCode):
1957 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1958
1959 case strings.EqualFold("RepositoryNotFoundException", errorCode):
1960 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
1961
1962 case strings.EqualFold("ServerException", errorCode):
1963 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
1964
1965 case strings.EqualFold("UnsupportedCommandException", errorCode):
1966 return awsAwsjson11_deserializeErrorUnsupportedCommandException(response, errorBody)
1967
1968 default:
1969 genericError := &smithy.GenericAPIError{
1970 Code: errorCode,
1971 Message: errorMessage,
1972 }
1973 return genericError
1974
1975 }
1976 }
1977
1978 type awsAwsjson11_deserializeOpPutImage struct {
1979 }
1980
1981 func (*awsAwsjson11_deserializeOpPutImage) ID() string {
1982 return "OperationDeserializer"
1983 }
1984
1985 func (m *awsAwsjson11_deserializeOpPutImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1986 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1987 ) {
1988 out, metadata, err = next.HandleDeserialize(ctx, in)
1989 if err != nil {
1990 return out, metadata, err
1991 }
1992
1993 response, ok := out.RawResponse.(*smithyhttp.Response)
1994 if !ok {
1995 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1996 }
1997
1998 if response.StatusCode < 200 || response.StatusCode >= 300 {
1999 return out, metadata, awsAwsjson11_deserializeOpErrorPutImage(response, &metadata)
2000 }
2001 output := &PutImageOutput{}
2002 out.Result = output
2003
2004 var buff [1024]byte
2005 ringBuffer := smithyio.NewRingBuffer(buff[:])
2006
2007 body := io.TeeReader(response.Body, ringBuffer)
2008 decoder := json.NewDecoder(body)
2009 decoder.UseNumber()
2010 var shape interface{}
2011 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2012 var snapshot bytes.Buffer
2013 io.Copy(&snapshot, ringBuffer)
2014 err = &smithy.DeserializationError{
2015 Err: fmt.Errorf("failed to decode response body, %w", err),
2016 Snapshot: snapshot.Bytes(),
2017 }
2018 return out, metadata, err
2019 }
2020
2021 err = awsAwsjson11_deserializeOpDocumentPutImageOutput(&output, shape)
2022 if err != nil {
2023 var snapshot bytes.Buffer
2024 io.Copy(&snapshot, ringBuffer)
2025 err = &smithy.DeserializationError{
2026 Err: fmt.Errorf("failed to decode response body, %w", err),
2027 Snapshot: snapshot.Bytes(),
2028 }
2029 return out, metadata, err
2030 }
2031
2032 return out, metadata, err
2033 }
2034
2035 func awsAwsjson11_deserializeOpErrorPutImage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2036 var errorBuffer bytes.Buffer
2037 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2038 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2039 }
2040 errorBody := bytes.NewReader(errorBuffer.Bytes())
2041
2042 errorCode := "UnknownError"
2043 errorMessage := errorCode
2044
2045 headerCode := response.Header.Get("X-Amzn-ErrorType")
2046 if len(headerCode) != 0 {
2047 errorCode = restjson.SanitizeErrorCode(headerCode)
2048 }
2049
2050 var buff [1024]byte
2051 ringBuffer := smithyio.NewRingBuffer(buff[:])
2052
2053 body := io.TeeReader(errorBody, ringBuffer)
2054 decoder := json.NewDecoder(body)
2055 decoder.UseNumber()
2056 jsonCode, message, err := restjson.GetErrorInfo(decoder)
2057 if err != nil {
2058 var snapshot bytes.Buffer
2059 io.Copy(&snapshot, ringBuffer)
2060 err = &smithy.DeserializationError{
2061 Err: fmt.Errorf("failed to decode response body, %w", err),
2062 Snapshot: snapshot.Bytes(),
2063 }
2064 return err
2065 }
2066
2067 errorBody.Seek(0, io.SeekStart)
2068 if len(headerCode) == 0 && len(jsonCode) != 0 {
2069 errorCode = restjson.SanitizeErrorCode(jsonCode)
2070 }
2071 if len(message) != 0 {
2072 errorMessage = message
2073 }
2074
2075 switch {
2076 case strings.EqualFold("ImageAlreadyExistsException", errorCode):
2077 return awsAwsjson11_deserializeErrorImageAlreadyExistsException(response, errorBody)
2078
2079 case strings.EqualFold("ImageDigestDoesNotMatchException", errorCode):
2080 return awsAwsjson11_deserializeErrorImageDigestDoesNotMatchException(response, errorBody)
2081
2082 case strings.EqualFold("ImageTagAlreadyExistsException", errorCode):
2083 return awsAwsjson11_deserializeErrorImageTagAlreadyExistsException(response, errorBody)
2084
2085 case strings.EqualFold("InvalidParameterException", errorCode):
2086 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
2087
2088 case strings.EqualFold("LayersNotFoundException", errorCode):
2089 return awsAwsjson11_deserializeErrorLayersNotFoundException(response, errorBody)
2090
2091 case strings.EqualFold("LimitExceededException", errorCode):
2092 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
2093
2094 case strings.EqualFold("ReferencedImagesNotFoundException", errorCode):
2095 return awsAwsjson11_deserializeErrorReferencedImagesNotFoundException(response, errorBody)
2096
2097 case strings.EqualFold("RegistryNotFoundException", errorCode):
2098 return awsAwsjson11_deserializeErrorRegistryNotFoundException(response, errorBody)
2099
2100 case strings.EqualFold("RepositoryNotFoundException", errorCode):
2101 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
2102
2103 case strings.EqualFold("ServerException", errorCode):
2104 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
2105
2106 case strings.EqualFold("UnsupportedCommandException", errorCode):
2107 return awsAwsjson11_deserializeErrorUnsupportedCommandException(response, errorBody)
2108
2109 default:
2110 genericError := &smithy.GenericAPIError{
2111 Code: errorCode,
2112 Message: errorMessage,
2113 }
2114 return genericError
2115
2116 }
2117 }
2118
2119 type awsAwsjson11_deserializeOpPutRegistryCatalogData struct {
2120 }
2121
2122 func (*awsAwsjson11_deserializeOpPutRegistryCatalogData) ID() string {
2123 return "OperationDeserializer"
2124 }
2125
2126 func (m *awsAwsjson11_deserializeOpPutRegistryCatalogData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2127 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2128 ) {
2129 out, metadata, err = next.HandleDeserialize(ctx, in)
2130 if err != nil {
2131 return out, metadata, err
2132 }
2133
2134 response, ok := out.RawResponse.(*smithyhttp.Response)
2135 if !ok {
2136 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2137 }
2138
2139 if response.StatusCode < 200 || response.StatusCode >= 300 {
2140 return out, metadata, awsAwsjson11_deserializeOpErrorPutRegistryCatalogData(response, &metadata)
2141 }
2142 output := &PutRegistryCatalogDataOutput{}
2143 out.Result = output
2144
2145 var buff [1024]byte
2146 ringBuffer := smithyio.NewRingBuffer(buff[:])
2147
2148 body := io.TeeReader(response.Body, ringBuffer)
2149 decoder := json.NewDecoder(body)
2150 decoder.UseNumber()
2151 var shape interface{}
2152 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2153 var snapshot bytes.Buffer
2154 io.Copy(&snapshot, ringBuffer)
2155 err = &smithy.DeserializationError{
2156 Err: fmt.Errorf("failed to decode response body, %w", err),
2157 Snapshot: snapshot.Bytes(),
2158 }
2159 return out, metadata, err
2160 }
2161
2162 err = awsAwsjson11_deserializeOpDocumentPutRegistryCatalogDataOutput(&output, shape)
2163 if err != nil {
2164 var snapshot bytes.Buffer
2165 io.Copy(&snapshot, ringBuffer)
2166 err = &smithy.DeserializationError{
2167 Err: fmt.Errorf("failed to decode response body, %w", err),
2168 Snapshot: snapshot.Bytes(),
2169 }
2170 return out, metadata, err
2171 }
2172
2173 return out, metadata, err
2174 }
2175
2176 func awsAwsjson11_deserializeOpErrorPutRegistryCatalogData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2177 var errorBuffer bytes.Buffer
2178 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2179 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2180 }
2181 errorBody := bytes.NewReader(errorBuffer.Bytes())
2182
2183 errorCode := "UnknownError"
2184 errorMessage := errorCode
2185
2186 headerCode := response.Header.Get("X-Amzn-ErrorType")
2187 if len(headerCode) != 0 {
2188 errorCode = restjson.SanitizeErrorCode(headerCode)
2189 }
2190
2191 var buff [1024]byte
2192 ringBuffer := smithyio.NewRingBuffer(buff[:])
2193
2194 body := io.TeeReader(errorBody, ringBuffer)
2195 decoder := json.NewDecoder(body)
2196 decoder.UseNumber()
2197 jsonCode, message, err := restjson.GetErrorInfo(decoder)
2198 if err != nil {
2199 var snapshot bytes.Buffer
2200 io.Copy(&snapshot, ringBuffer)
2201 err = &smithy.DeserializationError{
2202 Err: fmt.Errorf("failed to decode response body, %w", err),
2203 Snapshot: snapshot.Bytes(),
2204 }
2205 return err
2206 }
2207
2208 errorBody.Seek(0, io.SeekStart)
2209 if len(headerCode) == 0 && len(jsonCode) != 0 {
2210 errorCode = restjson.SanitizeErrorCode(jsonCode)
2211 }
2212 if len(message) != 0 {
2213 errorMessage = message
2214 }
2215
2216 switch {
2217 case strings.EqualFold("InvalidParameterException", errorCode):
2218 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
2219
2220 case strings.EqualFold("ServerException", errorCode):
2221 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
2222
2223 case strings.EqualFold("UnsupportedCommandException", errorCode):
2224 return awsAwsjson11_deserializeErrorUnsupportedCommandException(response, errorBody)
2225
2226 default:
2227 genericError := &smithy.GenericAPIError{
2228 Code: errorCode,
2229 Message: errorMessage,
2230 }
2231 return genericError
2232
2233 }
2234 }
2235
2236 type awsAwsjson11_deserializeOpPutRepositoryCatalogData struct {
2237 }
2238
2239 func (*awsAwsjson11_deserializeOpPutRepositoryCatalogData) ID() string {
2240 return "OperationDeserializer"
2241 }
2242
2243 func (m *awsAwsjson11_deserializeOpPutRepositoryCatalogData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2244 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2245 ) {
2246 out, metadata, err = next.HandleDeserialize(ctx, in)
2247 if err != nil {
2248 return out, metadata, err
2249 }
2250
2251 response, ok := out.RawResponse.(*smithyhttp.Response)
2252 if !ok {
2253 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2254 }
2255
2256 if response.StatusCode < 200 || response.StatusCode >= 300 {
2257 return out, metadata, awsAwsjson11_deserializeOpErrorPutRepositoryCatalogData(response, &metadata)
2258 }
2259 output := &PutRepositoryCatalogDataOutput{}
2260 out.Result = output
2261
2262 var buff [1024]byte
2263 ringBuffer := smithyio.NewRingBuffer(buff[:])
2264
2265 body := io.TeeReader(response.Body, ringBuffer)
2266 decoder := json.NewDecoder(body)
2267 decoder.UseNumber()
2268 var shape interface{}
2269 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2270 var snapshot bytes.Buffer
2271 io.Copy(&snapshot, ringBuffer)
2272 err = &smithy.DeserializationError{
2273 Err: fmt.Errorf("failed to decode response body, %w", err),
2274 Snapshot: snapshot.Bytes(),
2275 }
2276 return out, metadata, err
2277 }
2278
2279 err = awsAwsjson11_deserializeOpDocumentPutRepositoryCatalogDataOutput(&output, shape)
2280 if err != nil {
2281 var snapshot bytes.Buffer
2282 io.Copy(&snapshot, ringBuffer)
2283 err = &smithy.DeserializationError{
2284 Err: fmt.Errorf("failed to decode response body, %w", err),
2285 Snapshot: snapshot.Bytes(),
2286 }
2287 return out, metadata, err
2288 }
2289
2290 return out, metadata, err
2291 }
2292
2293 func awsAwsjson11_deserializeOpErrorPutRepositoryCatalogData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2294 var errorBuffer bytes.Buffer
2295 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2296 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2297 }
2298 errorBody := bytes.NewReader(errorBuffer.Bytes())
2299
2300 errorCode := "UnknownError"
2301 errorMessage := errorCode
2302
2303 headerCode := response.Header.Get("X-Amzn-ErrorType")
2304 if len(headerCode) != 0 {
2305 errorCode = restjson.SanitizeErrorCode(headerCode)
2306 }
2307
2308 var buff [1024]byte
2309 ringBuffer := smithyio.NewRingBuffer(buff[:])
2310
2311 body := io.TeeReader(errorBody, ringBuffer)
2312 decoder := json.NewDecoder(body)
2313 decoder.UseNumber()
2314 jsonCode, message, err := restjson.GetErrorInfo(decoder)
2315 if err != nil {
2316 var snapshot bytes.Buffer
2317 io.Copy(&snapshot, ringBuffer)
2318 err = &smithy.DeserializationError{
2319 Err: fmt.Errorf("failed to decode response body, %w", err),
2320 Snapshot: snapshot.Bytes(),
2321 }
2322 return err
2323 }
2324
2325 errorBody.Seek(0, io.SeekStart)
2326 if len(headerCode) == 0 && len(jsonCode) != 0 {
2327 errorCode = restjson.SanitizeErrorCode(jsonCode)
2328 }
2329 if len(message) != 0 {
2330 errorMessage = message
2331 }
2332
2333 switch {
2334 case strings.EqualFold("InvalidParameterException", errorCode):
2335 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
2336
2337 case strings.EqualFold("RepositoryNotFoundException", errorCode):
2338 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
2339
2340 case strings.EqualFold("ServerException", errorCode):
2341 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
2342
2343 case strings.EqualFold("UnsupportedCommandException", errorCode):
2344 return awsAwsjson11_deserializeErrorUnsupportedCommandException(response, errorBody)
2345
2346 default:
2347 genericError := &smithy.GenericAPIError{
2348 Code: errorCode,
2349 Message: errorMessage,
2350 }
2351 return genericError
2352
2353 }
2354 }
2355
2356 type awsAwsjson11_deserializeOpSetRepositoryPolicy struct {
2357 }
2358
2359 func (*awsAwsjson11_deserializeOpSetRepositoryPolicy) ID() string {
2360 return "OperationDeserializer"
2361 }
2362
2363 func (m *awsAwsjson11_deserializeOpSetRepositoryPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2364 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2365 ) {
2366 out, metadata, err = next.HandleDeserialize(ctx, in)
2367 if err != nil {
2368 return out, metadata, err
2369 }
2370
2371 response, ok := out.RawResponse.(*smithyhttp.Response)
2372 if !ok {
2373 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2374 }
2375
2376 if response.StatusCode < 200 || response.StatusCode >= 300 {
2377 return out, metadata, awsAwsjson11_deserializeOpErrorSetRepositoryPolicy(response, &metadata)
2378 }
2379 output := &SetRepositoryPolicyOutput{}
2380 out.Result = output
2381
2382 var buff [1024]byte
2383 ringBuffer := smithyio.NewRingBuffer(buff[:])
2384
2385 body := io.TeeReader(response.Body, ringBuffer)
2386 decoder := json.NewDecoder(body)
2387 decoder.UseNumber()
2388 var shape interface{}
2389 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2390 var snapshot bytes.Buffer
2391 io.Copy(&snapshot, ringBuffer)
2392 err = &smithy.DeserializationError{
2393 Err: fmt.Errorf("failed to decode response body, %w", err),
2394 Snapshot: snapshot.Bytes(),
2395 }
2396 return out, metadata, err
2397 }
2398
2399 err = awsAwsjson11_deserializeOpDocumentSetRepositoryPolicyOutput(&output, shape)
2400 if err != nil {
2401 var snapshot bytes.Buffer
2402 io.Copy(&snapshot, ringBuffer)
2403 err = &smithy.DeserializationError{
2404 Err: fmt.Errorf("failed to decode response body, %w", err),
2405 Snapshot: snapshot.Bytes(),
2406 }
2407 return out, metadata, err
2408 }
2409
2410 return out, metadata, err
2411 }
2412
2413 func awsAwsjson11_deserializeOpErrorSetRepositoryPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2414 var errorBuffer bytes.Buffer
2415 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2416 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2417 }
2418 errorBody := bytes.NewReader(errorBuffer.Bytes())
2419
2420 errorCode := "UnknownError"
2421 errorMessage := errorCode
2422
2423 headerCode := response.Header.Get("X-Amzn-ErrorType")
2424 if len(headerCode) != 0 {
2425 errorCode = restjson.SanitizeErrorCode(headerCode)
2426 }
2427
2428 var buff [1024]byte
2429 ringBuffer := smithyio.NewRingBuffer(buff[:])
2430
2431 body := io.TeeReader(errorBody, ringBuffer)
2432 decoder := json.NewDecoder(body)
2433 decoder.UseNumber()
2434 jsonCode, message, err := restjson.GetErrorInfo(decoder)
2435 if err != nil {
2436 var snapshot bytes.Buffer
2437 io.Copy(&snapshot, ringBuffer)
2438 err = &smithy.DeserializationError{
2439 Err: fmt.Errorf("failed to decode response body, %w", err),
2440 Snapshot: snapshot.Bytes(),
2441 }
2442 return err
2443 }
2444
2445 errorBody.Seek(0, io.SeekStart)
2446 if len(headerCode) == 0 && len(jsonCode) != 0 {
2447 errorCode = restjson.SanitizeErrorCode(jsonCode)
2448 }
2449 if len(message) != 0 {
2450 errorMessage = message
2451 }
2452
2453 switch {
2454 case strings.EqualFold("InvalidParameterException", errorCode):
2455 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
2456
2457 case strings.EqualFold("RepositoryNotFoundException", errorCode):
2458 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
2459
2460 case strings.EqualFold("ServerException", errorCode):
2461 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
2462
2463 case strings.EqualFold("UnsupportedCommandException", errorCode):
2464 return awsAwsjson11_deserializeErrorUnsupportedCommandException(response, errorBody)
2465
2466 default:
2467 genericError := &smithy.GenericAPIError{
2468 Code: errorCode,
2469 Message: errorMessage,
2470 }
2471 return genericError
2472
2473 }
2474 }
2475
2476 type awsAwsjson11_deserializeOpTagResource struct {
2477 }
2478
2479 func (*awsAwsjson11_deserializeOpTagResource) ID() string {
2480 return "OperationDeserializer"
2481 }
2482
2483 func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2484 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2485 ) {
2486 out, metadata, err = next.HandleDeserialize(ctx, in)
2487 if err != nil {
2488 return out, metadata, err
2489 }
2490
2491 response, ok := out.RawResponse.(*smithyhttp.Response)
2492 if !ok {
2493 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2494 }
2495
2496 if response.StatusCode < 200 || response.StatusCode >= 300 {
2497 return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata)
2498 }
2499 output := &TagResourceOutput{}
2500 out.Result = output
2501
2502 var buff [1024]byte
2503 ringBuffer := smithyio.NewRingBuffer(buff[:])
2504
2505 body := io.TeeReader(response.Body, ringBuffer)
2506 decoder := json.NewDecoder(body)
2507 decoder.UseNumber()
2508 var shape interface{}
2509 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2510 var snapshot bytes.Buffer
2511 io.Copy(&snapshot, ringBuffer)
2512 err = &smithy.DeserializationError{
2513 Err: fmt.Errorf("failed to decode response body, %w", err),
2514 Snapshot: snapshot.Bytes(),
2515 }
2516 return out, metadata, err
2517 }
2518
2519 err = awsAwsjson11_deserializeOpDocumentTagResourceOutput(&output, shape)
2520 if err != nil {
2521 var snapshot bytes.Buffer
2522 io.Copy(&snapshot, ringBuffer)
2523 err = &smithy.DeserializationError{
2524 Err: fmt.Errorf("failed to decode response body, %w", err),
2525 Snapshot: snapshot.Bytes(),
2526 }
2527 return out, metadata, err
2528 }
2529
2530 return out, metadata, err
2531 }
2532
2533 func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2534 var errorBuffer bytes.Buffer
2535 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2536 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2537 }
2538 errorBody := bytes.NewReader(errorBuffer.Bytes())
2539
2540 errorCode := "UnknownError"
2541 errorMessage := errorCode
2542
2543 headerCode := response.Header.Get("X-Amzn-ErrorType")
2544 if len(headerCode) != 0 {
2545 errorCode = restjson.SanitizeErrorCode(headerCode)
2546 }
2547
2548 var buff [1024]byte
2549 ringBuffer := smithyio.NewRingBuffer(buff[:])
2550
2551 body := io.TeeReader(errorBody, ringBuffer)
2552 decoder := json.NewDecoder(body)
2553 decoder.UseNumber()
2554 jsonCode, message, err := restjson.GetErrorInfo(decoder)
2555 if err != nil {
2556 var snapshot bytes.Buffer
2557 io.Copy(&snapshot, ringBuffer)
2558 err = &smithy.DeserializationError{
2559 Err: fmt.Errorf("failed to decode response body, %w", err),
2560 Snapshot: snapshot.Bytes(),
2561 }
2562 return err
2563 }
2564
2565 errorBody.Seek(0, io.SeekStart)
2566 if len(headerCode) == 0 && len(jsonCode) != 0 {
2567 errorCode = restjson.SanitizeErrorCode(jsonCode)
2568 }
2569 if len(message) != 0 {
2570 errorMessage = message
2571 }
2572
2573 switch {
2574 case strings.EqualFold("InvalidParameterException", errorCode):
2575 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
2576
2577 case strings.EqualFold("InvalidTagParameterException", errorCode):
2578 return awsAwsjson11_deserializeErrorInvalidTagParameterException(response, errorBody)
2579
2580 case strings.EqualFold("RepositoryNotFoundException", errorCode):
2581 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
2582
2583 case strings.EqualFold("ServerException", errorCode):
2584 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
2585
2586 case strings.EqualFold("TooManyTagsException", errorCode):
2587 return awsAwsjson11_deserializeErrorTooManyTagsException(response, errorBody)
2588
2589 case strings.EqualFold("UnsupportedCommandException", errorCode):
2590 return awsAwsjson11_deserializeErrorUnsupportedCommandException(response, errorBody)
2591
2592 default:
2593 genericError := &smithy.GenericAPIError{
2594 Code: errorCode,
2595 Message: errorMessage,
2596 }
2597 return genericError
2598
2599 }
2600 }
2601
2602 type awsAwsjson11_deserializeOpUntagResource struct {
2603 }
2604
2605 func (*awsAwsjson11_deserializeOpUntagResource) ID() string {
2606 return "OperationDeserializer"
2607 }
2608
2609 func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2610 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2611 ) {
2612 out, metadata, err = next.HandleDeserialize(ctx, in)
2613 if err != nil {
2614 return out, metadata, err
2615 }
2616
2617 response, ok := out.RawResponse.(*smithyhttp.Response)
2618 if !ok {
2619 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2620 }
2621
2622 if response.StatusCode < 200 || response.StatusCode >= 300 {
2623 return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata)
2624 }
2625 output := &UntagResourceOutput{}
2626 out.Result = output
2627
2628 var buff [1024]byte
2629 ringBuffer := smithyio.NewRingBuffer(buff[:])
2630
2631 body := io.TeeReader(response.Body, ringBuffer)
2632 decoder := json.NewDecoder(body)
2633 decoder.UseNumber()
2634 var shape interface{}
2635 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2636 var snapshot bytes.Buffer
2637 io.Copy(&snapshot, ringBuffer)
2638 err = &smithy.DeserializationError{
2639 Err: fmt.Errorf("failed to decode response body, %w", err),
2640 Snapshot: snapshot.Bytes(),
2641 }
2642 return out, metadata, err
2643 }
2644
2645 err = awsAwsjson11_deserializeOpDocumentUntagResourceOutput(&output, shape)
2646 if err != nil {
2647 var snapshot bytes.Buffer
2648 io.Copy(&snapshot, ringBuffer)
2649 err = &smithy.DeserializationError{
2650 Err: fmt.Errorf("failed to decode response body, %w", err),
2651 Snapshot: snapshot.Bytes(),
2652 }
2653 return out, metadata, err
2654 }
2655
2656 return out, metadata, err
2657 }
2658
2659 func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2660 var errorBuffer bytes.Buffer
2661 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2662 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2663 }
2664 errorBody := bytes.NewReader(errorBuffer.Bytes())
2665
2666 errorCode := "UnknownError"
2667 errorMessage := errorCode
2668
2669 headerCode := response.Header.Get("X-Amzn-ErrorType")
2670 if len(headerCode) != 0 {
2671 errorCode = restjson.SanitizeErrorCode(headerCode)
2672 }
2673
2674 var buff [1024]byte
2675 ringBuffer := smithyio.NewRingBuffer(buff[:])
2676
2677 body := io.TeeReader(errorBody, ringBuffer)
2678 decoder := json.NewDecoder(body)
2679 decoder.UseNumber()
2680 jsonCode, message, err := restjson.GetErrorInfo(decoder)
2681 if err != nil {
2682 var snapshot bytes.Buffer
2683 io.Copy(&snapshot, ringBuffer)
2684 err = &smithy.DeserializationError{
2685 Err: fmt.Errorf("failed to decode response body, %w", err),
2686 Snapshot: snapshot.Bytes(),
2687 }
2688 return err
2689 }
2690
2691 errorBody.Seek(0, io.SeekStart)
2692 if len(headerCode) == 0 && len(jsonCode) != 0 {
2693 errorCode = restjson.SanitizeErrorCode(jsonCode)
2694 }
2695 if len(message) != 0 {
2696 errorMessage = message
2697 }
2698
2699 switch {
2700 case strings.EqualFold("InvalidParameterException", errorCode):
2701 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
2702
2703 case strings.EqualFold("InvalidTagParameterException", errorCode):
2704 return awsAwsjson11_deserializeErrorInvalidTagParameterException(response, errorBody)
2705
2706 case strings.EqualFold("RepositoryNotFoundException", errorCode):
2707 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
2708
2709 case strings.EqualFold("ServerException", errorCode):
2710 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
2711
2712 case strings.EqualFold("TooManyTagsException", errorCode):
2713 return awsAwsjson11_deserializeErrorTooManyTagsException(response, errorBody)
2714
2715 case strings.EqualFold("UnsupportedCommandException", errorCode):
2716 return awsAwsjson11_deserializeErrorUnsupportedCommandException(response, errorBody)
2717
2718 default:
2719 genericError := &smithy.GenericAPIError{
2720 Code: errorCode,
2721 Message: errorMessage,
2722 }
2723 return genericError
2724
2725 }
2726 }
2727
2728 type awsAwsjson11_deserializeOpUploadLayerPart struct {
2729 }
2730
2731 func (*awsAwsjson11_deserializeOpUploadLayerPart) ID() string {
2732 return "OperationDeserializer"
2733 }
2734
2735 func (m *awsAwsjson11_deserializeOpUploadLayerPart) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2736 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2737 ) {
2738 out, metadata, err = next.HandleDeserialize(ctx, in)
2739 if err != nil {
2740 return out, metadata, err
2741 }
2742
2743 response, ok := out.RawResponse.(*smithyhttp.Response)
2744 if !ok {
2745 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2746 }
2747
2748 if response.StatusCode < 200 || response.StatusCode >= 300 {
2749 return out, metadata, awsAwsjson11_deserializeOpErrorUploadLayerPart(response, &metadata)
2750 }
2751 output := &UploadLayerPartOutput{}
2752 out.Result = output
2753
2754 var buff [1024]byte
2755 ringBuffer := smithyio.NewRingBuffer(buff[:])
2756
2757 body := io.TeeReader(response.Body, ringBuffer)
2758 decoder := json.NewDecoder(body)
2759 decoder.UseNumber()
2760 var shape interface{}
2761 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2762 var snapshot bytes.Buffer
2763 io.Copy(&snapshot, ringBuffer)
2764 err = &smithy.DeserializationError{
2765 Err: fmt.Errorf("failed to decode response body, %w", err),
2766 Snapshot: snapshot.Bytes(),
2767 }
2768 return out, metadata, err
2769 }
2770
2771 err = awsAwsjson11_deserializeOpDocumentUploadLayerPartOutput(&output, shape)
2772 if err != nil {
2773 var snapshot bytes.Buffer
2774 io.Copy(&snapshot, ringBuffer)
2775 err = &smithy.DeserializationError{
2776 Err: fmt.Errorf("failed to decode response body, %w", err),
2777 Snapshot: snapshot.Bytes(),
2778 }
2779 return out, metadata, err
2780 }
2781
2782 return out, metadata, err
2783 }
2784
2785 func awsAwsjson11_deserializeOpErrorUploadLayerPart(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2786 var errorBuffer bytes.Buffer
2787 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2788 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2789 }
2790 errorBody := bytes.NewReader(errorBuffer.Bytes())
2791
2792 errorCode := "UnknownError"
2793 errorMessage := errorCode
2794
2795 headerCode := response.Header.Get("X-Amzn-ErrorType")
2796 if len(headerCode) != 0 {
2797 errorCode = restjson.SanitizeErrorCode(headerCode)
2798 }
2799
2800 var buff [1024]byte
2801 ringBuffer := smithyio.NewRingBuffer(buff[:])
2802
2803 body := io.TeeReader(errorBody, ringBuffer)
2804 decoder := json.NewDecoder(body)
2805 decoder.UseNumber()
2806 jsonCode, message, err := restjson.GetErrorInfo(decoder)
2807 if err != nil {
2808 var snapshot bytes.Buffer
2809 io.Copy(&snapshot, ringBuffer)
2810 err = &smithy.DeserializationError{
2811 Err: fmt.Errorf("failed to decode response body, %w", err),
2812 Snapshot: snapshot.Bytes(),
2813 }
2814 return err
2815 }
2816
2817 errorBody.Seek(0, io.SeekStart)
2818 if len(headerCode) == 0 && len(jsonCode) != 0 {
2819 errorCode = restjson.SanitizeErrorCode(jsonCode)
2820 }
2821 if len(message) != 0 {
2822 errorMessage = message
2823 }
2824
2825 switch {
2826 case strings.EqualFold("InvalidLayerPartException", errorCode):
2827 return awsAwsjson11_deserializeErrorInvalidLayerPartException(response, errorBody)
2828
2829 case strings.EqualFold("InvalidParameterException", errorCode):
2830 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
2831
2832 case strings.EqualFold("LimitExceededException", errorCode):
2833 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
2834
2835 case strings.EqualFold("RegistryNotFoundException", errorCode):
2836 return awsAwsjson11_deserializeErrorRegistryNotFoundException(response, errorBody)
2837
2838 case strings.EqualFold("RepositoryNotFoundException", errorCode):
2839 return awsAwsjson11_deserializeErrorRepositoryNotFoundException(response, errorBody)
2840
2841 case strings.EqualFold("ServerException", errorCode):
2842 return awsAwsjson11_deserializeErrorServerException(response, errorBody)
2843
2844 case strings.EqualFold("UnsupportedCommandException", errorCode):
2845 return awsAwsjson11_deserializeErrorUnsupportedCommandException(response, errorBody)
2846
2847 case strings.EqualFold("UploadNotFoundException", errorCode):
2848 return awsAwsjson11_deserializeErrorUploadNotFoundException(response, errorBody)
2849
2850 default:
2851 genericError := &smithy.GenericAPIError{
2852 Code: errorCode,
2853 Message: errorMessage,
2854 }
2855 return genericError
2856
2857 }
2858 }
2859
2860 func awsAwsjson11_deserializeErrorEmptyUploadException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
2861 var buff [1024]byte
2862 ringBuffer := smithyio.NewRingBuffer(buff[:])
2863
2864 body := io.TeeReader(errorBody, ringBuffer)
2865 decoder := json.NewDecoder(body)
2866 decoder.UseNumber()
2867 var shape interface{}
2868 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2869 var snapshot bytes.Buffer
2870 io.Copy(&snapshot, ringBuffer)
2871 err = &smithy.DeserializationError{
2872 Err: fmt.Errorf("failed to decode response body, %w", err),
2873 Snapshot: snapshot.Bytes(),
2874 }
2875 return err
2876 }
2877
2878 output := &types.EmptyUploadException{}
2879 err := awsAwsjson11_deserializeDocumentEmptyUploadException(&output, shape)
2880
2881 if err != nil {
2882 var snapshot bytes.Buffer
2883 io.Copy(&snapshot, ringBuffer)
2884 err = &smithy.DeserializationError{
2885 Err: fmt.Errorf("failed to decode response body, %w", err),
2886 Snapshot: snapshot.Bytes(),
2887 }
2888 return err
2889 }
2890
2891 errorBody.Seek(0, io.SeekStart)
2892 return output
2893 }
2894
2895 func awsAwsjson11_deserializeErrorImageAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
2896 var buff [1024]byte
2897 ringBuffer := smithyio.NewRingBuffer(buff[:])
2898
2899 body := io.TeeReader(errorBody, ringBuffer)
2900 decoder := json.NewDecoder(body)
2901 decoder.UseNumber()
2902 var shape interface{}
2903 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2904 var snapshot bytes.Buffer
2905 io.Copy(&snapshot, ringBuffer)
2906 err = &smithy.DeserializationError{
2907 Err: fmt.Errorf("failed to decode response body, %w", err),
2908 Snapshot: snapshot.Bytes(),
2909 }
2910 return err
2911 }
2912
2913 output := &types.ImageAlreadyExistsException{}
2914 err := awsAwsjson11_deserializeDocumentImageAlreadyExistsException(&output, shape)
2915
2916 if err != nil {
2917 var snapshot bytes.Buffer
2918 io.Copy(&snapshot, ringBuffer)
2919 err = &smithy.DeserializationError{
2920 Err: fmt.Errorf("failed to decode response body, %w", err),
2921 Snapshot: snapshot.Bytes(),
2922 }
2923 return err
2924 }
2925
2926 errorBody.Seek(0, io.SeekStart)
2927 return output
2928 }
2929
2930 func awsAwsjson11_deserializeErrorImageDigestDoesNotMatchException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
2931 var buff [1024]byte
2932 ringBuffer := smithyio.NewRingBuffer(buff[:])
2933
2934 body := io.TeeReader(errorBody, ringBuffer)
2935 decoder := json.NewDecoder(body)
2936 decoder.UseNumber()
2937 var shape interface{}
2938 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2939 var snapshot bytes.Buffer
2940 io.Copy(&snapshot, ringBuffer)
2941 err = &smithy.DeserializationError{
2942 Err: fmt.Errorf("failed to decode response body, %w", err),
2943 Snapshot: snapshot.Bytes(),
2944 }
2945 return err
2946 }
2947
2948 output := &types.ImageDigestDoesNotMatchException{}
2949 err := awsAwsjson11_deserializeDocumentImageDigestDoesNotMatchException(&output, shape)
2950
2951 if err != nil {
2952 var snapshot bytes.Buffer
2953 io.Copy(&snapshot, ringBuffer)
2954 err = &smithy.DeserializationError{
2955 Err: fmt.Errorf("failed to decode response body, %w", err),
2956 Snapshot: snapshot.Bytes(),
2957 }
2958 return err
2959 }
2960
2961 errorBody.Seek(0, io.SeekStart)
2962 return output
2963 }
2964
2965 func awsAwsjson11_deserializeErrorImageNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
2966 var buff [1024]byte
2967 ringBuffer := smithyio.NewRingBuffer(buff[:])
2968
2969 body := io.TeeReader(errorBody, ringBuffer)
2970 decoder := json.NewDecoder(body)
2971 decoder.UseNumber()
2972 var shape interface{}
2973 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2974 var snapshot bytes.Buffer
2975 io.Copy(&snapshot, ringBuffer)
2976 err = &smithy.DeserializationError{
2977 Err: fmt.Errorf("failed to decode response body, %w", err),
2978 Snapshot: snapshot.Bytes(),
2979 }
2980 return err
2981 }
2982
2983 output := &types.ImageNotFoundException{}
2984 err := awsAwsjson11_deserializeDocumentImageNotFoundException(&output, shape)
2985
2986 if err != nil {
2987 var snapshot bytes.Buffer
2988 io.Copy(&snapshot, ringBuffer)
2989 err = &smithy.DeserializationError{
2990 Err: fmt.Errorf("failed to decode response body, %w", err),
2991 Snapshot: snapshot.Bytes(),
2992 }
2993 return err
2994 }
2995
2996 errorBody.Seek(0, io.SeekStart)
2997 return output
2998 }
2999
3000 func awsAwsjson11_deserializeErrorImageTagAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
3001 var buff [1024]byte
3002 ringBuffer := smithyio.NewRingBuffer(buff[:])
3003
3004 body := io.TeeReader(errorBody, ringBuffer)
3005 decoder := json.NewDecoder(body)
3006 decoder.UseNumber()
3007 var shape interface{}
3008 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3009 var snapshot bytes.Buffer
3010 io.Copy(&snapshot, ringBuffer)
3011 err = &smithy.DeserializationError{
3012 Err: fmt.Errorf("failed to decode response body, %w", err),
3013 Snapshot: snapshot.Bytes(),
3014 }
3015 return err
3016 }
3017
3018 output := &types.ImageTagAlreadyExistsException{}
3019 err := awsAwsjson11_deserializeDocumentImageTagAlreadyExistsException(&output, shape)
3020
3021 if err != nil {
3022 var snapshot bytes.Buffer
3023 io.Copy(&snapshot, ringBuffer)
3024 err = &smithy.DeserializationError{
3025 Err: fmt.Errorf("failed to decode response body, %w", err),
3026 Snapshot: snapshot.Bytes(),
3027 }
3028 return err
3029 }
3030
3031 errorBody.Seek(0, io.SeekStart)
3032 return output
3033 }
3034
3035 func awsAwsjson11_deserializeErrorInvalidLayerException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
3036 var buff [1024]byte
3037 ringBuffer := smithyio.NewRingBuffer(buff[:])
3038
3039 body := io.TeeReader(errorBody, ringBuffer)
3040 decoder := json.NewDecoder(body)
3041 decoder.UseNumber()
3042 var shape interface{}
3043 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3044 var snapshot bytes.Buffer
3045 io.Copy(&snapshot, ringBuffer)
3046 err = &smithy.DeserializationError{
3047 Err: fmt.Errorf("failed to decode response body, %w", err),
3048 Snapshot: snapshot.Bytes(),
3049 }
3050 return err
3051 }
3052
3053 output := &types.InvalidLayerException{}
3054 err := awsAwsjson11_deserializeDocumentInvalidLayerException(&output, shape)
3055
3056 if err != nil {
3057 var snapshot bytes.Buffer
3058 io.Copy(&snapshot, ringBuffer)
3059 err = &smithy.DeserializationError{
3060 Err: fmt.Errorf("failed to decode response body, %w", err),
3061 Snapshot: snapshot.Bytes(),
3062 }
3063 return err
3064 }
3065
3066 errorBody.Seek(0, io.SeekStart)
3067 return output
3068 }
3069
3070 func awsAwsjson11_deserializeErrorInvalidLayerPartException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
3071 var buff [1024]byte
3072 ringBuffer := smithyio.NewRingBuffer(buff[:])
3073
3074 body := io.TeeReader(errorBody, ringBuffer)
3075 decoder := json.NewDecoder(body)
3076 decoder.UseNumber()
3077 var shape interface{}
3078 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3079 var snapshot bytes.Buffer
3080 io.Copy(&snapshot, ringBuffer)
3081 err = &smithy.DeserializationError{
3082 Err: fmt.Errorf("failed to decode response body, %w", err),
3083 Snapshot: snapshot.Bytes(),
3084 }
3085 return err
3086 }
3087
3088 output := &types.InvalidLayerPartException{}
3089 err := awsAwsjson11_deserializeDocumentInvalidLayerPartException(&output, shape)
3090
3091 if err != nil {
3092 var snapshot bytes.Buffer
3093 io.Copy(&snapshot, ringBuffer)
3094 err = &smithy.DeserializationError{
3095 Err: fmt.Errorf("failed to decode response body, %w", err),
3096 Snapshot: snapshot.Bytes(),
3097 }
3098 return err
3099 }
3100
3101 errorBody.Seek(0, io.SeekStart)
3102 return output
3103 }
3104
3105 func awsAwsjson11_deserializeErrorInvalidParameterException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
3106 var buff [1024]byte
3107 ringBuffer := smithyio.NewRingBuffer(buff[:])
3108
3109 body := io.TeeReader(errorBody, ringBuffer)
3110 decoder := json.NewDecoder(body)
3111 decoder.UseNumber()
3112 var shape interface{}
3113 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3114 var snapshot bytes.Buffer
3115 io.Copy(&snapshot, ringBuffer)
3116 err = &smithy.DeserializationError{
3117 Err: fmt.Errorf("failed to decode response body, %w", err),
3118 Snapshot: snapshot.Bytes(),
3119 }
3120 return err
3121 }
3122
3123 output := &types.InvalidParameterException{}
3124 err := awsAwsjson11_deserializeDocumentInvalidParameterException(&output, shape)
3125
3126 if err != nil {
3127 var snapshot bytes.Buffer
3128 io.Copy(&snapshot, ringBuffer)
3129 err = &smithy.DeserializationError{
3130 Err: fmt.Errorf("failed to decode response body, %w", err),
3131 Snapshot: snapshot.Bytes(),
3132 }
3133 return err
3134 }
3135
3136 errorBody.Seek(0, io.SeekStart)
3137 return output
3138 }
3139
3140 func awsAwsjson11_deserializeErrorInvalidTagParameterException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
3141 var buff [1024]byte
3142 ringBuffer := smithyio.NewRingBuffer(buff[:])
3143
3144 body := io.TeeReader(errorBody, ringBuffer)
3145 decoder := json.NewDecoder(body)
3146 decoder.UseNumber()
3147 var shape interface{}
3148 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3149 var snapshot bytes.Buffer
3150 io.Copy(&snapshot, ringBuffer)
3151 err = &smithy.DeserializationError{
3152 Err: fmt.Errorf("failed to decode response body, %w", err),
3153 Snapshot: snapshot.Bytes(),
3154 }
3155 return err
3156 }
3157
3158 output := &types.InvalidTagParameterException{}
3159 err := awsAwsjson11_deserializeDocumentInvalidTagParameterException(&output, shape)
3160
3161 if err != nil {
3162 var snapshot bytes.Buffer
3163 io.Copy(&snapshot, ringBuffer)
3164 err = &smithy.DeserializationError{
3165 Err: fmt.Errorf("failed to decode response body, %w", err),
3166 Snapshot: snapshot.Bytes(),
3167 }
3168 return err
3169 }
3170
3171 errorBody.Seek(0, io.SeekStart)
3172 return output
3173 }
3174
3175 func awsAwsjson11_deserializeErrorLayerAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
3176 var buff [1024]byte
3177 ringBuffer := smithyio.NewRingBuffer(buff[:])
3178
3179 body := io.TeeReader(errorBody, ringBuffer)
3180 decoder := json.NewDecoder(body)
3181 decoder.UseNumber()
3182 var shape interface{}
3183 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3184 var snapshot bytes.Buffer
3185 io.Copy(&snapshot, ringBuffer)
3186 err = &smithy.DeserializationError{
3187 Err: fmt.Errorf("failed to decode response body, %w", err),
3188 Snapshot: snapshot.Bytes(),
3189 }
3190 return err
3191 }
3192
3193 output := &types.LayerAlreadyExistsException{}
3194 err := awsAwsjson11_deserializeDocumentLayerAlreadyExistsException(&output, shape)
3195
3196 if err != nil {
3197 var snapshot bytes.Buffer
3198 io.Copy(&snapshot, ringBuffer)
3199 err = &smithy.DeserializationError{
3200 Err: fmt.Errorf("failed to decode response body, %w", err),
3201 Snapshot: snapshot.Bytes(),
3202 }
3203 return err
3204 }
3205
3206 errorBody.Seek(0, io.SeekStart)
3207 return output
3208 }
3209
3210 func awsAwsjson11_deserializeErrorLayerPartTooSmallException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
3211 var buff [1024]byte
3212 ringBuffer := smithyio.NewRingBuffer(buff[:])
3213
3214 body := io.TeeReader(errorBody, ringBuffer)
3215 decoder := json.NewDecoder(body)
3216 decoder.UseNumber()
3217 var shape interface{}
3218 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3219 var snapshot bytes.Buffer
3220 io.Copy(&snapshot, ringBuffer)
3221 err = &smithy.DeserializationError{
3222 Err: fmt.Errorf("failed to decode response body, %w", err),
3223 Snapshot: snapshot.Bytes(),
3224 }
3225 return err
3226 }
3227
3228 output := &types.LayerPartTooSmallException{}
3229 err := awsAwsjson11_deserializeDocumentLayerPartTooSmallException(&output, shape)
3230
3231 if err != nil {
3232 var snapshot bytes.Buffer
3233 io.Copy(&snapshot, ringBuffer)
3234 err = &smithy.DeserializationError{
3235 Err: fmt.Errorf("failed to decode response body, %w", err),
3236 Snapshot: snapshot.Bytes(),
3237 }
3238 return err
3239 }
3240
3241 errorBody.Seek(0, io.SeekStart)
3242 return output
3243 }
3244
3245 func awsAwsjson11_deserializeErrorLayersNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
3246 var buff [1024]byte
3247 ringBuffer := smithyio.NewRingBuffer(buff[:])
3248
3249 body := io.TeeReader(errorBody, ringBuffer)
3250 decoder := json.NewDecoder(body)
3251 decoder.UseNumber()
3252 var shape interface{}
3253 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3254 var snapshot bytes.Buffer
3255 io.Copy(&snapshot, ringBuffer)
3256 err = &smithy.DeserializationError{
3257 Err: fmt.Errorf("failed to decode response body, %w", err),
3258 Snapshot: snapshot.Bytes(),
3259 }
3260 return err
3261 }
3262
3263 output := &types.LayersNotFoundException{}
3264 err := awsAwsjson11_deserializeDocumentLayersNotFoundException(&output, shape)
3265
3266 if err != nil {
3267 var snapshot bytes.Buffer
3268 io.Copy(&snapshot, ringBuffer)
3269 err = &smithy.DeserializationError{
3270 Err: fmt.Errorf("failed to decode response body, %w", err),
3271 Snapshot: snapshot.Bytes(),
3272 }
3273 return err
3274 }
3275
3276 errorBody.Seek(0, io.SeekStart)
3277 return output
3278 }
3279
3280 func awsAwsjson11_deserializeErrorLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
3281 var buff [1024]byte
3282 ringBuffer := smithyio.NewRingBuffer(buff[:])
3283
3284 body := io.TeeReader(errorBody, ringBuffer)
3285 decoder := json.NewDecoder(body)
3286 decoder.UseNumber()
3287 var shape interface{}
3288 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3289 var snapshot bytes.Buffer
3290 io.Copy(&snapshot, ringBuffer)
3291 err = &smithy.DeserializationError{
3292 Err: fmt.Errorf("failed to decode response body, %w", err),
3293 Snapshot: snapshot.Bytes(),
3294 }
3295 return err
3296 }
3297
3298 output := &types.LimitExceededException{}
3299 err := awsAwsjson11_deserializeDocumentLimitExceededException(&output, shape)
3300
3301 if err != nil {
3302 var snapshot bytes.Buffer
3303 io.Copy(&snapshot, ringBuffer)
3304 err = &smithy.DeserializationError{
3305 Err: fmt.Errorf("failed to decode response body, %w", err),
3306 Snapshot: snapshot.Bytes(),
3307 }
3308 return err
3309 }
3310
3311 errorBody.Seek(0, io.SeekStart)
3312 return output
3313 }
3314
3315 func awsAwsjson11_deserializeErrorReferencedImagesNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
3316 var buff [1024]byte
3317 ringBuffer := smithyio.NewRingBuffer(buff[:])
3318
3319 body := io.TeeReader(errorBody, 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 err
3331 }
3332
3333 output := &types.ReferencedImagesNotFoundException{}
3334 err := awsAwsjson11_deserializeDocumentReferencedImagesNotFoundException(&output, shape)
3335
3336 if err != nil {
3337 var snapshot bytes.Buffer
3338 io.Copy(&snapshot, ringBuffer)
3339 err = &smithy.DeserializationError{
3340 Err: fmt.Errorf("failed to decode response body, %w", err),
3341 Snapshot: snapshot.Bytes(),
3342 }
3343 return err
3344 }
3345
3346 errorBody.Seek(0, io.SeekStart)
3347 return output
3348 }
3349
3350 func awsAwsjson11_deserializeErrorRegistryNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
3351 var buff [1024]byte
3352 ringBuffer := smithyio.NewRingBuffer(buff[:])
3353
3354 body := io.TeeReader(errorBody, ringBuffer)
3355 decoder := json.NewDecoder(body)
3356 decoder.UseNumber()
3357 var shape interface{}
3358 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3359 var snapshot bytes.Buffer
3360 io.Copy(&snapshot, ringBuffer)
3361 err = &smithy.DeserializationError{
3362 Err: fmt.Errorf("failed to decode response body, %w", err),
3363 Snapshot: snapshot.Bytes(),
3364 }
3365 return err
3366 }
3367
3368 output := &types.RegistryNotFoundException{}
3369 err := awsAwsjson11_deserializeDocumentRegistryNotFoundException(&output, shape)
3370
3371 if err != nil {
3372 var snapshot bytes.Buffer
3373 io.Copy(&snapshot, ringBuffer)
3374 err = &smithy.DeserializationError{
3375 Err: fmt.Errorf("failed to decode response body, %w", err),
3376 Snapshot: snapshot.Bytes(),
3377 }
3378 return err
3379 }
3380
3381 errorBody.Seek(0, io.SeekStart)
3382 return output
3383 }
3384
3385 func awsAwsjson11_deserializeErrorRepositoryAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
3386 var buff [1024]byte
3387 ringBuffer := smithyio.NewRingBuffer(buff[:])
3388
3389 body := io.TeeReader(errorBody, ringBuffer)
3390 decoder := json.NewDecoder(body)
3391 decoder.UseNumber()
3392 var shape interface{}
3393 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3394 var snapshot bytes.Buffer
3395 io.Copy(&snapshot, ringBuffer)
3396 err = &smithy.DeserializationError{
3397 Err: fmt.Errorf("failed to decode response body, %w", err),
3398 Snapshot: snapshot.Bytes(),
3399 }
3400 return err
3401 }
3402
3403 output := &types.RepositoryAlreadyExistsException{}
3404 err := awsAwsjson11_deserializeDocumentRepositoryAlreadyExistsException(&output, shape)
3405
3406 if err != nil {
3407 var snapshot bytes.Buffer
3408 io.Copy(&snapshot, ringBuffer)
3409 err = &smithy.DeserializationError{
3410 Err: fmt.Errorf("failed to decode response body, %w", err),
3411 Snapshot: snapshot.Bytes(),
3412 }
3413 return err
3414 }
3415
3416 errorBody.Seek(0, io.SeekStart)
3417 return output
3418 }
3419
3420 func awsAwsjson11_deserializeErrorRepositoryCatalogDataNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
3421 var buff [1024]byte
3422 ringBuffer := smithyio.NewRingBuffer(buff[:])
3423
3424 body := io.TeeReader(errorBody, ringBuffer)
3425 decoder := json.NewDecoder(body)
3426 decoder.UseNumber()
3427 var shape interface{}
3428 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3429 var snapshot bytes.Buffer
3430 io.Copy(&snapshot, ringBuffer)
3431 err = &smithy.DeserializationError{
3432 Err: fmt.Errorf("failed to decode response body, %w", err),
3433 Snapshot: snapshot.Bytes(),
3434 }
3435 return err
3436 }
3437
3438 output := &types.RepositoryCatalogDataNotFoundException{}
3439 err := awsAwsjson11_deserializeDocumentRepositoryCatalogDataNotFoundException(&output, shape)
3440
3441 if err != nil {
3442 var snapshot bytes.Buffer
3443 io.Copy(&snapshot, ringBuffer)
3444 err = &smithy.DeserializationError{
3445 Err: fmt.Errorf("failed to decode response body, %w", err),
3446 Snapshot: snapshot.Bytes(),
3447 }
3448 return err
3449 }
3450
3451 errorBody.Seek(0, io.SeekStart)
3452 return output
3453 }
3454
3455 func awsAwsjson11_deserializeErrorRepositoryNotEmptyException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
3456 var buff [1024]byte
3457 ringBuffer := smithyio.NewRingBuffer(buff[:])
3458
3459 body := io.TeeReader(errorBody, ringBuffer)
3460 decoder := json.NewDecoder(body)
3461 decoder.UseNumber()
3462 var shape interface{}
3463 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3464 var snapshot bytes.Buffer
3465 io.Copy(&snapshot, ringBuffer)
3466 err = &smithy.DeserializationError{
3467 Err: fmt.Errorf("failed to decode response body, %w", err),
3468 Snapshot: snapshot.Bytes(),
3469 }
3470 return err
3471 }
3472
3473 output := &types.RepositoryNotEmptyException{}
3474 err := awsAwsjson11_deserializeDocumentRepositoryNotEmptyException(&output, shape)
3475
3476 if err != nil {
3477 var snapshot bytes.Buffer
3478 io.Copy(&snapshot, ringBuffer)
3479 err = &smithy.DeserializationError{
3480 Err: fmt.Errorf("failed to decode response body, %w", err),
3481 Snapshot: snapshot.Bytes(),
3482 }
3483 return err
3484 }
3485
3486 errorBody.Seek(0, io.SeekStart)
3487 return output
3488 }
3489
3490 func awsAwsjson11_deserializeErrorRepositoryNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
3491 var buff [1024]byte
3492 ringBuffer := smithyio.NewRingBuffer(buff[:])
3493
3494 body := io.TeeReader(errorBody, ringBuffer)
3495 decoder := json.NewDecoder(body)
3496 decoder.UseNumber()
3497 var shape interface{}
3498 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3499 var snapshot bytes.Buffer
3500 io.Copy(&snapshot, ringBuffer)
3501 err = &smithy.DeserializationError{
3502 Err: fmt.Errorf("failed to decode response body, %w", err),
3503 Snapshot: snapshot.Bytes(),
3504 }
3505 return err
3506 }
3507
3508 output := &types.RepositoryNotFoundException{}
3509 err := awsAwsjson11_deserializeDocumentRepositoryNotFoundException(&output, shape)
3510
3511 if err != nil {
3512 var snapshot bytes.Buffer
3513 io.Copy(&snapshot, ringBuffer)
3514 err = &smithy.DeserializationError{
3515 Err: fmt.Errorf("failed to decode response body, %w", err),
3516 Snapshot: snapshot.Bytes(),
3517 }
3518 return err
3519 }
3520
3521 errorBody.Seek(0, io.SeekStart)
3522 return output
3523 }
3524
3525 func awsAwsjson11_deserializeErrorRepositoryPolicyNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
3526 var buff [1024]byte
3527 ringBuffer := smithyio.NewRingBuffer(buff[:])
3528
3529 body := io.TeeReader(errorBody, ringBuffer)
3530 decoder := json.NewDecoder(body)
3531 decoder.UseNumber()
3532 var shape interface{}
3533 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3534 var snapshot bytes.Buffer
3535 io.Copy(&snapshot, ringBuffer)
3536 err = &smithy.DeserializationError{
3537 Err: fmt.Errorf("failed to decode response body, %w", err),
3538 Snapshot: snapshot.Bytes(),
3539 }
3540 return err
3541 }
3542
3543 output := &types.RepositoryPolicyNotFoundException{}
3544 err := awsAwsjson11_deserializeDocumentRepositoryPolicyNotFoundException(&output, shape)
3545
3546 if err != nil {
3547 var snapshot bytes.Buffer
3548 io.Copy(&snapshot, ringBuffer)
3549 err = &smithy.DeserializationError{
3550 Err: fmt.Errorf("failed to decode response body, %w", err),
3551 Snapshot: snapshot.Bytes(),
3552 }
3553 return err
3554 }
3555
3556 errorBody.Seek(0, io.SeekStart)
3557 return output
3558 }
3559
3560 func awsAwsjson11_deserializeErrorServerException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
3561 var buff [1024]byte
3562 ringBuffer := smithyio.NewRingBuffer(buff[:])
3563
3564 body := io.TeeReader(errorBody, ringBuffer)
3565 decoder := json.NewDecoder(body)
3566 decoder.UseNumber()
3567 var shape interface{}
3568 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3569 var snapshot bytes.Buffer
3570 io.Copy(&snapshot, ringBuffer)
3571 err = &smithy.DeserializationError{
3572 Err: fmt.Errorf("failed to decode response body, %w", err),
3573 Snapshot: snapshot.Bytes(),
3574 }
3575 return err
3576 }
3577
3578 output := &types.ServerException{}
3579 err := awsAwsjson11_deserializeDocumentServerException(&output, shape)
3580
3581 if err != nil {
3582 var snapshot bytes.Buffer
3583 io.Copy(&snapshot, ringBuffer)
3584 err = &smithy.DeserializationError{
3585 Err: fmt.Errorf("failed to decode response body, %w", err),
3586 Snapshot: snapshot.Bytes(),
3587 }
3588 return err
3589 }
3590
3591 errorBody.Seek(0, io.SeekStart)
3592 return output
3593 }
3594
3595 func awsAwsjson11_deserializeErrorTooManyTagsException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
3596 var buff [1024]byte
3597 ringBuffer := smithyio.NewRingBuffer(buff[:])
3598
3599 body := io.TeeReader(errorBody, ringBuffer)
3600 decoder := json.NewDecoder(body)
3601 decoder.UseNumber()
3602 var shape interface{}
3603 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3604 var snapshot bytes.Buffer
3605 io.Copy(&snapshot, ringBuffer)
3606 err = &smithy.DeserializationError{
3607 Err: fmt.Errorf("failed to decode response body, %w", err),
3608 Snapshot: snapshot.Bytes(),
3609 }
3610 return err
3611 }
3612
3613 output := &types.TooManyTagsException{}
3614 err := awsAwsjson11_deserializeDocumentTooManyTagsException(&output, shape)
3615
3616 if err != nil {
3617 var snapshot bytes.Buffer
3618 io.Copy(&snapshot, ringBuffer)
3619 err = &smithy.DeserializationError{
3620 Err: fmt.Errorf("failed to decode response body, %w", err),
3621 Snapshot: snapshot.Bytes(),
3622 }
3623 return err
3624 }
3625
3626 errorBody.Seek(0, io.SeekStart)
3627 return output
3628 }
3629
3630 func awsAwsjson11_deserializeErrorUnsupportedCommandException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
3631 var buff [1024]byte
3632 ringBuffer := smithyio.NewRingBuffer(buff[:])
3633
3634 body := io.TeeReader(errorBody, ringBuffer)
3635 decoder := json.NewDecoder(body)
3636 decoder.UseNumber()
3637 var shape interface{}
3638 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3639 var snapshot bytes.Buffer
3640 io.Copy(&snapshot, ringBuffer)
3641 err = &smithy.DeserializationError{
3642 Err: fmt.Errorf("failed to decode response body, %w", err),
3643 Snapshot: snapshot.Bytes(),
3644 }
3645 return err
3646 }
3647
3648 output := &types.UnsupportedCommandException{}
3649 err := awsAwsjson11_deserializeDocumentUnsupportedCommandException(&output, shape)
3650
3651 if err != nil {
3652 var snapshot bytes.Buffer
3653 io.Copy(&snapshot, ringBuffer)
3654 err = &smithy.DeserializationError{
3655 Err: fmt.Errorf("failed to decode response body, %w", err),
3656 Snapshot: snapshot.Bytes(),
3657 }
3658 return err
3659 }
3660
3661 errorBody.Seek(0, io.SeekStart)
3662 return output
3663 }
3664
3665 func awsAwsjson11_deserializeErrorUploadNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
3666 var buff [1024]byte
3667 ringBuffer := smithyio.NewRingBuffer(buff[:])
3668
3669 body := io.TeeReader(errorBody, ringBuffer)
3670 decoder := json.NewDecoder(body)
3671 decoder.UseNumber()
3672 var shape interface{}
3673 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3674 var snapshot bytes.Buffer
3675 io.Copy(&snapshot, ringBuffer)
3676 err = &smithy.DeserializationError{
3677 Err: fmt.Errorf("failed to decode response body, %w", err),
3678 Snapshot: snapshot.Bytes(),
3679 }
3680 return err
3681 }
3682
3683 output := &types.UploadNotFoundException{}
3684 err := awsAwsjson11_deserializeDocumentUploadNotFoundException(&output, shape)
3685
3686 if err != nil {
3687 var snapshot bytes.Buffer
3688 io.Copy(&snapshot, ringBuffer)
3689 err = &smithy.DeserializationError{
3690 Err: fmt.Errorf("failed to decode response body, %w", err),
3691 Snapshot: snapshot.Bytes(),
3692 }
3693 return err
3694 }
3695
3696 errorBody.Seek(0, io.SeekStart)
3697 return output
3698 }
3699
3700 func awsAwsjson11_deserializeDocumentArchitectureList(v *[]string, value interface{}) error {
3701 if v == nil {
3702 return fmt.Errorf("unexpected nil of type %T", v)
3703 }
3704 if value == nil {
3705 return nil
3706 }
3707
3708 shape, ok := value.([]interface{})
3709 if !ok {
3710 return fmt.Errorf("unexpected JSON type %v", value)
3711 }
3712
3713 var cv []string
3714 if *v == nil {
3715 cv = []string{}
3716 } else {
3717 cv = *v
3718 }
3719
3720 for _, value := range shape {
3721 var col string
3722 if value != nil {
3723 jtv, ok := value.(string)
3724 if !ok {
3725 return fmt.Errorf("expected Architecture to be of type string, got %T instead", value)
3726 }
3727 col = jtv
3728 }
3729 cv = append(cv, col)
3730
3731 }
3732 *v = cv
3733 return nil
3734 }
3735
3736 func awsAwsjson11_deserializeDocumentAuthorizationData(v **types.AuthorizationData, value interface{}) error {
3737 if v == nil {
3738 return fmt.Errorf("unexpected nil of type %T", v)
3739 }
3740 if value == nil {
3741 return nil
3742 }
3743
3744 shape, ok := value.(map[string]interface{})
3745 if !ok {
3746 return fmt.Errorf("unexpected JSON type %v", value)
3747 }
3748
3749 var sv *types.AuthorizationData
3750 if *v == nil {
3751 sv = &types.AuthorizationData{}
3752 } else {
3753 sv = *v
3754 }
3755
3756 for key, value := range shape {
3757 switch key {
3758 case "authorizationToken":
3759 if value != nil {
3760 jtv, ok := value.(string)
3761 if !ok {
3762 return fmt.Errorf("expected Base64 to be of type string, got %T instead", value)
3763 }
3764 sv.AuthorizationToken = ptr.String(jtv)
3765 }
3766
3767 case "expiresAt":
3768 if value != nil {
3769 switch jtv := value.(type) {
3770 case json.Number:
3771 f64, err := jtv.Float64()
3772 if err != nil {
3773 return err
3774 }
3775 sv.ExpiresAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
3776
3777 default:
3778 return fmt.Errorf("expected ExpirationTimestamp to be a JSON Number, got %T instead", value)
3779
3780 }
3781 }
3782
3783 default:
3784 _, _ = key, value
3785
3786 }
3787 }
3788 *v = sv
3789 return nil
3790 }
3791
3792 func awsAwsjson11_deserializeDocumentEmptyUploadException(v **types.EmptyUploadException, value interface{}) error {
3793 if v == nil {
3794 return fmt.Errorf("unexpected nil of type %T", v)
3795 }
3796 if value == nil {
3797 return nil
3798 }
3799
3800 shape, ok := value.(map[string]interface{})
3801 if !ok {
3802 return fmt.Errorf("unexpected JSON type %v", value)
3803 }
3804
3805 var sv *types.EmptyUploadException
3806 if *v == nil {
3807 sv = &types.EmptyUploadException{}
3808 } else {
3809 sv = *v
3810 }
3811
3812 for key, value := range shape {
3813 switch key {
3814 case "message":
3815 if value != nil {
3816 jtv, ok := value.(string)
3817 if !ok {
3818 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
3819 }
3820 sv.Message = ptr.String(jtv)
3821 }
3822
3823 default:
3824 _, _ = key, value
3825
3826 }
3827 }
3828 *v = sv
3829 return nil
3830 }
3831
3832 func awsAwsjson11_deserializeDocumentImage(v **types.Image, value interface{}) error {
3833 if v == nil {
3834 return fmt.Errorf("unexpected nil of type %T", v)
3835 }
3836 if value == nil {
3837 return nil
3838 }
3839
3840 shape, ok := value.(map[string]interface{})
3841 if !ok {
3842 return fmt.Errorf("unexpected JSON type %v", value)
3843 }
3844
3845 var sv *types.Image
3846 if *v == nil {
3847 sv = &types.Image{}
3848 } else {
3849 sv = *v
3850 }
3851
3852 for key, value := range shape {
3853 switch key {
3854 case "imageId":
3855 if err := awsAwsjson11_deserializeDocumentImageIdentifier(&sv.ImageId, value); err != nil {
3856 return err
3857 }
3858
3859 case "imageManifest":
3860 if value != nil {
3861 jtv, ok := value.(string)
3862 if !ok {
3863 return fmt.Errorf("expected ImageManifest to be of type string, got %T instead", value)
3864 }
3865 sv.ImageManifest = ptr.String(jtv)
3866 }
3867
3868 case "imageManifestMediaType":
3869 if value != nil {
3870 jtv, ok := value.(string)
3871 if !ok {
3872 return fmt.Errorf("expected MediaType to be of type string, got %T instead", value)
3873 }
3874 sv.ImageManifestMediaType = ptr.String(jtv)
3875 }
3876
3877 case "registryId":
3878 if value != nil {
3879 jtv, ok := value.(string)
3880 if !ok {
3881 return fmt.Errorf("expected RegistryIdOrAlias to be of type string, got %T instead", value)
3882 }
3883 sv.RegistryId = ptr.String(jtv)
3884 }
3885
3886 case "repositoryName":
3887 if value != nil {
3888 jtv, ok := value.(string)
3889 if !ok {
3890 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
3891 }
3892 sv.RepositoryName = ptr.String(jtv)
3893 }
3894
3895 default:
3896 _, _ = key, value
3897
3898 }
3899 }
3900 *v = sv
3901 return nil
3902 }
3903
3904 func awsAwsjson11_deserializeDocumentImageAlreadyExistsException(v **types.ImageAlreadyExistsException, value interface{}) error {
3905 if v == nil {
3906 return fmt.Errorf("unexpected nil of type %T", v)
3907 }
3908 if value == nil {
3909 return nil
3910 }
3911
3912 shape, ok := value.(map[string]interface{})
3913 if !ok {
3914 return fmt.Errorf("unexpected JSON type %v", value)
3915 }
3916
3917 var sv *types.ImageAlreadyExistsException
3918 if *v == nil {
3919 sv = &types.ImageAlreadyExistsException{}
3920 } else {
3921 sv = *v
3922 }
3923
3924 for key, value := range shape {
3925 switch key {
3926 case "message":
3927 if value != nil {
3928 jtv, ok := value.(string)
3929 if !ok {
3930 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
3931 }
3932 sv.Message = ptr.String(jtv)
3933 }
3934
3935 default:
3936 _, _ = key, value
3937
3938 }
3939 }
3940 *v = sv
3941 return nil
3942 }
3943
3944 func awsAwsjson11_deserializeDocumentImageDetail(v **types.ImageDetail, value interface{}) error {
3945 if v == nil {
3946 return fmt.Errorf("unexpected nil of type %T", v)
3947 }
3948 if value == nil {
3949 return nil
3950 }
3951
3952 shape, ok := value.(map[string]interface{})
3953 if !ok {
3954 return fmt.Errorf("unexpected JSON type %v", value)
3955 }
3956
3957 var sv *types.ImageDetail
3958 if *v == nil {
3959 sv = &types.ImageDetail{}
3960 } else {
3961 sv = *v
3962 }
3963
3964 for key, value := range shape {
3965 switch key {
3966 case "artifactMediaType":
3967 if value != nil {
3968 jtv, ok := value.(string)
3969 if !ok {
3970 return fmt.Errorf("expected MediaType to be of type string, got %T instead", value)
3971 }
3972 sv.ArtifactMediaType = ptr.String(jtv)
3973 }
3974
3975 case "imageDigest":
3976 if value != nil {
3977 jtv, ok := value.(string)
3978 if !ok {
3979 return fmt.Errorf("expected ImageDigest to be of type string, got %T instead", value)
3980 }
3981 sv.ImageDigest = ptr.String(jtv)
3982 }
3983
3984 case "imageManifestMediaType":
3985 if value != nil {
3986 jtv, ok := value.(string)
3987 if !ok {
3988 return fmt.Errorf("expected MediaType to be of type string, got %T instead", value)
3989 }
3990 sv.ImageManifestMediaType = ptr.String(jtv)
3991 }
3992
3993 case "imagePushedAt":
3994 if value != nil {
3995 switch jtv := value.(type) {
3996 case json.Number:
3997 f64, err := jtv.Float64()
3998 if err != nil {
3999 return err
4000 }
4001 sv.ImagePushedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
4002
4003 default:
4004 return fmt.Errorf("expected PushTimestamp to be a JSON Number, got %T instead", value)
4005
4006 }
4007 }
4008
4009 case "imageSizeInBytes":
4010 if value != nil {
4011 jtv, ok := value.(json.Number)
4012 if !ok {
4013 return fmt.Errorf("expected ImageSizeInBytes to be json.Number, got %T instead", value)
4014 }
4015 i64, err := jtv.Int64()
4016 if err != nil {
4017 return err
4018 }
4019 sv.ImageSizeInBytes = ptr.Int64(i64)
4020 }
4021
4022 case "imageTags":
4023 if err := awsAwsjson11_deserializeDocumentImageTagList(&sv.ImageTags, value); err != nil {
4024 return err
4025 }
4026
4027 case "registryId":
4028 if value != nil {
4029 jtv, ok := value.(string)
4030 if !ok {
4031 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
4032 }
4033 sv.RegistryId = ptr.String(jtv)
4034 }
4035
4036 case "repositoryName":
4037 if value != nil {
4038 jtv, ok := value.(string)
4039 if !ok {
4040 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
4041 }
4042 sv.RepositoryName = ptr.String(jtv)
4043 }
4044
4045 default:
4046 _, _ = key, value
4047
4048 }
4049 }
4050 *v = sv
4051 return nil
4052 }
4053
4054 func awsAwsjson11_deserializeDocumentImageDetailList(v *[]types.ImageDetail, value interface{}) error {
4055 if v == nil {
4056 return fmt.Errorf("unexpected nil of type %T", v)
4057 }
4058 if value == nil {
4059 return nil
4060 }
4061
4062 shape, ok := value.([]interface{})
4063 if !ok {
4064 return fmt.Errorf("unexpected JSON type %v", value)
4065 }
4066
4067 var cv []types.ImageDetail
4068 if *v == nil {
4069 cv = []types.ImageDetail{}
4070 } else {
4071 cv = *v
4072 }
4073
4074 for _, value := range shape {
4075 var col types.ImageDetail
4076 destAddr := &col
4077 if err := awsAwsjson11_deserializeDocumentImageDetail(&destAddr, value); err != nil {
4078 return err
4079 }
4080 col = *destAddr
4081 cv = append(cv, col)
4082
4083 }
4084 *v = cv
4085 return nil
4086 }
4087
4088 func awsAwsjson11_deserializeDocumentImageDigestDoesNotMatchException(v **types.ImageDigestDoesNotMatchException, value interface{}) error {
4089 if v == nil {
4090 return fmt.Errorf("unexpected nil of type %T", v)
4091 }
4092 if value == nil {
4093 return nil
4094 }
4095
4096 shape, ok := value.(map[string]interface{})
4097 if !ok {
4098 return fmt.Errorf("unexpected JSON type %v", value)
4099 }
4100
4101 var sv *types.ImageDigestDoesNotMatchException
4102 if *v == nil {
4103 sv = &types.ImageDigestDoesNotMatchException{}
4104 } else {
4105 sv = *v
4106 }
4107
4108 for key, value := range shape {
4109 switch key {
4110 case "message":
4111 if value != nil {
4112 jtv, ok := value.(string)
4113 if !ok {
4114 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
4115 }
4116 sv.Message = ptr.String(jtv)
4117 }
4118
4119 default:
4120 _, _ = key, value
4121
4122 }
4123 }
4124 *v = sv
4125 return nil
4126 }
4127
4128 func awsAwsjson11_deserializeDocumentImageFailure(v **types.ImageFailure, value interface{}) error {
4129 if v == nil {
4130 return fmt.Errorf("unexpected nil of type %T", v)
4131 }
4132 if value == nil {
4133 return nil
4134 }
4135
4136 shape, ok := value.(map[string]interface{})
4137 if !ok {
4138 return fmt.Errorf("unexpected JSON type %v", value)
4139 }
4140
4141 var sv *types.ImageFailure
4142 if *v == nil {
4143 sv = &types.ImageFailure{}
4144 } else {
4145 sv = *v
4146 }
4147
4148 for key, value := range shape {
4149 switch key {
4150 case "failureCode":
4151 if value != nil {
4152 jtv, ok := value.(string)
4153 if !ok {
4154 return fmt.Errorf("expected ImageFailureCode to be of type string, got %T instead", value)
4155 }
4156 sv.FailureCode = types.ImageFailureCode(jtv)
4157 }
4158
4159 case "failureReason":
4160 if value != nil {
4161 jtv, ok := value.(string)
4162 if !ok {
4163 return fmt.Errorf("expected ImageFailureReason to be of type string, got %T instead", value)
4164 }
4165 sv.FailureReason = ptr.String(jtv)
4166 }
4167
4168 case "imageId":
4169 if err := awsAwsjson11_deserializeDocumentImageIdentifier(&sv.ImageId, value); err != nil {
4170 return err
4171 }
4172
4173 default:
4174 _, _ = key, value
4175
4176 }
4177 }
4178 *v = sv
4179 return nil
4180 }
4181
4182 func awsAwsjson11_deserializeDocumentImageFailureList(v *[]types.ImageFailure, value interface{}) error {
4183 if v == nil {
4184 return fmt.Errorf("unexpected nil of type %T", v)
4185 }
4186 if value == nil {
4187 return nil
4188 }
4189
4190 shape, ok := value.([]interface{})
4191 if !ok {
4192 return fmt.Errorf("unexpected JSON type %v", value)
4193 }
4194
4195 var cv []types.ImageFailure
4196 if *v == nil {
4197 cv = []types.ImageFailure{}
4198 } else {
4199 cv = *v
4200 }
4201
4202 for _, value := range shape {
4203 var col types.ImageFailure
4204 destAddr := &col
4205 if err := awsAwsjson11_deserializeDocumentImageFailure(&destAddr, value); err != nil {
4206 return err
4207 }
4208 col = *destAddr
4209 cv = append(cv, col)
4210
4211 }
4212 *v = cv
4213 return nil
4214 }
4215
4216 func awsAwsjson11_deserializeDocumentImageIdentifier(v **types.ImageIdentifier, value interface{}) error {
4217 if v == nil {
4218 return fmt.Errorf("unexpected nil of type %T", v)
4219 }
4220 if value == nil {
4221 return nil
4222 }
4223
4224 shape, ok := value.(map[string]interface{})
4225 if !ok {
4226 return fmt.Errorf("unexpected JSON type %v", value)
4227 }
4228
4229 var sv *types.ImageIdentifier
4230 if *v == nil {
4231 sv = &types.ImageIdentifier{}
4232 } else {
4233 sv = *v
4234 }
4235
4236 for key, value := range shape {
4237 switch key {
4238 case "imageDigest":
4239 if value != nil {
4240 jtv, ok := value.(string)
4241 if !ok {
4242 return fmt.Errorf("expected ImageDigest to be of type string, got %T instead", value)
4243 }
4244 sv.ImageDigest = ptr.String(jtv)
4245 }
4246
4247 case "imageTag":
4248 if value != nil {
4249 jtv, ok := value.(string)
4250 if !ok {
4251 return fmt.Errorf("expected ImageTag to be of type string, got %T instead", value)
4252 }
4253 sv.ImageTag = ptr.String(jtv)
4254 }
4255
4256 default:
4257 _, _ = key, value
4258
4259 }
4260 }
4261 *v = sv
4262 return nil
4263 }
4264
4265 func awsAwsjson11_deserializeDocumentImageIdentifierList(v *[]types.ImageIdentifier, value interface{}) error {
4266 if v == nil {
4267 return fmt.Errorf("unexpected nil of type %T", v)
4268 }
4269 if value == nil {
4270 return nil
4271 }
4272
4273 shape, ok := value.([]interface{})
4274 if !ok {
4275 return fmt.Errorf("unexpected JSON type %v", value)
4276 }
4277
4278 var cv []types.ImageIdentifier
4279 if *v == nil {
4280 cv = []types.ImageIdentifier{}
4281 } else {
4282 cv = *v
4283 }
4284
4285 for _, value := range shape {
4286 var col types.ImageIdentifier
4287 destAddr := &col
4288 if err := awsAwsjson11_deserializeDocumentImageIdentifier(&destAddr, value); err != nil {
4289 return err
4290 }
4291 col = *destAddr
4292 cv = append(cv, col)
4293
4294 }
4295 *v = cv
4296 return nil
4297 }
4298
4299 func awsAwsjson11_deserializeDocumentImageNotFoundException(v **types.ImageNotFoundException, value interface{}) error {
4300 if v == nil {
4301 return fmt.Errorf("unexpected nil of type %T", v)
4302 }
4303 if value == nil {
4304 return nil
4305 }
4306
4307 shape, ok := value.(map[string]interface{})
4308 if !ok {
4309 return fmt.Errorf("unexpected JSON type %v", value)
4310 }
4311
4312 var sv *types.ImageNotFoundException
4313 if *v == nil {
4314 sv = &types.ImageNotFoundException{}
4315 } else {
4316 sv = *v
4317 }
4318
4319 for key, value := range shape {
4320 switch key {
4321 case "message":
4322 if value != nil {
4323 jtv, ok := value.(string)
4324 if !ok {
4325 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
4326 }
4327 sv.Message = ptr.String(jtv)
4328 }
4329
4330 default:
4331 _, _ = key, value
4332
4333 }
4334 }
4335 *v = sv
4336 return nil
4337 }
4338
4339 func awsAwsjson11_deserializeDocumentImageTagAlreadyExistsException(v **types.ImageTagAlreadyExistsException, value interface{}) error {
4340 if v == nil {
4341 return fmt.Errorf("unexpected nil of type %T", v)
4342 }
4343 if value == nil {
4344 return nil
4345 }
4346
4347 shape, ok := value.(map[string]interface{})
4348 if !ok {
4349 return fmt.Errorf("unexpected JSON type %v", value)
4350 }
4351
4352 var sv *types.ImageTagAlreadyExistsException
4353 if *v == nil {
4354 sv = &types.ImageTagAlreadyExistsException{}
4355 } else {
4356 sv = *v
4357 }
4358
4359 for key, value := range shape {
4360 switch key {
4361 case "message":
4362 if value != nil {
4363 jtv, ok := value.(string)
4364 if !ok {
4365 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
4366 }
4367 sv.Message = ptr.String(jtv)
4368 }
4369
4370 default:
4371 _, _ = key, value
4372
4373 }
4374 }
4375 *v = sv
4376 return nil
4377 }
4378
4379 func awsAwsjson11_deserializeDocumentImageTagDetail(v **types.ImageTagDetail, value interface{}) error {
4380 if v == nil {
4381 return fmt.Errorf("unexpected nil of type %T", v)
4382 }
4383 if value == nil {
4384 return nil
4385 }
4386
4387 shape, ok := value.(map[string]interface{})
4388 if !ok {
4389 return fmt.Errorf("unexpected JSON type %v", value)
4390 }
4391
4392 var sv *types.ImageTagDetail
4393 if *v == nil {
4394 sv = &types.ImageTagDetail{}
4395 } else {
4396 sv = *v
4397 }
4398
4399 for key, value := range shape {
4400 switch key {
4401 case "createdAt":
4402 if value != nil {
4403 switch jtv := value.(type) {
4404 case json.Number:
4405 f64, err := jtv.Float64()
4406 if err != nil {
4407 return err
4408 }
4409 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
4410
4411 default:
4412 return fmt.Errorf("expected CreationTimestamp to be a JSON Number, got %T instead", value)
4413
4414 }
4415 }
4416
4417 case "imageDetail":
4418 if err := awsAwsjson11_deserializeDocumentReferencedImageDetail(&sv.ImageDetail, value); err != nil {
4419 return err
4420 }
4421
4422 case "imageTag":
4423 if value != nil {
4424 jtv, ok := value.(string)
4425 if !ok {
4426 return fmt.Errorf("expected ImageTag to be of type string, got %T instead", value)
4427 }
4428 sv.ImageTag = ptr.String(jtv)
4429 }
4430
4431 default:
4432 _, _ = key, value
4433
4434 }
4435 }
4436 *v = sv
4437 return nil
4438 }
4439
4440 func awsAwsjson11_deserializeDocumentImageTagDetailList(v *[]types.ImageTagDetail, value interface{}) error {
4441 if v == nil {
4442 return fmt.Errorf("unexpected nil of type %T", v)
4443 }
4444 if value == nil {
4445 return nil
4446 }
4447
4448 shape, ok := value.([]interface{})
4449 if !ok {
4450 return fmt.Errorf("unexpected JSON type %v", value)
4451 }
4452
4453 var cv []types.ImageTagDetail
4454 if *v == nil {
4455 cv = []types.ImageTagDetail{}
4456 } else {
4457 cv = *v
4458 }
4459
4460 for _, value := range shape {
4461 var col types.ImageTagDetail
4462 destAddr := &col
4463 if err := awsAwsjson11_deserializeDocumentImageTagDetail(&destAddr, value); err != nil {
4464 return err
4465 }
4466 col = *destAddr
4467 cv = append(cv, col)
4468
4469 }
4470 *v = cv
4471 return nil
4472 }
4473
4474 func awsAwsjson11_deserializeDocumentImageTagList(v *[]string, value interface{}) error {
4475 if v == nil {
4476 return fmt.Errorf("unexpected nil of type %T", v)
4477 }
4478 if value == nil {
4479 return nil
4480 }
4481
4482 shape, ok := value.([]interface{})
4483 if !ok {
4484 return fmt.Errorf("unexpected JSON type %v", value)
4485 }
4486
4487 var cv []string
4488 if *v == nil {
4489 cv = []string{}
4490 } else {
4491 cv = *v
4492 }
4493
4494 for _, value := range shape {
4495 var col string
4496 if value != nil {
4497 jtv, ok := value.(string)
4498 if !ok {
4499 return fmt.Errorf("expected ImageTag to be of type string, got %T instead", value)
4500 }
4501 col = jtv
4502 }
4503 cv = append(cv, col)
4504
4505 }
4506 *v = cv
4507 return nil
4508 }
4509
4510 func awsAwsjson11_deserializeDocumentInvalidLayerException(v **types.InvalidLayerException, value interface{}) error {
4511 if v == nil {
4512 return fmt.Errorf("unexpected nil of type %T", v)
4513 }
4514 if value == nil {
4515 return nil
4516 }
4517
4518 shape, ok := value.(map[string]interface{})
4519 if !ok {
4520 return fmt.Errorf("unexpected JSON type %v", value)
4521 }
4522
4523 var sv *types.InvalidLayerException
4524 if *v == nil {
4525 sv = &types.InvalidLayerException{}
4526 } else {
4527 sv = *v
4528 }
4529
4530 for key, value := range shape {
4531 switch key {
4532 case "message":
4533 if value != nil {
4534 jtv, ok := value.(string)
4535 if !ok {
4536 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
4537 }
4538 sv.Message = ptr.String(jtv)
4539 }
4540
4541 default:
4542 _, _ = key, value
4543
4544 }
4545 }
4546 *v = sv
4547 return nil
4548 }
4549
4550 func awsAwsjson11_deserializeDocumentInvalidLayerPartException(v **types.InvalidLayerPartException, value interface{}) error {
4551 if v == nil {
4552 return fmt.Errorf("unexpected nil of type %T", v)
4553 }
4554 if value == nil {
4555 return nil
4556 }
4557
4558 shape, ok := value.(map[string]interface{})
4559 if !ok {
4560 return fmt.Errorf("unexpected JSON type %v", value)
4561 }
4562
4563 var sv *types.InvalidLayerPartException
4564 if *v == nil {
4565 sv = &types.InvalidLayerPartException{}
4566 } else {
4567 sv = *v
4568 }
4569
4570 for key, value := range shape {
4571 switch key {
4572 case "lastValidByteReceived":
4573 if value != nil {
4574 jtv, ok := value.(json.Number)
4575 if !ok {
4576 return fmt.Errorf("expected PartSize to be json.Number, got %T instead", value)
4577 }
4578 i64, err := jtv.Int64()
4579 if err != nil {
4580 return err
4581 }
4582 sv.LastValidByteReceived = ptr.Int64(i64)
4583 }
4584
4585 case "message":
4586 if value != nil {
4587 jtv, ok := value.(string)
4588 if !ok {
4589 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
4590 }
4591 sv.Message = ptr.String(jtv)
4592 }
4593
4594 case "registryId":
4595 if value != nil {
4596 jtv, ok := value.(string)
4597 if !ok {
4598 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
4599 }
4600 sv.RegistryId = ptr.String(jtv)
4601 }
4602
4603 case "repositoryName":
4604 if value != nil {
4605 jtv, ok := value.(string)
4606 if !ok {
4607 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
4608 }
4609 sv.RepositoryName = ptr.String(jtv)
4610 }
4611
4612 case "uploadId":
4613 if value != nil {
4614 jtv, ok := value.(string)
4615 if !ok {
4616 return fmt.Errorf("expected UploadId to be of type string, got %T instead", value)
4617 }
4618 sv.UploadId = ptr.String(jtv)
4619 }
4620
4621 default:
4622 _, _ = key, value
4623
4624 }
4625 }
4626 *v = sv
4627 return nil
4628 }
4629
4630 func awsAwsjson11_deserializeDocumentInvalidParameterException(v **types.InvalidParameterException, value interface{}) error {
4631 if v == nil {
4632 return fmt.Errorf("unexpected nil of type %T", v)
4633 }
4634 if value == nil {
4635 return nil
4636 }
4637
4638 shape, ok := value.(map[string]interface{})
4639 if !ok {
4640 return fmt.Errorf("unexpected JSON type %v", value)
4641 }
4642
4643 var sv *types.InvalidParameterException
4644 if *v == nil {
4645 sv = &types.InvalidParameterException{}
4646 } else {
4647 sv = *v
4648 }
4649
4650 for key, value := range shape {
4651 switch key {
4652 case "message":
4653 if value != nil {
4654 jtv, ok := value.(string)
4655 if !ok {
4656 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
4657 }
4658 sv.Message = ptr.String(jtv)
4659 }
4660
4661 default:
4662 _, _ = key, value
4663
4664 }
4665 }
4666 *v = sv
4667 return nil
4668 }
4669
4670 func awsAwsjson11_deserializeDocumentInvalidTagParameterException(v **types.InvalidTagParameterException, value interface{}) error {
4671 if v == nil {
4672 return fmt.Errorf("unexpected nil of type %T", v)
4673 }
4674 if value == nil {
4675 return nil
4676 }
4677
4678 shape, ok := value.(map[string]interface{})
4679 if !ok {
4680 return fmt.Errorf("unexpected JSON type %v", value)
4681 }
4682
4683 var sv *types.InvalidTagParameterException
4684 if *v == nil {
4685 sv = &types.InvalidTagParameterException{}
4686 } else {
4687 sv = *v
4688 }
4689
4690 for key, value := range shape {
4691 switch key {
4692 case "message":
4693 if value != nil {
4694 jtv, ok := value.(string)
4695 if !ok {
4696 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
4697 }
4698 sv.Message = ptr.String(jtv)
4699 }
4700
4701 default:
4702 _, _ = key, value
4703
4704 }
4705 }
4706 *v = sv
4707 return nil
4708 }
4709
4710 func awsAwsjson11_deserializeDocumentLayer(v **types.Layer, value interface{}) error {
4711 if v == nil {
4712 return fmt.Errorf("unexpected nil of type %T", v)
4713 }
4714 if value == nil {
4715 return nil
4716 }
4717
4718 shape, ok := value.(map[string]interface{})
4719 if !ok {
4720 return fmt.Errorf("unexpected JSON type %v", value)
4721 }
4722
4723 var sv *types.Layer
4724 if *v == nil {
4725 sv = &types.Layer{}
4726 } else {
4727 sv = *v
4728 }
4729
4730 for key, value := range shape {
4731 switch key {
4732 case "layerAvailability":
4733 if value != nil {
4734 jtv, ok := value.(string)
4735 if !ok {
4736 return fmt.Errorf("expected LayerAvailability to be of type string, got %T instead", value)
4737 }
4738 sv.LayerAvailability = types.LayerAvailability(jtv)
4739 }
4740
4741 case "layerDigest":
4742 if value != nil {
4743 jtv, ok := value.(string)
4744 if !ok {
4745 return fmt.Errorf("expected LayerDigest to be of type string, got %T instead", value)
4746 }
4747 sv.LayerDigest = ptr.String(jtv)
4748 }
4749
4750 case "layerSize":
4751 if value != nil {
4752 jtv, ok := value.(json.Number)
4753 if !ok {
4754 return fmt.Errorf("expected LayerSizeInBytes to be json.Number, got %T instead", value)
4755 }
4756 i64, err := jtv.Int64()
4757 if err != nil {
4758 return err
4759 }
4760 sv.LayerSize = ptr.Int64(i64)
4761 }
4762
4763 case "mediaType":
4764 if value != nil {
4765 jtv, ok := value.(string)
4766 if !ok {
4767 return fmt.Errorf("expected MediaType to be of type string, got %T instead", value)
4768 }
4769 sv.MediaType = ptr.String(jtv)
4770 }
4771
4772 default:
4773 _, _ = key, value
4774
4775 }
4776 }
4777 *v = sv
4778 return nil
4779 }
4780
4781 func awsAwsjson11_deserializeDocumentLayerAlreadyExistsException(v **types.LayerAlreadyExistsException, value interface{}) error {
4782 if v == nil {
4783 return fmt.Errorf("unexpected nil of type %T", v)
4784 }
4785 if value == nil {
4786 return nil
4787 }
4788
4789 shape, ok := value.(map[string]interface{})
4790 if !ok {
4791 return fmt.Errorf("unexpected JSON type %v", value)
4792 }
4793
4794 var sv *types.LayerAlreadyExistsException
4795 if *v == nil {
4796 sv = &types.LayerAlreadyExistsException{}
4797 } else {
4798 sv = *v
4799 }
4800
4801 for key, value := range shape {
4802 switch key {
4803 case "message":
4804 if value != nil {
4805 jtv, ok := value.(string)
4806 if !ok {
4807 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
4808 }
4809 sv.Message = ptr.String(jtv)
4810 }
4811
4812 default:
4813 _, _ = key, value
4814
4815 }
4816 }
4817 *v = sv
4818 return nil
4819 }
4820
4821 func awsAwsjson11_deserializeDocumentLayerFailure(v **types.LayerFailure, value interface{}) error {
4822 if v == nil {
4823 return fmt.Errorf("unexpected nil of type %T", v)
4824 }
4825 if value == nil {
4826 return nil
4827 }
4828
4829 shape, ok := value.(map[string]interface{})
4830 if !ok {
4831 return fmt.Errorf("unexpected JSON type %v", value)
4832 }
4833
4834 var sv *types.LayerFailure
4835 if *v == nil {
4836 sv = &types.LayerFailure{}
4837 } else {
4838 sv = *v
4839 }
4840
4841 for key, value := range shape {
4842 switch key {
4843 case "failureCode":
4844 if value != nil {
4845 jtv, ok := value.(string)
4846 if !ok {
4847 return fmt.Errorf("expected LayerFailureCode to be of type string, got %T instead", value)
4848 }
4849 sv.FailureCode = types.LayerFailureCode(jtv)
4850 }
4851
4852 case "failureReason":
4853 if value != nil {
4854 jtv, ok := value.(string)
4855 if !ok {
4856 return fmt.Errorf("expected LayerFailureReason to be of type string, got %T instead", value)
4857 }
4858 sv.FailureReason = ptr.String(jtv)
4859 }
4860
4861 case "layerDigest":
4862 if value != nil {
4863 jtv, ok := value.(string)
4864 if !ok {
4865 return fmt.Errorf("expected BatchedOperationLayerDigest to be of type string, got %T instead", value)
4866 }
4867 sv.LayerDigest = ptr.String(jtv)
4868 }
4869
4870 default:
4871 _, _ = key, value
4872
4873 }
4874 }
4875 *v = sv
4876 return nil
4877 }
4878
4879 func awsAwsjson11_deserializeDocumentLayerFailureList(v *[]types.LayerFailure, value interface{}) error {
4880 if v == nil {
4881 return fmt.Errorf("unexpected nil of type %T", v)
4882 }
4883 if value == nil {
4884 return nil
4885 }
4886
4887 shape, ok := value.([]interface{})
4888 if !ok {
4889 return fmt.Errorf("unexpected JSON type %v", value)
4890 }
4891
4892 var cv []types.LayerFailure
4893 if *v == nil {
4894 cv = []types.LayerFailure{}
4895 } else {
4896 cv = *v
4897 }
4898
4899 for _, value := range shape {
4900 var col types.LayerFailure
4901 destAddr := &col
4902 if err := awsAwsjson11_deserializeDocumentLayerFailure(&destAddr, value); err != nil {
4903 return err
4904 }
4905 col = *destAddr
4906 cv = append(cv, col)
4907
4908 }
4909 *v = cv
4910 return nil
4911 }
4912
4913 func awsAwsjson11_deserializeDocumentLayerList(v *[]types.Layer, value interface{}) error {
4914 if v == nil {
4915 return fmt.Errorf("unexpected nil of type %T", v)
4916 }
4917 if value == nil {
4918 return nil
4919 }
4920
4921 shape, ok := value.([]interface{})
4922 if !ok {
4923 return fmt.Errorf("unexpected JSON type %v", value)
4924 }
4925
4926 var cv []types.Layer
4927 if *v == nil {
4928 cv = []types.Layer{}
4929 } else {
4930 cv = *v
4931 }
4932
4933 for _, value := range shape {
4934 var col types.Layer
4935 destAddr := &col
4936 if err := awsAwsjson11_deserializeDocumentLayer(&destAddr, value); err != nil {
4937 return err
4938 }
4939 col = *destAddr
4940 cv = append(cv, col)
4941
4942 }
4943 *v = cv
4944 return nil
4945 }
4946
4947 func awsAwsjson11_deserializeDocumentLayerPartTooSmallException(v **types.LayerPartTooSmallException, value interface{}) error {
4948 if v == nil {
4949 return fmt.Errorf("unexpected nil of type %T", v)
4950 }
4951 if value == nil {
4952 return nil
4953 }
4954
4955 shape, ok := value.(map[string]interface{})
4956 if !ok {
4957 return fmt.Errorf("unexpected JSON type %v", value)
4958 }
4959
4960 var sv *types.LayerPartTooSmallException
4961 if *v == nil {
4962 sv = &types.LayerPartTooSmallException{}
4963 } else {
4964 sv = *v
4965 }
4966
4967 for key, value := range shape {
4968 switch key {
4969 case "message":
4970 if value != nil {
4971 jtv, ok := value.(string)
4972 if !ok {
4973 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
4974 }
4975 sv.Message = ptr.String(jtv)
4976 }
4977
4978 default:
4979 _, _ = key, value
4980
4981 }
4982 }
4983 *v = sv
4984 return nil
4985 }
4986
4987 func awsAwsjson11_deserializeDocumentLayersNotFoundException(v **types.LayersNotFoundException, value interface{}) error {
4988 if v == nil {
4989 return fmt.Errorf("unexpected nil of type %T", v)
4990 }
4991 if value == nil {
4992 return nil
4993 }
4994
4995 shape, ok := value.(map[string]interface{})
4996 if !ok {
4997 return fmt.Errorf("unexpected JSON type %v", value)
4998 }
4999
5000 var sv *types.LayersNotFoundException
5001 if *v == nil {
5002 sv = &types.LayersNotFoundException{}
5003 } else {
5004 sv = *v
5005 }
5006
5007 for key, value := range shape {
5008 switch key {
5009 case "message":
5010 if value != nil {
5011 jtv, ok := value.(string)
5012 if !ok {
5013 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
5014 }
5015 sv.Message = ptr.String(jtv)
5016 }
5017
5018 default:
5019 _, _ = key, value
5020
5021 }
5022 }
5023 *v = sv
5024 return nil
5025 }
5026
5027 func awsAwsjson11_deserializeDocumentLimitExceededException(v **types.LimitExceededException, value interface{}) error {
5028 if v == nil {
5029 return fmt.Errorf("unexpected nil of type %T", v)
5030 }
5031 if value == nil {
5032 return nil
5033 }
5034
5035 shape, ok := value.(map[string]interface{})
5036 if !ok {
5037 return fmt.Errorf("unexpected JSON type %v", value)
5038 }
5039
5040 var sv *types.LimitExceededException
5041 if *v == nil {
5042 sv = &types.LimitExceededException{}
5043 } else {
5044 sv = *v
5045 }
5046
5047 for key, value := range shape {
5048 switch key {
5049 case "message":
5050 if value != nil {
5051 jtv, ok := value.(string)
5052 if !ok {
5053 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
5054 }
5055 sv.Message = ptr.String(jtv)
5056 }
5057
5058 default:
5059 _, _ = key, value
5060
5061 }
5062 }
5063 *v = sv
5064 return nil
5065 }
5066
5067 func awsAwsjson11_deserializeDocumentOperatingSystemList(v *[]string, value interface{}) error {
5068 if v == nil {
5069 return fmt.Errorf("unexpected nil of type %T", v)
5070 }
5071 if value == nil {
5072 return nil
5073 }
5074
5075 shape, ok := value.([]interface{})
5076 if !ok {
5077 return fmt.Errorf("unexpected JSON type %v", value)
5078 }
5079
5080 var cv []string
5081 if *v == nil {
5082 cv = []string{}
5083 } else {
5084 cv = *v
5085 }
5086
5087 for _, value := range shape {
5088 var col string
5089 if value != nil {
5090 jtv, ok := value.(string)
5091 if !ok {
5092 return fmt.Errorf("expected OperatingSystem to be of type string, got %T instead", value)
5093 }
5094 col = jtv
5095 }
5096 cv = append(cv, col)
5097
5098 }
5099 *v = cv
5100 return nil
5101 }
5102
5103 func awsAwsjson11_deserializeDocumentReferencedImageDetail(v **types.ReferencedImageDetail, value interface{}) error {
5104 if v == nil {
5105 return fmt.Errorf("unexpected nil of type %T", v)
5106 }
5107 if value == nil {
5108 return nil
5109 }
5110
5111 shape, ok := value.(map[string]interface{})
5112 if !ok {
5113 return fmt.Errorf("unexpected JSON type %v", value)
5114 }
5115
5116 var sv *types.ReferencedImageDetail
5117 if *v == nil {
5118 sv = &types.ReferencedImageDetail{}
5119 } else {
5120 sv = *v
5121 }
5122
5123 for key, value := range shape {
5124 switch key {
5125 case "artifactMediaType":
5126 if value != nil {
5127 jtv, ok := value.(string)
5128 if !ok {
5129 return fmt.Errorf("expected MediaType to be of type string, got %T instead", value)
5130 }
5131 sv.ArtifactMediaType = ptr.String(jtv)
5132 }
5133
5134 case "imageDigest":
5135 if value != nil {
5136 jtv, ok := value.(string)
5137 if !ok {
5138 return fmt.Errorf("expected ImageDigest to be of type string, got %T instead", value)
5139 }
5140 sv.ImageDigest = ptr.String(jtv)
5141 }
5142
5143 case "imageManifestMediaType":
5144 if value != nil {
5145 jtv, ok := value.(string)
5146 if !ok {
5147 return fmt.Errorf("expected MediaType to be of type string, got %T instead", value)
5148 }
5149 sv.ImageManifestMediaType = ptr.String(jtv)
5150 }
5151
5152 case "imagePushedAt":
5153 if value != nil {
5154 switch jtv := value.(type) {
5155 case json.Number:
5156 f64, err := jtv.Float64()
5157 if err != nil {
5158 return err
5159 }
5160 sv.ImagePushedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
5161
5162 default:
5163 return fmt.Errorf("expected PushTimestamp to be a JSON Number, got %T instead", value)
5164
5165 }
5166 }
5167
5168 case "imageSizeInBytes":
5169 if value != nil {
5170 jtv, ok := value.(json.Number)
5171 if !ok {
5172 return fmt.Errorf("expected ImageSizeInBytes to be json.Number, got %T instead", value)
5173 }
5174 i64, err := jtv.Int64()
5175 if err != nil {
5176 return err
5177 }
5178 sv.ImageSizeInBytes = ptr.Int64(i64)
5179 }
5180
5181 default:
5182 _, _ = key, value
5183
5184 }
5185 }
5186 *v = sv
5187 return nil
5188 }
5189
5190 func awsAwsjson11_deserializeDocumentReferencedImagesNotFoundException(v **types.ReferencedImagesNotFoundException, value interface{}) error {
5191 if v == nil {
5192 return fmt.Errorf("unexpected nil of type %T", v)
5193 }
5194 if value == nil {
5195 return nil
5196 }
5197
5198 shape, ok := value.(map[string]interface{})
5199 if !ok {
5200 return fmt.Errorf("unexpected JSON type %v", value)
5201 }
5202
5203 var sv *types.ReferencedImagesNotFoundException
5204 if *v == nil {
5205 sv = &types.ReferencedImagesNotFoundException{}
5206 } else {
5207 sv = *v
5208 }
5209
5210 for key, value := range shape {
5211 switch key {
5212 case "message":
5213 if value != nil {
5214 jtv, ok := value.(string)
5215 if !ok {
5216 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
5217 }
5218 sv.Message = ptr.String(jtv)
5219 }
5220
5221 default:
5222 _, _ = key, value
5223
5224 }
5225 }
5226 *v = sv
5227 return nil
5228 }
5229
5230 func awsAwsjson11_deserializeDocumentRegistry(v **types.Registry, value interface{}) error {
5231 if v == nil {
5232 return fmt.Errorf("unexpected nil of type %T", v)
5233 }
5234 if value == nil {
5235 return nil
5236 }
5237
5238 shape, ok := value.(map[string]interface{})
5239 if !ok {
5240 return fmt.Errorf("unexpected JSON type %v", value)
5241 }
5242
5243 var sv *types.Registry
5244 if *v == nil {
5245 sv = &types.Registry{}
5246 } else {
5247 sv = *v
5248 }
5249
5250 for key, value := range shape {
5251 switch key {
5252 case "aliases":
5253 if err := awsAwsjson11_deserializeDocumentRegistryAliasList(&sv.Aliases, value); err != nil {
5254 return err
5255 }
5256
5257 case "registryArn":
5258 if value != nil {
5259 jtv, ok := value.(string)
5260 if !ok {
5261 return fmt.Errorf("expected Arn to be of type string, got %T instead", value)
5262 }
5263 sv.RegistryArn = ptr.String(jtv)
5264 }
5265
5266 case "registryId":
5267 if value != nil {
5268 jtv, ok := value.(string)
5269 if !ok {
5270 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
5271 }
5272 sv.RegistryId = ptr.String(jtv)
5273 }
5274
5275 case "registryUri":
5276 if value != nil {
5277 jtv, ok := value.(string)
5278 if !ok {
5279 return fmt.Errorf("expected Url to be of type string, got %T instead", value)
5280 }
5281 sv.RegistryUri = ptr.String(jtv)
5282 }
5283
5284 case "verified":
5285 if value != nil {
5286 jtv, ok := value.(bool)
5287 if !ok {
5288 return fmt.Errorf("expected RegistryVerified to be of type *bool, got %T instead", value)
5289 }
5290 sv.Verified = ptr.Bool(jtv)
5291 }
5292
5293 default:
5294 _, _ = key, value
5295
5296 }
5297 }
5298 *v = sv
5299 return nil
5300 }
5301
5302 func awsAwsjson11_deserializeDocumentRegistryAlias(v **types.RegistryAlias, value interface{}) error {
5303 if v == nil {
5304 return fmt.Errorf("unexpected nil of type %T", v)
5305 }
5306 if value == nil {
5307 return nil
5308 }
5309
5310 shape, ok := value.(map[string]interface{})
5311 if !ok {
5312 return fmt.Errorf("unexpected JSON type %v", value)
5313 }
5314
5315 var sv *types.RegistryAlias
5316 if *v == nil {
5317 sv = &types.RegistryAlias{}
5318 } else {
5319 sv = *v
5320 }
5321
5322 for key, value := range shape {
5323 switch key {
5324 case "defaultRegistryAlias":
5325 if value != nil {
5326 jtv, ok := value.(bool)
5327 if !ok {
5328 return fmt.Errorf("expected DefaultRegistryAliasFlag to be of type *bool, got %T instead", value)
5329 }
5330 sv.DefaultRegistryAlias = jtv
5331 }
5332
5333 case "name":
5334 if value != nil {
5335 jtv, ok := value.(string)
5336 if !ok {
5337 return fmt.Errorf("expected RegistryAliasName to be of type string, got %T instead", value)
5338 }
5339 sv.Name = ptr.String(jtv)
5340 }
5341
5342 case "primaryRegistryAlias":
5343 if value != nil {
5344 jtv, ok := value.(bool)
5345 if !ok {
5346 return fmt.Errorf("expected PrimaryRegistryAliasFlag to be of type *bool, got %T instead", value)
5347 }
5348 sv.PrimaryRegistryAlias = jtv
5349 }
5350
5351 case "status":
5352 if value != nil {
5353 jtv, ok := value.(string)
5354 if !ok {
5355 return fmt.Errorf("expected RegistryAliasStatus to be of type string, got %T instead", value)
5356 }
5357 sv.Status = types.RegistryAliasStatus(jtv)
5358 }
5359
5360 default:
5361 _, _ = key, value
5362
5363 }
5364 }
5365 *v = sv
5366 return nil
5367 }
5368
5369 func awsAwsjson11_deserializeDocumentRegistryAliasList(v *[]types.RegistryAlias, value interface{}) error {
5370 if v == nil {
5371 return fmt.Errorf("unexpected nil of type %T", v)
5372 }
5373 if value == nil {
5374 return nil
5375 }
5376
5377 shape, ok := value.([]interface{})
5378 if !ok {
5379 return fmt.Errorf("unexpected JSON type %v", value)
5380 }
5381
5382 var cv []types.RegistryAlias
5383 if *v == nil {
5384 cv = []types.RegistryAlias{}
5385 } else {
5386 cv = *v
5387 }
5388
5389 for _, value := range shape {
5390 var col types.RegistryAlias
5391 destAddr := &col
5392 if err := awsAwsjson11_deserializeDocumentRegistryAlias(&destAddr, value); err != nil {
5393 return err
5394 }
5395 col = *destAddr
5396 cv = append(cv, col)
5397
5398 }
5399 *v = cv
5400 return nil
5401 }
5402
5403 func awsAwsjson11_deserializeDocumentRegistryCatalogData(v **types.RegistryCatalogData, value interface{}) error {
5404 if v == nil {
5405 return fmt.Errorf("unexpected nil of type %T", v)
5406 }
5407 if value == nil {
5408 return nil
5409 }
5410
5411 shape, ok := value.(map[string]interface{})
5412 if !ok {
5413 return fmt.Errorf("unexpected JSON type %v", value)
5414 }
5415
5416 var sv *types.RegistryCatalogData
5417 if *v == nil {
5418 sv = &types.RegistryCatalogData{}
5419 } else {
5420 sv = *v
5421 }
5422
5423 for key, value := range shape {
5424 switch key {
5425 case "displayName":
5426 if value != nil {
5427 jtv, ok := value.(string)
5428 if !ok {
5429 return fmt.Errorf("expected RegistryDisplayName to be of type string, got %T instead", value)
5430 }
5431 sv.DisplayName = ptr.String(jtv)
5432 }
5433
5434 default:
5435 _, _ = key, value
5436
5437 }
5438 }
5439 *v = sv
5440 return nil
5441 }
5442
5443 func awsAwsjson11_deserializeDocumentRegistryList(v *[]types.Registry, value interface{}) error {
5444 if v == nil {
5445 return fmt.Errorf("unexpected nil of type %T", v)
5446 }
5447 if value == nil {
5448 return nil
5449 }
5450
5451 shape, ok := value.([]interface{})
5452 if !ok {
5453 return fmt.Errorf("unexpected JSON type %v", value)
5454 }
5455
5456 var cv []types.Registry
5457 if *v == nil {
5458 cv = []types.Registry{}
5459 } else {
5460 cv = *v
5461 }
5462
5463 for _, value := range shape {
5464 var col types.Registry
5465 destAddr := &col
5466 if err := awsAwsjson11_deserializeDocumentRegistry(&destAddr, value); err != nil {
5467 return err
5468 }
5469 col = *destAddr
5470 cv = append(cv, col)
5471
5472 }
5473 *v = cv
5474 return nil
5475 }
5476
5477 func awsAwsjson11_deserializeDocumentRegistryNotFoundException(v **types.RegistryNotFoundException, value interface{}) error {
5478 if v == nil {
5479 return fmt.Errorf("unexpected nil of type %T", v)
5480 }
5481 if value == nil {
5482 return nil
5483 }
5484
5485 shape, ok := value.(map[string]interface{})
5486 if !ok {
5487 return fmt.Errorf("unexpected JSON type %v", value)
5488 }
5489
5490 var sv *types.RegistryNotFoundException
5491 if *v == nil {
5492 sv = &types.RegistryNotFoundException{}
5493 } else {
5494 sv = *v
5495 }
5496
5497 for key, value := range shape {
5498 switch key {
5499 case "message":
5500 if value != nil {
5501 jtv, ok := value.(string)
5502 if !ok {
5503 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
5504 }
5505 sv.Message = ptr.String(jtv)
5506 }
5507
5508 default:
5509 _, _ = key, value
5510
5511 }
5512 }
5513 *v = sv
5514 return nil
5515 }
5516
5517 func awsAwsjson11_deserializeDocumentRepository(v **types.Repository, value interface{}) error {
5518 if v == nil {
5519 return fmt.Errorf("unexpected nil of type %T", v)
5520 }
5521 if value == nil {
5522 return nil
5523 }
5524
5525 shape, ok := value.(map[string]interface{})
5526 if !ok {
5527 return fmt.Errorf("unexpected JSON type %v", value)
5528 }
5529
5530 var sv *types.Repository
5531 if *v == nil {
5532 sv = &types.Repository{}
5533 } else {
5534 sv = *v
5535 }
5536
5537 for key, value := range shape {
5538 switch key {
5539 case "createdAt":
5540 if value != nil {
5541 switch jtv := value.(type) {
5542 case json.Number:
5543 f64, err := jtv.Float64()
5544 if err != nil {
5545 return err
5546 }
5547 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
5548
5549 default:
5550 return fmt.Errorf("expected CreationTimestamp to be a JSON Number, got %T instead", value)
5551
5552 }
5553 }
5554
5555 case "registryId":
5556 if value != nil {
5557 jtv, ok := value.(string)
5558 if !ok {
5559 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
5560 }
5561 sv.RegistryId = ptr.String(jtv)
5562 }
5563
5564 case "repositoryArn":
5565 if value != nil {
5566 jtv, ok := value.(string)
5567 if !ok {
5568 return fmt.Errorf("expected Arn to be of type string, got %T instead", value)
5569 }
5570 sv.RepositoryArn = ptr.String(jtv)
5571 }
5572
5573 case "repositoryName":
5574 if value != nil {
5575 jtv, ok := value.(string)
5576 if !ok {
5577 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
5578 }
5579 sv.RepositoryName = ptr.String(jtv)
5580 }
5581
5582 case "repositoryUri":
5583 if value != nil {
5584 jtv, ok := value.(string)
5585 if !ok {
5586 return fmt.Errorf("expected Url to be of type string, got %T instead", value)
5587 }
5588 sv.RepositoryUri = ptr.String(jtv)
5589 }
5590
5591 default:
5592 _, _ = key, value
5593
5594 }
5595 }
5596 *v = sv
5597 return nil
5598 }
5599
5600 func awsAwsjson11_deserializeDocumentRepositoryAlreadyExistsException(v **types.RepositoryAlreadyExistsException, value interface{}) error {
5601 if v == nil {
5602 return fmt.Errorf("unexpected nil of type %T", v)
5603 }
5604 if value == nil {
5605 return nil
5606 }
5607
5608 shape, ok := value.(map[string]interface{})
5609 if !ok {
5610 return fmt.Errorf("unexpected JSON type %v", value)
5611 }
5612
5613 var sv *types.RepositoryAlreadyExistsException
5614 if *v == nil {
5615 sv = &types.RepositoryAlreadyExistsException{}
5616 } else {
5617 sv = *v
5618 }
5619
5620 for key, value := range shape {
5621 switch key {
5622 case "message":
5623 if value != nil {
5624 jtv, ok := value.(string)
5625 if !ok {
5626 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
5627 }
5628 sv.Message = ptr.String(jtv)
5629 }
5630
5631 default:
5632 _, _ = key, value
5633
5634 }
5635 }
5636 *v = sv
5637 return nil
5638 }
5639
5640 func awsAwsjson11_deserializeDocumentRepositoryCatalogData(v **types.RepositoryCatalogData, value interface{}) error {
5641 if v == nil {
5642 return fmt.Errorf("unexpected nil of type %T", v)
5643 }
5644 if value == nil {
5645 return nil
5646 }
5647
5648 shape, ok := value.(map[string]interface{})
5649 if !ok {
5650 return fmt.Errorf("unexpected JSON type %v", value)
5651 }
5652
5653 var sv *types.RepositoryCatalogData
5654 if *v == nil {
5655 sv = &types.RepositoryCatalogData{}
5656 } else {
5657 sv = *v
5658 }
5659
5660 for key, value := range shape {
5661 switch key {
5662 case "aboutText":
5663 if value != nil {
5664 jtv, ok := value.(string)
5665 if !ok {
5666 return fmt.Errorf("expected AboutText to be of type string, got %T instead", value)
5667 }
5668 sv.AboutText = ptr.String(jtv)
5669 }
5670
5671 case "architectures":
5672 if err := awsAwsjson11_deserializeDocumentArchitectureList(&sv.Architectures, value); err != nil {
5673 return err
5674 }
5675
5676 case "description":
5677 if value != nil {
5678 jtv, ok := value.(string)
5679 if !ok {
5680 return fmt.Errorf("expected RepositoryDescription to be of type string, got %T instead", value)
5681 }
5682 sv.Description = ptr.String(jtv)
5683 }
5684
5685 case "logoUrl":
5686 if value != nil {
5687 jtv, ok := value.(string)
5688 if !ok {
5689 return fmt.Errorf("expected ResourceUrl to be of type string, got %T instead", value)
5690 }
5691 sv.LogoUrl = ptr.String(jtv)
5692 }
5693
5694 case "marketplaceCertified":
5695 if value != nil {
5696 jtv, ok := value.(bool)
5697 if !ok {
5698 return fmt.Errorf("expected MarketplaceCertified to be of type *bool, got %T instead", value)
5699 }
5700 sv.MarketplaceCertified = ptr.Bool(jtv)
5701 }
5702
5703 case "operatingSystems":
5704 if err := awsAwsjson11_deserializeDocumentOperatingSystemList(&sv.OperatingSystems, value); err != nil {
5705 return err
5706 }
5707
5708 case "usageText":
5709 if value != nil {
5710 jtv, ok := value.(string)
5711 if !ok {
5712 return fmt.Errorf("expected UsageText to be of type string, got %T instead", value)
5713 }
5714 sv.UsageText = ptr.String(jtv)
5715 }
5716
5717 default:
5718 _, _ = key, value
5719
5720 }
5721 }
5722 *v = sv
5723 return nil
5724 }
5725
5726 func awsAwsjson11_deserializeDocumentRepositoryCatalogDataNotFoundException(v **types.RepositoryCatalogDataNotFoundException, value interface{}) error {
5727 if v == nil {
5728 return fmt.Errorf("unexpected nil of type %T", v)
5729 }
5730 if value == nil {
5731 return nil
5732 }
5733
5734 shape, ok := value.(map[string]interface{})
5735 if !ok {
5736 return fmt.Errorf("unexpected JSON type %v", value)
5737 }
5738
5739 var sv *types.RepositoryCatalogDataNotFoundException
5740 if *v == nil {
5741 sv = &types.RepositoryCatalogDataNotFoundException{}
5742 } else {
5743 sv = *v
5744 }
5745
5746 for key, value := range shape {
5747 switch key {
5748 case "message":
5749 if value != nil {
5750 jtv, ok := value.(string)
5751 if !ok {
5752 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
5753 }
5754 sv.Message = ptr.String(jtv)
5755 }
5756
5757 default:
5758 _, _ = key, value
5759
5760 }
5761 }
5762 *v = sv
5763 return nil
5764 }
5765
5766 func awsAwsjson11_deserializeDocumentRepositoryList(v *[]types.Repository, value interface{}) error {
5767 if v == nil {
5768 return fmt.Errorf("unexpected nil of type %T", v)
5769 }
5770 if value == nil {
5771 return nil
5772 }
5773
5774 shape, ok := value.([]interface{})
5775 if !ok {
5776 return fmt.Errorf("unexpected JSON type %v", value)
5777 }
5778
5779 var cv []types.Repository
5780 if *v == nil {
5781 cv = []types.Repository{}
5782 } else {
5783 cv = *v
5784 }
5785
5786 for _, value := range shape {
5787 var col types.Repository
5788 destAddr := &col
5789 if err := awsAwsjson11_deserializeDocumentRepository(&destAddr, value); err != nil {
5790 return err
5791 }
5792 col = *destAddr
5793 cv = append(cv, col)
5794
5795 }
5796 *v = cv
5797 return nil
5798 }
5799
5800 func awsAwsjson11_deserializeDocumentRepositoryNotEmptyException(v **types.RepositoryNotEmptyException, value interface{}) error {
5801 if v == nil {
5802 return fmt.Errorf("unexpected nil of type %T", v)
5803 }
5804 if value == nil {
5805 return nil
5806 }
5807
5808 shape, ok := value.(map[string]interface{})
5809 if !ok {
5810 return fmt.Errorf("unexpected JSON type %v", value)
5811 }
5812
5813 var sv *types.RepositoryNotEmptyException
5814 if *v == nil {
5815 sv = &types.RepositoryNotEmptyException{}
5816 } else {
5817 sv = *v
5818 }
5819
5820 for key, value := range shape {
5821 switch key {
5822 case "message":
5823 if value != nil {
5824 jtv, ok := value.(string)
5825 if !ok {
5826 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
5827 }
5828 sv.Message = ptr.String(jtv)
5829 }
5830
5831 default:
5832 _, _ = key, value
5833
5834 }
5835 }
5836 *v = sv
5837 return nil
5838 }
5839
5840 func awsAwsjson11_deserializeDocumentRepositoryNotFoundException(v **types.RepositoryNotFoundException, value interface{}) error {
5841 if v == nil {
5842 return fmt.Errorf("unexpected nil of type %T", v)
5843 }
5844 if value == nil {
5845 return nil
5846 }
5847
5848 shape, ok := value.(map[string]interface{})
5849 if !ok {
5850 return fmt.Errorf("unexpected JSON type %v", value)
5851 }
5852
5853 var sv *types.RepositoryNotFoundException
5854 if *v == nil {
5855 sv = &types.RepositoryNotFoundException{}
5856 } else {
5857 sv = *v
5858 }
5859
5860 for key, value := range shape {
5861 switch key {
5862 case "message":
5863 if value != nil {
5864 jtv, ok := value.(string)
5865 if !ok {
5866 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
5867 }
5868 sv.Message = ptr.String(jtv)
5869 }
5870
5871 default:
5872 _, _ = key, value
5873
5874 }
5875 }
5876 *v = sv
5877 return nil
5878 }
5879
5880 func awsAwsjson11_deserializeDocumentRepositoryPolicyNotFoundException(v **types.RepositoryPolicyNotFoundException, value interface{}) error {
5881 if v == nil {
5882 return fmt.Errorf("unexpected nil of type %T", v)
5883 }
5884 if value == nil {
5885 return nil
5886 }
5887
5888 shape, ok := value.(map[string]interface{})
5889 if !ok {
5890 return fmt.Errorf("unexpected JSON type %v", value)
5891 }
5892
5893 var sv *types.RepositoryPolicyNotFoundException
5894 if *v == nil {
5895 sv = &types.RepositoryPolicyNotFoundException{}
5896 } else {
5897 sv = *v
5898 }
5899
5900 for key, value := range shape {
5901 switch key {
5902 case "message":
5903 if value != nil {
5904 jtv, ok := value.(string)
5905 if !ok {
5906 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
5907 }
5908 sv.Message = ptr.String(jtv)
5909 }
5910
5911 default:
5912 _, _ = key, value
5913
5914 }
5915 }
5916 *v = sv
5917 return nil
5918 }
5919
5920 func awsAwsjson11_deserializeDocumentServerException(v **types.ServerException, value interface{}) error {
5921 if v == nil {
5922 return fmt.Errorf("unexpected nil of type %T", v)
5923 }
5924 if value == nil {
5925 return nil
5926 }
5927
5928 shape, ok := value.(map[string]interface{})
5929 if !ok {
5930 return fmt.Errorf("unexpected JSON type %v", value)
5931 }
5932
5933 var sv *types.ServerException
5934 if *v == nil {
5935 sv = &types.ServerException{}
5936 } else {
5937 sv = *v
5938 }
5939
5940 for key, value := range shape {
5941 switch key {
5942 case "message":
5943 if value != nil {
5944 jtv, ok := value.(string)
5945 if !ok {
5946 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
5947 }
5948 sv.Message = ptr.String(jtv)
5949 }
5950
5951 default:
5952 _, _ = key, value
5953
5954 }
5955 }
5956 *v = sv
5957 return nil
5958 }
5959
5960 func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error {
5961 if v == nil {
5962 return fmt.Errorf("unexpected nil of type %T", v)
5963 }
5964 if value == nil {
5965 return nil
5966 }
5967
5968 shape, ok := value.(map[string]interface{})
5969 if !ok {
5970 return fmt.Errorf("unexpected JSON type %v", value)
5971 }
5972
5973 var sv *types.Tag
5974 if *v == nil {
5975 sv = &types.Tag{}
5976 } else {
5977 sv = *v
5978 }
5979
5980 for key, value := range shape {
5981 switch key {
5982 case "Key":
5983 if value != nil {
5984 jtv, ok := value.(string)
5985 if !ok {
5986 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value)
5987 }
5988 sv.Key = ptr.String(jtv)
5989 }
5990
5991 case "Value":
5992 if value != nil {
5993 jtv, ok := value.(string)
5994 if !ok {
5995 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value)
5996 }
5997 sv.Value = ptr.String(jtv)
5998 }
5999
6000 default:
6001 _, _ = key, value
6002
6003 }
6004 }
6005 *v = sv
6006 return nil
6007 }
6008
6009 func awsAwsjson11_deserializeDocumentTagList(v *[]types.Tag, value interface{}) error {
6010 if v == nil {
6011 return fmt.Errorf("unexpected nil of type %T", v)
6012 }
6013 if value == nil {
6014 return nil
6015 }
6016
6017 shape, ok := value.([]interface{})
6018 if !ok {
6019 return fmt.Errorf("unexpected JSON type %v", value)
6020 }
6021
6022 var cv []types.Tag
6023 if *v == nil {
6024 cv = []types.Tag{}
6025 } else {
6026 cv = *v
6027 }
6028
6029 for _, value := range shape {
6030 var col types.Tag
6031 destAddr := &col
6032 if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil {
6033 return err
6034 }
6035 col = *destAddr
6036 cv = append(cv, col)
6037
6038 }
6039 *v = cv
6040 return nil
6041 }
6042
6043 func awsAwsjson11_deserializeDocumentTooManyTagsException(v **types.TooManyTagsException, value interface{}) error {
6044 if v == nil {
6045 return fmt.Errorf("unexpected nil of type %T", v)
6046 }
6047 if value == nil {
6048 return nil
6049 }
6050
6051 shape, ok := value.(map[string]interface{})
6052 if !ok {
6053 return fmt.Errorf("unexpected JSON type %v", value)
6054 }
6055
6056 var sv *types.TooManyTagsException
6057 if *v == nil {
6058 sv = &types.TooManyTagsException{}
6059 } else {
6060 sv = *v
6061 }
6062
6063 for key, value := range shape {
6064 switch key {
6065 case "message":
6066 if value != nil {
6067 jtv, ok := value.(string)
6068 if !ok {
6069 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
6070 }
6071 sv.Message = ptr.String(jtv)
6072 }
6073
6074 default:
6075 _, _ = key, value
6076
6077 }
6078 }
6079 *v = sv
6080 return nil
6081 }
6082
6083 func awsAwsjson11_deserializeDocumentUnsupportedCommandException(v **types.UnsupportedCommandException, value interface{}) error {
6084 if v == nil {
6085 return fmt.Errorf("unexpected nil of type %T", v)
6086 }
6087 if value == nil {
6088 return nil
6089 }
6090
6091 shape, ok := value.(map[string]interface{})
6092 if !ok {
6093 return fmt.Errorf("unexpected JSON type %v", value)
6094 }
6095
6096 var sv *types.UnsupportedCommandException
6097 if *v == nil {
6098 sv = &types.UnsupportedCommandException{}
6099 } else {
6100 sv = *v
6101 }
6102
6103 for key, value := range shape {
6104 switch key {
6105 case "message":
6106 if value != nil {
6107 jtv, ok := value.(string)
6108 if !ok {
6109 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
6110 }
6111 sv.Message = ptr.String(jtv)
6112 }
6113
6114 default:
6115 _, _ = key, value
6116
6117 }
6118 }
6119 *v = sv
6120 return nil
6121 }
6122
6123 func awsAwsjson11_deserializeDocumentUploadNotFoundException(v **types.UploadNotFoundException, value interface{}) error {
6124 if v == nil {
6125 return fmt.Errorf("unexpected nil of type %T", v)
6126 }
6127 if value == nil {
6128 return nil
6129 }
6130
6131 shape, ok := value.(map[string]interface{})
6132 if !ok {
6133 return fmt.Errorf("unexpected JSON type %v", value)
6134 }
6135
6136 var sv *types.UploadNotFoundException
6137 if *v == nil {
6138 sv = &types.UploadNotFoundException{}
6139 } else {
6140 sv = *v
6141 }
6142
6143 for key, value := range shape {
6144 switch key {
6145 case "message":
6146 if value != nil {
6147 jtv, ok := value.(string)
6148 if !ok {
6149 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
6150 }
6151 sv.Message = ptr.String(jtv)
6152 }
6153
6154 default:
6155 _, _ = key, value
6156
6157 }
6158 }
6159 *v = sv
6160 return nil
6161 }
6162
6163 func awsAwsjson11_deserializeOpDocumentBatchCheckLayerAvailabilityOutput(v **BatchCheckLayerAvailabilityOutput, value interface{}) error {
6164 if v == nil {
6165 return fmt.Errorf("unexpected nil of type %T", v)
6166 }
6167 if value == nil {
6168 return nil
6169 }
6170
6171 shape, ok := value.(map[string]interface{})
6172 if !ok {
6173 return fmt.Errorf("unexpected JSON type %v", value)
6174 }
6175
6176 var sv *BatchCheckLayerAvailabilityOutput
6177 if *v == nil {
6178 sv = &BatchCheckLayerAvailabilityOutput{}
6179 } else {
6180 sv = *v
6181 }
6182
6183 for key, value := range shape {
6184 switch key {
6185 case "failures":
6186 if err := awsAwsjson11_deserializeDocumentLayerFailureList(&sv.Failures, value); err != nil {
6187 return err
6188 }
6189
6190 case "layers":
6191 if err := awsAwsjson11_deserializeDocumentLayerList(&sv.Layers, value); err != nil {
6192 return err
6193 }
6194
6195 default:
6196 _, _ = key, value
6197
6198 }
6199 }
6200 *v = sv
6201 return nil
6202 }
6203
6204 func awsAwsjson11_deserializeOpDocumentBatchDeleteImageOutput(v **BatchDeleteImageOutput, 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.(map[string]interface{})
6213 if !ok {
6214 return fmt.Errorf("unexpected JSON type %v", value)
6215 }
6216
6217 var sv *BatchDeleteImageOutput
6218 if *v == nil {
6219 sv = &BatchDeleteImageOutput{}
6220 } else {
6221 sv = *v
6222 }
6223
6224 for key, value := range shape {
6225 switch key {
6226 case "failures":
6227 if err := awsAwsjson11_deserializeDocumentImageFailureList(&sv.Failures, value); err != nil {
6228 return err
6229 }
6230
6231 case "imageIds":
6232 if err := awsAwsjson11_deserializeDocumentImageIdentifierList(&sv.ImageIds, value); err != nil {
6233 return err
6234 }
6235
6236 default:
6237 _, _ = key, value
6238
6239 }
6240 }
6241 *v = sv
6242 return nil
6243 }
6244
6245 func awsAwsjson11_deserializeOpDocumentCompleteLayerUploadOutput(v **CompleteLayerUploadOutput, value interface{}) error {
6246 if v == nil {
6247 return fmt.Errorf("unexpected nil of type %T", v)
6248 }
6249 if value == nil {
6250 return nil
6251 }
6252
6253 shape, ok := value.(map[string]interface{})
6254 if !ok {
6255 return fmt.Errorf("unexpected JSON type %v", value)
6256 }
6257
6258 var sv *CompleteLayerUploadOutput
6259 if *v == nil {
6260 sv = &CompleteLayerUploadOutput{}
6261 } else {
6262 sv = *v
6263 }
6264
6265 for key, value := range shape {
6266 switch key {
6267 case "layerDigest":
6268 if value != nil {
6269 jtv, ok := value.(string)
6270 if !ok {
6271 return fmt.Errorf("expected LayerDigest to be of type string, got %T instead", value)
6272 }
6273 sv.LayerDigest = ptr.String(jtv)
6274 }
6275
6276 case "registryId":
6277 if value != nil {
6278 jtv, ok := value.(string)
6279 if !ok {
6280 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
6281 }
6282 sv.RegistryId = ptr.String(jtv)
6283 }
6284
6285 case "repositoryName":
6286 if value != nil {
6287 jtv, ok := value.(string)
6288 if !ok {
6289 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
6290 }
6291 sv.RepositoryName = ptr.String(jtv)
6292 }
6293
6294 case "uploadId":
6295 if value != nil {
6296 jtv, ok := value.(string)
6297 if !ok {
6298 return fmt.Errorf("expected UploadId to be of type string, got %T instead", value)
6299 }
6300 sv.UploadId = ptr.String(jtv)
6301 }
6302
6303 default:
6304 _, _ = key, value
6305
6306 }
6307 }
6308 *v = sv
6309 return nil
6310 }
6311
6312 func awsAwsjson11_deserializeOpDocumentCreateRepositoryOutput(v **CreateRepositoryOutput, value interface{}) error {
6313 if v == nil {
6314 return fmt.Errorf("unexpected nil of type %T", v)
6315 }
6316 if value == nil {
6317 return nil
6318 }
6319
6320 shape, ok := value.(map[string]interface{})
6321 if !ok {
6322 return fmt.Errorf("unexpected JSON type %v", value)
6323 }
6324
6325 var sv *CreateRepositoryOutput
6326 if *v == nil {
6327 sv = &CreateRepositoryOutput{}
6328 } else {
6329 sv = *v
6330 }
6331
6332 for key, value := range shape {
6333 switch key {
6334 case "catalogData":
6335 if err := awsAwsjson11_deserializeDocumentRepositoryCatalogData(&sv.CatalogData, value); err != nil {
6336 return err
6337 }
6338
6339 case "repository":
6340 if err := awsAwsjson11_deserializeDocumentRepository(&sv.Repository, value); err != nil {
6341 return err
6342 }
6343
6344 default:
6345 _, _ = key, value
6346
6347 }
6348 }
6349 *v = sv
6350 return nil
6351 }
6352
6353 func awsAwsjson11_deserializeOpDocumentDeleteRepositoryOutput(v **DeleteRepositoryOutput, value interface{}) error {
6354 if v == nil {
6355 return fmt.Errorf("unexpected nil of type %T", v)
6356 }
6357 if value == nil {
6358 return nil
6359 }
6360
6361 shape, ok := value.(map[string]interface{})
6362 if !ok {
6363 return fmt.Errorf("unexpected JSON type %v", value)
6364 }
6365
6366 var sv *DeleteRepositoryOutput
6367 if *v == nil {
6368 sv = &DeleteRepositoryOutput{}
6369 } else {
6370 sv = *v
6371 }
6372
6373 for key, value := range shape {
6374 switch key {
6375 case "repository":
6376 if err := awsAwsjson11_deserializeDocumentRepository(&sv.Repository, value); err != nil {
6377 return err
6378 }
6379
6380 default:
6381 _, _ = key, value
6382
6383 }
6384 }
6385 *v = sv
6386 return nil
6387 }
6388
6389 func awsAwsjson11_deserializeOpDocumentDeleteRepositoryPolicyOutput(v **DeleteRepositoryPolicyOutput, value interface{}) error {
6390 if v == nil {
6391 return fmt.Errorf("unexpected nil of type %T", v)
6392 }
6393 if value == nil {
6394 return nil
6395 }
6396
6397 shape, ok := value.(map[string]interface{})
6398 if !ok {
6399 return fmt.Errorf("unexpected JSON type %v", value)
6400 }
6401
6402 var sv *DeleteRepositoryPolicyOutput
6403 if *v == nil {
6404 sv = &DeleteRepositoryPolicyOutput{}
6405 } else {
6406 sv = *v
6407 }
6408
6409 for key, value := range shape {
6410 switch key {
6411 case "policyText":
6412 if value != nil {
6413 jtv, ok := value.(string)
6414 if !ok {
6415 return fmt.Errorf("expected RepositoryPolicyText to be of type string, got %T instead", value)
6416 }
6417 sv.PolicyText = ptr.String(jtv)
6418 }
6419
6420 case "registryId":
6421 if value != nil {
6422 jtv, ok := value.(string)
6423 if !ok {
6424 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
6425 }
6426 sv.RegistryId = ptr.String(jtv)
6427 }
6428
6429 case "repositoryName":
6430 if value != nil {
6431 jtv, ok := value.(string)
6432 if !ok {
6433 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
6434 }
6435 sv.RepositoryName = ptr.String(jtv)
6436 }
6437
6438 default:
6439 _, _ = key, value
6440
6441 }
6442 }
6443 *v = sv
6444 return nil
6445 }
6446
6447 func awsAwsjson11_deserializeOpDocumentDescribeImagesOutput(v **DescribeImagesOutput, value interface{}) error {
6448 if v == nil {
6449 return fmt.Errorf("unexpected nil of type %T", v)
6450 }
6451 if value == nil {
6452 return nil
6453 }
6454
6455 shape, ok := value.(map[string]interface{})
6456 if !ok {
6457 return fmt.Errorf("unexpected JSON type %v", value)
6458 }
6459
6460 var sv *DescribeImagesOutput
6461 if *v == nil {
6462 sv = &DescribeImagesOutput{}
6463 } else {
6464 sv = *v
6465 }
6466
6467 for key, value := range shape {
6468 switch key {
6469 case "imageDetails":
6470 if err := awsAwsjson11_deserializeDocumentImageDetailList(&sv.ImageDetails, value); err != nil {
6471 return err
6472 }
6473
6474 case "nextToken":
6475 if value != nil {
6476 jtv, ok := value.(string)
6477 if !ok {
6478 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
6479 }
6480 sv.NextToken = ptr.String(jtv)
6481 }
6482
6483 default:
6484 _, _ = key, value
6485
6486 }
6487 }
6488 *v = sv
6489 return nil
6490 }
6491
6492 func awsAwsjson11_deserializeOpDocumentDescribeImageTagsOutput(v **DescribeImageTagsOutput, value interface{}) error {
6493 if v == nil {
6494 return fmt.Errorf("unexpected nil of type %T", v)
6495 }
6496 if value == nil {
6497 return nil
6498 }
6499
6500 shape, ok := value.(map[string]interface{})
6501 if !ok {
6502 return fmt.Errorf("unexpected JSON type %v", value)
6503 }
6504
6505 var sv *DescribeImageTagsOutput
6506 if *v == nil {
6507 sv = &DescribeImageTagsOutput{}
6508 } else {
6509 sv = *v
6510 }
6511
6512 for key, value := range shape {
6513 switch key {
6514 case "imageTagDetails":
6515 if err := awsAwsjson11_deserializeDocumentImageTagDetailList(&sv.ImageTagDetails, value); err != nil {
6516 return err
6517 }
6518
6519 case "nextToken":
6520 if value != nil {
6521 jtv, ok := value.(string)
6522 if !ok {
6523 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
6524 }
6525 sv.NextToken = ptr.String(jtv)
6526 }
6527
6528 default:
6529 _, _ = key, value
6530
6531 }
6532 }
6533 *v = sv
6534 return nil
6535 }
6536
6537 func awsAwsjson11_deserializeOpDocumentDescribeRegistriesOutput(v **DescribeRegistriesOutput, value interface{}) error {
6538 if v == nil {
6539 return fmt.Errorf("unexpected nil of type %T", v)
6540 }
6541 if value == nil {
6542 return nil
6543 }
6544
6545 shape, ok := value.(map[string]interface{})
6546 if !ok {
6547 return fmt.Errorf("unexpected JSON type %v", value)
6548 }
6549
6550 var sv *DescribeRegistriesOutput
6551 if *v == nil {
6552 sv = &DescribeRegistriesOutput{}
6553 } else {
6554 sv = *v
6555 }
6556
6557 for key, value := range shape {
6558 switch key {
6559 case "nextToken":
6560 if value != nil {
6561 jtv, ok := value.(string)
6562 if !ok {
6563 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
6564 }
6565 sv.NextToken = ptr.String(jtv)
6566 }
6567
6568 case "registries":
6569 if err := awsAwsjson11_deserializeDocumentRegistryList(&sv.Registries, value); err != nil {
6570 return err
6571 }
6572
6573 default:
6574 _, _ = key, value
6575
6576 }
6577 }
6578 *v = sv
6579 return nil
6580 }
6581
6582 func awsAwsjson11_deserializeOpDocumentDescribeRepositoriesOutput(v **DescribeRepositoriesOutput, value interface{}) error {
6583 if v == nil {
6584 return fmt.Errorf("unexpected nil of type %T", v)
6585 }
6586 if value == nil {
6587 return nil
6588 }
6589
6590 shape, ok := value.(map[string]interface{})
6591 if !ok {
6592 return fmt.Errorf("unexpected JSON type %v", value)
6593 }
6594
6595 var sv *DescribeRepositoriesOutput
6596 if *v == nil {
6597 sv = &DescribeRepositoriesOutput{}
6598 } else {
6599 sv = *v
6600 }
6601
6602 for key, value := range shape {
6603 switch key {
6604 case "nextToken":
6605 if value != nil {
6606 jtv, ok := value.(string)
6607 if !ok {
6608 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
6609 }
6610 sv.NextToken = ptr.String(jtv)
6611 }
6612
6613 case "repositories":
6614 if err := awsAwsjson11_deserializeDocumentRepositoryList(&sv.Repositories, value); err != nil {
6615 return err
6616 }
6617
6618 default:
6619 _, _ = key, value
6620
6621 }
6622 }
6623 *v = sv
6624 return nil
6625 }
6626
6627 func awsAwsjson11_deserializeOpDocumentGetAuthorizationTokenOutput(v **GetAuthorizationTokenOutput, value interface{}) error {
6628 if v == nil {
6629 return fmt.Errorf("unexpected nil of type %T", v)
6630 }
6631 if value == nil {
6632 return nil
6633 }
6634
6635 shape, ok := value.(map[string]interface{})
6636 if !ok {
6637 return fmt.Errorf("unexpected JSON type %v", value)
6638 }
6639
6640 var sv *GetAuthorizationTokenOutput
6641 if *v == nil {
6642 sv = &GetAuthorizationTokenOutput{}
6643 } else {
6644 sv = *v
6645 }
6646
6647 for key, value := range shape {
6648 switch key {
6649 case "authorizationData":
6650 if err := awsAwsjson11_deserializeDocumentAuthorizationData(&sv.AuthorizationData, value); err != nil {
6651 return err
6652 }
6653
6654 default:
6655 _, _ = key, value
6656
6657 }
6658 }
6659 *v = sv
6660 return nil
6661 }
6662
6663 func awsAwsjson11_deserializeOpDocumentGetRegistryCatalogDataOutput(v **GetRegistryCatalogDataOutput, value interface{}) error {
6664 if v == nil {
6665 return fmt.Errorf("unexpected nil of type %T", v)
6666 }
6667 if value == nil {
6668 return nil
6669 }
6670
6671 shape, ok := value.(map[string]interface{})
6672 if !ok {
6673 return fmt.Errorf("unexpected JSON type %v", value)
6674 }
6675
6676 var sv *GetRegistryCatalogDataOutput
6677 if *v == nil {
6678 sv = &GetRegistryCatalogDataOutput{}
6679 } else {
6680 sv = *v
6681 }
6682
6683 for key, value := range shape {
6684 switch key {
6685 case "registryCatalogData":
6686 if err := awsAwsjson11_deserializeDocumentRegistryCatalogData(&sv.RegistryCatalogData, value); err != nil {
6687 return err
6688 }
6689
6690 default:
6691 _, _ = key, value
6692
6693 }
6694 }
6695 *v = sv
6696 return nil
6697 }
6698
6699 func awsAwsjson11_deserializeOpDocumentGetRepositoryCatalogDataOutput(v **GetRepositoryCatalogDataOutput, value interface{}) error {
6700 if v == nil {
6701 return fmt.Errorf("unexpected nil of type %T", v)
6702 }
6703 if value == nil {
6704 return nil
6705 }
6706
6707 shape, ok := value.(map[string]interface{})
6708 if !ok {
6709 return fmt.Errorf("unexpected JSON type %v", value)
6710 }
6711
6712 var sv *GetRepositoryCatalogDataOutput
6713 if *v == nil {
6714 sv = &GetRepositoryCatalogDataOutput{}
6715 } else {
6716 sv = *v
6717 }
6718
6719 for key, value := range shape {
6720 switch key {
6721 case "catalogData":
6722 if err := awsAwsjson11_deserializeDocumentRepositoryCatalogData(&sv.CatalogData, value); err != nil {
6723 return err
6724 }
6725
6726 default:
6727 _, _ = key, value
6728
6729 }
6730 }
6731 *v = sv
6732 return nil
6733 }
6734
6735 func awsAwsjson11_deserializeOpDocumentGetRepositoryPolicyOutput(v **GetRepositoryPolicyOutput, value interface{}) error {
6736 if v == nil {
6737 return fmt.Errorf("unexpected nil of type %T", v)
6738 }
6739 if value == nil {
6740 return nil
6741 }
6742
6743 shape, ok := value.(map[string]interface{})
6744 if !ok {
6745 return fmt.Errorf("unexpected JSON type %v", value)
6746 }
6747
6748 var sv *GetRepositoryPolicyOutput
6749 if *v == nil {
6750 sv = &GetRepositoryPolicyOutput{}
6751 } else {
6752 sv = *v
6753 }
6754
6755 for key, value := range shape {
6756 switch key {
6757 case "policyText":
6758 if value != nil {
6759 jtv, ok := value.(string)
6760 if !ok {
6761 return fmt.Errorf("expected RepositoryPolicyText to be of type string, got %T instead", value)
6762 }
6763 sv.PolicyText = ptr.String(jtv)
6764 }
6765
6766 case "registryId":
6767 if value != nil {
6768 jtv, ok := value.(string)
6769 if !ok {
6770 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
6771 }
6772 sv.RegistryId = ptr.String(jtv)
6773 }
6774
6775 case "repositoryName":
6776 if value != nil {
6777 jtv, ok := value.(string)
6778 if !ok {
6779 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
6780 }
6781 sv.RepositoryName = ptr.String(jtv)
6782 }
6783
6784 default:
6785 _, _ = key, value
6786
6787 }
6788 }
6789 *v = sv
6790 return nil
6791 }
6792
6793 func awsAwsjson11_deserializeOpDocumentInitiateLayerUploadOutput(v **InitiateLayerUploadOutput, value interface{}) error {
6794 if v == nil {
6795 return fmt.Errorf("unexpected nil of type %T", v)
6796 }
6797 if value == nil {
6798 return nil
6799 }
6800
6801 shape, ok := value.(map[string]interface{})
6802 if !ok {
6803 return fmt.Errorf("unexpected JSON type %v", value)
6804 }
6805
6806 var sv *InitiateLayerUploadOutput
6807 if *v == nil {
6808 sv = &InitiateLayerUploadOutput{}
6809 } else {
6810 sv = *v
6811 }
6812
6813 for key, value := range shape {
6814 switch key {
6815 case "partSize":
6816 if value != nil {
6817 jtv, ok := value.(json.Number)
6818 if !ok {
6819 return fmt.Errorf("expected PartSize to be json.Number, got %T instead", value)
6820 }
6821 i64, err := jtv.Int64()
6822 if err != nil {
6823 return err
6824 }
6825 sv.PartSize = ptr.Int64(i64)
6826 }
6827
6828 case "uploadId":
6829 if value != nil {
6830 jtv, ok := value.(string)
6831 if !ok {
6832 return fmt.Errorf("expected UploadId to be of type string, got %T instead", value)
6833 }
6834 sv.UploadId = ptr.String(jtv)
6835 }
6836
6837 default:
6838 _, _ = key, value
6839
6840 }
6841 }
6842 *v = sv
6843 return nil
6844 }
6845
6846 func awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error {
6847 if v == nil {
6848 return fmt.Errorf("unexpected nil of type %T", v)
6849 }
6850 if value == nil {
6851 return nil
6852 }
6853
6854 shape, ok := value.(map[string]interface{})
6855 if !ok {
6856 return fmt.Errorf("unexpected JSON type %v", value)
6857 }
6858
6859 var sv *ListTagsForResourceOutput
6860 if *v == nil {
6861 sv = &ListTagsForResourceOutput{}
6862 } else {
6863 sv = *v
6864 }
6865
6866 for key, value := range shape {
6867 switch key {
6868 case "tags":
6869 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
6870 return err
6871 }
6872
6873 default:
6874 _, _ = key, value
6875
6876 }
6877 }
6878 *v = sv
6879 return nil
6880 }
6881
6882 func awsAwsjson11_deserializeOpDocumentPutImageOutput(v **PutImageOutput, value interface{}) error {
6883 if v == nil {
6884 return fmt.Errorf("unexpected nil of type %T", v)
6885 }
6886 if value == nil {
6887 return nil
6888 }
6889
6890 shape, ok := value.(map[string]interface{})
6891 if !ok {
6892 return fmt.Errorf("unexpected JSON type %v", value)
6893 }
6894
6895 var sv *PutImageOutput
6896 if *v == nil {
6897 sv = &PutImageOutput{}
6898 } else {
6899 sv = *v
6900 }
6901
6902 for key, value := range shape {
6903 switch key {
6904 case "image":
6905 if err := awsAwsjson11_deserializeDocumentImage(&sv.Image, value); err != nil {
6906 return err
6907 }
6908
6909 default:
6910 _, _ = key, value
6911
6912 }
6913 }
6914 *v = sv
6915 return nil
6916 }
6917
6918 func awsAwsjson11_deserializeOpDocumentPutRegistryCatalogDataOutput(v **PutRegistryCatalogDataOutput, value interface{}) error {
6919 if v == nil {
6920 return fmt.Errorf("unexpected nil of type %T", v)
6921 }
6922 if value == nil {
6923 return nil
6924 }
6925
6926 shape, ok := value.(map[string]interface{})
6927 if !ok {
6928 return fmt.Errorf("unexpected JSON type %v", value)
6929 }
6930
6931 var sv *PutRegistryCatalogDataOutput
6932 if *v == nil {
6933 sv = &PutRegistryCatalogDataOutput{}
6934 } else {
6935 sv = *v
6936 }
6937
6938 for key, value := range shape {
6939 switch key {
6940 case "registryCatalogData":
6941 if err := awsAwsjson11_deserializeDocumentRegistryCatalogData(&sv.RegistryCatalogData, value); err != nil {
6942 return err
6943 }
6944
6945 default:
6946 _, _ = key, value
6947
6948 }
6949 }
6950 *v = sv
6951 return nil
6952 }
6953
6954 func awsAwsjson11_deserializeOpDocumentPutRepositoryCatalogDataOutput(v **PutRepositoryCatalogDataOutput, value interface{}) error {
6955 if v == nil {
6956 return fmt.Errorf("unexpected nil of type %T", v)
6957 }
6958 if value == nil {
6959 return nil
6960 }
6961
6962 shape, ok := value.(map[string]interface{})
6963 if !ok {
6964 return fmt.Errorf("unexpected JSON type %v", value)
6965 }
6966
6967 var sv *PutRepositoryCatalogDataOutput
6968 if *v == nil {
6969 sv = &PutRepositoryCatalogDataOutput{}
6970 } else {
6971 sv = *v
6972 }
6973
6974 for key, value := range shape {
6975 switch key {
6976 case "catalogData":
6977 if err := awsAwsjson11_deserializeDocumentRepositoryCatalogData(&sv.CatalogData, value); err != nil {
6978 return err
6979 }
6980
6981 default:
6982 _, _ = key, value
6983
6984 }
6985 }
6986 *v = sv
6987 return nil
6988 }
6989
6990 func awsAwsjson11_deserializeOpDocumentSetRepositoryPolicyOutput(v **SetRepositoryPolicyOutput, value interface{}) error {
6991 if v == nil {
6992 return fmt.Errorf("unexpected nil of type %T", v)
6993 }
6994 if value == nil {
6995 return nil
6996 }
6997
6998 shape, ok := value.(map[string]interface{})
6999 if !ok {
7000 return fmt.Errorf("unexpected JSON type %v", value)
7001 }
7002
7003 var sv *SetRepositoryPolicyOutput
7004 if *v == nil {
7005 sv = &SetRepositoryPolicyOutput{}
7006 } else {
7007 sv = *v
7008 }
7009
7010 for key, value := range shape {
7011 switch key {
7012 case "policyText":
7013 if value != nil {
7014 jtv, ok := value.(string)
7015 if !ok {
7016 return fmt.Errorf("expected RepositoryPolicyText to be of type string, got %T instead", value)
7017 }
7018 sv.PolicyText = ptr.String(jtv)
7019 }
7020
7021 case "registryId":
7022 if value != nil {
7023 jtv, ok := value.(string)
7024 if !ok {
7025 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
7026 }
7027 sv.RegistryId = ptr.String(jtv)
7028 }
7029
7030 case "repositoryName":
7031 if value != nil {
7032 jtv, ok := value.(string)
7033 if !ok {
7034 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
7035 }
7036 sv.RepositoryName = ptr.String(jtv)
7037 }
7038
7039 default:
7040 _, _ = key, value
7041
7042 }
7043 }
7044 *v = sv
7045 return nil
7046 }
7047
7048 func awsAwsjson11_deserializeOpDocumentTagResourceOutput(v **TagResourceOutput, value interface{}) error {
7049 if v == nil {
7050 return fmt.Errorf("unexpected nil of type %T", v)
7051 }
7052 if value == nil {
7053 return nil
7054 }
7055
7056 shape, ok := value.(map[string]interface{})
7057 if !ok {
7058 return fmt.Errorf("unexpected JSON type %v", value)
7059 }
7060
7061 var sv *TagResourceOutput
7062 if *v == nil {
7063 sv = &TagResourceOutput{}
7064 } else {
7065 sv = *v
7066 }
7067
7068 for key, value := range shape {
7069 switch key {
7070 default:
7071 _, _ = key, value
7072
7073 }
7074 }
7075 *v = sv
7076 return nil
7077 }
7078
7079 func awsAwsjson11_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutput, value interface{}) error {
7080 if v == nil {
7081 return fmt.Errorf("unexpected nil of type %T", v)
7082 }
7083 if value == nil {
7084 return nil
7085 }
7086
7087 shape, ok := value.(map[string]interface{})
7088 if !ok {
7089 return fmt.Errorf("unexpected JSON type %v", value)
7090 }
7091
7092 var sv *UntagResourceOutput
7093 if *v == nil {
7094 sv = &UntagResourceOutput{}
7095 } else {
7096 sv = *v
7097 }
7098
7099 for key, value := range shape {
7100 switch key {
7101 default:
7102 _, _ = key, value
7103
7104 }
7105 }
7106 *v = sv
7107 return nil
7108 }
7109
7110 func awsAwsjson11_deserializeOpDocumentUploadLayerPartOutput(v **UploadLayerPartOutput, value interface{}) error {
7111 if v == nil {
7112 return fmt.Errorf("unexpected nil of type %T", v)
7113 }
7114 if value == nil {
7115 return nil
7116 }
7117
7118 shape, ok := value.(map[string]interface{})
7119 if !ok {
7120 return fmt.Errorf("unexpected JSON type %v", value)
7121 }
7122
7123 var sv *UploadLayerPartOutput
7124 if *v == nil {
7125 sv = &UploadLayerPartOutput{}
7126 } else {
7127 sv = *v
7128 }
7129
7130 for key, value := range shape {
7131 switch key {
7132 case "lastByteReceived":
7133 if value != nil {
7134 jtv, ok := value.(json.Number)
7135 if !ok {
7136 return fmt.Errorf("expected PartSize to be json.Number, got %T instead", value)
7137 }
7138 i64, err := jtv.Int64()
7139 if err != nil {
7140 return err
7141 }
7142 sv.LastByteReceived = ptr.Int64(i64)
7143 }
7144
7145 case "registryId":
7146 if value != nil {
7147 jtv, ok := value.(string)
7148 if !ok {
7149 return fmt.Errorf("expected RegistryId to be of type string, got %T instead", value)
7150 }
7151 sv.RegistryId = ptr.String(jtv)
7152 }
7153
7154 case "repositoryName":
7155 if value != nil {
7156 jtv, ok := value.(string)
7157 if !ok {
7158 return fmt.Errorf("expected RepositoryName to be of type string, got %T instead", value)
7159 }
7160 sv.RepositoryName = ptr.String(jtv)
7161 }
7162
7163 case "uploadId":
7164 if value != nil {
7165 jtv, ok := value.(string)
7166 if !ok {
7167 return fmt.Errorf("expected UploadId to be of type string, got %T instead", value)
7168 }
7169 sv.UploadId = ptr.String(jtv)
7170 }
7171
7172 default:
7173 _, _ = key, value
7174
7175 }
7176 }
7177 *v = sv
7178 return nil
7179 }
7180
View as plain text