1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package ecr
4
5import (
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)
16
17type awsAwsjson11_serializeOpBatchCheckLayerAvailability struct {
18}
19
20func (*awsAwsjson11_serializeOpBatchCheckLayerAvailability) ID() string {
21	return "OperationSerializer"
22}
23
24func (m *awsAwsjson11_serializeOpBatchCheckLayerAvailability) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
25	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
26) {
27	request, ok := in.Request.(*smithyhttp.Request)
28	if !ok {
29		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
30	}
31
32	input, ok := in.Parameters.(*BatchCheckLayerAvailabilityInput)
33	_ = input
34	if !ok {
35		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
36	}
37
38	request.Request.URL.Path = "/"
39	request.Request.Method = "POST"
40	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
41	if err != nil {
42		return out, metadata, &smithy.SerializationError{Err: err}
43	}
44	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
45	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.BatchCheckLayerAvailability")
46
47	jsonEncoder := smithyjson.NewEncoder()
48	if err := awsAwsjson11_serializeOpDocumentBatchCheckLayerAvailabilityInput(input, jsonEncoder.Value); err != nil {
49		return out, metadata, &smithy.SerializationError{Err: err}
50	}
51
52	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
53		return out, metadata, &smithy.SerializationError{Err: err}
54	}
55
56	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
57		return out, metadata, &smithy.SerializationError{Err: err}
58	}
59	in.Request = request
60
61	return next.HandleSerialize(ctx, in)
62}
63
64type awsAwsjson11_serializeOpBatchDeleteImage struct {
65}
66
67func (*awsAwsjson11_serializeOpBatchDeleteImage) ID() string {
68	return "OperationSerializer"
69}
70
71func (m *awsAwsjson11_serializeOpBatchDeleteImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
72	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
73) {
74	request, ok := in.Request.(*smithyhttp.Request)
75	if !ok {
76		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
77	}
78
79	input, ok := in.Parameters.(*BatchDeleteImageInput)
80	_ = input
81	if !ok {
82		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
83	}
84
85	request.Request.URL.Path = "/"
86	request.Request.Method = "POST"
87	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
88	if err != nil {
89		return out, metadata, &smithy.SerializationError{Err: err}
90	}
91	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
92	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.BatchDeleteImage")
93
94	jsonEncoder := smithyjson.NewEncoder()
95	if err := awsAwsjson11_serializeOpDocumentBatchDeleteImageInput(input, jsonEncoder.Value); err != nil {
96		return out, metadata, &smithy.SerializationError{Err: err}
97	}
98
99	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
100		return out, metadata, &smithy.SerializationError{Err: err}
101	}
102
103	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
104		return out, metadata, &smithy.SerializationError{Err: err}
105	}
106	in.Request = request
107
108	return next.HandleSerialize(ctx, in)
109}
110
111type awsAwsjson11_serializeOpBatchGetImage struct {
112}
113
114func (*awsAwsjson11_serializeOpBatchGetImage) ID() string {
115	return "OperationSerializer"
116}
117
118func (m *awsAwsjson11_serializeOpBatchGetImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
119	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
120) {
121	request, ok := in.Request.(*smithyhttp.Request)
122	if !ok {
123		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
124	}
125
126	input, ok := in.Parameters.(*BatchGetImageInput)
127	_ = input
128	if !ok {
129		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
130	}
131
132	request.Request.URL.Path = "/"
133	request.Request.Method = "POST"
134	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
135	if err != nil {
136		return out, metadata, &smithy.SerializationError{Err: err}
137	}
138	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
139	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.BatchGetImage")
140
141	jsonEncoder := smithyjson.NewEncoder()
142	if err := awsAwsjson11_serializeOpDocumentBatchGetImageInput(input, jsonEncoder.Value); err != nil {
143		return out, metadata, &smithy.SerializationError{Err: err}
144	}
145
146	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
147		return out, metadata, &smithy.SerializationError{Err: err}
148	}
149
150	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
151		return out, metadata, &smithy.SerializationError{Err: err}
152	}
153	in.Request = request
154
155	return next.HandleSerialize(ctx, in)
156}
157
158type awsAwsjson11_serializeOpCompleteLayerUpload struct {
159}
160
161func (*awsAwsjson11_serializeOpCompleteLayerUpload) ID() string {
162	return "OperationSerializer"
163}
164
165func (m *awsAwsjson11_serializeOpCompleteLayerUpload) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
166	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
167) {
168	request, ok := in.Request.(*smithyhttp.Request)
169	if !ok {
170		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
171	}
172
173	input, ok := in.Parameters.(*CompleteLayerUploadInput)
174	_ = input
175	if !ok {
176		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
177	}
178
179	request.Request.URL.Path = "/"
180	request.Request.Method = "POST"
181	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
182	if err != nil {
183		return out, metadata, &smithy.SerializationError{Err: err}
184	}
185	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
186	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.CompleteLayerUpload")
187
188	jsonEncoder := smithyjson.NewEncoder()
189	if err := awsAwsjson11_serializeOpDocumentCompleteLayerUploadInput(input, jsonEncoder.Value); err != nil {
190		return out, metadata, &smithy.SerializationError{Err: err}
191	}
192
193	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
194		return out, metadata, &smithy.SerializationError{Err: err}
195	}
196
197	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
198		return out, metadata, &smithy.SerializationError{Err: err}
199	}
200	in.Request = request
201
202	return next.HandleSerialize(ctx, in)
203}
204
205type awsAwsjson11_serializeOpCreateRepository struct {
206}
207
208func (*awsAwsjson11_serializeOpCreateRepository) ID() string {
209	return "OperationSerializer"
210}
211
212func (m *awsAwsjson11_serializeOpCreateRepository) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
213	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
214) {
215	request, ok := in.Request.(*smithyhttp.Request)
216	if !ok {
217		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
218	}
219
220	input, ok := in.Parameters.(*CreateRepositoryInput)
221	_ = input
222	if !ok {
223		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
224	}
225
226	request.Request.URL.Path = "/"
227	request.Request.Method = "POST"
228	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
229	if err != nil {
230		return out, metadata, &smithy.SerializationError{Err: err}
231	}
232	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
233	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.CreateRepository")
234
235	jsonEncoder := smithyjson.NewEncoder()
236	if err := awsAwsjson11_serializeOpDocumentCreateRepositoryInput(input, jsonEncoder.Value); err != nil {
237		return out, metadata, &smithy.SerializationError{Err: err}
238	}
239
240	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
241		return out, metadata, &smithy.SerializationError{Err: err}
242	}
243
244	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
245		return out, metadata, &smithy.SerializationError{Err: err}
246	}
247	in.Request = request
248
249	return next.HandleSerialize(ctx, in)
250}
251
252type awsAwsjson11_serializeOpDeleteLifecyclePolicy struct {
253}
254
255func (*awsAwsjson11_serializeOpDeleteLifecyclePolicy) ID() string {
256	return "OperationSerializer"
257}
258
259func (m *awsAwsjson11_serializeOpDeleteLifecyclePolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
260	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
261) {
262	request, ok := in.Request.(*smithyhttp.Request)
263	if !ok {
264		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
265	}
266
267	input, ok := in.Parameters.(*DeleteLifecyclePolicyInput)
268	_ = input
269	if !ok {
270		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
271	}
272
273	request.Request.URL.Path = "/"
274	request.Request.Method = "POST"
275	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
276	if err != nil {
277		return out, metadata, &smithy.SerializationError{Err: err}
278	}
279	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
280	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.DeleteLifecyclePolicy")
281
282	jsonEncoder := smithyjson.NewEncoder()
283	if err := awsAwsjson11_serializeOpDocumentDeleteLifecyclePolicyInput(input, jsonEncoder.Value); err != nil {
284		return out, metadata, &smithy.SerializationError{Err: err}
285	}
286
287	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
288		return out, metadata, &smithy.SerializationError{Err: err}
289	}
290
291	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
292		return out, metadata, &smithy.SerializationError{Err: err}
293	}
294	in.Request = request
295
296	return next.HandleSerialize(ctx, in)
297}
298
299type awsAwsjson11_serializeOpDeleteRegistryPolicy struct {
300}
301
302func (*awsAwsjson11_serializeOpDeleteRegistryPolicy) ID() string {
303	return "OperationSerializer"
304}
305
306func (m *awsAwsjson11_serializeOpDeleteRegistryPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
307	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
308) {
309	request, ok := in.Request.(*smithyhttp.Request)
310	if !ok {
311		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
312	}
313
314	input, ok := in.Parameters.(*DeleteRegistryPolicyInput)
315	_ = input
316	if !ok {
317		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
318	}
319
320	request.Request.URL.Path = "/"
321	request.Request.Method = "POST"
322	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
323	if err != nil {
324		return out, metadata, &smithy.SerializationError{Err: err}
325	}
326	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
327	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.DeleteRegistryPolicy")
328
329	jsonEncoder := smithyjson.NewEncoder()
330	if err := awsAwsjson11_serializeOpDocumentDeleteRegistryPolicyInput(input, jsonEncoder.Value); err != nil {
331		return out, metadata, &smithy.SerializationError{Err: err}
332	}
333
334	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
335		return out, metadata, &smithy.SerializationError{Err: err}
336	}
337
338	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
339		return out, metadata, &smithy.SerializationError{Err: err}
340	}
341	in.Request = request
342
343	return next.HandleSerialize(ctx, in)
344}
345
346type awsAwsjson11_serializeOpDeleteRepository struct {
347}
348
349func (*awsAwsjson11_serializeOpDeleteRepository) ID() string {
350	return "OperationSerializer"
351}
352
353func (m *awsAwsjson11_serializeOpDeleteRepository) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
354	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
355) {
356	request, ok := in.Request.(*smithyhttp.Request)
357	if !ok {
358		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
359	}
360
361	input, ok := in.Parameters.(*DeleteRepositoryInput)
362	_ = input
363	if !ok {
364		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
365	}
366
367	request.Request.URL.Path = "/"
368	request.Request.Method = "POST"
369	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
370	if err != nil {
371		return out, metadata, &smithy.SerializationError{Err: err}
372	}
373	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
374	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.DeleteRepository")
375
376	jsonEncoder := smithyjson.NewEncoder()
377	if err := awsAwsjson11_serializeOpDocumentDeleteRepositoryInput(input, jsonEncoder.Value); err != nil {
378		return out, metadata, &smithy.SerializationError{Err: err}
379	}
380
381	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
382		return out, metadata, &smithy.SerializationError{Err: err}
383	}
384
385	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
386		return out, metadata, &smithy.SerializationError{Err: err}
387	}
388	in.Request = request
389
390	return next.HandleSerialize(ctx, in)
391}
392
393type awsAwsjson11_serializeOpDeleteRepositoryPolicy struct {
394}
395
396func (*awsAwsjson11_serializeOpDeleteRepositoryPolicy) ID() string {
397	return "OperationSerializer"
398}
399
400func (m *awsAwsjson11_serializeOpDeleteRepositoryPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
401	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
402) {
403	request, ok := in.Request.(*smithyhttp.Request)
404	if !ok {
405		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
406	}
407
408	input, ok := in.Parameters.(*DeleteRepositoryPolicyInput)
409	_ = input
410	if !ok {
411		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
412	}
413
414	request.Request.URL.Path = "/"
415	request.Request.Method = "POST"
416	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
417	if err != nil {
418		return out, metadata, &smithy.SerializationError{Err: err}
419	}
420	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
421	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.DeleteRepositoryPolicy")
422
423	jsonEncoder := smithyjson.NewEncoder()
424	if err := awsAwsjson11_serializeOpDocumentDeleteRepositoryPolicyInput(input, jsonEncoder.Value); err != nil {
425		return out, metadata, &smithy.SerializationError{Err: err}
426	}
427
428	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
429		return out, metadata, &smithy.SerializationError{Err: err}
430	}
431
432	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
433		return out, metadata, &smithy.SerializationError{Err: err}
434	}
435	in.Request = request
436
437	return next.HandleSerialize(ctx, in)
438}
439
440type awsAwsjson11_serializeOpDescribeImages struct {
441}
442
443func (*awsAwsjson11_serializeOpDescribeImages) ID() string {
444	return "OperationSerializer"
445}
446
447func (m *awsAwsjson11_serializeOpDescribeImages) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
448	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
449) {
450	request, ok := in.Request.(*smithyhttp.Request)
451	if !ok {
452		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
453	}
454
455	input, ok := in.Parameters.(*DescribeImagesInput)
456	_ = input
457	if !ok {
458		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
459	}
460
461	request.Request.URL.Path = "/"
462	request.Request.Method = "POST"
463	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
464	if err != nil {
465		return out, metadata, &smithy.SerializationError{Err: err}
466	}
467	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
468	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.DescribeImages")
469
470	jsonEncoder := smithyjson.NewEncoder()
471	if err := awsAwsjson11_serializeOpDocumentDescribeImagesInput(input, jsonEncoder.Value); err != nil {
472		return out, metadata, &smithy.SerializationError{Err: err}
473	}
474
475	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
476		return out, metadata, &smithy.SerializationError{Err: err}
477	}
478
479	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
480		return out, metadata, &smithy.SerializationError{Err: err}
481	}
482	in.Request = request
483
484	return next.HandleSerialize(ctx, in)
485}
486
487type awsAwsjson11_serializeOpDescribeImageScanFindings struct {
488}
489
490func (*awsAwsjson11_serializeOpDescribeImageScanFindings) ID() string {
491	return "OperationSerializer"
492}
493
494func (m *awsAwsjson11_serializeOpDescribeImageScanFindings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
495	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
496) {
497	request, ok := in.Request.(*smithyhttp.Request)
498	if !ok {
499		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
500	}
501
502	input, ok := in.Parameters.(*DescribeImageScanFindingsInput)
503	_ = input
504	if !ok {
505		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
506	}
507
508	request.Request.URL.Path = "/"
509	request.Request.Method = "POST"
510	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
511	if err != nil {
512		return out, metadata, &smithy.SerializationError{Err: err}
513	}
514	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
515	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.DescribeImageScanFindings")
516
517	jsonEncoder := smithyjson.NewEncoder()
518	if err := awsAwsjson11_serializeOpDocumentDescribeImageScanFindingsInput(input, jsonEncoder.Value); err != nil {
519		return out, metadata, &smithy.SerializationError{Err: err}
520	}
521
522	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
523		return out, metadata, &smithy.SerializationError{Err: err}
524	}
525
526	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
527		return out, metadata, &smithy.SerializationError{Err: err}
528	}
529	in.Request = request
530
531	return next.HandleSerialize(ctx, in)
532}
533
534type awsAwsjson11_serializeOpDescribeRegistry struct {
535}
536
537func (*awsAwsjson11_serializeOpDescribeRegistry) ID() string {
538	return "OperationSerializer"
539}
540
541func (m *awsAwsjson11_serializeOpDescribeRegistry) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
542	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
543) {
544	request, ok := in.Request.(*smithyhttp.Request)
545	if !ok {
546		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
547	}
548
549	input, ok := in.Parameters.(*DescribeRegistryInput)
550	_ = input
551	if !ok {
552		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
553	}
554
555	request.Request.URL.Path = "/"
556	request.Request.Method = "POST"
557	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
558	if err != nil {
559		return out, metadata, &smithy.SerializationError{Err: err}
560	}
561	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
562	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.DescribeRegistry")
563
564	jsonEncoder := smithyjson.NewEncoder()
565	if err := awsAwsjson11_serializeOpDocumentDescribeRegistryInput(input, jsonEncoder.Value); err != nil {
566		return out, metadata, &smithy.SerializationError{Err: err}
567	}
568
569	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
570		return out, metadata, &smithy.SerializationError{Err: err}
571	}
572
573	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
574		return out, metadata, &smithy.SerializationError{Err: err}
575	}
576	in.Request = request
577
578	return next.HandleSerialize(ctx, in)
579}
580
581type awsAwsjson11_serializeOpDescribeRepositories struct {
582}
583
584func (*awsAwsjson11_serializeOpDescribeRepositories) ID() string {
585	return "OperationSerializer"
586}
587
588func (m *awsAwsjson11_serializeOpDescribeRepositories) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
589	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
590) {
591	request, ok := in.Request.(*smithyhttp.Request)
592	if !ok {
593		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
594	}
595
596	input, ok := in.Parameters.(*DescribeRepositoriesInput)
597	_ = input
598	if !ok {
599		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
600	}
601
602	request.Request.URL.Path = "/"
603	request.Request.Method = "POST"
604	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
605	if err != nil {
606		return out, metadata, &smithy.SerializationError{Err: err}
607	}
608	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
609	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.DescribeRepositories")
610
611	jsonEncoder := smithyjson.NewEncoder()
612	if err := awsAwsjson11_serializeOpDocumentDescribeRepositoriesInput(input, jsonEncoder.Value); err != nil {
613		return out, metadata, &smithy.SerializationError{Err: err}
614	}
615
616	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
617		return out, metadata, &smithy.SerializationError{Err: err}
618	}
619
620	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
621		return out, metadata, &smithy.SerializationError{Err: err}
622	}
623	in.Request = request
624
625	return next.HandleSerialize(ctx, in)
626}
627
628type awsAwsjson11_serializeOpGetAuthorizationToken struct {
629}
630
631func (*awsAwsjson11_serializeOpGetAuthorizationToken) ID() string {
632	return "OperationSerializer"
633}
634
635func (m *awsAwsjson11_serializeOpGetAuthorizationToken) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
636	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
637) {
638	request, ok := in.Request.(*smithyhttp.Request)
639	if !ok {
640		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
641	}
642
643	input, ok := in.Parameters.(*GetAuthorizationTokenInput)
644	_ = input
645	if !ok {
646		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
647	}
648
649	request.Request.URL.Path = "/"
650	request.Request.Method = "POST"
651	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
652	if err != nil {
653		return out, metadata, &smithy.SerializationError{Err: err}
654	}
655	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
656	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.GetAuthorizationToken")
657
658	jsonEncoder := smithyjson.NewEncoder()
659	if err := awsAwsjson11_serializeOpDocumentGetAuthorizationTokenInput(input, jsonEncoder.Value); err != nil {
660		return out, metadata, &smithy.SerializationError{Err: err}
661	}
662
663	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
664		return out, metadata, &smithy.SerializationError{Err: err}
665	}
666
667	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
668		return out, metadata, &smithy.SerializationError{Err: err}
669	}
670	in.Request = request
671
672	return next.HandleSerialize(ctx, in)
673}
674
675type awsAwsjson11_serializeOpGetDownloadUrlForLayer struct {
676}
677
678func (*awsAwsjson11_serializeOpGetDownloadUrlForLayer) ID() string {
679	return "OperationSerializer"
680}
681
682func (m *awsAwsjson11_serializeOpGetDownloadUrlForLayer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
683	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
684) {
685	request, ok := in.Request.(*smithyhttp.Request)
686	if !ok {
687		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
688	}
689
690	input, ok := in.Parameters.(*GetDownloadUrlForLayerInput)
691	_ = input
692	if !ok {
693		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
694	}
695
696	request.Request.URL.Path = "/"
697	request.Request.Method = "POST"
698	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
699	if err != nil {
700		return out, metadata, &smithy.SerializationError{Err: err}
701	}
702	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
703	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.GetDownloadUrlForLayer")
704
705	jsonEncoder := smithyjson.NewEncoder()
706	if err := awsAwsjson11_serializeOpDocumentGetDownloadUrlForLayerInput(input, jsonEncoder.Value); err != nil {
707		return out, metadata, &smithy.SerializationError{Err: err}
708	}
709
710	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
711		return out, metadata, &smithy.SerializationError{Err: err}
712	}
713
714	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
715		return out, metadata, &smithy.SerializationError{Err: err}
716	}
717	in.Request = request
718
719	return next.HandleSerialize(ctx, in)
720}
721
722type awsAwsjson11_serializeOpGetLifecyclePolicy struct {
723}
724
725func (*awsAwsjson11_serializeOpGetLifecyclePolicy) ID() string {
726	return "OperationSerializer"
727}
728
729func (m *awsAwsjson11_serializeOpGetLifecyclePolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
730	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
731) {
732	request, ok := in.Request.(*smithyhttp.Request)
733	if !ok {
734		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
735	}
736
737	input, ok := in.Parameters.(*GetLifecyclePolicyInput)
738	_ = input
739	if !ok {
740		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
741	}
742
743	request.Request.URL.Path = "/"
744	request.Request.Method = "POST"
745	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
746	if err != nil {
747		return out, metadata, &smithy.SerializationError{Err: err}
748	}
749	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
750	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.GetLifecyclePolicy")
751
752	jsonEncoder := smithyjson.NewEncoder()
753	if err := awsAwsjson11_serializeOpDocumentGetLifecyclePolicyInput(input, jsonEncoder.Value); err != nil {
754		return out, metadata, &smithy.SerializationError{Err: err}
755	}
756
757	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
758		return out, metadata, &smithy.SerializationError{Err: err}
759	}
760
761	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
762		return out, metadata, &smithy.SerializationError{Err: err}
763	}
764	in.Request = request
765
766	return next.HandleSerialize(ctx, in)
767}
768
769type awsAwsjson11_serializeOpGetLifecyclePolicyPreview struct {
770}
771
772func (*awsAwsjson11_serializeOpGetLifecyclePolicyPreview) ID() string {
773	return "OperationSerializer"
774}
775
776func (m *awsAwsjson11_serializeOpGetLifecyclePolicyPreview) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
777	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
778) {
779	request, ok := in.Request.(*smithyhttp.Request)
780	if !ok {
781		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
782	}
783
784	input, ok := in.Parameters.(*GetLifecyclePolicyPreviewInput)
785	_ = input
786	if !ok {
787		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
788	}
789
790	request.Request.URL.Path = "/"
791	request.Request.Method = "POST"
792	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
793	if err != nil {
794		return out, metadata, &smithy.SerializationError{Err: err}
795	}
796	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
797	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.GetLifecyclePolicyPreview")
798
799	jsonEncoder := smithyjson.NewEncoder()
800	if err := awsAwsjson11_serializeOpDocumentGetLifecyclePolicyPreviewInput(input, jsonEncoder.Value); err != nil {
801		return out, metadata, &smithy.SerializationError{Err: err}
802	}
803
804	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
805		return out, metadata, &smithy.SerializationError{Err: err}
806	}
807
808	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
809		return out, metadata, &smithy.SerializationError{Err: err}
810	}
811	in.Request = request
812
813	return next.HandleSerialize(ctx, in)
814}
815
816type awsAwsjson11_serializeOpGetRegistryPolicy struct {
817}
818
819func (*awsAwsjson11_serializeOpGetRegistryPolicy) ID() string {
820	return "OperationSerializer"
821}
822
823func (m *awsAwsjson11_serializeOpGetRegistryPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
824	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
825) {
826	request, ok := in.Request.(*smithyhttp.Request)
827	if !ok {
828		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
829	}
830
831	input, ok := in.Parameters.(*GetRegistryPolicyInput)
832	_ = input
833	if !ok {
834		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
835	}
836
837	request.Request.URL.Path = "/"
838	request.Request.Method = "POST"
839	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
840	if err != nil {
841		return out, metadata, &smithy.SerializationError{Err: err}
842	}
843	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
844	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.GetRegistryPolicy")
845
846	jsonEncoder := smithyjson.NewEncoder()
847	if err := awsAwsjson11_serializeOpDocumentGetRegistryPolicyInput(input, jsonEncoder.Value); err != nil {
848		return out, metadata, &smithy.SerializationError{Err: err}
849	}
850
851	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
852		return out, metadata, &smithy.SerializationError{Err: err}
853	}
854
855	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
856		return out, metadata, &smithy.SerializationError{Err: err}
857	}
858	in.Request = request
859
860	return next.HandleSerialize(ctx, in)
861}
862
863type awsAwsjson11_serializeOpGetRepositoryPolicy struct {
864}
865
866func (*awsAwsjson11_serializeOpGetRepositoryPolicy) ID() string {
867	return "OperationSerializer"
868}
869
870func (m *awsAwsjson11_serializeOpGetRepositoryPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
871	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
872) {
873	request, ok := in.Request.(*smithyhttp.Request)
874	if !ok {
875		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
876	}
877
878	input, ok := in.Parameters.(*GetRepositoryPolicyInput)
879	_ = input
880	if !ok {
881		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
882	}
883
884	request.Request.URL.Path = "/"
885	request.Request.Method = "POST"
886	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
887	if err != nil {
888		return out, metadata, &smithy.SerializationError{Err: err}
889	}
890	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
891	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.GetRepositoryPolicy")
892
893	jsonEncoder := smithyjson.NewEncoder()
894	if err := awsAwsjson11_serializeOpDocumentGetRepositoryPolicyInput(input, jsonEncoder.Value); err != nil {
895		return out, metadata, &smithy.SerializationError{Err: err}
896	}
897
898	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
899		return out, metadata, &smithy.SerializationError{Err: err}
900	}
901
902	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
903		return out, metadata, &smithy.SerializationError{Err: err}
904	}
905	in.Request = request
906
907	return next.HandleSerialize(ctx, in)
908}
909
910type awsAwsjson11_serializeOpInitiateLayerUpload struct {
911}
912
913func (*awsAwsjson11_serializeOpInitiateLayerUpload) ID() string {
914	return "OperationSerializer"
915}
916
917func (m *awsAwsjson11_serializeOpInitiateLayerUpload) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
918	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
919) {
920	request, ok := in.Request.(*smithyhttp.Request)
921	if !ok {
922		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
923	}
924
925	input, ok := in.Parameters.(*InitiateLayerUploadInput)
926	_ = input
927	if !ok {
928		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
929	}
930
931	request.Request.URL.Path = "/"
932	request.Request.Method = "POST"
933	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
934	if err != nil {
935		return out, metadata, &smithy.SerializationError{Err: err}
936	}
937	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
938	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.InitiateLayerUpload")
939
940	jsonEncoder := smithyjson.NewEncoder()
941	if err := awsAwsjson11_serializeOpDocumentInitiateLayerUploadInput(input, jsonEncoder.Value); err != nil {
942		return out, metadata, &smithy.SerializationError{Err: err}
943	}
944
945	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
946		return out, metadata, &smithy.SerializationError{Err: err}
947	}
948
949	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
950		return out, metadata, &smithy.SerializationError{Err: err}
951	}
952	in.Request = request
953
954	return next.HandleSerialize(ctx, in)
955}
956
957type awsAwsjson11_serializeOpListImages struct {
958}
959
960func (*awsAwsjson11_serializeOpListImages) ID() string {
961	return "OperationSerializer"
962}
963
964func (m *awsAwsjson11_serializeOpListImages) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
965	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
966) {
967	request, ok := in.Request.(*smithyhttp.Request)
968	if !ok {
969		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
970	}
971
972	input, ok := in.Parameters.(*ListImagesInput)
973	_ = input
974	if !ok {
975		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
976	}
977
978	request.Request.URL.Path = "/"
979	request.Request.Method = "POST"
980	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
981	if err != nil {
982		return out, metadata, &smithy.SerializationError{Err: err}
983	}
984	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
985	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.ListImages")
986
987	jsonEncoder := smithyjson.NewEncoder()
988	if err := awsAwsjson11_serializeOpDocumentListImagesInput(input, jsonEncoder.Value); err != nil {
989		return out, metadata, &smithy.SerializationError{Err: err}
990	}
991
992	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
993		return out, metadata, &smithy.SerializationError{Err: err}
994	}
995
996	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
997		return out, metadata, &smithy.SerializationError{Err: err}
998	}
999	in.Request = request
1000
1001	return next.HandleSerialize(ctx, in)
1002}
1003
1004type awsAwsjson11_serializeOpListTagsForResource struct {
1005}
1006
1007func (*awsAwsjson11_serializeOpListTagsForResource) ID() string {
1008	return "OperationSerializer"
1009}
1010
1011func (m *awsAwsjson11_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1012	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1013) {
1014	request, ok := in.Request.(*smithyhttp.Request)
1015	if !ok {
1016		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1017	}
1018
1019	input, ok := in.Parameters.(*ListTagsForResourceInput)
1020	_ = input
1021	if !ok {
1022		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1023	}
1024
1025	request.Request.URL.Path = "/"
1026	request.Request.Method = "POST"
1027	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1028	if err != nil {
1029		return out, metadata, &smithy.SerializationError{Err: err}
1030	}
1031	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1032	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.ListTagsForResource")
1033
1034	jsonEncoder := smithyjson.NewEncoder()
1035	if err := awsAwsjson11_serializeOpDocumentListTagsForResourceInput(input, jsonEncoder.Value); err != nil {
1036		return out, metadata, &smithy.SerializationError{Err: err}
1037	}
1038
1039	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1040		return out, metadata, &smithy.SerializationError{Err: err}
1041	}
1042
1043	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1044		return out, metadata, &smithy.SerializationError{Err: err}
1045	}
1046	in.Request = request
1047
1048	return next.HandleSerialize(ctx, in)
1049}
1050
1051type awsAwsjson11_serializeOpPutImage struct {
1052}
1053
1054func (*awsAwsjson11_serializeOpPutImage) ID() string {
1055	return "OperationSerializer"
1056}
1057
1058func (m *awsAwsjson11_serializeOpPutImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1059	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1060) {
1061	request, ok := in.Request.(*smithyhttp.Request)
1062	if !ok {
1063		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1064	}
1065
1066	input, ok := in.Parameters.(*PutImageInput)
1067	_ = input
1068	if !ok {
1069		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1070	}
1071
1072	request.Request.URL.Path = "/"
1073	request.Request.Method = "POST"
1074	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1075	if err != nil {
1076		return out, metadata, &smithy.SerializationError{Err: err}
1077	}
1078	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1079	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.PutImage")
1080
1081	jsonEncoder := smithyjson.NewEncoder()
1082	if err := awsAwsjson11_serializeOpDocumentPutImageInput(input, jsonEncoder.Value); err != nil {
1083		return out, metadata, &smithy.SerializationError{Err: err}
1084	}
1085
1086	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1087		return out, metadata, &smithy.SerializationError{Err: err}
1088	}
1089
1090	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1091		return out, metadata, &smithy.SerializationError{Err: err}
1092	}
1093	in.Request = request
1094
1095	return next.HandleSerialize(ctx, in)
1096}
1097
1098type awsAwsjson11_serializeOpPutImageScanningConfiguration struct {
1099}
1100
1101func (*awsAwsjson11_serializeOpPutImageScanningConfiguration) ID() string {
1102	return "OperationSerializer"
1103}
1104
1105func (m *awsAwsjson11_serializeOpPutImageScanningConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1106	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1107) {
1108	request, ok := in.Request.(*smithyhttp.Request)
1109	if !ok {
1110		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1111	}
1112
1113	input, ok := in.Parameters.(*PutImageScanningConfigurationInput)
1114	_ = input
1115	if !ok {
1116		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1117	}
1118
1119	request.Request.URL.Path = "/"
1120	request.Request.Method = "POST"
1121	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1122	if err != nil {
1123		return out, metadata, &smithy.SerializationError{Err: err}
1124	}
1125	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1126	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.PutImageScanningConfiguration")
1127
1128	jsonEncoder := smithyjson.NewEncoder()
1129	if err := awsAwsjson11_serializeOpDocumentPutImageScanningConfigurationInput(input, jsonEncoder.Value); err != nil {
1130		return out, metadata, &smithy.SerializationError{Err: err}
1131	}
1132
1133	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1134		return out, metadata, &smithy.SerializationError{Err: err}
1135	}
1136
1137	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1138		return out, metadata, &smithy.SerializationError{Err: err}
1139	}
1140	in.Request = request
1141
1142	return next.HandleSerialize(ctx, in)
1143}
1144
1145type awsAwsjson11_serializeOpPutImageTagMutability struct {
1146}
1147
1148func (*awsAwsjson11_serializeOpPutImageTagMutability) ID() string {
1149	return "OperationSerializer"
1150}
1151
1152func (m *awsAwsjson11_serializeOpPutImageTagMutability) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1153	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1154) {
1155	request, ok := in.Request.(*smithyhttp.Request)
1156	if !ok {
1157		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1158	}
1159
1160	input, ok := in.Parameters.(*PutImageTagMutabilityInput)
1161	_ = input
1162	if !ok {
1163		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1164	}
1165
1166	request.Request.URL.Path = "/"
1167	request.Request.Method = "POST"
1168	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1169	if err != nil {
1170		return out, metadata, &smithy.SerializationError{Err: err}
1171	}
1172	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1173	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.PutImageTagMutability")
1174
1175	jsonEncoder := smithyjson.NewEncoder()
1176	if err := awsAwsjson11_serializeOpDocumentPutImageTagMutabilityInput(input, jsonEncoder.Value); err != nil {
1177		return out, metadata, &smithy.SerializationError{Err: err}
1178	}
1179
1180	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1181		return out, metadata, &smithy.SerializationError{Err: err}
1182	}
1183
1184	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1185		return out, metadata, &smithy.SerializationError{Err: err}
1186	}
1187	in.Request = request
1188
1189	return next.HandleSerialize(ctx, in)
1190}
1191
1192type awsAwsjson11_serializeOpPutLifecyclePolicy struct {
1193}
1194
1195func (*awsAwsjson11_serializeOpPutLifecyclePolicy) ID() string {
1196	return "OperationSerializer"
1197}
1198
1199func (m *awsAwsjson11_serializeOpPutLifecyclePolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1200	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1201) {
1202	request, ok := in.Request.(*smithyhttp.Request)
1203	if !ok {
1204		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1205	}
1206
1207	input, ok := in.Parameters.(*PutLifecyclePolicyInput)
1208	_ = input
1209	if !ok {
1210		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1211	}
1212
1213	request.Request.URL.Path = "/"
1214	request.Request.Method = "POST"
1215	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1216	if err != nil {
1217		return out, metadata, &smithy.SerializationError{Err: err}
1218	}
1219	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1220	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.PutLifecyclePolicy")
1221
1222	jsonEncoder := smithyjson.NewEncoder()
1223	if err := awsAwsjson11_serializeOpDocumentPutLifecyclePolicyInput(input, jsonEncoder.Value); err != nil {
1224		return out, metadata, &smithy.SerializationError{Err: err}
1225	}
1226
1227	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1228		return out, metadata, &smithy.SerializationError{Err: err}
1229	}
1230
1231	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1232		return out, metadata, &smithy.SerializationError{Err: err}
1233	}
1234	in.Request = request
1235
1236	return next.HandleSerialize(ctx, in)
1237}
1238
1239type awsAwsjson11_serializeOpPutRegistryPolicy struct {
1240}
1241
1242func (*awsAwsjson11_serializeOpPutRegistryPolicy) ID() string {
1243	return "OperationSerializer"
1244}
1245
1246func (m *awsAwsjson11_serializeOpPutRegistryPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1247	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1248) {
1249	request, ok := in.Request.(*smithyhttp.Request)
1250	if !ok {
1251		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1252	}
1253
1254	input, ok := in.Parameters.(*PutRegistryPolicyInput)
1255	_ = input
1256	if !ok {
1257		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1258	}
1259
1260	request.Request.URL.Path = "/"
1261	request.Request.Method = "POST"
1262	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1263	if err != nil {
1264		return out, metadata, &smithy.SerializationError{Err: err}
1265	}
1266	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1267	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.PutRegistryPolicy")
1268
1269	jsonEncoder := smithyjson.NewEncoder()
1270	if err := awsAwsjson11_serializeOpDocumentPutRegistryPolicyInput(input, jsonEncoder.Value); err != nil {
1271		return out, metadata, &smithy.SerializationError{Err: err}
1272	}
1273
1274	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1275		return out, metadata, &smithy.SerializationError{Err: err}
1276	}
1277
1278	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1279		return out, metadata, &smithy.SerializationError{Err: err}
1280	}
1281	in.Request = request
1282
1283	return next.HandleSerialize(ctx, in)
1284}
1285
1286type awsAwsjson11_serializeOpPutReplicationConfiguration struct {
1287}
1288
1289func (*awsAwsjson11_serializeOpPutReplicationConfiguration) ID() string {
1290	return "OperationSerializer"
1291}
1292
1293func (m *awsAwsjson11_serializeOpPutReplicationConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1294	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1295) {
1296	request, ok := in.Request.(*smithyhttp.Request)
1297	if !ok {
1298		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1299	}
1300
1301	input, ok := in.Parameters.(*PutReplicationConfigurationInput)
1302	_ = input
1303	if !ok {
1304		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1305	}
1306
1307	request.Request.URL.Path = "/"
1308	request.Request.Method = "POST"
1309	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1310	if err != nil {
1311		return out, metadata, &smithy.SerializationError{Err: err}
1312	}
1313	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1314	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.PutReplicationConfiguration")
1315
1316	jsonEncoder := smithyjson.NewEncoder()
1317	if err := awsAwsjson11_serializeOpDocumentPutReplicationConfigurationInput(input, jsonEncoder.Value); err != nil {
1318		return out, metadata, &smithy.SerializationError{Err: err}
1319	}
1320
1321	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1322		return out, metadata, &smithy.SerializationError{Err: err}
1323	}
1324
1325	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1326		return out, metadata, &smithy.SerializationError{Err: err}
1327	}
1328	in.Request = request
1329
1330	return next.HandleSerialize(ctx, in)
1331}
1332
1333type awsAwsjson11_serializeOpSetRepositoryPolicy struct {
1334}
1335
1336func (*awsAwsjson11_serializeOpSetRepositoryPolicy) ID() string {
1337	return "OperationSerializer"
1338}
1339
1340func (m *awsAwsjson11_serializeOpSetRepositoryPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1341	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1342) {
1343	request, ok := in.Request.(*smithyhttp.Request)
1344	if !ok {
1345		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1346	}
1347
1348	input, ok := in.Parameters.(*SetRepositoryPolicyInput)
1349	_ = input
1350	if !ok {
1351		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1352	}
1353
1354	request.Request.URL.Path = "/"
1355	request.Request.Method = "POST"
1356	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1357	if err != nil {
1358		return out, metadata, &smithy.SerializationError{Err: err}
1359	}
1360	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1361	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.SetRepositoryPolicy")
1362
1363	jsonEncoder := smithyjson.NewEncoder()
1364	if err := awsAwsjson11_serializeOpDocumentSetRepositoryPolicyInput(input, jsonEncoder.Value); err != nil {
1365		return out, metadata, &smithy.SerializationError{Err: err}
1366	}
1367
1368	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1369		return out, metadata, &smithy.SerializationError{Err: err}
1370	}
1371
1372	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1373		return out, metadata, &smithy.SerializationError{Err: err}
1374	}
1375	in.Request = request
1376
1377	return next.HandleSerialize(ctx, in)
1378}
1379
1380type awsAwsjson11_serializeOpStartImageScan struct {
1381}
1382
1383func (*awsAwsjson11_serializeOpStartImageScan) ID() string {
1384	return "OperationSerializer"
1385}
1386
1387func (m *awsAwsjson11_serializeOpStartImageScan) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1388	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1389) {
1390	request, ok := in.Request.(*smithyhttp.Request)
1391	if !ok {
1392		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1393	}
1394
1395	input, ok := in.Parameters.(*StartImageScanInput)
1396	_ = input
1397	if !ok {
1398		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1399	}
1400
1401	request.Request.URL.Path = "/"
1402	request.Request.Method = "POST"
1403	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1404	if err != nil {
1405		return out, metadata, &smithy.SerializationError{Err: err}
1406	}
1407	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1408	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.StartImageScan")
1409
1410	jsonEncoder := smithyjson.NewEncoder()
1411	if err := awsAwsjson11_serializeOpDocumentStartImageScanInput(input, jsonEncoder.Value); err != nil {
1412		return out, metadata, &smithy.SerializationError{Err: err}
1413	}
1414
1415	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1416		return out, metadata, &smithy.SerializationError{Err: err}
1417	}
1418
1419	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1420		return out, metadata, &smithy.SerializationError{Err: err}
1421	}
1422	in.Request = request
1423
1424	return next.HandleSerialize(ctx, in)
1425}
1426
1427type awsAwsjson11_serializeOpStartLifecyclePolicyPreview struct {
1428}
1429
1430func (*awsAwsjson11_serializeOpStartLifecyclePolicyPreview) ID() string {
1431	return "OperationSerializer"
1432}
1433
1434func (m *awsAwsjson11_serializeOpStartLifecyclePolicyPreview) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1435	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1436) {
1437	request, ok := in.Request.(*smithyhttp.Request)
1438	if !ok {
1439		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1440	}
1441
1442	input, ok := in.Parameters.(*StartLifecyclePolicyPreviewInput)
1443	_ = input
1444	if !ok {
1445		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1446	}
1447
1448	request.Request.URL.Path = "/"
1449	request.Request.Method = "POST"
1450	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1451	if err != nil {
1452		return out, metadata, &smithy.SerializationError{Err: err}
1453	}
1454	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1455	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.StartLifecyclePolicyPreview")
1456
1457	jsonEncoder := smithyjson.NewEncoder()
1458	if err := awsAwsjson11_serializeOpDocumentStartLifecyclePolicyPreviewInput(input, jsonEncoder.Value); err != nil {
1459		return out, metadata, &smithy.SerializationError{Err: err}
1460	}
1461
1462	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1463		return out, metadata, &smithy.SerializationError{Err: err}
1464	}
1465
1466	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1467		return out, metadata, &smithy.SerializationError{Err: err}
1468	}
1469	in.Request = request
1470
1471	return next.HandleSerialize(ctx, in)
1472}
1473
1474type awsAwsjson11_serializeOpTagResource struct {
1475}
1476
1477func (*awsAwsjson11_serializeOpTagResource) ID() string {
1478	return "OperationSerializer"
1479}
1480
1481func (m *awsAwsjson11_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1482	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1483) {
1484	request, ok := in.Request.(*smithyhttp.Request)
1485	if !ok {
1486		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1487	}
1488
1489	input, ok := in.Parameters.(*TagResourceInput)
1490	_ = input
1491	if !ok {
1492		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1493	}
1494
1495	request.Request.URL.Path = "/"
1496	request.Request.Method = "POST"
1497	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1498	if err != nil {
1499		return out, metadata, &smithy.SerializationError{Err: err}
1500	}
1501	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1502	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.TagResource")
1503
1504	jsonEncoder := smithyjson.NewEncoder()
1505	if err := awsAwsjson11_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil {
1506		return out, metadata, &smithy.SerializationError{Err: err}
1507	}
1508
1509	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1510		return out, metadata, &smithy.SerializationError{Err: err}
1511	}
1512
1513	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1514		return out, metadata, &smithy.SerializationError{Err: err}
1515	}
1516	in.Request = request
1517
1518	return next.HandleSerialize(ctx, in)
1519}
1520
1521type awsAwsjson11_serializeOpUntagResource struct {
1522}
1523
1524func (*awsAwsjson11_serializeOpUntagResource) ID() string {
1525	return "OperationSerializer"
1526}
1527
1528func (m *awsAwsjson11_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1529	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1530) {
1531	request, ok := in.Request.(*smithyhttp.Request)
1532	if !ok {
1533		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1534	}
1535
1536	input, ok := in.Parameters.(*UntagResourceInput)
1537	_ = input
1538	if !ok {
1539		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1540	}
1541
1542	request.Request.URL.Path = "/"
1543	request.Request.Method = "POST"
1544	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1545	if err != nil {
1546		return out, metadata, &smithy.SerializationError{Err: err}
1547	}
1548	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1549	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.UntagResource")
1550
1551	jsonEncoder := smithyjson.NewEncoder()
1552	if err := awsAwsjson11_serializeOpDocumentUntagResourceInput(input, jsonEncoder.Value); err != nil {
1553		return out, metadata, &smithy.SerializationError{Err: err}
1554	}
1555
1556	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1557		return out, metadata, &smithy.SerializationError{Err: err}
1558	}
1559
1560	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1561		return out, metadata, &smithy.SerializationError{Err: err}
1562	}
1563	in.Request = request
1564
1565	return next.HandleSerialize(ctx, in)
1566}
1567
1568type awsAwsjson11_serializeOpUploadLayerPart struct {
1569}
1570
1571func (*awsAwsjson11_serializeOpUploadLayerPart) ID() string {
1572	return "OperationSerializer"
1573}
1574
1575func (m *awsAwsjson11_serializeOpUploadLayerPart) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1576	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1577) {
1578	request, ok := in.Request.(*smithyhttp.Request)
1579	if !ok {
1580		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1581	}
1582
1583	input, ok := in.Parameters.(*UploadLayerPartInput)
1584	_ = input
1585	if !ok {
1586		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1587	}
1588
1589	request.Request.URL.Path = "/"
1590	request.Request.Method = "POST"
1591	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1592	if err != nil {
1593		return out, metadata, &smithy.SerializationError{Err: err}
1594	}
1595	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1596	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerRegistry_V20150921.UploadLayerPart")
1597
1598	jsonEncoder := smithyjson.NewEncoder()
1599	if err := awsAwsjson11_serializeOpDocumentUploadLayerPartInput(input, jsonEncoder.Value); err != nil {
1600		return out, metadata, &smithy.SerializationError{Err: err}
1601	}
1602
1603	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1604		return out, metadata, &smithy.SerializationError{Err: err}
1605	}
1606
1607	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1608		return out, metadata, &smithy.SerializationError{Err: err}
1609	}
1610	in.Request = request
1611
1612	return next.HandleSerialize(ctx, in)
1613}
1614func awsAwsjson11_serializeDocumentBatchedOperationLayerDigestList(v []string, value smithyjson.Value) error {
1615	array := value.Array()
1616	defer array.Close()
1617
1618	for i := range v {
1619		av := array.Value()
1620		av.String(v[i])
1621	}
1622	return nil
1623}
1624
1625func awsAwsjson11_serializeDocumentDescribeImagesFilter(v *types.DescribeImagesFilter, value smithyjson.Value) error {
1626	object := value.Object()
1627	defer object.Close()
1628
1629	if len(v.TagStatus) > 0 {
1630		ok := object.Key("tagStatus")
1631		ok.String(string(v.TagStatus))
1632	}
1633
1634	return nil
1635}
1636
1637func awsAwsjson11_serializeDocumentEncryptionConfiguration(v *types.EncryptionConfiguration, value smithyjson.Value) error {
1638	object := value.Object()
1639	defer object.Close()
1640
1641	if len(v.EncryptionType) > 0 {
1642		ok := object.Key("encryptionType")
1643		ok.String(string(v.EncryptionType))
1644	}
1645
1646	if v.KmsKey != nil {
1647		ok := object.Key("kmsKey")
1648		ok.String(*v.KmsKey)
1649	}
1650
1651	return nil
1652}
1653
1654func awsAwsjson11_serializeDocumentGetAuthorizationTokenRegistryIdList(v []string, value smithyjson.Value) error {
1655	array := value.Array()
1656	defer array.Close()
1657
1658	for i := range v {
1659		av := array.Value()
1660		av.String(v[i])
1661	}
1662	return nil
1663}
1664
1665func awsAwsjson11_serializeDocumentImageIdentifier(v *types.ImageIdentifier, value smithyjson.Value) error {
1666	object := value.Object()
1667	defer object.Close()
1668
1669	if v.ImageDigest != nil {
1670		ok := object.Key("imageDigest")
1671		ok.String(*v.ImageDigest)
1672	}
1673
1674	if v.ImageTag != nil {
1675		ok := object.Key("imageTag")
1676		ok.String(*v.ImageTag)
1677	}
1678
1679	return nil
1680}
1681
1682func awsAwsjson11_serializeDocumentImageIdentifierList(v []types.ImageIdentifier, value smithyjson.Value) error {
1683	array := value.Array()
1684	defer array.Close()
1685
1686	for i := range v {
1687		av := array.Value()
1688		if err := awsAwsjson11_serializeDocumentImageIdentifier(&v[i], av); err != nil {
1689			return err
1690		}
1691	}
1692	return nil
1693}
1694
1695func awsAwsjson11_serializeDocumentImageScanningConfiguration(v *types.ImageScanningConfiguration, value smithyjson.Value) error {
1696	object := value.Object()
1697	defer object.Close()
1698
1699	if v.ScanOnPush {
1700		ok := object.Key("scanOnPush")
1701		ok.Boolean(v.ScanOnPush)
1702	}
1703
1704	return nil
1705}
1706
1707func awsAwsjson11_serializeDocumentLayerDigestList(v []string, value smithyjson.Value) error {
1708	array := value.Array()
1709	defer array.Close()
1710
1711	for i := range v {
1712		av := array.Value()
1713		av.String(v[i])
1714	}
1715	return nil
1716}
1717
1718func awsAwsjson11_serializeDocumentLifecyclePolicyPreviewFilter(v *types.LifecyclePolicyPreviewFilter, value smithyjson.Value) error {
1719	object := value.Object()
1720	defer object.Close()
1721
1722	if len(v.TagStatus) > 0 {
1723		ok := object.Key("tagStatus")
1724		ok.String(string(v.TagStatus))
1725	}
1726
1727	return nil
1728}
1729
1730func awsAwsjson11_serializeDocumentListImagesFilter(v *types.ListImagesFilter, value smithyjson.Value) error {
1731	object := value.Object()
1732	defer object.Close()
1733
1734	if len(v.TagStatus) > 0 {
1735		ok := object.Key("tagStatus")
1736		ok.String(string(v.TagStatus))
1737	}
1738
1739	return nil
1740}
1741
1742func awsAwsjson11_serializeDocumentMediaTypeList(v []string, value smithyjson.Value) error {
1743	array := value.Array()
1744	defer array.Close()
1745
1746	for i := range v {
1747		av := array.Value()
1748		av.String(v[i])
1749	}
1750	return nil
1751}
1752
1753func awsAwsjson11_serializeDocumentReplicationConfiguration(v *types.ReplicationConfiguration, value smithyjson.Value) error {
1754	object := value.Object()
1755	defer object.Close()
1756
1757	if v.Rules != nil {
1758		ok := object.Key("rules")
1759		if err := awsAwsjson11_serializeDocumentReplicationRuleList(v.Rules, ok); err != nil {
1760			return err
1761		}
1762	}
1763
1764	return nil
1765}
1766
1767func awsAwsjson11_serializeDocumentReplicationDestination(v *types.ReplicationDestination, value smithyjson.Value) error {
1768	object := value.Object()
1769	defer object.Close()
1770
1771	if v.Region != nil {
1772		ok := object.Key("region")
1773		ok.String(*v.Region)
1774	}
1775
1776	if v.RegistryId != nil {
1777		ok := object.Key("registryId")
1778		ok.String(*v.RegistryId)
1779	}
1780
1781	return nil
1782}
1783
1784func awsAwsjson11_serializeDocumentReplicationDestinationList(v []types.ReplicationDestination, value smithyjson.Value) error {
1785	array := value.Array()
1786	defer array.Close()
1787
1788	for i := range v {
1789		av := array.Value()
1790		if err := awsAwsjson11_serializeDocumentReplicationDestination(&v[i], av); err != nil {
1791			return err
1792		}
1793	}
1794	return nil
1795}
1796
1797func awsAwsjson11_serializeDocumentReplicationRule(v *types.ReplicationRule, value smithyjson.Value) error {
1798	object := value.Object()
1799	defer object.Close()
1800
1801	if v.Destinations != nil {
1802		ok := object.Key("destinations")
1803		if err := awsAwsjson11_serializeDocumentReplicationDestinationList(v.Destinations, ok); err != nil {
1804			return err
1805		}
1806	}
1807
1808	return nil
1809}
1810
1811func awsAwsjson11_serializeDocumentReplicationRuleList(v []types.ReplicationRule, value smithyjson.Value) error {
1812	array := value.Array()
1813	defer array.Close()
1814
1815	for i := range v {
1816		av := array.Value()
1817		if err := awsAwsjson11_serializeDocumentReplicationRule(&v[i], av); err != nil {
1818			return err
1819		}
1820	}
1821	return nil
1822}
1823
1824func awsAwsjson11_serializeDocumentRepositoryNameList(v []string, value smithyjson.Value) error {
1825	array := value.Array()
1826	defer array.Close()
1827
1828	for i := range v {
1829		av := array.Value()
1830		av.String(v[i])
1831	}
1832	return nil
1833}
1834
1835func awsAwsjson11_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error {
1836	object := value.Object()
1837	defer object.Close()
1838
1839	if v.Key != nil {
1840		ok := object.Key("Key")
1841		ok.String(*v.Key)
1842	}
1843
1844	if v.Value != nil {
1845		ok := object.Key("Value")
1846		ok.String(*v.Value)
1847	}
1848
1849	return nil
1850}
1851
1852func awsAwsjson11_serializeDocumentTagKeyList(v []string, value smithyjson.Value) error {
1853	array := value.Array()
1854	defer array.Close()
1855
1856	for i := range v {
1857		av := array.Value()
1858		av.String(v[i])
1859	}
1860	return nil
1861}
1862
1863func awsAwsjson11_serializeDocumentTagList(v []types.Tag, value smithyjson.Value) error {
1864	array := value.Array()
1865	defer array.Close()
1866
1867	for i := range v {
1868		av := array.Value()
1869		if err := awsAwsjson11_serializeDocumentTag(&v[i], av); err != nil {
1870			return err
1871		}
1872	}
1873	return nil
1874}
1875
1876func awsAwsjson11_serializeOpDocumentBatchCheckLayerAvailabilityInput(v *BatchCheckLayerAvailabilityInput, value smithyjson.Value) error {
1877	object := value.Object()
1878	defer object.Close()
1879
1880	if v.LayerDigests != nil {
1881		ok := object.Key("layerDigests")
1882		if err := awsAwsjson11_serializeDocumentBatchedOperationLayerDigestList(v.LayerDigests, ok); err != nil {
1883			return err
1884		}
1885	}
1886
1887	if v.RegistryId != nil {
1888		ok := object.Key("registryId")
1889		ok.String(*v.RegistryId)
1890	}
1891
1892	if v.RepositoryName != nil {
1893		ok := object.Key("repositoryName")
1894		ok.String(*v.RepositoryName)
1895	}
1896
1897	return nil
1898}
1899
1900func awsAwsjson11_serializeOpDocumentBatchDeleteImageInput(v *BatchDeleteImageInput, value smithyjson.Value) error {
1901	object := value.Object()
1902	defer object.Close()
1903
1904	if v.ImageIds != nil {
1905		ok := object.Key("imageIds")
1906		if err := awsAwsjson11_serializeDocumentImageIdentifierList(v.ImageIds, ok); err != nil {
1907			return err
1908		}
1909	}
1910
1911	if v.RegistryId != nil {
1912		ok := object.Key("registryId")
1913		ok.String(*v.RegistryId)
1914	}
1915
1916	if v.RepositoryName != nil {
1917		ok := object.Key("repositoryName")
1918		ok.String(*v.RepositoryName)
1919	}
1920
1921	return nil
1922}
1923
1924func awsAwsjson11_serializeOpDocumentBatchGetImageInput(v *BatchGetImageInput, value smithyjson.Value) error {
1925	object := value.Object()
1926	defer object.Close()
1927
1928	if v.AcceptedMediaTypes != nil {
1929		ok := object.Key("acceptedMediaTypes")
1930		if err := awsAwsjson11_serializeDocumentMediaTypeList(v.AcceptedMediaTypes, ok); err != nil {
1931			return err
1932		}
1933	}
1934
1935	if v.ImageIds != nil {
1936		ok := object.Key("imageIds")
1937		if err := awsAwsjson11_serializeDocumentImageIdentifierList(v.ImageIds, ok); err != nil {
1938			return err
1939		}
1940	}
1941
1942	if v.RegistryId != nil {
1943		ok := object.Key("registryId")
1944		ok.String(*v.RegistryId)
1945	}
1946
1947	if v.RepositoryName != nil {
1948		ok := object.Key("repositoryName")
1949		ok.String(*v.RepositoryName)
1950	}
1951
1952	return nil
1953}
1954
1955func awsAwsjson11_serializeOpDocumentCompleteLayerUploadInput(v *CompleteLayerUploadInput, value smithyjson.Value) error {
1956	object := value.Object()
1957	defer object.Close()
1958
1959	if v.LayerDigests != nil {
1960		ok := object.Key("layerDigests")
1961		if err := awsAwsjson11_serializeDocumentLayerDigestList(v.LayerDigests, ok); err != nil {
1962			return err
1963		}
1964	}
1965
1966	if v.RegistryId != nil {
1967		ok := object.Key("registryId")
1968		ok.String(*v.RegistryId)
1969	}
1970
1971	if v.RepositoryName != nil {
1972		ok := object.Key("repositoryName")
1973		ok.String(*v.RepositoryName)
1974	}
1975
1976	if v.UploadId != nil {
1977		ok := object.Key("uploadId")
1978		ok.String(*v.UploadId)
1979	}
1980
1981	return nil
1982}
1983
1984func awsAwsjson11_serializeOpDocumentCreateRepositoryInput(v *CreateRepositoryInput, value smithyjson.Value) error {
1985	object := value.Object()
1986	defer object.Close()
1987
1988	if v.EncryptionConfiguration != nil {
1989		ok := object.Key("encryptionConfiguration")
1990		if err := awsAwsjson11_serializeDocumentEncryptionConfiguration(v.EncryptionConfiguration, ok); err != nil {
1991			return err
1992		}
1993	}
1994
1995	if v.ImageScanningConfiguration != nil {
1996		ok := object.Key("imageScanningConfiguration")
1997		if err := awsAwsjson11_serializeDocumentImageScanningConfiguration(v.ImageScanningConfiguration, ok); err != nil {
1998			return err
1999		}
2000	}
2001
2002	if len(v.ImageTagMutability) > 0 {
2003		ok := object.Key("imageTagMutability")
2004		ok.String(string(v.ImageTagMutability))
2005	}
2006
2007	if v.RepositoryName != nil {
2008		ok := object.Key("repositoryName")
2009		ok.String(*v.RepositoryName)
2010	}
2011
2012	if v.Tags != nil {
2013		ok := object.Key("tags")
2014		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
2015			return err
2016		}
2017	}
2018
2019	return nil
2020}
2021
2022func awsAwsjson11_serializeOpDocumentDeleteLifecyclePolicyInput(v *DeleteLifecyclePolicyInput, value smithyjson.Value) error {
2023	object := value.Object()
2024	defer object.Close()
2025
2026	if v.RegistryId != nil {
2027		ok := object.Key("registryId")
2028		ok.String(*v.RegistryId)
2029	}
2030
2031	if v.RepositoryName != nil {
2032		ok := object.Key("repositoryName")
2033		ok.String(*v.RepositoryName)
2034	}
2035
2036	return nil
2037}
2038
2039func awsAwsjson11_serializeOpDocumentDeleteRegistryPolicyInput(v *DeleteRegistryPolicyInput, value smithyjson.Value) error {
2040	object := value.Object()
2041	defer object.Close()
2042
2043	return nil
2044}
2045
2046func awsAwsjson11_serializeOpDocumentDeleteRepositoryInput(v *DeleteRepositoryInput, value smithyjson.Value) error {
2047	object := value.Object()
2048	defer object.Close()
2049
2050	if v.Force {
2051		ok := object.Key("force")
2052		ok.Boolean(v.Force)
2053	}
2054
2055	if v.RegistryId != nil {
2056		ok := object.Key("registryId")
2057		ok.String(*v.RegistryId)
2058	}
2059
2060	if v.RepositoryName != nil {
2061		ok := object.Key("repositoryName")
2062		ok.String(*v.RepositoryName)
2063	}
2064
2065	return nil
2066}
2067
2068func awsAwsjson11_serializeOpDocumentDeleteRepositoryPolicyInput(v *DeleteRepositoryPolicyInput, value smithyjson.Value) error {
2069	object := value.Object()
2070	defer object.Close()
2071
2072	if v.RegistryId != nil {
2073		ok := object.Key("registryId")
2074		ok.String(*v.RegistryId)
2075	}
2076
2077	if v.RepositoryName != nil {
2078		ok := object.Key("repositoryName")
2079		ok.String(*v.RepositoryName)
2080	}
2081
2082	return nil
2083}
2084
2085func awsAwsjson11_serializeOpDocumentDescribeImageScanFindingsInput(v *DescribeImageScanFindingsInput, value smithyjson.Value) error {
2086	object := value.Object()
2087	defer object.Close()
2088
2089	if v.ImageId != nil {
2090		ok := object.Key("imageId")
2091		if err := awsAwsjson11_serializeDocumentImageIdentifier(v.ImageId, ok); err != nil {
2092			return err
2093		}
2094	}
2095
2096	if v.MaxResults != nil {
2097		ok := object.Key("maxResults")
2098		ok.Integer(*v.MaxResults)
2099	}
2100
2101	if v.NextToken != nil {
2102		ok := object.Key("nextToken")
2103		ok.String(*v.NextToken)
2104	}
2105
2106	if v.RegistryId != nil {
2107		ok := object.Key("registryId")
2108		ok.String(*v.RegistryId)
2109	}
2110
2111	if v.RepositoryName != nil {
2112		ok := object.Key("repositoryName")
2113		ok.String(*v.RepositoryName)
2114	}
2115
2116	return nil
2117}
2118
2119func awsAwsjson11_serializeOpDocumentDescribeImagesInput(v *DescribeImagesInput, value smithyjson.Value) error {
2120	object := value.Object()
2121	defer object.Close()
2122
2123	if v.Filter != nil {
2124		ok := object.Key("filter")
2125		if err := awsAwsjson11_serializeDocumentDescribeImagesFilter(v.Filter, ok); err != nil {
2126			return err
2127		}
2128	}
2129
2130	if v.ImageIds != nil {
2131		ok := object.Key("imageIds")
2132		if err := awsAwsjson11_serializeDocumentImageIdentifierList(v.ImageIds, ok); err != nil {
2133			return err
2134		}
2135	}
2136
2137	if v.MaxResults != nil {
2138		ok := object.Key("maxResults")
2139		ok.Integer(*v.MaxResults)
2140	}
2141
2142	if v.NextToken != nil {
2143		ok := object.Key("nextToken")
2144		ok.String(*v.NextToken)
2145	}
2146
2147	if v.RegistryId != nil {
2148		ok := object.Key("registryId")
2149		ok.String(*v.RegistryId)
2150	}
2151
2152	if v.RepositoryName != nil {
2153		ok := object.Key("repositoryName")
2154		ok.String(*v.RepositoryName)
2155	}
2156
2157	return nil
2158}
2159
2160func awsAwsjson11_serializeOpDocumentDescribeRegistryInput(v *DescribeRegistryInput, value smithyjson.Value) error {
2161	object := value.Object()
2162	defer object.Close()
2163
2164	return nil
2165}
2166
2167func awsAwsjson11_serializeOpDocumentDescribeRepositoriesInput(v *DescribeRepositoriesInput, value smithyjson.Value) error {
2168	object := value.Object()
2169	defer object.Close()
2170
2171	if v.MaxResults != nil {
2172		ok := object.Key("maxResults")
2173		ok.Integer(*v.MaxResults)
2174	}
2175
2176	if v.NextToken != nil {
2177		ok := object.Key("nextToken")
2178		ok.String(*v.NextToken)
2179	}
2180
2181	if v.RegistryId != nil {
2182		ok := object.Key("registryId")
2183		ok.String(*v.RegistryId)
2184	}
2185
2186	if v.RepositoryNames != nil {
2187		ok := object.Key("repositoryNames")
2188		if err := awsAwsjson11_serializeDocumentRepositoryNameList(v.RepositoryNames, ok); err != nil {
2189			return err
2190		}
2191	}
2192
2193	return nil
2194}
2195
2196func awsAwsjson11_serializeOpDocumentGetAuthorizationTokenInput(v *GetAuthorizationTokenInput, value smithyjson.Value) error {
2197	object := value.Object()
2198	defer object.Close()
2199
2200	if v.RegistryIds != nil {
2201		ok := object.Key("registryIds")
2202		if err := awsAwsjson11_serializeDocumentGetAuthorizationTokenRegistryIdList(v.RegistryIds, ok); err != nil {
2203			return err
2204		}
2205	}
2206
2207	return nil
2208}
2209
2210func awsAwsjson11_serializeOpDocumentGetDownloadUrlForLayerInput(v *GetDownloadUrlForLayerInput, value smithyjson.Value) error {
2211	object := value.Object()
2212	defer object.Close()
2213
2214	if v.LayerDigest != nil {
2215		ok := object.Key("layerDigest")
2216		ok.String(*v.LayerDigest)
2217	}
2218
2219	if v.RegistryId != nil {
2220		ok := object.Key("registryId")
2221		ok.String(*v.RegistryId)
2222	}
2223
2224	if v.RepositoryName != nil {
2225		ok := object.Key("repositoryName")
2226		ok.String(*v.RepositoryName)
2227	}
2228
2229	return nil
2230}
2231
2232func awsAwsjson11_serializeOpDocumentGetLifecyclePolicyInput(v *GetLifecyclePolicyInput, value smithyjson.Value) error {
2233	object := value.Object()
2234	defer object.Close()
2235
2236	if v.RegistryId != nil {
2237		ok := object.Key("registryId")
2238		ok.String(*v.RegistryId)
2239	}
2240
2241	if v.RepositoryName != nil {
2242		ok := object.Key("repositoryName")
2243		ok.String(*v.RepositoryName)
2244	}
2245
2246	return nil
2247}
2248
2249func awsAwsjson11_serializeOpDocumentGetLifecyclePolicyPreviewInput(v *GetLifecyclePolicyPreviewInput, value smithyjson.Value) error {
2250	object := value.Object()
2251	defer object.Close()
2252
2253	if v.Filter != nil {
2254		ok := object.Key("filter")
2255		if err := awsAwsjson11_serializeDocumentLifecyclePolicyPreviewFilter(v.Filter, ok); err != nil {
2256			return err
2257		}
2258	}
2259
2260	if v.ImageIds != nil {
2261		ok := object.Key("imageIds")
2262		if err := awsAwsjson11_serializeDocumentImageIdentifierList(v.ImageIds, ok); err != nil {
2263			return err
2264		}
2265	}
2266
2267	if v.MaxResults != nil {
2268		ok := object.Key("maxResults")
2269		ok.Integer(*v.MaxResults)
2270	}
2271
2272	if v.NextToken != nil {
2273		ok := object.Key("nextToken")
2274		ok.String(*v.NextToken)
2275	}
2276
2277	if v.RegistryId != nil {
2278		ok := object.Key("registryId")
2279		ok.String(*v.RegistryId)
2280	}
2281
2282	if v.RepositoryName != nil {
2283		ok := object.Key("repositoryName")
2284		ok.String(*v.RepositoryName)
2285	}
2286
2287	return nil
2288}
2289
2290func awsAwsjson11_serializeOpDocumentGetRegistryPolicyInput(v *GetRegistryPolicyInput, value smithyjson.Value) error {
2291	object := value.Object()
2292	defer object.Close()
2293
2294	return nil
2295}
2296
2297func awsAwsjson11_serializeOpDocumentGetRepositoryPolicyInput(v *GetRepositoryPolicyInput, value smithyjson.Value) error {
2298	object := value.Object()
2299	defer object.Close()
2300
2301	if v.RegistryId != nil {
2302		ok := object.Key("registryId")
2303		ok.String(*v.RegistryId)
2304	}
2305
2306	if v.RepositoryName != nil {
2307		ok := object.Key("repositoryName")
2308		ok.String(*v.RepositoryName)
2309	}
2310
2311	return nil
2312}
2313
2314func awsAwsjson11_serializeOpDocumentInitiateLayerUploadInput(v *InitiateLayerUploadInput, value smithyjson.Value) error {
2315	object := value.Object()
2316	defer object.Close()
2317
2318	if v.RegistryId != nil {
2319		ok := object.Key("registryId")
2320		ok.String(*v.RegistryId)
2321	}
2322
2323	if v.RepositoryName != nil {
2324		ok := object.Key("repositoryName")
2325		ok.String(*v.RepositoryName)
2326	}
2327
2328	return nil
2329}
2330
2331func awsAwsjson11_serializeOpDocumentListImagesInput(v *ListImagesInput, value smithyjson.Value) error {
2332	object := value.Object()
2333	defer object.Close()
2334
2335	if v.Filter != nil {
2336		ok := object.Key("filter")
2337		if err := awsAwsjson11_serializeDocumentListImagesFilter(v.Filter, ok); err != nil {
2338			return err
2339		}
2340	}
2341
2342	if v.MaxResults != nil {
2343		ok := object.Key("maxResults")
2344		ok.Integer(*v.MaxResults)
2345	}
2346
2347	if v.NextToken != nil {
2348		ok := object.Key("nextToken")
2349		ok.String(*v.NextToken)
2350	}
2351
2352	if v.RegistryId != nil {
2353		ok := object.Key("registryId")
2354		ok.String(*v.RegistryId)
2355	}
2356
2357	if v.RepositoryName != nil {
2358		ok := object.Key("repositoryName")
2359		ok.String(*v.RepositoryName)
2360	}
2361
2362	return nil
2363}
2364
2365func awsAwsjson11_serializeOpDocumentListTagsForResourceInput(v *ListTagsForResourceInput, value smithyjson.Value) error {
2366	object := value.Object()
2367	defer object.Close()
2368
2369	if v.ResourceArn != nil {
2370		ok := object.Key("resourceArn")
2371		ok.String(*v.ResourceArn)
2372	}
2373
2374	return nil
2375}
2376
2377func awsAwsjson11_serializeOpDocumentPutImageInput(v *PutImageInput, value smithyjson.Value) error {
2378	object := value.Object()
2379	defer object.Close()
2380
2381	if v.ImageDigest != nil {
2382		ok := object.Key("imageDigest")
2383		ok.String(*v.ImageDigest)
2384	}
2385
2386	if v.ImageManifest != nil {
2387		ok := object.Key("imageManifest")
2388		ok.String(*v.ImageManifest)
2389	}
2390
2391	if v.ImageManifestMediaType != nil {
2392		ok := object.Key("imageManifestMediaType")
2393		ok.String(*v.ImageManifestMediaType)
2394	}
2395
2396	if v.ImageTag != nil {
2397		ok := object.Key("imageTag")
2398		ok.String(*v.ImageTag)
2399	}
2400
2401	if v.RegistryId != nil {
2402		ok := object.Key("registryId")
2403		ok.String(*v.RegistryId)
2404	}
2405
2406	if v.RepositoryName != nil {
2407		ok := object.Key("repositoryName")
2408		ok.String(*v.RepositoryName)
2409	}
2410
2411	return nil
2412}
2413
2414func awsAwsjson11_serializeOpDocumentPutImageScanningConfigurationInput(v *PutImageScanningConfigurationInput, value smithyjson.Value) error {
2415	object := value.Object()
2416	defer object.Close()
2417
2418	if v.ImageScanningConfiguration != nil {
2419		ok := object.Key("imageScanningConfiguration")
2420		if err := awsAwsjson11_serializeDocumentImageScanningConfiguration(v.ImageScanningConfiguration, ok); err != nil {
2421			return err
2422		}
2423	}
2424
2425	if v.RegistryId != nil {
2426		ok := object.Key("registryId")
2427		ok.String(*v.RegistryId)
2428	}
2429
2430	if v.RepositoryName != nil {
2431		ok := object.Key("repositoryName")
2432		ok.String(*v.RepositoryName)
2433	}
2434
2435	return nil
2436}
2437
2438func awsAwsjson11_serializeOpDocumentPutImageTagMutabilityInput(v *PutImageTagMutabilityInput, value smithyjson.Value) error {
2439	object := value.Object()
2440	defer object.Close()
2441
2442	if len(v.ImageTagMutability) > 0 {
2443		ok := object.Key("imageTagMutability")
2444		ok.String(string(v.ImageTagMutability))
2445	}
2446
2447	if v.RegistryId != nil {
2448		ok := object.Key("registryId")
2449		ok.String(*v.RegistryId)
2450	}
2451
2452	if v.RepositoryName != nil {
2453		ok := object.Key("repositoryName")
2454		ok.String(*v.RepositoryName)
2455	}
2456
2457	return nil
2458}
2459
2460func awsAwsjson11_serializeOpDocumentPutLifecyclePolicyInput(v *PutLifecyclePolicyInput, value smithyjson.Value) error {
2461	object := value.Object()
2462	defer object.Close()
2463
2464	if v.LifecyclePolicyText != nil {
2465		ok := object.Key("lifecyclePolicyText")
2466		ok.String(*v.LifecyclePolicyText)
2467	}
2468
2469	if v.RegistryId != nil {
2470		ok := object.Key("registryId")
2471		ok.String(*v.RegistryId)
2472	}
2473
2474	if v.RepositoryName != nil {
2475		ok := object.Key("repositoryName")
2476		ok.String(*v.RepositoryName)
2477	}
2478
2479	return nil
2480}
2481
2482func awsAwsjson11_serializeOpDocumentPutRegistryPolicyInput(v *PutRegistryPolicyInput, value smithyjson.Value) error {
2483	object := value.Object()
2484	defer object.Close()
2485
2486	if v.PolicyText != nil {
2487		ok := object.Key("policyText")
2488		ok.String(*v.PolicyText)
2489	}
2490
2491	return nil
2492}
2493
2494func awsAwsjson11_serializeOpDocumentPutReplicationConfigurationInput(v *PutReplicationConfigurationInput, value smithyjson.Value) error {
2495	object := value.Object()
2496	defer object.Close()
2497
2498	if v.ReplicationConfiguration != nil {
2499		ok := object.Key("replicationConfiguration")
2500		if err := awsAwsjson11_serializeDocumentReplicationConfiguration(v.ReplicationConfiguration, ok); err != nil {
2501			return err
2502		}
2503	}
2504
2505	return nil
2506}
2507
2508func awsAwsjson11_serializeOpDocumentSetRepositoryPolicyInput(v *SetRepositoryPolicyInput, value smithyjson.Value) error {
2509	object := value.Object()
2510	defer object.Close()
2511
2512	if v.Force {
2513		ok := object.Key("force")
2514		ok.Boolean(v.Force)
2515	}
2516
2517	if v.PolicyText != nil {
2518		ok := object.Key("policyText")
2519		ok.String(*v.PolicyText)
2520	}
2521
2522	if v.RegistryId != nil {
2523		ok := object.Key("registryId")
2524		ok.String(*v.RegistryId)
2525	}
2526
2527	if v.RepositoryName != nil {
2528		ok := object.Key("repositoryName")
2529		ok.String(*v.RepositoryName)
2530	}
2531
2532	return nil
2533}
2534
2535func awsAwsjson11_serializeOpDocumentStartImageScanInput(v *StartImageScanInput, value smithyjson.Value) error {
2536	object := value.Object()
2537	defer object.Close()
2538
2539	if v.ImageId != nil {
2540		ok := object.Key("imageId")
2541		if err := awsAwsjson11_serializeDocumentImageIdentifier(v.ImageId, ok); err != nil {
2542			return err
2543		}
2544	}
2545
2546	if v.RegistryId != nil {
2547		ok := object.Key("registryId")
2548		ok.String(*v.RegistryId)
2549	}
2550
2551	if v.RepositoryName != nil {
2552		ok := object.Key("repositoryName")
2553		ok.String(*v.RepositoryName)
2554	}
2555
2556	return nil
2557}
2558
2559func awsAwsjson11_serializeOpDocumentStartLifecyclePolicyPreviewInput(v *StartLifecyclePolicyPreviewInput, value smithyjson.Value) error {
2560	object := value.Object()
2561	defer object.Close()
2562
2563	if v.LifecyclePolicyText != nil {
2564		ok := object.Key("lifecyclePolicyText")
2565		ok.String(*v.LifecyclePolicyText)
2566	}
2567
2568	if v.RegistryId != nil {
2569		ok := object.Key("registryId")
2570		ok.String(*v.RegistryId)
2571	}
2572
2573	if v.RepositoryName != nil {
2574		ok := object.Key("repositoryName")
2575		ok.String(*v.RepositoryName)
2576	}
2577
2578	return nil
2579}
2580
2581func awsAwsjson11_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
2582	object := value.Object()
2583	defer object.Close()
2584
2585	if v.ResourceArn != nil {
2586		ok := object.Key("resourceArn")
2587		ok.String(*v.ResourceArn)
2588	}
2589
2590	if v.Tags != nil {
2591		ok := object.Key("tags")
2592		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
2593			return err
2594		}
2595	}
2596
2597	return nil
2598}
2599
2600func awsAwsjson11_serializeOpDocumentUntagResourceInput(v *UntagResourceInput, value smithyjson.Value) error {
2601	object := value.Object()
2602	defer object.Close()
2603
2604	if v.ResourceArn != nil {
2605		ok := object.Key("resourceArn")
2606		ok.String(*v.ResourceArn)
2607	}
2608
2609	if v.TagKeys != nil {
2610		ok := object.Key("tagKeys")
2611		if err := awsAwsjson11_serializeDocumentTagKeyList(v.TagKeys, ok); err != nil {
2612			return err
2613		}
2614	}
2615
2616	return nil
2617}
2618
2619func awsAwsjson11_serializeOpDocumentUploadLayerPartInput(v *UploadLayerPartInput, value smithyjson.Value) error {
2620	object := value.Object()
2621	defer object.Close()
2622
2623	if v.LayerPartBlob != nil {
2624		ok := object.Key("layerPartBlob")
2625		ok.Base64EncodeBytes(v.LayerPartBlob)
2626	}
2627
2628	if v.PartFirstByte != nil {
2629		ok := object.Key("partFirstByte")
2630		ok.Long(*v.PartFirstByte)
2631	}
2632
2633	if v.PartLastByte != nil {
2634		ok := object.Key("partLastByte")
2635		ok.Long(*v.PartLastByte)
2636	}
2637
2638	if v.RegistryId != nil {
2639		ok := object.Key("registryId")
2640		ok.String(*v.RegistryId)
2641	}
2642
2643	if v.RepositoryName != nil {
2644		ok := object.Key("repositoryName")
2645		ok.String(*v.RepositoryName)
2646	}
2647
2648	if v.UploadId != nil {
2649		ok := object.Key("uploadId")
2650		ok.String(*v.UploadId)
2651	}
2652
2653	return nil
2654}
2655