1
2
3 package ecr
4
5 import (
6 "bytes"
7 "context"
8 "fmt"
9 "github.com/aws/aws-sdk-go-v2/service/ecr/types"
10 smithy "github.com/aws/smithy-go"
11 "github.com/aws/smithy-go/encoding/httpbinding"
12 smithyjson "github.com/aws/smithy-go/encoding/json"
13 "github.com/aws/smithy-go/middleware"
14 smithyhttp "github.com/aws/smithy-go/transport/http"
15 "path"
16 )
17
18 type awsAwsjson11_serializeOpBatchCheckLayerAvailability struct {
19 }
20
21 func (*awsAwsjson11_serializeOpBatchCheckLayerAvailability) ID() string {
22 return "OperationSerializer"
23 }
24
25 func (m *awsAwsjson11_serializeOpBatchCheckLayerAvailability) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
26 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
27 ) {
28 request, ok := in.Request.(*smithyhttp.Request)
29 if !ok {
30 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
31 }
32
33 input, ok := in.Parameters.(*BatchCheckLayerAvailabilityInput)
34 _ = input
35 if !ok {
36 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
37 }
38
39 operationPath := "/"
40 if len(request.Request.URL.Path) == 0 {
41 request.Request.URL.Path = operationPath
42 } else {
43 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
44 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
45 request.Request.URL.Path += "/"
46 }
47 }
48 request.Request.Method = "POST"
49 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
50 if err != nil {
51 return out, metadata, &smithy.SerializationError{Err: err}
52 }
53 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
54 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.BatchCheckLayerAvailability")
55
56 jsonEncoder := smithyjson.NewEncoder()
57 if err := awsAwsjson11_serializeOpDocumentBatchCheckLayerAvailabilityInput(input, jsonEncoder.Value); err != nil {
58 return out, metadata, &smithy.SerializationError{Err: err}
59 }
60
61 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
62 return out, metadata, &smithy.SerializationError{Err: err}
63 }
64
65 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
66 return out, metadata, &smithy.SerializationError{Err: err}
67 }
68 in.Request = request
69
70 return next.HandleSerialize(ctx, in)
71 }
72
73 type awsAwsjson11_serializeOpBatchDeleteImage struct {
74 }
75
76 func (*awsAwsjson11_serializeOpBatchDeleteImage) ID() string {
77 return "OperationSerializer"
78 }
79
80 func (m *awsAwsjson11_serializeOpBatchDeleteImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
81 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
82 ) {
83 request, ok := in.Request.(*smithyhttp.Request)
84 if !ok {
85 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
86 }
87
88 input, ok := in.Parameters.(*BatchDeleteImageInput)
89 _ = input
90 if !ok {
91 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
92 }
93
94 operationPath := "/"
95 if len(request.Request.URL.Path) == 0 {
96 request.Request.URL.Path = operationPath
97 } else {
98 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
99 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
100 request.Request.URL.Path += "/"
101 }
102 }
103 request.Request.Method = "POST"
104 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
105 if err != nil {
106 return out, metadata, &smithy.SerializationError{Err: err}
107 }
108 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
109 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.BatchDeleteImage")
110
111 jsonEncoder := smithyjson.NewEncoder()
112 if err := awsAwsjson11_serializeOpDocumentBatchDeleteImageInput(input, jsonEncoder.Value); err != nil {
113 return out, metadata, &smithy.SerializationError{Err: err}
114 }
115
116 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
117 return out, metadata, &smithy.SerializationError{Err: err}
118 }
119
120 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
121 return out, metadata, &smithy.SerializationError{Err: err}
122 }
123 in.Request = request
124
125 return next.HandleSerialize(ctx, in)
126 }
127
128 type awsAwsjson11_serializeOpBatchGetImage struct {
129 }
130
131 func (*awsAwsjson11_serializeOpBatchGetImage) ID() string {
132 return "OperationSerializer"
133 }
134
135 func (m *awsAwsjson11_serializeOpBatchGetImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
136 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
137 ) {
138 request, ok := in.Request.(*smithyhttp.Request)
139 if !ok {
140 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
141 }
142
143 input, ok := in.Parameters.(*BatchGetImageInput)
144 _ = input
145 if !ok {
146 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
147 }
148
149 operationPath := "/"
150 if len(request.Request.URL.Path) == 0 {
151 request.Request.URL.Path = operationPath
152 } else {
153 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
154 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
155 request.Request.URL.Path += "/"
156 }
157 }
158 request.Request.Method = "POST"
159 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
160 if err != nil {
161 return out, metadata, &smithy.SerializationError{Err: err}
162 }
163 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
164 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.BatchGetImage")
165
166 jsonEncoder := smithyjson.NewEncoder()
167 if err := awsAwsjson11_serializeOpDocumentBatchGetImageInput(input, jsonEncoder.Value); err != nil {
168 return out, metadata, &smithy.SerializationError{Err: err}
169 }
170
171 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
172 return out, metadata, &smithy.SerializationError{Err: err}
173 }
174
175 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
176 return out, metadata, &smithy.SerializationError{Err: err}
177 }
178 in.Request = request
179
180 return next.HandleSerialize(ctx, in)
181 }
182
183 type awsAwsjson11_serializeOpBatchGetRepositoryScanningConfiguration struct {
184 }
185
186 func (*awsAwsjson11_serializeOpBatchGetRepositoryScanningConfiguration) ID() string {
187 return "OperationSerializer"
188 }
189
190 func (m *awsAwsjson11_serializeOpBatchGetRepositoryScanningConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
191 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
192 ) {
193 request, ok := in.Request.(*smithyhttp.Request)
194 if !ok {
195 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
196 }
197
198 input, ok := in.Parameters.(*BatchGetRepositoryScanningConfigurationInput)
199 _ = input
200 if !ok {
201 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
202 }
203
204 operationPath := "/"
205 if len(request.Request.URL.Path) == 0 {
206 request.Request.URL.Path = operationPath
207 } else {
208 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
209 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
210 request.Request.URL.Path += "/"
211 }
212 }
213 request.Request.Method = "POST"
214 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
215 if err != nil {
216 return out, metadata, &smithy.SerializationError{Err: err}
217 }
218 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
219 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.BatchGetRepositoryScanningConfiguration")
220
221 jsonEncoder := smithyjson.NewEncoder()
222 if err := awsAwsjson11_serializeOpDocumentBatchGetRepositoryScanningConfigurationInput(input, jsonEncoder.Value); err != nil {
223 return out, metadata, &smithy.SerializationError{Err: err}
224 }
225
226 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
227 return out, metadata, &smithy.SerializationError{Err: err}
228 }
229
230 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
231 return out, metadata, &smithy.SerializationError{Err: err}
232 }
233 in.Request = request
234
235 return next.HandleSerialize(ctx, in)
236 }
237
238 type awsAwsjson11_serializeOpCompleteLayerUpload struct {
239 }
240
241 func (*awsAwsjson11_serializeOpCompleteLayerUpload) ID() string {
242 return "OperationSerializer"
243 }
244
245 func (m *awsAwsjson11_serializeOpCompleteLayerUpload) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
246 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
247 ) {
248 request, ok := in.Request.(*smithyhttp.Request)
249 if !ok {
250 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
251 }
252
253 input, ok := in.Parameters.(*CompleteLayerUploadInput)
254 _ = input
255 if !ok {
256 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
257 }
258
259 operationPath := "/"
260 if len(request.Request.URL.Path) == 0 {
261 request.Request.URL.Path = operationPath
262 } else {
263 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
264 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
265 request.Request.URL.Path += "/"
266 }
267 }
268 request.Request.Method = "POST"
269 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
270 if err != nil {
271 return out, metadata, &smithy.SerializationError{Err: err}
272 }
273 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
274 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.CompleteLayerUpload")
275
276 jsonEncoder := smithyjson.NewEncoder()
277 if err := awsAwsjson11_serializeOpDocumentCompleteLayerUploadInput(input, jsonEncoder.Value); err != nil {
278 return out, metadata, &smithy.SerializationError{Err: err}
279 }
280
281 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
282 return out, metadata, &smithy.SerializationError{Err: err}
283 }
284
285 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
286 return out, metadata, &smithy.SerializationError{Err: err}
287 }
288 in.Request = request
289
290 return next.HandleSerialize(ctx, in)
291 }
292
293 type awsAwsjson11_serializeOpCreatePullThroughCacheRule struct {
294 }
295
296 func (*awsAwsjson11_serializeOpCreatePullThroughCacheRule) ID() string {
297 return "OperationSerializer"
298 }
299
300 func (m *awsAwsjson11_serializeOpCreatePullThroughCacheRule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
301 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
302 ) {
303 request, ok := in.Request.(*smithyhttp.Request)
304 if !ok {
305 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
306 }
307
308 input, ok := in.Parameters.(*CreatePullThroughCacheRuleInput)
309 _ = input
310 if !ok {
311 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
312 }
313
314 operationPath := "/"
315 if len(request.Request.URL.Path) == 0 {
316 request.Request.URL.Path = operationPath
317 } else {
318 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
319 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
320 request.Request.URL.Path += "/"
321 }
322 }
323 request.Request.Method = "POST"
324 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
325 if err != nil {
326 return out, metadata, &smithy.SerializationError{Err: err}
327 }
328 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
329 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.CreatePullThroughCacheRule")
330
331 jsonEncoder := smithyjson.NewEncoder()
332 if err := awsAwsjson11_serializeOpDocumentCreatePullThroughCacheRuleInput(input, jsonEncoder.Value); err != nil {
333 return out, metadata, &smithy.SerializationError{Err: err}
334 }
335
336 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
337 return out, metadata, &smithy.SerializationError{Err: err}
338 }
339
340 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
341 return out, metadata, &smithy.SerializationError{Err: err}
342 }
343 in.Request = request
344
345 return next.HandleSerialize(ctx, in)
346 }
347
348 type awsAwsjson11_serializeOpCreateRepository struct {
349 }
350
351 func (*awsAwsjson11_serializeOpCreateRepository) ID() string {
352 return "OperationSerializer"
353 }
354
355 func (m *awsAwsjson11_serializeOpCreateRepository) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
356 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
357 ) {
358 request, ok := in.Request.(*smithyhttp.Request)
359 if !ok {
360 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
361 }
362
363 input, ok := in.Parameters.(*CreateRepositoryInput)
364 _ = input
365 if !ok {
366 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
367 }
368
369 operationPath := "/"
370 if len(request.Request.URL.Path) == 0 {
371 request.Request.URL.Path = operationPath
372 } else {
373 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
374 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
375 request.Request.URL.Path += "/"
376 }
377 }
378 request.Request.Method = "POST"
379 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
380 if err != nil {
381 return out, metadata, &smithy.SerializationError{Err: err}
382 }
383 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
384 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.CreateRepository")
385
386 jsonEncoder := smithyjson.NewEncoder()
387 if err := awsAwsjson11_serializeOpDocumentCreateRepositoryInput(input, jsonEncoder.Value); err != nil {
388 return out, metadata, &smithy.SerializationError{Err: err}
389 }
390
391 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
392 return out, metadata, &smithy.SerializationError{Err: err}
393 }
394
395 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
396 return out, metadata, &smithy.SerializationError{Err: err}
397 }
398 in.Request = request
399
400 return next.HandleSerialize(ctx, in)
401 }
402
403 type awsAwsjson11_serializeOpDeleteLifecyclePolicy struct {
404 }
405
406 func (*awsAwsjson11_serializeOpDeleteLifecyclePolicy) ID() string {
407 return "OperationSerializer"
408 }
409
410 func (m *awsAwsjson11_serializeOpDeleteLifecyclePolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
411 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
412 ) {
413 request, ok := in.Request.(*smithyhttp.Request)
414 if !ok {
415 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
416 }
417
418 input, ok := in.Parameters.(*DeleteLifecyclePolicyInput)
419 _ = input
420 if !ok {
421 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
422 }
423
424 operationPath := "/"
425 if len(request.Request.URL.Path) == 0 {
426 request.Request.URL.Path = operationPath
427 } else {
428 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
429 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
430 request.Request.URL.Path += "/"
431 }
432 }
433 request.Request.Method = "POST"
434 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
435 if err != nil {
436 return out, metadata, &smithy.SerializationError{Err: err}
437 }
438 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
439 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.DeleteLifecyclePolicy")
440
441 jsonEncoder := smithyjson.NewEncoder()
442 if err := awsAwsjson11_serializeOpDocumentDeleteLifecyclePolicyInput(input, jsonEncoder.Value); err != nil {
443 return out, metadata, &smithy.SerializationError{Err: err}
444 }
445
446 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
447 return out, metadata, &smithy.SerializationError{Err: err}
448 }
449
450 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
451 return out, metadata, &smithy.SerializationError{Err: err}
452 }
453 in.Request = request
454
455 return next.HandleSerialize(ctx, in)
456 }
457
458 type awsAwsjson11_serializeOpDeletePullThroughCacheRule struct {
459 }
460
461 func (*awsAwsjson11_serializeOpDeletePullThroughCacheRule) ID() string {
462 return "OperationSerializer"
463 }
464
465 func (m *awsAwsjson11_serializeOpDeletePullThroughCacheRule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
466 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
467 ) {
468 request, ok := in.Request.(*smithyhttp.Request)
469 if !ok {
470 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
471 }
472
473 input, ok := in.Parameters.(*DeletePullThroughCacheRuleInput)
474 _ = input
475 if !ok {
476 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
477 }
478
479 operationPath := "/"
480 if len(request.Request.URL.Path) == 0 {
481 request.Request.URL.Path = operationPath
482 } else {
483 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
484 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
485 request.Request.URL.Path += "/"
486 }
487 }
488 request.Request.Method = "POST"
489 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
490 if err != nil {
491 return out, metadata, &smithy.SerializationError{Err: err}
492 }
493 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
494 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.DeletePullThroughCacheRule")
495
496 jsonEncoder := smithyjson.NewEncoder()
497 if err := awsAwsjson11_serializeOpDocumentDeletePullThroughCacheRuleInput(input, jsonEncoder.Value); err != nil {
498 return out, metadata, &smithy.SerializationError{Err: err}
499 }
500
501 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
502 return out, metadata, &smithy.SerializationError{Err: err}
503 }
504
505 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
506 return out, metadata, &smithy.SerializationError{Err: err}
507 }
508 in.Request = request
509
510 return next.HandleSerialize(ctx, in)
511 }
512
513 type awsAwsjson11_serializeOpDeleteRegistryPolicy struct {
514 }
515
516 func (*awsAwsjson11_serializeOpDeleteRegistryPolicy) ID() string {
517 return "OperationSerializer"
518 }
519
520 func (m *awsAwsjson11_serializeOpDeleteRegistryPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
521 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
522 ) {
523 request, ok := in.Request.(*smithyhttp.Request)
524 if !ok {
525 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
526 }
527
528 input, ok := in.Parameters.(*DeleteRegistryPolicyInput)
529 _ = input
530 if !ok {
531 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
532 }
533
534 operationPath := "/"
535 if len(request.Request.URL.Path) == 0 {
536 request.Request.URL.Path = operationPath
537 } else {
538 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
539 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
540 request.Request.URL.Path += "/"
541 }
542 }
543 request.Request.Method = "POST"
544 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
545 if err != nil {
546 return out, metadata, &smithy.SerializationError{Err: err}
547 }
548 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
549 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.DeleteRegistryPolicy")
550
551 jsonEncoder := smithyjson.NewEncoder()
552 if err := awsAwsjson11_serializeOpDocumentDeleteRegistryPolicyInput(input, jsonEncoder.Value); err != nil {
553 return out, metadata, &smithy.SerializationError{Err: err}
554 }
555
556 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
557 return out, metadata, &smithy.SerializationError{Err: err}
558 }
559
560 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
561 return out, metadata, &smithy.SerializationError{Err: err}
562 }
563 in.Request = request
564
565 return next.HandleSerialize(ctx, in)
566 }
567
568 type awsAwsjson11_serializeOpDeleteRepository struct {
569 }
570
571 func (*awsAwsjson11_serializeOpDeleteRepository) ID() string {
572 return "OperationSerializer"
573 }
574
575 func (m *awsAwsjson11_serializeOpDeleteRepository) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
576 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
577 ) {
578 request, ok := in.Request.(*smithyhttp.Request)
579 if !ok {
580 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
581 }
582
583 input, ok := in.Parameters.(*DeleteRepositoryInput)
584 _ = input
585 if !ok {
586 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
587 }
588
589 operationPath := "/"
590 if len(request.Request.URL.Path) == 0 {
591 request.Request.URL.Path = operationPath
592 } else {
593 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
594 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
595 request.Request.URL.Path += "/"
596 }
597 }
598 request.Request.Method = "POST"
599 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
600 if err != nil {
601 return out, metadata, &smithy.SerializationError{Err: err}
602 }
603 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
604 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.DeleteRepository")
605
606 jsonEncoder := smithyjson.NewEncoder()
607 if err := awsAwsjson11_serializeOpDocumentDeleteRepositoryInput(input, jsonEncoder.Value); err != nil {
608 return out, metadata, &smithy.SerializationError{Err: err}
609 }
610
611 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
612 return out, metadata, &smithy.SerializationError{Err: err}
613 }
614
615 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
616 return out, metadata, &smithy.SerializationError{Err: err}
617 }
618 in.Request = request
619
620 return next.HandleSerialize(ctx, in)
621 }
622
623 type awsAwsjson11_serializeOpDeleteRepositoryPolicy struct {
624 }
625
626 func (*awsAwsjson11_serializeOpDeleteRepositoryPolicy) ID() string {
627 return "OperationSerializer"
628 }
629
630 func (m *awsAwsjson11_serializeOpDeleteRepositoryPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
631 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
632 ) {
633 request, ok := in.Request.(*smithyhttp.Request)
634 if !ok {
635 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
636 }
637
638 input, ok := in.Parameters.(*DeleteRepositoryPolicyInput)
639 _ = input
640 if !ok {
641 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
642 }
643
644 operationPath := "/"
645 if len(request.Request.URL.Path) == 0 {
646 request.Request.URL.Path = operationPath
647 } else {
648 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
649 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
650 request.Request.URL.Path += "/"
651 }
652 }
653 request.Request.Method = "POST"
654 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
655 if err != nil {
656 return out, metadata, &smithy.SerializationError{Err: err}
657 }
658 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
659 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.DeleteRepositoryPolicy")
660
661 jsonEncoder := smithyjson.NewEncoder()
662 if err := awsAwsjson11_serializeOpDocumentDeleteRepositoryPolicyInput(input, jsonEncoder.Value); err != nil {
663 return out, metadata, &smithy.SerializationError{Err: err}
664 }
665
666 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
667 return out, metadata, &smithy.SerializationError{Err: err}
668 }
669
670 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
671 return out, metadata, &smithy.SerializationError{Err: err}
672 }
673 in.Request = request
674
675 return next.HandleSerialize(ctx, in)
676 }
677
678 type awsAwsjson11_serializeOpDescribeImageReplicationStatus struct {
679 }
680
681 func (*awsAwsjson11_serializeOpDescribeImageReplicationStatus) ID() string {
682 return "OperationSerializer"
683 }
684
685 func (m *awsAwsjson11_serializeOpDescribeImageReplicationStatus) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
686 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
687 ) {
688 request, ok := in.Request.(*smithyhttp.Request)
689 if !ok {
690 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
691 }
692
693 input, ok := in.Parameters.(*DescribeImageReplicationStatusInput)
694 _ = input
695 if !ok {
696 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
697 }
698
699 operationPath := "/"
700 if len(request.Request.URL.Path) == 0 {
701 request.Request.URL.Path = operationPath
702 } else {
703 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
704 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
705 request.Request.URL.Path += "/"
706 }
707 }
708 request.Request.Method = "POST"
709 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
710 if err != nil {
711 return out, metadata, &smithy.SerializationError{Err: err}
712 }
713 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
714 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.DescribeImageReplicationStatus")
715
716 jsonEncoder := smithyjson.NewEncoder()
717 if err := awsAwsjson11_serializeOpDocumentDescribeImageReplicationStatusInput(input, jsonEncoder.Value); err != nil {
718 return out, metadata, &smithy.SerializationError{Err: err}
719 }
720
721 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
722 return out, metadata, &smithy.SerializationError{Err: err}
723 }
724
725 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
726 return out, metadata, &smithy.SerializationError{Err: err}
727 }
728 in.Request = request
729
730 return next.HandleSerialize(ctx, in)
731 }
732
733 type awsAwsjson11_serializeOpDescribeImages struct {
734 }
735
736 func (*awsAwsjson11_serializeOpDescribeImages) ID() string {
737 return "OperationSerializer"
738 }
739
740 func (m *awsAwsjson11_serializeOpDescribeImages) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
741 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
742 ) {
743 request, ok := in.Request.(*smithyhttp.Request)
744 if !ok {
745 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
746 }
747
748 input, ok := in.Parameters.(*DescribeImagesInput)
749 _ = input
750 if !ok {
751 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
752 }
753
754 operationPath := "/"
755 if len(request.Request.URL.Path) == 0 {
756 request.Request.URL.Path = operationPath
757 } else {
758 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
759 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
760 request.Request.URL.Path += "/"
761 }
762 }
763 request.Request.Method = "POST"
764 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
765 if err != nil {
766 return out, metadata, &smithy.SerializationError{Err: err}
767 }
768 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
769 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.DescribeImages")
770
771 jsonEncoder := smithyjson.NewEncoder()
772 if err := awsAwsjson11_serializeOpDocumentDescribeImagesInput(input, jsonEncoder.Value); err != nil {
773 return out, metadata, &smithy.SerializationError{Err: err}
774 }
775
776 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
777 return out, metadata, &smithy.SerializationError{Err: err}
778 }
779
780 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
781 return out, metadata, &smithy.SerializationError{Err: err}
782 }
783 in.Request = request
784
785 return next.HandleSerialize(ctx, in)
786 }
787
788 type awsAwsjson11_serializeOpDescribeImageScanFindings struct {
789 }
790
791 func (*awsAwsjson11_serializeOpDescribeImageScanFindings) ID() string {
792 return "OperationSerializer"
793 }
794
795 func (m *awsAwsjson11_serializeOpDescribeImageScanFindings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
796 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
797 ) {
798 request, ok := in.Request.(*smithyhttp.Request)
799 if !ok {
800 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
801 }
802
803 input, ok := in.Parameters.(*DescribeImageScanFindingsInput)
804 _ = input
805 if !ok {
806 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
807 }
808
809 operationPath := "/"
810 if len(request.Request.URL.Path) == 0 {
811 request.Request.URL.Path = operationPath
812 } else {
813 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
814 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
815 request.Request.URL.Path += "/"
816 }
817 }
818 request.Request.Method = "POST"
819 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
820 if err != nil {
821 return out, metadata, &smithy.SerializationError{Err: err}
822 }
823 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
824 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.DescribeImageScanFindings")
825
826 jsonEncoder := smithyjson.NewEncoder()
827 if err := awsAwsjson11_serializeOpDocumentDescribeImageScanFindingsInput(input, jsonEncoder.Value); err != nil {
828 return out, metadata, &smithy.SerializationError{Err: err}
829 }
830
831 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
832 return out, metadata, &smithy.SerializationError{Err: err}
833 }
834
835 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
836 return out, metadata, &smithy.SerializationError{Err: err}
837 }
838 in.Request = request
839
840 return next.HandleSerialize(ctx, in)
841 }
842
843 type awsAwsjson11_serializeOpDescribePullThroughCacheRules struct {
844 }
845
846 func (*awsAwsjson11_serializeOpDescribePullThroughCacheRules) ID() string {
847 return "OperationSerializer"
848 }
849
850 func (m *awsAwsjson11_serializeOpDescribePullThroughCacheRules) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
851 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
852 ) {
853 request, ok := in.Request.(*smithyhttp.Request)
854 if !ok {
855 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
856 }
857
858 input, ok := in.Parameters.(*DescribePullThroughCacheRulesInput)
859 _ = input
860 if !ok {
861 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
862 }
863
864 operationPath := "/"
865 if len(request.Request.URL.Path) == 0 {
866 request.Request.URL.Path = operationPath
867 } else {
868 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
869 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
870 request.Request.URL.Path += "/"
871 }
872 }
873 request.Request.Method = "POST"
874 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
875 if err != nil {
876 return out, metadata, &smithy.SerializationError{Err: err}
877 }
878 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
879 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.DescribePullThroughCacheRules")
880
881 jsonEncoder := smithyjson.NewEncoder()
882 if err := awsAwsjson11_serializeOpDocumentDescribePullThroughCacheRulesInput(input, jsonEncoder.Value); err != nil {
883 return out, metadata, &smithy.SerializationError{Err: err}
884 }
885
886 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
887 return out, metadata, &smithy.SerializationError{Err: err}
888 }
889
890 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
891 return out, metadata, &smithy.SerializationError{Err: err}
892 }
893 in.Request = request
894
895 return next.HandleSerialize(ctx, in)
896 }
897
898 type awsAwsjson11_serializeOpDescribeRegistry struct {
899 }
900
901 func (*awsAwsjson11_serializeOpDescribeRegistry) ID() string {
902 return "OperationSerializer"
903 }
904
905 func (m *awsAwsjson11_serializeOpDescribeRegistry) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
906 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
907 ) {
908 request, ok := in.Request.(*smithyhttp.Request)
909 if !ok {
910 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
911 }
912
913 input, ok := in.Parameters.(*DescribeRegistryInput)
914 _ = input
915 if !ok {
916 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
917 }
918
919 operationPath := "/"
920 if len(request.Request.URL.Path) == 0 {
921 request.Request.URL.Path = operationPath
922 } else {
923 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
924 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
925 request.Request.URL.Path += "/"
926 }
927 }
928 request.Request.Method = "POST"
929 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
930 if err != nil {
931 return out, metadata, &smithy.SerializationError{Err: err}
932 }
933 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
934 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.DescribeRegistry")
935
936 jsonEncoder := smithyjson.NewEncoder()
937 if err := awsAwsjson11_serializeOpDocumentDescribeRegistryInput(input, jsonEncoder.Value); err != nil {
938 return out, metadata, &smithy.SerializationError{Err: err}
939 }
940
941 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
942 return out, metadata, &smithy.SerializationError{Err: err}
943 }
944
945 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
946 return out, metadata, &smithy.SerializationError{Err: err}
947 }
948 in.Request = request
949
950 return next.HandleSerialize(ctx, in)
951 }
952
953 type awsAwsjson11_serializeOpDescribeRepositories struct {
954 }
955
956 func (*awsAwsjson11_serializeOpDescribeRepositories) ID() string {
957 return "OperationSerializer"
958 }
959
960 func (m *awsAwsjson11_serializeOpDescribeRepositories) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
961 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
962 ) {
963 request, ok := in.Request.(*smithyhttp.Request)
964 if !ok {
965 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
966 }
967
968 input, ok := in.Parameters.(*DescribeRepositoriesInput)
969 _ = input
970 if !ok {
971 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
972 }
973
974 operationPath := "/"
975 if len(request.Request.URL.Path) == 0 {
976 request.Request.URL.Path = operationPath
977 } else {
978 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
979 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
980 request.Request.URL.Path += "/"
981 }
982 }
983 request.Request.Method = "POST"
984 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
985 if err != nil {
986 return out, metadata, &smithy.SerializationError{Err: err}
987 }
988 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
989 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.DescribeRepositories")
990
991 jsonEncoder := smithyjson.NewEncoder()
992 if err := awsAwsjson11_serializeOpDocumentDescribeRepositoriesInput(input, jsonEncoder.Value); err != nil {
993 return out, metadata, &smithy.SerializationError{Err: err}
994 }
995
996 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
997 return out, metadata, &smithy.SerializationError{Err: err}
998 }
999
1000 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1001 return out, metadata, &smithy.SerializationError{Err: err}
1002 }
1003 in.Request = request
1004
1005 return next.HandleSerialize(ctx, in)
1006 }
1007
1008 type awsAwsjson11_serializeOpGetAuthorizationToken struct {
1009 }
1010
1011 func (*awsAwsjson11_serializeOpGetAuthorizationToken) ID() string {
1012 return "OperationSerializer"
1013 }
1014
1015 func (m *awsAwsjson11_serializeOpGetAuthorizationToken) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1016 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1017 ) {
1018 request, ok := in.Request.(*smithyhttp.Request)
1019 if !ok {
1020 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1021 }
1022
1023 input, ok := in.Parameters.(*GetAuthorizationTokenInput)
1024 _ = input
1025 if !ok {
1026 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1027 }
1028
1029 operationPath := "/"
1030 if len(request.Request.URL.Path) == 0 {
1031 request.Request.URL.Path = operationPath
1032 } else {
1033 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1034 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1035 request.Request.URL.Path += "/"
1036 }
1037 }
1038 request.Request.Method = "POST"
1039 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1040 if err != nil {
1041 return out, metadata, &smithy.SerializationError{Err: err}
1042 }
1043 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1044 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.GetAuthorizationToken")
1045
1046 jsonEncoder := smithyjson.NewEncoder()
1047 if err := awsAwsjson11_serializeOpDocumentGetAuthorizationTokenInput(input, jsonEncoder.Value); err != nil {
1048 return out, metadata, &smithy.SerializationError{Err: err}
1049 }
1050
1051 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1052 return out, metadata, &smithy.SerializationError{Err: err}
1053 }
1054
1055 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1056 return out, metadata, &smithy.SerializationError{Err: err}
1057 }
1058 in.Request = request
1059
1060 return next.HandleSerialize(ctx, in)
1061 }
1062
1063 type awsAwsjson11_serializeOpGetDownloadUrlForLayer struct {
1064 }
1065
1066 func (*awsAwsjson11_serializeOpGetDownloadUrlForLayer) ID() string {
1067 return "OperationSerializer"
1068 }
1069
1070 func (m *awsAwsjson11_serializeOpGetDownloadUrlForLayer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1071 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1072 ) {
1073 request, ok := in.Request.(*smithyhttp.Request)
1074 if !ok {
1075 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1076 }
1077
1078 input, ok := in.Parameters.(*GetDownloadUrlForLayerInput)
1079 _ = input
1080 if !ok {
1081 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1082 }
1083
1084 operationPath := "/"
1085 if len(request.Request.URL.Path) == 0 {
1086 request.Request.URL.Path = operationPath
1087 } else {
1088 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1089 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1090 request.Request.URL.Path += "/"
1091 }
1092 }
1093 request.Request.Method = "POST"
1094 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1095 if err != nil {
1096 return out, metadata, &smithy.SerializationError{Err: err}
1097 }
1098 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1099 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.GetDownloadUrlForLayer")
1100
1101 jsonEncoder := smithyjson.NewEncoder()
1102 if err := awsAwsjson11_serializeOpDocumentGetDownloadUrlForLayerInput(input, jsonEncoder.Value); err != nil {
1103 return out, metadata, &smithy.SerializationError{Err: err}
1104 }
1105
1106 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1107 return out, metadata, &smithy.SerializationError{Err: err}
1108 }
1109
1110 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1111 return out, metadata, &smithy.SerializationError{Err: err}
1112 }
1113 in.Request = request
1114
1115 return next.HandleSerialize(ctx, in)
1116 }
1117
1118 type awsAwsjson11_serializeOpGetLifecyclePolicy struct {
1119 }
1120
1121 func (*awsAwsjson11_serializeOpGetLifecyclePolicy) ID() string {
1122 return "OperationSerializer"
1123 }
1124
1125 func (m *awsAwsjson11_serializeOpGetLifecyclePolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1126 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1127 ) {
1128 request, ok := in.Request.(*smithyhttp.Request)
1129 if !ok {
1130 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1131 }
1132
1133 input, ok := in.Parameters.(*GetLifecyclePolicyInput)
1134 _ = input
1135 if !ok {
1136 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1137 }
1138
1139 operationPath := "/"
1140 if len(request.Request.URL.Path) == 0 {
1141 request.Request.URL.Path = operationPath
1142 } else {
1143 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1144 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1145 request.Request.URL.Path += "/"
1146 }
1147 }
1148 request.Request.Method = "POST"
1149 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1150 if err != nil {
1151 return out, metadata, &smithy.SerializationError{Err: err}
1152 }
1153 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1154 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.GetLifecyclePolicy")
1155
1156 jsonEncoder := smithyjson.NewEncoder()
1157 if err := awsAwsjson11_serializeOpDocumentGetLifecyclePolicyInput(input, jsonEncoder.Value); err != nil {
1158 return out, metadata, &smithy.SerializationError{Err: err}
1159 }
1160
1161 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1162 return out, metadata, &smithy.SerializationError{Err: err}
1163 }
1164
1165 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1166 return out, metadata, &smithy.SerializationError{Err: err}
1167 }
1168 in.Request = request
1169
1170 return next.HandleSerialize(ctx, in)
1171 }
1172
1173 type awsAwsjson11_serializeOpGetLifecyclePolicyPreview struct {
1174 }
1175
1176 func (*awsAwsjson11_serializeOpGetLifecyclePolicyPreview) ID() string {
1177 return "OperationSerializer"
1178 }
1179
1180 func (m *awsAwsjson11_serializeOpGetLifecyclePolicyPreview) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1181 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1182 ) {
1183 request, ok := in.Request.(*smithyhttp.Request)
1184 if !ok {
1185 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1186 }
1187
1188 input, ok := in.Parameters.(*GetLifecyclePolicyPreviewInput)
1189 _ = input
1190 if !ok {
1191 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1192 }
1193
1194 operationPath := "/"
1195 if len(request.Request.URL.Path) == 0 {
1196 request.Request.URL.Path = operationPath
1197 } else {
1198 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1199 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1200 request.Request.URL.Path += "/"
1201 }
1202 }
1203 request.Request.Method = "POST"
1204 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1205 if err != nil {
1206 return out, metadata, &smithy.SerializationError{Err: err}
1207 }
1208 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1209 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.GetLifecyclePolicyPreview")
1210
1211 jsonEncoder := smithyjson.NewEncoder()
1212 if err := awsAwsjson11_serializeOpDocumentGetLifecyclePolicyPreviewInput(input, jsonEncoder.Value); err != nil {
1213 return out, metadata, &smithy.SerializationError{Err: err}
1214 }
1215
1216 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1217 return out, metadata, &smithy.SerializationError{Err: err}
1218 }
1219
1220 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1221 return out, metadata, &smithy.SerializationError{Err: err}
1222 }
1223 in.Request = request
1224
1225 return next.HandleSerialize(ctx, in)
1226 }
1227
1228 type awsAwsjson11_serializeOpGetRegistryPolicy struct {
1229 }
1230
1231 func (*awsAwsjson11_serializeOpGetRegistryPolicy) ID() string {
1232 return "OperationSerializer"
1233 }
1234
1235 func (m *awsAwsjson11_serializeOpGetRegistryPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1236 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1237 ) {
1238 request, ok := in.Request.(*smithyhttp.Request)
1239 if !ok {
1240 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1241 }
1242
1243 input, ok := in.Parameters.(*GetRegistryPolicyInput)
1244 _ = input
1245 if !ok {
1246 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1247 }
1248
1249 operationPath := "/"
1250 if len(request.Request.URL.Path) == 0 {
1251 request.Request.URL.Path = operationPath
1252 } else {
1253 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1254 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1255 request.Request.URL.Path += "/"
1256 }
1257 }
1258 request.Request.Method = "POST"
1259 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1260 if err != nil {
1261 return out, metadata, &smithy.SerializationError{Err: err}
1262 }
1263 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1264 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.GetRegistryPolicy")
1265
1266 jsonEncoder := smithyjson.NewEncoder()
1267 if err := awsAwsjson11_serializeOpDocumentGetRegistryPolicyInput(input, jsonEncoder.Value); err != nil {
1268 return out, metadata, &smithy.SerializationError{Err: err}
1269 }
1270
1271 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1272 return out, metadata, &smithy.SerializationError{Err: err}
1273 }
1274
1275 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1276 return out, metadata, &smithy.SerializationError{Err: err}
1277 }
1278 in.Request = request
1279
1280 return next.HandleSerialize(ctx, in)
1281 }
1282
1283 type awsAwsjson11_serializeOpGetRegistryScanningConfiguration struct {
1284 }
1285
1286 func (*awsAwsjson11_serializeOpGetRegistryScanningConfiguration) ID() string {
1287 return "OperationSerializer"
1288 }
1289
1290 func (m *awsAwsjson11_serializeOpGetRegistryScanningConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1291 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1292 ) {
1293 request, ok := in.Request.(*smithyhttp.Request)
1294 if !ok {
1295 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1296 }
1297
1298 input, ok := in.Parameters.(*GetRegistryScanningConfigurationInput)
1299 _ = input
1300 if !ok {
1301 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1302 }
1303
1304 operationPath := "/"
1305 if len(request.Request.URL.Path) == 0 {
1306 request.Request.URL.Path = operationPath
1307 } else {
1308 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1309 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1310 request.Request.URL.Path += "/"
1311 }
1312 }
1313 request.Request.Method = "POST"
1314 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1315 if err != nil {
1316 return out, metadata, &smithy.SerializationError{Err: err}
1317 }
1318 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1319 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.GetRegistryScanningConfiguration")
1320
1321 jsonEncoder := smithyjson.NewEncoder()
1322 if err := awsAwsjson11_serializeOpDocumentGetRegistryScanningConfigurationInput(input, jsonEncoder.Value); err != nil {
1323 return out, metadata, &smithy.SerializationError{Err: err}
1324 }
1325
1326 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1327 return out, metadata, &smithy.SerializationError{Err: err}
1328 }
1329
1330 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1331 return out, metadata, &smithy.SerializationError{Err: err}
1332 }
1333 in.Request = request
1334
1335 return next.HandleSerialize(ctx, in)
1336 }
1337
1338 type awsAwsjson11_serializeOpGetRepositoryPolicy struct {
1339 }
1340
1341 func (*awsAwsjson11_serializeOpGetRepositoryPolicy) ID() string {
1342 return "OperationSerializer"
1343 }
1344
1345 func (m *awsAwsjson11_serializeOpGetRepositoryPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1346 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1347 ) {
1348 request, ok := in.Request.(*smithyhttp.Request)
1349 if !ok {
1350 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1351 }
1352
1353 input, ok := in.Parameters.(*GetRepositoryPolicyInput)
1354 _ = input
1355 if !ok {
1356 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1357 }
1358
1359 operationPath := "/"
1360 if len(request.Request.URL.Path) == 0 {
1361 request.Request.URL.Path = operationPath
1362 } else {
1363 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1364 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1365 request.Request.URL.Path += "/"
1366 }
1367 }
1368 request.Request.Method = "POST"
1369 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1370 if err != nil {
1371 return out, metadata, &smithy.SerializationError{Err: err}
1372 }
1373 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1374 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.GetRepositoryPolicy")
1375
1376 jsonEncoder := smithyjson.NewEncoder()
1377 if err := awsAwsjson11_serializeOpDocumentGetRepositoryPolicyInput(input, jsonEncoder.Value); err != nil {
1378 return out, metadata, &smithy.SerializationError{Err: err}
1379 }
1380
1381 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1382 return out, metadata, &smithy.SerializationError{Err: err}
1383 }
1384
1385 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1386 return out, metadata, &smithy.SerializationError{Err: err}
1387 }
1388 in.Request = request
1389
1390 return next.HandleSerialize(ctx, in)
1391 }
1392
1393 type awsAwsjson11_serializeOpInitiateLayerUpload struct {
1394 }
1395
1396 func (*awsAwsjson11_serializeOpInitiateLayerUpload) ID() string {
1397 return "OperationSerializer"
1398 }
1399
1400 func (m *awsAwsjson11_serializeOpInitiateLayerUpload) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1401 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1402 ) {
1403 request, ok := in.Request.(*smithyhttp.Request)
1404 if !ok {
1405 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1406 }
1407
1408 input, ok := in.Parameters.(*InitiateLayerUploadInput)
1409 _ = input
1410 if !ok {
1411 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1412 }
1413
1414 operationPath := "/"
1415 if len(request.Request.URL.Path) == 0 {
1416 request.Request.URL.Path = operationPath
1417 } else {
1418 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1419 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1420 request.Request.URL.Path += "/"
1421 }
1422 }
1423 request.Request.Method = "POST"
1424 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1425 if err != nil {
1426 return out, metadata, &smithy.SerializationError{Err: err}
1427 }
1428 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1429 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.InitiateLayerUpload")
1430
1431 jsonEncoder := smithyjson.NewEncoder()
1432 if err := awsAwsjson11_serializeOpDocumentInitiateLayerUploadInput(input, jsonEncoder.Value); err != nil {
1433 return out, metadata, &smithy.SerializationError{Err: err}
1434 }
1435
1436 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1437 return out, metadata, &smithy.SerializationError{Err: err}
1438 }
1439
1440 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1441 return out, metadata, &smithy.SerializationError{Err: err}
1442 }
1443 in.Request = request
1444
1445 return next.HandleSerialize(ctx, in)
1446 }
1447
1448 type awsAwsjson11_serializeOpListImages struct {
1449 }
1450
1451 func (*awsAwsjson11_serializeOpListImages) ID() string {
1452 return "OperationSerializer"
1453 }
1454
1455 func (m *awsAwsjson11_serializeOpListImages) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1456 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1457 ) {
1458 request, ok := in.Request.(*smithyhttp.Request)
1459 if !ok {
1460 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1461 }
1462
1463 input, ok := in.Parameters.(*ListImagesInput)
1464 _ = input
1465 if !ok {
1466 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1467 }
1468
1469 operationPath := "/"
1470 if len(request.Request.URL.Path) == 0 {
1471 request.Request.URL.Path = operationPath
1472 } else {
1473 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1474 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1475 request.Request.URL.Path += "/"
1476 }
1477 }
1478 request.Request.Method = "POST"
1479 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1480 if err != nil {
1481 return out, metadata, &smithy.SerializationError{Err: err}
1482 }
1483 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1484 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.ListImages")
1485
1486 jsonEncoder := smithyjson.NewEncoder()
1487 if err := awsAwsjson11_serializeOpDocumentListImagesInput(input, jsonEncoder.Value); err != nil {
1488 return out, metadata, &smithy.SerializationError{Err: err}
1489 }
1490
1491 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1492 return out, metadata, &smithy.SerializationError{Err: err}
1493 }
1494
1495 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1496 return out, metadata, &smithy.SerializationError{Err: err}
1497 }
1498 in.Request = request
1499
1500 return next.HandleSerialize(ctx, in)
1501 }
1502
1503 type awsAwsjson11_serializeOpListTagsForResource struct {
1504 }
1505
1506 func (*awsAwsjson11_serializeOpListTagsForResource) ID() string {
1507 return "OperationSerializer"
1508 }
1509
1510 func (m *awsAwsjson11_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1511 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1512 ) {
1513 request, ok := in.Request.(*smithyhttp.Request)
1514 if !ok {
1515 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1516 }
1517
1518 input, ok := in.Parameters.(*ListTagsForResourceInput)
1519 _ = input
1520 if !ok {
1521 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1522 }
1523
1524 operationPath := "/"
1525 if len(request.Request.URL.Path) == 0 {
1526 request.Request.URL.Path = operationPath
1527 } else {
1528 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1529 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1530 request.Request.URL.Path += "/"
1531 }
1532 }
1533 request.Request.Method = "POST"
1534 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1535 if err != nil {
1536 return out, metadata, &smithy.SerializationError{Err: err}
1537 }
1538 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1539 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.ListTagsForResource")
1540
1541 jsonEncoder := smithyjson.NewEncoder()
1542 if err := awsAwsjson11_serializeOpDocumentListTagsForResourceInput(input, jsonEncoder.Value); err != nil {
1543 return out, metadata, &smithy.SerializationError{Err: err}
1544 }
1545
1546 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1547 return out, metadata, &smithy.SerializationError{Err: err}
1548 }
1549
1550 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1551 return out, metadata, &smithy.SerializationError{Err: err}
1552 }
1553 in.Request = request
1554
1555 return next.HandleSerialize(ctx, in)
1556 }
1557
1558 type awsAwsjson11_serializeOpPutImage struct {
1559 }
1560
1561 func (*awsAwsjson11_serializeOpPutImage) ID() string {
1562 return "OperationSerializer"
1563 }
1564
1565 func (m *awsAwsjson11_serializeOpPutImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1566 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1567 ) {
1568 request, ok := in.Request.(*smithyhttp.Request)
1569 if !ok {
1570 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1571 }
1572
1573 input, ok := in.Parameters.(*PutImageInput)
1574 _ = input
1575 if !ok {
1576 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1577 }
1578
1579 operationPath := "/"
1580 if len(request.Request.URL.Path) == 0 {
1581 request.Request.URL.Path = operationPath
1582 } else {
1583 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1584 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1585 request.Request.URL.Path += "/"
1586 }
1587 }
1588 request.Request.Method = "POST"
1589 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1590 if err != nil {
1591 return out, metadata, &smithy.SerializationError{Err: err}
1592 }
1593 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1594 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.PutImage")
1595
1596 jsonEncoder := smithyjson.NewEncoder()
1597 if err := awsAwsjson11_serializeOpDocumentPutImageInput(input, jsonEncoder.Value); err != nil {
1598 return out, metadata, &smithy.SerializationError{Err: err}
1599 }
1600
1601 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1602 return out, metadata, &smithy.SerializationError{Err: err}
1603 }
1604
1605 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1606 return out, metadata, &smithy.SerializationError{Err: err}
1607 }
1608 in.Request = request
1609
1610 return next.HandleSerialize(ctx, in)
1611 }
1612
1613 type awsAwsjson11_serializeOpPutImageScanningConfiguration struct {
1614 }
1615
1616 func (*awsAwsjson11_serializeOpPutImageScanningConfiguration) ID() string {
1617 return "OperationSerializer"
1618 }
1619
1620 func (m *awsAwsjson11_serializeOpPutImageScanningConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1621 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1622 ) {
1623 request, ok := in.Request.(*smithyhttp.Request)
1624 if !ok {
1625 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1626 }
1627
1628 input, ok := in.Parameters.(*PutImageScanningConfigurationInput)
1629 _ = input
1630 if !ok {
1631 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1632 }
1633
1634 operationPath := "/"
1635 if len(request.Request.URL.Path) == 0 {
1636 request.Request.URL.Path = operationPath
1637 } else {
1638 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1639 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1640 request.Request.URL.Path += "/"
1641 }
1642 }
1643 request.Request.Method = "POST"
1644 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1645 if err != nil {
1646 return out, metadata, &smithy.SerializationError{Err: err}
1647 }
1648 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1649 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.PutImageScanningConfiguration")
1650
1651 jsonEncoder := smithyjson.NewEncoder()
1652 if err := awsAwsjson11_serializeOpDocumentPutImageScanningConfigurationInput(input, jsonEncoder.Value); err != nil {
1653 return out, metadata, &smithy.SerializationError{Err: err}
1654 }
1655
1656 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1657 return out, metadata, &smithy.SerializationError{Err: err}
1658 }
1659
1660 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1661 return out, metadata, &smithy.SerializationError{Err: err}
1662 }
1663 in.Request = request
1664
1665 return next.HandleSerialize(ctx, in)
1666 }
1667
1668 type awsAwsjson11_serializeOpPutImageTagMutability struct {
1669 }
1670
1671 func (*awsAwsjson11_serializeOpPutImageTagMutability) ID() string {
1672 return "OperationSerializer"
1673 }
1674
1675 func (m *awsAwsjson11_serializeOpPutImageTagMutability) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1676 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1677 ) {
1678 request, ok := in.Request.(*smithyhttp.Request)
1679 if !ok {
1680 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1681 }
1682
1683 input, ok := in.Parameters.(*PutImageTagMutabilityInput)
1684 _ = input
1685 if !ok {
1686 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1687 }
1688
1689 operationPath := "/"
1690 if len(request.Request.URL.Path) == 0 {
1691 request.Request.URL.Path = operationPath
1692 } else {
1693 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1694 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1695 request.Request.URL.Path += "/"
1696 }
1697 }
1698 request.Request.Method = "POST"
1699 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1700 if err != nil {
1701 return out, metadata, &smithy.SerializationError{Err: err}
1702 }
1703 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1704 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.PutImageTagMutability")
1705
1706 jsonEncoder := smithyjson.NewEncoder()
1707 if err := awsAwsjson11_serializeOpDocumentPutImageTagMutabilityInput(input, jsonEncoder.Value); err != nil {
1708 return out, metadata, &smithy.SerializationError{Err: err}
1709 }
1710
1711 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1712 return out, metadata, &smithy.SerializationError{Err: err}
1713 }
1714
1715 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1716 return out, metadata, &smithy.SerializationError{Err: err}
1717 }
1718 in.Request = request
1719
1720 return next.HandleSerialize(ctx, in)
1721 }
1722
1723 type awsAwsjson11_serializeOpPutLifecyclePolicy struct {
1724 }
1725
1726 func (*awsAwsjson11_serializeOpPutLifecyclePolicy) ID() string {
1727 return "OperationSerializer"
1728 }
1729
1730 func (m *awsAwsjson11_serializeOpPutLifecyclePolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1731 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1732 ) {
1733 request, ok := in.Request.(*smithyhttp.Request)
1734 if !ok {
1735 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1736 }
1737
1738 input, ok := in.Parameters.(*PutLifecyclePolicyInput)
1739 _ = input
1740 if !ok {
1741 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1742 }
1743
1744 operationPath := "/"
1745 if len(request.Request.URL.Path) == 0 {
1746 request.Request.URL.Path = operationPath
1747 } else {
1748 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1749 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1750 request.Request.URL.Path += "/"
1751 }
1752 }
1753 request.Request.Method = "POST"
1754 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1755 if err != nil {
1756 return out, metadata, &smithy.SerializationError{Err: err}
1757 }
1758 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1759 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.PutLifecyclePolicy")
1760
1761 jsonEncoder := smithyjson.NewEncoder()
1762 if err := awsAwsjson11_serializeOpDocumentPutLifecyclePolicyInput(input, jsonEncoder.Value); err != nil {
1763 return out, metadata, &smithy.SerializationError{Err: err}
1764 }
1765
1766 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1767 return out, metadata, &smithy.SerializationError{Err: err}
1768 }
1769
1770 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1771 return out, metadata, &smithy.SerializationError{Err: err}
1772 }
1773 in.Request = request
1774
1775 return next.HandleSerialize(ctx, in)
1776 }
1777
1778 type awsAwsjson11_serializeOpPutRegistryPolicy struct {
1779 }
1780
1781 func (*awsAwsjson11_serializeOpPutRegistryPolicy) ID() string {
1782 return "OperationSerializer"
1783 }
1784
1785 func (m *awsAwsjson11_serializeOpPutRegistryPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1786 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1787 ) {
1788 request, ok := in.Request.(*smithyhttp.Request)
1789 if !ok {
1790 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1791 }
1792
1793 input, ok := in.Parameters.(*PutRegistryPolicyInput)
1794 _ = input
1795 if !ok {
1796 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1797 }
1798
1799 operationPath := "/"
1800 if len(request.Request.URL.Path) == 0 {
1801 request.Request.URL.Path = operationPath
1802 } else {
1803 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1804 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1805 request.Request.URL.Path += "/"
1806 }
1807 }
1808 request.Request.Method = "POST"
1809 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1810 if err != nil {
1811 return out, metadata, &smithy.SerializationError{Err: err}
1812 }
1813 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1814 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.PutRegistryPolicy")
1815
1816 jsonEncoder := smithyjson.NewEncoder()
1817 if err := awsAwsjson11_serializeOpDocumentPutRegistryPolicyInput(input, jsonEncoder.Value); err != nil {
1818 return out, metadata, &smithy.SerializationError{Err: err}
1819 }
1820
1821 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1822 return out, metadata, &smithy.SerializationError{Err: err}
1823 }
1824
1825 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1826 return out, metadata, &smithy.SerializationError{Err: err}
1827 }
1828 in.Request = request
1829
1830 return next.HandleSerialize(ctx, in)
1831 }
1832
1833 type awsAwsjson11_serializeOpPutRegistryScanningConfiguration struct {
1834 }
1835
1836 func (*awsAwsjson11_serializeOpPutRegistryScanningConfiguration) ID() string {
1837 return "OperationSerializer"
1838 }
1839
1840 func (m *awsAwsjson11_serializeOpPutRegistryScanningConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1841 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1842 ) {
1843 request, ok := in.Request.(*smithyhttp.Request)
1844 if !ok {
1845 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1846 }
1847
1848 input, ok := in.Parameters.(*PutRegistryScanningConfigurationInput)
1849 _ = input
1850 if !ok {
1851 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1852 }
1853
1854 operationPath := "/"
1855 if len(request.Request.URL.Path) == 0 {
1856 request.Request.URL.Path = operationPath
1857 } else {
1858 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1859 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1860 request.Request.URL.Path += "/"
1861 }
1862 }
1863 request.Request.Method = "POST"
1864 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1865 if err != nil {
1866 return out, metadata, &smithy.SerializationError{Err: err}
1867 }
1868 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1869 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.PutRegistryScanningConfiguration")
1870
1871 jsonEncoder := smithyjson.NewEncoder()
1872 if err := awsAwsjson11_serializeOpDocumentPutRegistryScanningConfigurationInput(input, jsonEncoder.Value); err != nil {
1873 return out, metadata, &smithy.SerializationError{Err: err}
1874 }
1875
1876 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1877 return out, metadata, &smithy.SerializationError{Err: err}
1878 }
1879
1880 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1881 return out, metadata, &smithy.SerializationError{Err: err}
1882 }
1883 in.Request = request
1884
1885 return next.HandleSerialize(ctx, in)
1886 }
1887
1888 type awsAwsjson11_serializeOpPutReplicationConfiguration struct {
1889 }
1890
1891 func (*awsAwsjson11_serializeOpPutReplicationConfiguration) ID() string {
1892 return "OperationSerializer"
1893 }
1894
1895 func (m *awsAwsjson11_serializeOpPutReplicationConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1896 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1897 ) {
1898 request, ok := in.Request.(*smithyhttp.Request)
1899 if !ok {
1900 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1901 }
1902
1903 input, ok := in.Parameters.(*PutReplicationConfigurationInput)
1904 _ = input
1905 if !ok {
1906 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1907 }
1908
1909 operationPath := "/"
1910 if len(request.Request.URL.Path) == 0 {
1911 request.Request.URL.Path = operationPath
1912 } else {
1913 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1914 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1915 request.Request.URL.Path += "/"
1916 }
1917 }
1918 request.Request.Method = "POST"
1919 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1920 if err != nil {
1921 return out, metadata, &smithy.SerializationError{Err: err}
1922 }
1923 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1924 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.PutReplicationConfiguration")
1925
1926 jsonEncoder := smithyjson.NewEncoder()
1927 if err := awsAwsjson11_serializeOpDocumentPutReplicationConfigurationInput(input, jsonEncoder.Value); err != nil {
1928 return out, metadata, &smithy.SerializationError{Err: err}
1929 }
1930
1931 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1932 return out, metadata, &smithy.SerializationError{Err: err}
1933 }
1934
1935 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1936 return out, metadata, &smithy.SerializationError{Err: err}
1937 }
1938 in.Request = request
1939
1940 return next.HandleSerialize(ctx, in)
1941 }
1942
1943 type awsAwsjson11_serializeOpSetRepositoryPolicy struct {
1944 }
1945
1946 func (*awsAwsjson11_serializeOpSetRepositoryPolicy) ID() string {
1947 return "OperationSerializer"
1948 }
1949
1950 func (m *awsAwsjson11_serializeOpSetRepositoryPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1951 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1952 ) {
1953 request, ok := in.Request.(*smithyhttp.Request)
1954 if !ok {
1955 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1956 }
1957
1958 input, ok := in.Parameters.(*SetRepositoryPolicyInput)
1959 _ = input
1960 if !ok {
1961 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1962 }
1963
1964 operationPath := "/"
1965 if len(request.Request.URL.Path) == 0 {
1966 request.Request.URL.Path = operationPath
1967 } else {
1968 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1969 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1970 request.Request.URL.Path += "/"
1971 }
1972 }
1973 request.Request.Method = "POST"
1974 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1975 if err != nil {
1976 return out, metadata, &smithy.SerializationError{Err: err}
1977 }
1978 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1979 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.SetRepositoryPolicy")
1980
1981 jsonEncoder := smithyjson.NewEncoder()
1982 if err := awsAwsjson11_serializeOpDocumentSetRepositoryPolicyInput(input, jsonEncoder.Value); err != nil {
1983 return out, metadata, &smithy.SerializationError{Err: err}
1984 }
1985
1986 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1987 return out, metadata, &smithy.SerializationError{Err: err}
1988 }
1989
1990 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1991 return out, metadata, &smithy.SerializationError{Err: err}
1992 }
1993 in.Request = request
1994
1995 return next.HandleSerialize(ctx, in)
1996 }
1997
1998 type awsAwsjson11_serializeOpStartImageScan struct {
1999 }
2000
2001 func (*awsAwsjson11_serializeOpStartImageScan) ID() string {
2002 return "OperationSerializer"
2003 }
2004
2005 func (m *awsAwsjson11_serializeOpStartImageScan) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2006 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2007 ) {
2008 request, ok := in.Request.(*smithyhttp.Request)
2009 if !ok {
2010 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2011 }
2012
2013 input, ok := in.Parameters.(*StartImageScanInput)
2014 _ = input
2015 if !ok {
2016 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2017 }
2018
2019 operationPath := "/"
2020 if len(request.Request.URL.Path) == 0 {
2021 request.Request.URL.Path = operationPath
2022 } else {
2023 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
2024 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
2025 request.Request.URL.Path += "/"
2026 }
2027 }
2028 request.Request.Method = "POST"
2029 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2030 if err != nil {
2031 return out, metadata, &smithy.SerializationError{Err: err}
2032 }
2033 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2034 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.StartImageScan")
2035
2036 jsonEncoder := smithyjson.NewEncoder()
2037 if err := awsAwsjson11_serializeOpDocumentStartImageScanInput(input, jsonEncoder.Value); err != nil {
2038 return out, metadata, &smithy.SerializationError{Err: err}
2039 }
2040
2041 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2042 return out, metadata, &smithy.SerializationError{Err: err}
2043 }
2044
2045 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2046 return out, metadata, &smithy.SerializationError{Err: err}
2047 }
2048 in.Request = request
2049
2050 return next.HandleSerialize(ctx, in)
2051 }
2052
2053 type awsAwsjson11_serializeOpStartLifecyclePolicyPreview struct {
2054 }
2055
2056 func (*awsAwsjson11_serializeOpStartLifecyclePolicyPreview) ID() string {
2057 return "OperationSerializer"
2058 }
2059
2060 func (m *awsAwsjson11_serializeOpStartLifecyclePolicyPreview) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2061 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2062 ) {
2063 request, ok := in.Request.(*smithyhttp.Request)
2064 if !ok {
2065 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2066 }
2067
2068 input, ok := in.Parameters.(*StartLifecyclePolicyPreviewInput)
2069 _ = input
2070 if !ok {
2071 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2072 }
2073
2074 operationPath := "/"
2075 if len(request.Request.URL.Path) == 0 {
2076 request.Request.URL.Path = operationPath
2077 } else {
2078 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
2079 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
2080 request.Request.URL.Path += "/"
2081 }
2082 }
2083 request.Request.Method = "POST"
2084 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2085 if err != nil {
2086 return out, metadata, &smithy.SerializationError{Err: err}
2087 }
2088 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2089 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.StartLifecyclePolicyPreview")
2090
2091 jsonEncoder := smithyjson.NewEncoder()
2092 if err := awsAwsjson11_serializeOpDocumentStartLifecyclePolicyPreviewInput(input, jsonEncoder.Value); err != nil {
2093 return out, metadata, &smithy.SerializationError{Err: err}
2094 }
2095
2096 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2097 return out, metadata, &smithy.SerializationError{Err: err}
2098 }
2099
2100 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2101 return out, metadata, &smithy.SerializationError{Err: err}
2102 }
2103 in.Request = request
2104
2105 return next.HandleSerialize(ctx, in)
2106 }
2107
2108 type awsAwsjson11_serializeOpTagResource struct {
2109 }
2110
2111 func (*awsAwsjson11_serializeOpTagResource) ID() string {
2112 return "OperationSerializer"
2113 }
2114
2115 func (m *awsAwsjson11_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2116 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2117 ) {
2118 request, ok := in.Request.(*smithyhttp.Request)
2119 if !ok {
2120 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2121 }
2122
2123 input, ok := in.Parameters.(*TagResourceInput)
2124 _ = input
2125 if !ok {
2126 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2127 }
2128
2129 operationPath := "/"
2130 if len(request.Request.URL.Path) == 0 {
2131 request.Request.URL.Path = operationPath
2132 } else {
2133 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
2134 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
2135 request.Request.URL.Path += "/"
2136 }
2137 }
2138 request.Request.Method = "POST"
2139 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2140 if err != nil {
2141 return out, metadata, &smithy.SerializationError{Err: err}
2142 }
2143 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2144 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.TagResource")
2145
2146 jsonEncoder := smithyjson.NewEncoder()
2147 if err := awsAwsjson11_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil {
2148 return out, metadata, &smithy.SerializationError{Err: err}
2149 }
2150
2151 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2152 return out, metadata, &smithy.SerializationError{Err: err}
2153 }
2154
2155 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2156 return out, metadata, &smithy.SerializationError{Err: err}
2157 }
2158 in.Request = request
2159
2160 return next.HandleSerialize(ctx, in)
2161 }
2162
2163 type awsAwsjson11_serializeOpUntagResource struct {
2164 }
2165
2166 func (*awsAwsjson11_serializeOpUntagResource) ID() string {
2167 return "OperationSerializer"
2168 }
2169
2170 func (m *awsAwsjson11_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2171 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2172 ) {
2173 request, ok := in.Request.(*smithyhttp.Request)
2174 if !ok {
2175 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2176 }
2177
2178 input, ok := in.Parameters.(*UntagResourceInput)
2179 _ = input
2180 if !ok {
2181 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2182 }
2183
2184 operationPath := "/"
2185 if len(request.Request.URL.Path) == 0 {
2186 request.Request.URL.Path = operationPath
2187 } else {
2188 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
2189 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
2190 request.Request.URL.Path += "/"
2191 }
2192 }
2193 request.Request.Method = "POST"
2194 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2195 if err != nil {
2196 return out, metadata, &smithy.SerializationError{Err: err}
2197 }
2198 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2199 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.UntagResource")
2200
2201 jsonEncoder := smithyjson.NewEncoder()
2202 if err := awsAwsjson11_serializeOpDocumentUntagResourceInput(input, jsonEncoder.Value); err != nil {
2203 return out, metadata, &smithy.SerializationError{Err: err}
2204 }
2205
2206 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2207 return out, metadata, &smithy.SerializationError{Err: err}
2208 }
2209
2210 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2211 return out, metadata, &smithy.SerializationError{Err: err}
2212 }
2213 in.Request = request
2214
2215 return next.HandleSerialize(ctx, in)
2216 }
2217
2218 type awsAwsjson11_serializeOpUploadLayerPart struct {
2219 }
2220
2221 func (*awsAwsjson11_serializeOpUploadLayerPart) ID() string {
2222 return "OperationSerializer"
2223 }
2224
2225 func (m *awsAwsjson11_serializeOpUploadLayerPart) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2226 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2227 ) {
2228 request, ok := in.Request.(*smithyhttp.Request)
2229 if !ok {
2230 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2231 }
2232
2233 input, ok := in.Parameters.(*UploadLayerPartInput)
2234 _ = input
2235 if !ok {
2236 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2237 }
2238
2239 operationPath := "/"
2240 if len(request.Request.URL.Path) == 0 {
2241 request.Request.URL.Path = operationPath
2242 } else {
2243 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
2244 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
2245 request.Request.URL.Path += "/"
2246 }
2247 }
2248 request.Request.Method = "POST"
2249 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2250 if err != nil {
2251 return out, metadata, &smithy.SerializationError{Err: err}
2252 }
2253 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2254 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.UploadLayerPart")
2255
2256 jsonEncoder := smithyjson.NewEncoder()
2257 if err := awsAwsjson11_serializeOpDocumentUploadLayerPartInput(input, jsonEncoder.Value); err != nil {
2258 return out, metadata, &smithy.SerializationError{Err: err}
2259 }
2260
2261 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2262 return out, metadata, &smithy.SerializationError{Err: err}
2263 }
2264
2265 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2266 return out, metadata, &smithy.SerializationError{Err: err}
2267 }
2268 in.Request = request
2269
2270 return next.HandleSerialize(ctx, in)
2271 }
2272 func awsAwsjson11_serializeDocumentBatchedOperationLayerDigestList(v []string, value smithyjson.Value) error {
2273 array := value.Array()
2274 defer array.Close()
2275
2276 for i := range v {
2277 av := array.Value()
2278 av.String(v[i])
2279 }
2280 return nil
2281 }
2282
2283 func awsAwsjson11_serializeDocumentDescribeImagesFilter(v *types.DescribeImagesFilter, value smithyjson.Value) error {
2284 object := value.Object()
2285 defer object.Close()
2286
2287 if len(v.TagStatus) > 0 {
2288 ok := object.Key("tagStatus")
2289 ok.String(string(v.TagStatus))
2290 }
2291
2292 return nil
2293 }
2294
2295 func awsAwsjson11_serializeDocumentEncryptionConfiguration(v *types.EncryptionConfiguration, value smithyjson.Value) error {
2296 object := value.Object()
2297 defer object.Close()
2298
2299 if len(v.EncryptionType) > 0 {
2300 ok := object.Key("encryptionType")
2301 ok.String(string(v.EncryptionType))
2302 }
2303
2304 if v.KmsKey != nil {
2305 ok := object.Key("kmsKey")
2306 ok.String(*v.KmsKey)
2307 }
2308
2309 return nil
2310 }
2311
2312 func awsAwsjson11_serializeDocumentGetAuthorizationTokenRegistryIdList(v []string, value smithyjson.Value) error {
2313 array := value.Array()
2314 defer array.Close()
2315
2316 for i := range v {
2317 av := array.Value()
2318 av.String(v[i])
2319 }
2320 return nil
2321 }
2322
2323 func awsAwsjson11_serializeDocumentImageIdentifier(v *types.ImageIdentifier, value smithyjson.Value) error {
2324 object := value.Object()
2325 defer object.Close()
2326
2327 if v.ImageDigest != nil {
2328 ok := object.Key("imageDigest")
2329 ok.String(*v.ImageDigest)
2330 }
2331
2332 if v.ImageTag != nil {
2333 ok := object.Key("imageTag")
2334 ok.String(*v.ImageTag)
2335 }
2336
2337 return nil
2338 }
2339
2340 func awsAwsjson11_serializeDocumentImageIdentifierList(v []types.ImageIdentifier, value smithyjson.Value) error {
2341 array := value.Array()
2342 defer array.Close()
2343
2344 for i := range v {
2345 av := array.Value()
2346 if err := awsAwsjson11_serializeDocumentImageIdentifier(&v[i], av); err != nil {
2347 return err
2348 }
2349 }
2350 return nil
2351 }
2352
2353 func awsAwsjson11_serializeDocumentImageScanningConfiguration(v *types.ImageScanningConfiguration, value smithyjson.Value) error {
2354 object := value.Object()
2355 defer object.Close()
2356
2357 if v.ScanOnPush {
2358 ok := object.Key("scanOnPush")
2359 ok.Boolean(v.ScanOnPush)
2360 }
2361
2362 return nil
2363 }
2364
2365 func awsAwsjson11_serializeDocumentLayerDigestList(v []string, value smithyjson.Value) error {
2366 array := value.Array()
2367 defer array.Close()
2368
2369 for i := range v {
2370 av := array.Value()
2371 av.String(v[i])
2372 }
2373 return nil
2374 }
2375
2376 func awsAwsjson11_serializeDocumentLifecyclePolicyPreviewFilter(v *types.LifecyclePolicyPreviewFilter, value smithyjson.Value) error {
2377 object := value.Object()
2378 defer object.Close()
2379
2380 if len(v.TagStatus) > 0 {
2381 ok := object.Key("tagStatus")
2382 ok.String(string(v.TagStatus))
2383 }
2384
2385 return nil
2386 }
2387
2388 func awsAwsjson11_serializeDocumentListImagesFilter(v *types.ListImagesFilter, value smithyjson.Value) error {
2389 object := value.Object()
2390 defer object.Close()
2391
2392 if len(v.TagStatus) > 0 {
2393 ok := object.Key("tagStatus")
2394 ok.String(string(v.TagStatus))
2395 }
2396
2397 return nil
2398 }
2399
2400 func awsAwsjson11_serializeDocumentMediaTypeList(v []string, value smithyjson.Value) error {
2401 array := value.Array()
2402 defer array.Close()
2403
2404 for i := range v {
2405 av := array.Value()
2406 av.String(v[i])
2407 }
2408 return nil
2409 }
2410
2411 func awsAwsjson11_serializeDocumentPullThroughCacheRuleRepositoryPrefixList(v []string, value smithyjson.Value) error {
2412 array := value.Array()
2413 defer array.Close()
2414
2415 for i := range v {
2416 av := array.Value()
2417 av.String(v[i])
2418 }
2419 return nil
2420 }
2421
2422 func awsAwsjson11_serializeDocumentRegistryScanningRule(v *types.RegistryScanningRule, value smithyjson.Value) error {
2423 object := value.Object()
2424 defer object.Close()
2425
2426 if v.RepositoryFilters != nil {
2427 ok := object.Key("repositoryFilters")
2428 if err := awsAwsjson11_serializeDocumentScanningRepositoryFilterList(v.RepositoryFilters, ok); err != nil {
2429 return err
2430 }
2431 }
2432
2433 if len(v.ScanFrequency) > 0 {
2434 ok := object.Key("scanFrequency")
2435 ok.String(string(v.ScanFrequency))
2436 }
2437
2438 return nil
2439 }
2440
2441 func awsAwsjson11_serializeDocumentRegistryScanningRuleList(v []types.RegistryScanningRule, value smithyjson.Value) error {
2442 array := value.Array()
2443 defer array.Close()
2444
2445 for i := range v {
2446 av := array.Value()
2447 if err := awsAwsjson11_serializeDocumentRegistryScanningRule(&v[i], av); err != nil {
2448 return err
2449 }
2450 }
2451 return nil
2452 }
2453
2454 func awsAwsjson11_serializeDocumentReplicationConfiguration(v *types.ReplicationConfiguration, value smithyjson.Value) error {
2455 object := value.Object()
2456 defer object.Close()
2457
2458 if v.Rules != nil {
2459 ok := object.Key("rules")
2460 if err := awsAwsjson11_serializeDocumentReplicationRuleList(v.Rules, ok); err != nil {
2461 return err
2462 }
2463 }
2464
2465 return nil
2466 }
2467
2468 func awsAwsjson11_serializeDocumentReplicationDestination(v *types.ReplicationDestination, value smithyjson.Value) error {
2469 object := value.Object()
2470 defer object.Close()
2471
2472 if v.Region != nil {
2473 ok := object.Key("region")
2474 ok.String(*v.Region)
2475 }
2476
2477 if v.RegistryId != nil {
2478 ok := object.Key("registryId")
2479 ok.String(*v.RegistryId)
2480 }
2481
2482 return nil
2483 }
2484
2485 func awsAwsjson11_serializeDocumentReplicationDestinationList(v []types.ReplicationDestination, value smithyjson.Value) error {
2486 array := value.Array()
2487 defer array.Close()
2488
2489 for i := range v {
2490 av := array.Value()
2491 if err := awsAwsjson11_serializeDocumentReplicationDestination(&v[i], av); err != nil {
2492 return err
2493 }
2494 }
2495 return nil
2496 }
2497
2498 func awsAwsjson11_serializeDocumentReplicationRule(v *types.ReplicationRule, value smithyjson.Value) error {
2499 object := value.Object()
2500 defer object.Close()
2501
2502 if v.Destinations != nil {
2503 ok := object.Key("destinations")
2504 if err := awsAwsjson11_serializeDocumentReplicationDestinationList(v.Destinations, ok); err != nil {
2505 return err
2506 }
2507 }
2508
2509 if v.RepositoryFilters != nil {
2510 ok := object.Key("repositoryFilters")
2511 if err := awsAwsjson11_serializeDocumentRepositoryFilterList(v.RepositoryFilters, ok); err != nil {
2512 return err
2513 }
2514 }
2515
2516 return nil
2517 }
2518
2519 func awsAwsjson11_serializeDocumentReplicationRuleList(v []types.ReplicationRule, value smithyjson.Value) error {
2520 array := value.Array()
2521 defer array.Close()
2522
2523 for i := range v {
2524 av := array.Value()
2525 if err := awsAwsjson11_serializeDocumentReplicationRule(&v[i], av); err != nil {
2526 return err
2527 }
2528 }
2529 return nil
2530 }
2531
2532 func awsAwsjson11_serializeDocumentRepositoryFilter(v *types.RepositoryFilter, value smithyjson.Value) error {
2533 object := value.Object()
2534 defer object.Close()
2535
2536 if v.Filter != nil {
2537 ok := object.Key("filter")
2538 ok.String(*v.Filter)
2539 }
2540
2541 if len(v.FilterType) > 0 {
2542 ok := object.Key("filterType")
2543 ok.String(string(v.FilterType))
2544 }
2545
2546 return nil
2547 }
2548
2549 func awsAwsjson11_serializeDocumentRepositoryFilterList(v []types.RepositoryFilter, value smithyjson.Value) error {
2550 array := value.Array()
2551 defer array.Close()
2552
2553 for i := range v {
2554 av := array.Value()
2555 if err := awsAwsjson11_serializeDocumentRepositoryFilter(&v[i], av); err != nil {
2556 return err
2557 }
2558 }
2559 return nil
2560 }
2561
2562 func awsAwsjson11_serializeDocumentRepositoryNameList(v []string, value smithyjson.Value) error {
2563 array := value.Array()
2564 defer array.Close()
2565
2566 for i := range v {
2567 av := array.Value()
2568 av.String(v[i])
2569 }
2570 return nil
2571 }
2572
2573 func awsAwsjson11_serializeDocumentScanningConfigurationRepositoryNameList(v []string, value smithyjson.Value) error {
2574 array := value.Array()
2575 defer array.Close()
2576
2577 for i := range v {
2578 av := array.Value()
2579 av.String(v[i])
2580 }
2581 return nil
2582 }
2583
2584 func awsAwsjson11_serializeDocumentScanningRepositoryFilter(v *types.ScanningRepositoryFilter, value smithyjson.Value) error {
2585 object := value.Object()
2586 defer object.Close()
2587
2588 if v.Filter != nil {
2589 ok := object.Key("filter")
2590 ok.String(*v.Filter)
2591 }
2592
2593 if len(v.FilterType) > 0 {
2594 ok := object.Key("filterType")
2595 ok.String(string(v.FilterType))
2596 }
2597
2598 return nil
2599 }
2600
2601 func awsAwsjson11_serializeDocumentScanningRepositoryFilterList(v []types.ScanningRepositoryFilter, value smithyjson.Value) error {
2602 array := value.Array()
2603 defer array.Close()
2604
2605 for i := range v {
2606 av := array.Value()
2607 if err := awsAwsjson11_serializeDocumentScanningRepositoryFilter(&v[i], av); err != nil {
2608 return err
2609 }
2610 }
2611 return nil
2612 }
2613
2614 func awsAwsjson11_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error {
2615 object := value.Object()
2616 defer object.Close()
2617
2618 if v.Key != nil {
2619 ok := object.Key("Key")
2620 ok.String(*v.Key)
2621 }
2622
2623 if v.Value != nil {
2624 ok := object.Key("Value")
2625 ok.String(*v.Value)
2626 }
2627
2628 return nil
2629 }
2630
2631 func awsAwsjson11_serializeDocumentTagKeyList(v []string, value smithyjson.Value) error {
2632 array := value.Array()
2633 defer array.Close()
2634
2635 for i := range v {
2636 av := array.Value()
2637 av.String(v[i])
2638 }
2639 return nil
2640 }
2641
2642 func awsAwsjson11_serializeDocumentTagList(v []types.Tag, value smithyjson.Value) error {
2643 array := value.Array()
2644 defer array.Close()
2645
2646 for i := range v {
2647 av := array.Value()
2648 if err := awsAwsjson11_serializeDocumentTag(&v[i], av); err != nil {
2649 return err
2650 }
2651 }
2652 return nil
2653 }
2654
2655 func awsAwsjson11_serializeOpDocumentBatchCheckLayerAvailabilityInput(v *BatchCheckLayerAvailabilityInput, value smithyjson.Value) error {
2656 object := value.Object()
2657 defer object.Close()
2658
2659 if v.LayerDigests != nil {
2660 ok := object.Key("layerDigests")
2661 if err := awsAwsjson11_serializeDocumentBatchedOperationLayerDigestList(v.LayerDigests, ok); err != nil {
2662 return err
2663 }
2664 }
2665
2666 if v.RegistryId != nil {
2667 ok := object.Key("registryId")
2668 ok.String(*v.RegistryId)
2669 }
2670
2671 if v.RepositoryName != nil {
2672 ok := object.Key("repositoryName")
2673 ok.String(*v.RepositoryName)
2674 }
2675
2676 return nil
2677 }
2678
2679 func awsAwsjson11_serializeOpDocumentBatchDeleteImageInput(v *BatchDeleteImageInput, value smithyjson.Value) error {
2680 object := value.Object()
2681 defer object.Close()
2682
2683 if v.ImageIds != nil {
2684 ok := object.Key("imageIds")
2685 if err := awsAwsjson11_serializeDocumentImageIdentifierList(v.ImageIds, ok); err != nil {
2686 return err
2687 }
2688 }
2689
2690 if v.RegistryId != nil {
2691 ok := object.Key("registryId")
2692 ok.String(*v.RegistryId)
2693 }
2694
2695 if v.RepositoryName != nil {
2696 ok := object.Key("repositoryName")
2697 ok.String(*v.RepositoryName)
2698 }
2699
2700 return nil
2701 }
2702
2703 func awsAwsjson11_serializeOpDocumentBatchGetImageInput(v *BatchGetImageInput, value smithyjson.Value) error {
2704 object := value.Object()
2705 defer object.Close()
2706
2707 if v.AcceptedMediaTypes != nil {
2708 ok := object.Key("acceptedMediaTypes")
2709 if err := awsAwsjson11_serializeDocumentMediaTypeList(v.AcceptedMediaTypes, ok); err != nil {
2710 return err
2711 }
2712 }
2713
2714 if v.ImageIds != nil {
2715 ok := object.Key("imageIds")
2716 if err := awsAwsjson11_serializeDocumentImageIdentifierList(v.ImageIds, ok); err != nil {
2717 return err
2718 }
2719 }
2720
2721 if v.RegistryId != nil {
2722 ok := object.Key("registryId")
2723 ok.String(*v.RegistryId)
2724 }
2725
2726 if v.RepositoryName != nil {
2727 ok := object.Key("repositoryName")
2728 ok.String(*v.RepositoryName)
2729 }
2730
2731 return nil
2732 }
2733
2734 func awsAwsjson11_serializeOpDocumentBatchGetRepositoryScanningConfigurationInput(v *BatchGetRepositoryScanningConfigurationInput, value smithyjson.Value) error {
2735 object := value.Object()
2736 defer object.Close()
2737
2738 if v.RepositoryNames != nil {
2739 ok := object.Key("repositoryNames")
2740 if err := awsAwsjson11_serializeDocumentScanningConfigurationRepositoryNameList(v.RepositoryNames, ok); err != nil {
2741 return err
2742 }
2743 }
2744
2745 return nil
2746 }
2747
2748 func awsAwsjson11_serializeOpDocumentCompleteLayerUploadInput(v *CompleteLayerUploadInput, value smithyjson.Value) error {
2749 object := value.Object()
2750 defer object.Close()
2751
2752 if v.LayerDigests != nil {
2753 ok := object.Key("layerDigests")
2754 if err := awsAwsjson11_serializeDocumentLayerDigestList(v.LayerDigests, ok); err != nil {
2755 return err
2756 }
2757 }
2758
2759 if v.RegistryId != nil {
2760 ok := object.Key("registryId")
2761 ok.String(*v.RegistryId)
2762 }
2763
2764 if v.RepositoryName != nil {
2765 ok := object.Key("repositoryName")
2766 ok.String(*v.RepositoryName)
2767 }
2768
2769 if v.UploadId != nil {
2770 ok := object.Key("uploadId")
2771 ok.String(*v.UploadId)
2772 }
2773
2774 return nil
2775 }
2776
2777 func awsAwsjson11_serializeOpDocumentCreatePullThroughCacheRuleInput(v *CreatePullThroughCacheRuleInput, value smithyjson.Value) error {
2778 object := value.Object()
2779 defer object.Close()
2780
2781 if v.EcrRepositoryPrefix != nil {
2782 ok := object.Key("ecrRepositoryPrefix")
2783 ok.String(*v.EcrRepositoryPrefix)
2784 }
2785
2786 if v.RegistryId != nil {
2787 ok := object.Key("registryId")
2788 ok.String(*v.RegistryId)
2789 }
2790
2791 if v.UpstreamRegistryUrl != nil {
2792 ok := object.Key("upstreamRegistryUrl")
2793 ok.String(*v.UpstreamRegistryUrl)
2794 }
2795
2796 return nil
2797 }
2798
2799 func awsAwsjson11_serializeOpDocumentCreateRepositoryInput(v *CreateRepositoryInput, value smithyjson.Value) error {
2800 object := value.Object()
2801 defer object.Close()
2802
2803 if v.EncryptionConfiguration != nil {
2804 ok := object.Key("encryptionConfiguration")
2805 if err := awsAwsjson11_serializeDocumentEncryptionConfiguration(v.EncryptionConfiguration, ok); err != nil {
2806 return err
2807 }
2808 }
2809
2810 if v.ImageScanningConfiguration != nil {
2811 ok := object.Key("imageScanningConfiguration")
2812 if err := awsAwsjson11_serializeDocumentImageScanningConfiguration(v.ImageScanningConfiguration, ok); err != nil {
2813 return err
2814 }
2815 }
2816
2817 if len(v.ImageTagMutability) > 0 {
2818 ok := object.Key("imageTagMutability")
2819 ok.String(string(v.ImageTagMutability))
2820 }
2821
2822 if v.RegistryId != nil {
2823 ok := object.Key("registryId")
2824 ok.String(*v.RegistryId)
2825 }
2826
2827 if v.RepositoryName != nil {
2828 ok := object.Key("repositoryName")
2829 ok.String(*v.RepositoryName)
2830 }
2831
2832 if v.Tags != nil {
2833 ok := object.Key("tags")
2834 if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
2835 return err
2836 }
2837 }
2838
2839 return nil
2840 }
2841
2842 func awsAwsjson11_serializeOpDocumentDeleteLifecyclePolicyInput(v *DeleteLifecyclePolicyInput, value smithyjson.Value) error {
2843 object := value.Object()
2844 defer object.Close()
2845
2846 if v.RegistryId != nil {
2847 ok := object.Key("registryId")
2848 ok.String(*v.RegistryId)
2849 }
2850
2851 if v.RepositoryName != nil {
2852 ok := object.Key("repositoryName")
2853 ok.String(*v.RepositoryName)
2854 }
2855
2856 return nil
2857 }
2858
2859 func awsAwsjson11_serializeOpDocumentDeletePullThroughCacheRuleInput(v *DeletePullThroughCacheRuleInput, value smithyjson.Value) error {
2860 object := value.Object()
2861 defer object.Close()
2862
2863 if v.EcrRepositoryPrefix != nil {
2864 ok := object.Key("ecrRepositoryPrefix")
2865 ok.String(*v.EcrRepositoryPrefix)
2866 }
2867
2868 if v.RegistryId != nil {
2869 ok := object.Key("registryId")
2870 ok.String(*v.RegistryId)
2871 }
2872
2873 return nil
2874 }
2875
2876 func awsAwsjson11_serializeOpDocumentDeleteRegistryPolicyInput(v *DeleteRegistryPolicyInput, value smithyjson.Value) error {
2877 object := value.Object()
2878 defer object.Close()
2879
2880 return nil
2881 }
2882
2883 func awsAwsjson11_serializeOpDocumentDeleteRepositoryInput(v *DeleteRepositoryInput, value smithyjson.Value) error {
2884 object := value.Object()
2885 defer object.Close()
2886
2887 if v.Force {
2888 ok := object.Key("force")
2889 ok.Boolean(v.Force)
2890 }
2891
2892 if v.RegistryId != nil {
2893 ok := object.Key("registryId")
2894 ok.String(*v.RegistryId)
2895 }
2896
2897 if v.RepositoryName != nil {
2898 ok := object.Key("repositoryName")
2899 ok.String(*v.RepositoryName)
2900 }
2901
2902 return nil
2903 }
2904
2905 func awsAwsjson11_serializeOpDocumentDeleteRepositoryPolicyInput(v *DeleteRepositoryPolicyInput, value smithyjson.Value) error {
2906 object := value.Object()
2907 defer object.Close()
2908
2909 if v.RegistryId != nil {
2910 ok := object.Key("registryId")
2911 ok.String(*v.RegistryId)
2912 }
2913
2914 if v.RepositoryName != nil {
2915 ok := object.Key("repositoryName")
2916 ok.String(*v.RepositoryName)
2917 }
2918
2919 return nil
2920 }
2921
2922 func awsAwsjson11_serializeOpDocumentDescribeImageReplicationStatusInput(v *DescribeImageReplicationStatusInput, value smithyjson.Value) error {
2923 object := value.Object()
2924 defer object.Close()
2925
2926 if v.ImageId != nil {
2927 ok := object.Key("imageId")
2928 if err := awsAwsjson11_serializeDocumentImageIdentifier(v.ImageId, ok); err != nil {
2929 return err
2930 }
2931 }
2932
2933 if v.RegistryId != nil {
2934 ok := object.Key("registryId")
2935 ok.String(*v.RegistryId)
2936 }
2937
2938 if v.RepositoryName != nil {
2939 ok := object.Key("repositoryName")
2940 ok.String(*v.RepositoryName)
2941 }
2942
2943 return nil
2944 }
2945
2946 func awsAwsjson11_serializeOpDocumentDescribeImageScanFindingsInput(v *DescribeImageScanFindingsInput, value smithyjson.Value) error {
2947 object := value.Object()
2948 defer object.Close()
2949
2950 if v.ImageId != nil {
2951 ok := object.Key("imageId")
2952 if err := awsAwsjson11_serializeDocumentImageIdentifier(v.ImageId, ok); err != nil {
2953 return err
2954 }
2955 }
2956
2957 if v.MaxResults != nil {
2958 ok := object.Key("maxResults")
2959 ok.Integer(*v.MaxResults)
2960 }
2961
2962 if v.NextToken != nil {
2963 ok := object.Key("nextToken")
2964 ok.String(*v.NextToken)
2965 }
2966
2967 if v.RegistryId != nil {
2968 ok := object.Key("registryId")
2969 ok.String(*v.RegistryId)
2970 }
2971
2972 if v.RepositoryName != nil {
2973 ok := object.Key("repositoryName")
2974 ok.String(*v.RepositoryName)
2975 }
2976
2977 return nil
2978 }
2979
2980 func awsAwsjson11_serializeOpDocumentDescribeImagesInput(v *DescribeImagesInput, value smithyjson.Value) error {
2981 object := value.Object()
2982 defer object.Close()
2983
2984 if v.Filter != nil {
2985 ok := object.Key("filter")
2986 if err := awsAwsjson11_serializeDocumentDescribeImagesFilter(v.Filter, ok); err != nil {
2987 return err
2988 }
2989 }
2990
2991 if v.ImageIds != nil {
2992 ok := object.Key("imageIds")
2993 if err := awsAwsjson11_serializeDocumentImageIdentifierList(v.ImageIds, ok); err != nil {
2994 return err
2995 }
2996 }
2997
2998 if v.MaxResults != nil {
2999 ok := object.Key("maxResults")
3000 ok.Integer(*v.MaxResults)
3001 }
3002
3003 if v.NextToken != nil {
3004 ok := object.Key("nextToken")
3005 ok.String(*v.NextToken)
3006 }
3007
3008 if v.RegistryId != nil {
3009 ok := object.Key("registryId")
3010 ok.String(*v.RegistryId)
3011 }
3012
3013 if v.RepositoryName != nil {
3014 ok := object.Key("repositoryName")
3015 ok.String(*v.RepositoryName)
3016 }
3017
3018 return nil
3019 }
3020
3021 func awsAwsjson11_serializeOpDocumentDescribePullThroughCacheRulesInput(v *DescribePullThroughCacheRulesInput, value smithyjson.Value) error {
3022 object := value.Object()
3023 defer object.Close()
3024
3025 if v.EcrRepositoryPrefixes != nil {
3026 ok := object.Key("ecrRepositoryPrefixes")
3027 if err := awsAwsjson11_serializeDocumentPullThroughCacheRuleRepositoryPrefixList(v.EcrRepositoryPrefixes, ok); err != nil {
3028 return err
3029 }
3030 }
3031
3032 if v.MaxResults != nil {
3033 ok := object.Key("maxResults")
3034 ok.Integer(*v.MaxResults)
3035 }
3036
3037 if v.NextToken != nil {
3038 ok := object.Key("nextToken")
3039 ok.String(*v.NextToken)
3040 }
3041
3042 if v.RegistryId != nil {
3043 ok := object.Key("registryId")
3044 ok.String(*v.RegistryId)
3045 }
3046
3047 return nil
3048 }
3049
3050 func awsAwsjson11_serializeOpDocumentDescribeRegistryInput(v *DescribeRegistryInput, value smithyjson.Value) error {
3051 object := value.Object()
3052 defer object.Close()
3053
3054 return nil
3055 }
3056
3057 func awsAwsjson11_serializeOpDocumentDescribeRepositoriesInput(v *DescribeRepositoriesInput, value smithyjson.Value) error {
3058 object := value.Object()
3059 defer object.Close()
3060
3061 if v.MaxResults != nil {
3062 ok := object.Key("maxResults")
3063 ok.Integer(*v.MaxResults)
3064 }
3065
3066 if v.NextToken != nil {
3067 ok := object.Key("nextToken")
3068 ok.String(*v.NextToken)
3069 }
3070
3071 if v.RegistryId != nil {
3072 ok := object.Key("registryId")
3073 ok.String(*v.RegistryId)
3074 }
3075
3076 if v.RepositoryNames != nil {
3077 ok := object.Key("repositoryNames")
3078 if err := awsAwsjson11_serializeDocumentRepositoryNameList(v.RepositoryNames, ok); err != nil {
3079 return err
3080 }
3081 }
3082
3083 return nil
3084 }
3085
3086 func awsAwsjson11_serializeOpDocumentGetAuthorizationTokenInput(v *GetAuthorizationTokenInput, value smithyjson.Value) error {
3087 object := value.Object()
3088 defer object.Close()
3089
3090 if v.RegistryIds != nil {
3091 ok := object.Key("registryIds")
3092 if err := awsAwsjson11_serializeDocumentGetAuthorizationTokenRegistryIdList(v.RegistryIds, ok); err != nil {
3093 return err
3094 }
3095 }
3096
3097 return nil
3098 }
3099
3100 func awsAwsjson11_serializeOpDocumentGetDownloadUrlForLayerInput(v *GetDownloadUrlForLayerInput, value smithyjson.Value) error {
3101 object := value.Object()
3102 defer object.Close()
3103
3104 if v.LayerDigest != nil {
3105 ok := object.Key("layerDigest")
3106 ok.String(*v.LayerDigest)
3107 }
3108
3109 if v.RegistryId != nil {
3110 ok := object.Key("registryId")
3111 ok.String(*v.RegistryId)
3112 }
3113
3114 if v.RepositoryName != nil {
3115 ok := object.Key("repositoryName")
3116 ok.String(*v.RepositoryName)
3117 }
3118
3119 return nil
3120 }
3121
3122 func awsAwsjson11_serializeOpDocumentGetLifecyclePolicyInput(v *GetLifecyclePolicyInput, value smithyjson.Value) error {
3123 object := value.Object()
3124 defer object.Close()
3125
3126 if v.RegistryId != nil {
3127 ok := object.Key("registryId")
3128 ok.String(*v.RegistryId)
3129 }
3130
3131 if v.RepositoryName != nil {
3132 ok := object.Key("repositoryName")
3133 ok.String(*v.RepositoryName)
3134 }
3135
3136 return nil
3137 }
3138
3139 func awsAwsjson11_serializeOpDocumentGetLifecyclePolicyPreviewInput(v *GetLifecyclePolicyPreviewInput, value smithyjson.Value) error {
3140 object := value.Object()
3141 defer object.Close()
3142
3143 if v.Filter != nil {
3144 ok := object.Key("filter")
3145 if err := awsAwsjson11_serializeDocumentLifecyclePolicyPreviewFilter(v.Filter, ok); err != nil {
3146 return err
3147 }
3148 }
3149
3150 if v.ImageIds != nil {
3151 ok := object.Key("imageIds")
3152 if err := awsAwsjson11_serializeDocumentImageIdentifierList(v.ImageIds, ok); err != nil {
3153 return err
3154 }
3155 }
3156
3157 if v.MaxResults != nil {
3158 ok := object.Key("maxResults")
3159 ok.Integer(*v.MaxResults)
3160 }
3161
3162 if v.NextToken != nil {
3163 ok := object.Key("nextToken")
3164 ok.String(*v.NextToken)
3165 }
3166
3167 if v.RegistryId != nil {
3168 ok := object.Key("registryId")
3169 ok.String(*v.RegistryId)
3170 }
3171
3172 if v.RepositoryName != nil {
3173 ok := object.Key("repositoryName")
3174 ok.String(*v.RepositoryName)
3175 }
3176
3177 return nil
3178 }
3179
3180 func awsAwsjson11_serializeOpDocumentGetRegistryPolicyInput(v *GetRegistryPolicyInput, value smithyjson.Value) error {
3181 object := value.Object()
3182 defer object.Close()
3183
3184 return nil
3185 }
3186
3187 func awsAwsjson11_serializeOpDocumentGetRegistryScanningConfigurationInput(v *GetRegistryScanningConfigurationInput, value smithyjson.Value) error {
3188 object := value.Object()
3189 defer object.Close()
3190
3191 return nil
3192 }
3193
3194 func awsAwsjson11_serializeOpDocumentGetRepositoryPolicyInput(v *GetRepositoryPolicyInput, value smithyjson.Value) error {
3195 object := value.Object()
3196 defer object.Close()
3197
3198 if v.RegistryId != nil {
3199 ok := object.Key("registryId")
3200 ok.String(*v.RegistryId)
3201 }
3202
3203 if v.RepositoryName != nil {
3204 ok := object.Key("repositoryName")
3205 ok.String(*v.RepositoryName)
3206 }
3207
3208 return nil
3209 }
3210
3211 func awsAwsjson11_serializeOpDocumentInitiateLayerUploadInput(v *InitiateLayerUploadInput, value smithyjson.Value) error {
3212 object := value.Object()
3213 defer object.Close()
3214
3215 if v.RegistryId != nil {
3216 ok := object.Key("registryId")
3217 ok.String(*v.RegistryId)
3218 }
3219
3220 if v.RepositoryName != nil {
3221 ok := object.Key("repositoryName")
3222 ok.String(*v.RepositoryName)
3223 }
3224
3225 return nil
3226 }
3227
3228 func awsAwsjson11_serializeOpDocumentListImagesInput(v *ListImagesInput, value smithyjson.Value) error {
3229 object := value.Object()
3230 defer object.Close()
3231
3232 if v.Filter != nil {
3233 ok := object.Key("filter")
3234 if err := awsAwsjson11_serializeDocumentListImagesFilter(v.Filter, ok); err != nil {
3235 return err
3236 }
3237 }
3238
3239 if v.MaxResults != nil {
3240 ok := object.Key("maxResults")
3241 ok.Integer(*v.MaxResults)
3242 }
3243
3244 if v.NextToken != nil {
3245 ok := object.Key("nextToken")
3246 ok.String(*v.NextToken)
3247 }
3248
3249 if v.RegistryId != nil {
3250 ok := object.Key("registryId")
3251 ok.String(*v.RegistryId)
3252 }
3253
3254 if v.RepositoryName != nil {
3255 ok := object.Key("repositoryName")
3256 ok.String(*v.RepositoryName)
3257 }
3258
3259 return nil
3260 }
3261
3262 func awsAwsjson11_serializeOpDocumentListTagsForResourceInput(v *ListTagsForResourceInput, value smithyjson.Value) error {
3263 object := value.Object()
3264 defer object.Close()
3265
3266 if v.ResourceArn != nil {
3267 ok := object.Key("resourceArn")
3268 ok.String(*v.ResourceArn)
3269 }
3270
3271 return nil
3272 }
3273
3274 func awsAwsjson11_serializeOpDocumentPutImageInput(v *PutImageInput, value smithyjson.Value) error {
3275 object := value.Object()
3276 defer object.Close()
3277
3278 if v.ImageDigest != nil {
3279 ok := object.Key("imageDigest")
3280 ok.String(*v.ImageDigest)
3281 }
3282
3283 if v.ImageManifest != nil {
3284 ok := object.Key("imageManifest")
3285 ok.String(*v.ImageManifest)
3286 }
3287
3288 if v.ImageManifestMediaType != nil {
3289 ok := object.Key("imageManifestMediaType")
3290 ok.String(*v.ImageManifestMediaType)
3291 }
3292
3293 if v.ImageTag != nil {
3294 ok := object.Key("imageTag")
3295 ok.String(*v.ImageTag)
3296 }
3297
3298 if v.RegistryId != nil {
3299 ok := object.Key("registryId")
3300 ok.String(*v.RegistryId)
3301 }
3302
3303 if v.RepositoryName != nil {
3304 ok := object.Key("repositoryName")
3305 ok.String(*v.RepositoryName)
3306 }
3307
3308 return nil
3309 }
3310
3311 func awsAwsjson11_serializeOpDocumentPutImageScanningConfigurationInput(v *PutImageScanningConfigurationInput, value smithyjson.Value) error {
3312 object := value.Object()
3313 defer object.Close()
3314
3315 if v.ImageScanningConfiguration != nil {
3316 ok := object.Key("imageScanningConfiguration")
3317 if err := awsAwsjson11_serializeDocumentImageScanningConfiguration(v.ImageScanningConfiguration, ok); err != nil {
3318 return err
3319 }
3320 }
3321
3322 if v.RegistryId != nil {
3323 ok := object.Key("registryId")
3324 ok.String(*v.RegistryId)
3325 }
3326
3327 if v.RepositoryName != nil {
3328 ok := object.Key("repositoryName")
3329 ok.String(*v.RepositoryName)
3330 }
3331
3332 return nil
3333 }
3334
3335 func awsAwsjson11_serializeOpDocumentPutImageTagMutabilityInput(v *PutImageTagMutabilityInput, value smithyjson.Value) error {
3336 object := value.Object()
3337 defer object.Close()
3338
3339 if len(v.ImageTagMutability) > 0 {
3340 ok := object.Key("imageTagMutability")
3341 ok.String(string(v.ImageTagMutability))
3342 }
3343
3344 if v.RegistryId != nil {
3345 ok := object.Key("registryId")
3346 ok.String(*v.RegistryId)
3347 }
3348
3349 if v.RepositoryName != nil {
3350 ok := object.Key("repositoryName")
3351 ok.String(*v.RepositoryName)
3352 }
3353
3354 return nil
3355 }
3356
3357 func awsAwsjson11_serializeOpDocumentPutLifecyclePolicyInput(v *PutLifecyclePolicyInput, value smithyjson.Value) error {
3358 object := value.Object()
3359 defer object.Close()
3360
3361 if v.LifecyclePolicyText != nil {
3362 ok := object.Key("lifecyclePolicyText")
3363 ok.String(*v.LifecyclePolicyText)
3364 }
3365
3366 if v.RegistryId != nil {
3367 ok := object.Key("registryId")
3368 ok.String(*v.RegistryId)
3369 }
3370
3371 if v.RepositoryName != nil {
3372 ok := object.Key("repositoryName")
3373 ok.String(*v.RepositoryName)
3374 }
3375
3376 return nil
3377 }
3378
3379 func awsAwsjson11_serializeOpDocumentPutRegistryPolicyInput(v *PutRegistryPolicyInput, value smithyjson.Value) error {
3380 object := value.Object()
3381 defer object.Close()
3382
3383 if v.PolicyText != nil {
3384 ok := object.Key("policyText")
3385 ok.String(*v.PolicyText)
3386 }
3387
3388 return nil
3389 }
3390
3391 func awsAwsjson11_serializeOpDocumentPutRegistryScanningConfigurationInput(v *PutRegistryScanningConfigurationInput, value smithyjson.Value) error {
3392 object := value.Object()
3393 defer object.Close()
3394
3395 if v.Rules != nil {
3396 ok := object.Key("rules")
3397 if err := awsAwsjson11_serializeDocumentRegistryScanningRuleList(v.Rules, ok); err != nil {
3398 return err
3399 }
3400 }
3401
3402 if len(v.ScanType) > 0 {
3403 ok := object.Key("scanType")
3404 ok.String(string(v.ScanType))
3405 }
3406
3407 return nil
3408 }
3409
3410 func awsAwsjson11_serializeOpDocumentPutReplicationConfigurationInput(v *PutReplicationConfigurationInput, value smithyjson.Value) error {
3411 object := value.Object()
3412 defer object.Close()
3413
3414 if v.ReplicationConfiguration != nil {
3415 ok := object.Key("replicationConfiguration")
3416 if err := awsAwsjson11_serializeDocumentReplicationConfiguration(v.ReplicationConfiguration, ok); err != nil {
3417 return err
3418 }
3419 }
3420
3421 return nil
3422 }
3423
3424 func awsAwsjson11_serializeOpDocumentSetRepositoryPolicyInput(v *SetRepositoryPolicyInput, value smithyjson.Value) error {
3425 object := value.Object()
3426 defer object.Close()
3427
3428 if v.Force {
3429 ok := object.Key("force")
3430 ok.Boolean(v.Force)
3431 }
3432
3433 if v.PolicyText != nil {
3434 ok := object.Key("policyText")
3435 ok.String(*v.PolicyText)
3436 }
3437
3438 if v.RegistryId != nil {
3439 ok := object.Key("registryId")
3440 ok.String(*v.RegistryId)
3441 }
3442
3443 if v.RepositoryName != nil {
3444 ok := object.Key("repositoryName")
3445 ok.String(*v.RepositoryName)
3446 }
3447
3448 return nil
3449 }
3450
3451 func awsAwsjson11_serializeOpDocumentStartImageScanInput(v *StartImageScanInput, value smithyjson.Value) error {
3452 object := value.Object()
3453 defer object.Close()
3454
3455 if v.ImageId != nil {
3456 ok := object.Key("imageId")
3457 if err := awsAwsjson11_serializeDocumentImageIdentifier(v.ImageId, ok); err != nil {
3458 return err
3459 }
3460 }
3461
3462 if v.RegistryId != nil {
3463 ok := object.Key("registryId")
3464 ok.String(*v.RegistryId)
3465 }
3466
3467 if v.RepositoryName != nil {
3468 ok := object.Key("repositoryName")
3469 ok.String(*v.RepositoryName)
3470 }
3471
3472 return nil
3473 }
3474
3475 func awsAwsjson11_serializeOpDocumentStartLifecyclePolicyPreviewInput(v *StartLifecyclePolicyPreviewInput, value smithyjson.Value) error {
3476 object := value.Object()
3477 defer object.Close()
3478
3479 if v.LifecyclePolicyText != nil {
3480 ok := object.Key("lifecyclePolicyText")
3481 ok.String(*v.LifecyclePolicyText)
3482 }
3483
3484 if v.RegistryId != nil {
3485 ok := object.Key("registryId")
3486 ok.String(*v.RegistryId)
3487 }
3488
3489 if v.RepositoryName != nil {
3490 ok := object.Key("repositoryName")
3491 ok.String(*v.RepositoryName)
3492 }
3493
3494 return nil
3495 }
3496
3497 func awsAwsjson11_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
3498 object := value.Object()
3499 defer object.Close()
3500
3501 if v.ResourceArn != nil {
3502 ok := object.Key("resourceArn")
3503 ok.String(*v.ResourceArn)
3504 }
3505
3506 if v.Tags != nil {
3507 ok := object.Key("tags")
3508 if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
3509 return err
3510 }
3511 }
3512
3513 return nil
3514 }
3515
3516 func awsAwsjson11_serializeOpDocumentUntagResourceInput(v *UntagResourceInput, value smithyjson.Value) error {
3517 object := value.Object()
3518 defer object.Close()
3519
3520 if v.ResourceArn != nil {
3521 ok := object.Key("resourceArn")
3522 ok.String(*v.ResourceArn)
3523 }
3524
3525 if v.TagKeys != nil {
3526 ok := object.Key("tagKeys")
3527 if err := awsAwsjson11_serializeDocumentTagKeyList(v.TagKeys, ok); err != nil {
3528 return err
3529 }
3530 }
3531
3532 return nil
3533 }
3534
3535 func awsAwsjson11_serializeOpDocumentUploadLayerPartInput(v *UploadLayerPartInput, value smithyjson.Value) error {
3536 object := value.Object()
3537 defer object.Close()
3538
3539 if v.LayerPartBlob != nil {
3540 ok := object.Key("layerPartBlob")
3541 ok.Base64EncodeBytes(v.LayerPartBlob)
3542 }
3543
3544 if v.PartFirstByte != nil {
3545 ok := object.Key("partFirstByte")
3546 ok.Long(*v.PartFirstByte)
3547 }
3548
3549 if v.PartLastByte != nil {
3550 ok := object.Key("partLastByte")
3551 ok.Long(*v.PartLastByte)
3552 }
3553
3554 if v.RegistryId != nil {
3555 ok := object.Key("registryId")
3556 ok.String(*v.RegistryId)
3557 }
3558
3559 if v.RepositoryName != nil {
3560 ok := object.Key("repositoryName")
3561 ok.String(*v.RepositoryName)
3562 }
3563
3564 if v.UploadId != nil {
3565 ok := object.Key("uploadId")
3566 ok.String(*v.UploadId)
3567 }
3568
3569 return nil
3570 }
3571
View as plain text