1
2
3 package ecrpublic
4
5 import (
6 "bytes"
7 "context"
8 "fmt"
9 "github.com/aws/aws-sdk-go-v2/service/ecrpublic/types"
10 smithy "github.com/aws/smithy-go"
11 "github.com/aws/smithy-go/encoding/httpbinding"
12 smithyjson "github.com/aws/smithy-go/encoding/json"
13 "github.com/aws/smithy-go/middleware"
14 smithyhttp "github.com/aws/smithy-go/transport/http"
15 "path"
16 )
17
18 type awsAwsjson11_serializeOpBatchCheckLayerAvailability struct {
19 }
20
21 func (*awsAwsjson11_serializeOpBatchCheckLayerAvailability) ID() string {
22 return "OperationSerializer"
23 }
24
25 func (m *awsAwsjson11_serializeOpBatchCheckLayerAvailability) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
26 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
27 ) {
28 request, ok := in.Request.(*smithyhttp.Request)
29 if !ok {
30 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
31 }
32
33 input, ok := in.Parameters.(*BatchCheckLayerAvailabilityInput)
34 _ = input
35 if !ok {
36 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
37 }
38
39 operationPath := "/"
40 if len(request.Request.URL.Path) == 0 {
41 request.Request.URL.Path = operationPath
42 } else {
43 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
44 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
45 request.Request.URL.Path += "/"
46 }
47 }
48 request.Request.Method = "POST"
49 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
50 if err != nil {
51 return out, metadata, &smithy.SerializationError{Err: err}
52 }
53 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
54 httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.BatchCheckLayerAvailability")
55
56 jsonEncoder := smithyjson.NewEncoder()
57 if err := awsAwsjson11_serializeOpDocumentBatchCheckLayerAvailabilityInput(input, jsonEncoder.Value); err != nil {
58 return out, metadata, &smithy.SerializationError{Err: err}
59 }
60
61 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
62 return out, metadata, &smithy.SerializationError{Err: err}
63 }
64
65 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
66 return out, metadata, &smithy.SerializationError{Err: err}
67 }
68 in.Request = request
69
70 return next.HandleSerialize(ctx, in)
71 }
72
73 type awsAwsjson11_serializeOpBatchDeleteImage struct {
74 }
75
76 func (*awsAwsjson11_serializeOpBatchDeleteImage) ID() string {
77 return "OperationSerializer"
78 }
79
80 func (m *awsAwsjson11_serializeOpBatchDeleteImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
81 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
82 ) {
83 request, ok := in.Request.(*smithyhttp.Request)
84 if !ok {
85 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
86 }
87
88 input, ok := in.Parameters.(*BatchDeleteImageInput)
89 _ = input
90 if !ok {
91 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
92 }
93
94 operationPath := "/"
95 if len(request.Request.URL.Path) == 0 {
96 request.Request.URL.Path = operationPath
97 } else {
98 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
99 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
100 request.Request.URL.Path += "/"
101 }
102 }
103 request.Request.Method = "POST"
104 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
105 if err != nil {
106 return out, metadata, &smithy.SerializationError{Err: err}
107 }
108 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
109 httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.BatchDeleteImage")
110
111 jsonEncoder := smithyjson.NewEncoder()
112 if err := awsAwsjson11_serializeOpDocumentBatchDeleteImageInput(input, jsonEncoder.Value); err != nil {
113 return out, metadata, &smithy.SerializationError{Err: err}
114 }
115
116 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
117 return out, metadata, &smithy.SerializationError{Err: err}
118 }
119
120 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
121 return out, metadata, &smithy.SerializationError{Err: err}
122 }
123 in.Request = request
124
125 return next.HandleSerialize(ctx, in)
126 }
127
128 type awsAwsjson11_serializeOpCompleteLayerUpload struct {
129 }
130
131 func (*awsAwsjson11_serializeOpCompleteLayerUpload) ID() string {
132 return "OperationSerializer"
133 }
134
135 func (m *awsAwsjson11_serializeOpCompleteLayerUpload) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
136 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
137 ) {
138 request, ok := in.Request.(*smithyhttp.Request)
139 if !ok {
140 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
141 }
142
143 input, ok := in.Parameters.(*CompleteLayerUploadInput)
144 _ = input
145 if !ok {
146 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
147 }
148
149 operationPath := "/"
150 if len(request.Request.URL.Path) == 0 {
151 request.Request.URL.Path = operationPath
152 } else {
153 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
154 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
155 request.Request.URL.Path += "/"
156 }
157 }
158 request.Request.Method = "POST"
159 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
160 if err != nil {
161 return out, metadata, &smithy.SerializationError{Err: err}
162 }
163 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
164 httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.CompleteLayerUpload")
165
166 jsonEncoder := smithyjson.NewEncoder()
167 if err := awsAwsjson11_serializeOpDocumentCompleteLayerUploadInput(input, jsonEncoder.Value); err != nil {
168 return out, metadata, &smithy.SerializationError{Err: err}
169 }
170
171 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
172 return out, metadata, &smithy.SerializationError{Err: err}
173 }
174
175 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
176 return out, metadata, &smithy.SerializationError{Err: err}
177 }
178 in.Request = request
179
180 return next.HandleSerialize(ctx, in)
181 }
182
183 type awsAwsjson11_serializeOpCreateRepository struct {
184 }
185
186 func (*awsAwsjson11_serializeOpCreateRepository) ID() string {
187 return "OperationSerializer"
188 }
189
190 func (m *awsAwsjson11_serializeOpCreateRepository) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
191 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
192 ) {
193 request, ok := in.Request.(*smithyhttp.Request)
194 if !ok {
195 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
196 }
197
198 input, ok := in.Parameters.(*CreateRepositoryInput)
199 _ = input
200 if !ok {
201 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
202 }
203
204 operationPath := "/"
205 if len(request.Request.URL.Path) == 0 {
206 request.Request.URL.Path = operationPath
207 } else {
208 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
209 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
210 request.Request.URL.Path += "/"
211 }
212 }
213 request.Request.Method = "POST"
214 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
215 if err != nil {
216 return out, metadata, &smithy.SerializationError{Err: err}
217 }
218 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
219 httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.CreateRepository")
220
221 jsonEncoder := smithyjson.NewEncoder()
222 if err := awsAwsjson11_serializeOpDocumentCreateRepositoryInput(input, jsonEncoder.Value); err != nil {
223 return out, metadata, &smithy.SerializationError{Err: err}
224 }
225
226 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
227 return out, metadata, &smithy.SerializationError{Err: err}
228 }
229
230 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
231 return out, metadata, &smithy.SerializationError{Err: err}
232 }
233 in.Request = request
234
235 return next.HandleSerialize(ctx, in)
236 }
237
238 type awsAwsjson11_serializeOpDeleteRepository struct {
239 }
240
241 func (*awsAwsjson11_serializeOpDeleteRepository) ID() string {
242 return "OperationSerializer"
243 }
244
245 func (m *awsAwsjson11_serializeOpDeleteRepository) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
246 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
247 ) {
248 request, ok := in.Request.(*smithyhttp.Request)
249 if !ok {
250 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
251 }
252
253 input, ok := in.Parameters.(*DeleteRepositoryInput)
254 _ = input
255 if !ok {
256 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
257 }
258
259 operationPath := "/"
260 if len(request.Request.URL.Path) == 0 {
261 request.Request.URL.Path = operationPath
262 } else {
263 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
264 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
265 request.Request.URL.Path += "/"
266 }
267 }
268 request.Request.Method = "POST"
269 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
270 if err != nil {
271 return out, metadata, &smithy.SerializationError{Err: err}
272 }
273 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
274 httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.DeleteRepository")
275
276 jsonEncoder := smithyjson.NewEncoder()
277 if err := awsAwsjson11_serializeOpDocumentDeleteRepositoryInput(input, jsonEncoder.Value); err != nil {
278 return out, metadata, &smithy.SerializationError{Err: err}
279 }
280
281 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
282 return out, metadata, &smithy.SerializationError{Err: err}
283 }
284
285 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
286 return out, metadata, &smithy.SerializationError{Err: err}
287 }
288 in.Request = request
289
290 return next.HandleSerialize(ctx, in)
291 }
292
293 type awsAwsjson11_serializeOpDeleteRepositoryPolicy struct {
294 }
295
296 func (*awsAwsjson11_serializeOpDeleteRepositoryPolicy) ID() string {
297 return "OperationSerializer"
298 }
299
300 func (m *awsAwsjson11_serializeOpDeleteRepositoryPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
301 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
302 ) {
303 request, ok := in.Request.(*smithyhttp.Request)
304 if !ok {
305 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
306 }
307
308 input, ok := in.Parameters.(*DeleteRepositoryPolicyInput)
309 _ = input
310 if !ok {
311 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
312 }
313
314 operationPath := "/"
315 if len(request.Request.URL.Path) == 0 {
316 request.Request.URL.Path = operationPath
317 } else {
318 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
319 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
320 request.Request.URL.Path += "/"
321 }
322 }
323 request.Request.Method = "POST"
324 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
325 if err != nil {
326 return out, metadata, &smithy.SerializationError{Err: err}
327 }
328 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
329 httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.DeleteRepositoryPolicy")
330
331 jsonEncoder := smithyjson.NewEncoder()
332 if err := awsAwsjson11_serializeOpDocumentDeleteRepositoryPolicyInput(input, jsonEncoder.Value); err != nil {
333 return out, metadata, &smithy.SerializationError{Err: err}
334 }
335
336 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
337 return out, metadata, &smithy.SerializationError{Err: err}
338 }
339
340 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
341 return out, metadata, &smithy.SerializationError{Err: err}
342 }
343 in.Request = request
344
345 return next.HandleSerialize(ctx, in)
346 }
347
348 type awsAwsjson11_serializeOpDescribeImages struct {
349 }
350
351 func (*awsAwsjson11_serializeOpDescribeImages) ID() string {
352 return "OperationSerializer"
353 }
354
355 func (m *awsAwsjson11_serializeOpDescribeImages) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
356 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
357 ) {
358 request, ok := in.Request.(*smithyhttp.Request)
359 if !ok {
360 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
361 }
362
363 input, ok := in.Parameters.(*DescribeImagesInput)
364 _ = input
365 if !ok {
366 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
367 }
368
369 operationPath := "/"
370 if len(request.Request.URL.Path) == 0 {
371 request.Request.URL.Path = operationPath
372 } else {
373 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
374 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
375 request.Request.URL.Path += "/"
376 }
377 }
378 request.Request.Method = "POST"
379 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
380 if err != nil {
381 return out, metadata, &smithy.SerializationError{Err: err}
382 }
383 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
384 httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.DescribeImages")
385
386 jsonEncoder := smithyjson.NewEncoder()
387 if err := awsAwsjson11_serializeOpDocumentDescribeImagesInput(input, jsonEncoder.Value); err != nil {
388 return out, metadata, &smithy.SerializationError{Err: err}
389 }
390
391 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
392 return out, metadata, &smithy.SerializationError{Err: err}
393 }
394
395 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
396 return out, metadata, &smithy.SerializationError{Err: err}
397 }
398 in.Request = request
399
400 return next.HandleSerialize(ctx, in)
401 }
402
403 type awsAwsjson11_serializeOpDescribeImageTags struct {
404 }
405
406 func (*awsAwsjson11_serializeOpDescribeImageTags) ID() string {
407 return "OperationSerializer"
408 }
409
410 func (m *awsAwsjson11_serializeOpDescribeImageTags) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
411 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
412 ) {
413 request, ok := in.Request.(*smithyhttp.Request)
414 if !ok {
415 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
416 }
417
418 input, ok := in.Parameters.(*DescribeImageTagsInput)
419 _ = input
420 if !ok {
421 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
422 }
423
424 operationPath := "/"
425 if len(request.Request.URL.Path) == 0 {
426 request.Request.URL.Path = operationPath
427 } else {
428 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
429 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
430 request.Request.URL.Path += "/"
431 }
432 }
433 request.Request.Method = "POST"
434 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
435 if err != nil {
436 return out, metadata, &smithy.SerializationError{Err: err}
437 }
438 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
439 httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.DescribeImageTags")
440
441 jsonEncoder := smithyjson.NewEncoder()
442 if err := awsAwsjson11_serializeOpDocumentDescribeImageTagsInput(input, jsonEncoder.Value); err != nil {
443 return out, metadata, &smithy.SerializationError{Err: err}
444 }
445
446 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
447 return out, metadata, &smithy.SerializationError{Err: err}
448 }
449
450 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
451 return out, metadata, &smithy.SerializationError{Err: err}
452 }
453 in.Request = request
454
455 return next.HandleSerialize(ctx, in)
456 }
457
458 type awsAwsjson11_serializeOpDescribeRegistries struct {
459 }
460
461 func (*awsAwsjson11_serializeOpDescribeRegistries) ID() string {
462 return "OperationSerializer"
463 }
464
465 func (m *awsAwsjson11_serializeOpDescribeRegistries) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
466 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
467 ) {
468 request, ok := in.Request.(*smithyhttp.Request)
469 if !ok {
470 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
471 }
472
473 input, ok := in.Parameters.(*DescribeRegistriesInput)
474 _ = input
475 if !ok {
476 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
477 }
478
479 operationPath := "/"
480 if len(request.Request.URL.Path) == 0 {
481 request.Request.URL.Path = operationPath
482 } else {
483 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
484 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
485 request.Request.URL.Path += "/"
486 }
487 }
488 request.Request.Method = "POST"
489 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
490 if err != nil {
491 return out, metadata, &smithy.SerializationError{Err: err}
492 }
493 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
494 httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.DescribeRegistries")
495
496 jsonEncoder := smithyjson.NewEncoder()
497 if err := awsAwsjson11_serializeOpDocumentDescribeRegistriesInput(input, jsonEncoder.Value); err != nil {
498 return out, metadata, &smithy.SerializationError{Err: err}
499 }
500
501 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
502 return out, metadata, &smithy.SerializationError{Err: err}
503 }
504
505 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
506 return out, metadata, &smithy.SerializationError{Err: err}
507 }
508 in.Request = request
509
510 return next.HandleSerialize(ctx, in)
511 }
512
513 type awsAwsjson11_serializeOpDescribeRepositories struct {
514 }
515
516 func (*awsAwsjson11_serializeOpDescribeRepositories) ID() string {
517 return "OperationSerializer"
518 }
519
520 func (m *awsAwsjson11_serializeOpDescribeRepositories) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
521 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
522 ) {
523 request, ok := in.Request.(*smithyhttp.Request)
524 if !ok {
525 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
526 }
527
528 input, ok := in.Parameters.(*DescribeRepositoriesInput)
529 _ = input
530 if !ok {
531 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
532 }
533
534 operationPath := "/"
535 if len(request.Request.URL.Path) == 0 {
536 request.Request.URL.Path = operationPath
537 } else {
538 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
539 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
540 request.Request.URL.Path += "/"
541 }
542 }
543 request.Request.Method = "POST"
544 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
545 if err != nil {
546 return out, metadata, &smithy.SerializationError{Err: err}
547 }
548 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
549 httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.DescribeRepositories")
550
551 jsonEncoder := smithyjson.NewEncoder()
552 if err := awsAwsjson11_serializeOpDocumentDescribeRepositoriesInput(input, jsonEncoder.Value); err != nil {
553 return out, metadata, &smithy.SerializationError{Err: err}
554 }
555
556 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
557 return out, metadata, &smithy.SerializationError{Err: err}
558 }
559
560 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
561 return out, metadata, &smithy.SerializationError{Err: err}
562 }
563 in.Request = request
564
565 return next.HandleSerialize(ctx, in)
566 }
567
568 type awsAwsjson11_serializeOpGetAuthorizationToken struct {
569 }
570
571 func (*awsAwsjson11_serializeOpGetAuthorizationToken) ID() string {
572 return "OperationSerializer"
573 }
574
575 func (m *awsAwsjson11_serializeOpGetAuthorizationToken) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
576 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
577 ) {
578 request, ok := in.Request.(*smithyhttp.Request)
579 if !ok {
580 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
581 }
582
583 input, ok := in.Parameters.(*GetAuthorizationTokenInput)
584 _ = input
585 if !ok {
586 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
587 }
588
589 operationPath := "/"
590 if len(request.Request.URL.Path) == 0 {
591 request.Request.URL.Path = operationPath
592 } else {
593 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
594 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
595 request.Request.URL.Path += "/"
596 }
597 }
598 request.Request.Method = "POST"
599 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
600 if err != nil {
601 return out, metadata, &smithy.SerializationError{Err: err}
602 }
603 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
604 httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.GetAuthorizationToken")
605
606 jsonEncoder := smithyjson.NewEncoder()
607 if err := awsAwsjson11_serializeOpDocumentGetAuthorizationTokenInput(input, jsonEncoder.Value); err != nil {
608 return out, metadata, &smithy.SerializationError{Err: err}
609 }
610
611 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
612 return out, metadata, &smithy.SerializationError{Err: err}
613 }
614
615 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
616 return out, metadata, &smithy.SerializationError{Err: err}
617 }
618 in.Request = request
619
620 return next.HandleSerialize(ctx, in)
621 }
622
623 type awsAwsjson11_serializeOpGetRegistryCatalogData struct {
624 }
625
626 func (*awsAwsjson11_serializeOpGetRegistryCatalogData) ID() string {
627 return "OperationSerializer"
628 }
629
630 func (m *awsAwsjson11_serializeOpGetRegistryCatalogData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
631 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
632 ) {
633 request, ok := in.Request.(*smithyhttp.Request)
634 if !ok {
635 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
636 }
637
638 input, ok := in.Parameters.(*GetRegistryCatalogDataInput)
639 _ = input
640 if !ok {
641 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
642 }
643
644 operationPath := "/"
645 if len(request.Request.URL.Path) == 0 {
646 request.Request.URL.Path = operationPath
647 } else {
648 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
649 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
650 request.Request.URL.Path += "/"
651 }
652 }
653 request.Request.Method = "POST"
654 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
655 if err != nil {
656 return out, metadata, &smithy.SerializationError{Err: err}
657 }
658 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
659 httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.GetRegistryCatalogData")
660
661 jsonEncoder := smithyjson.NewEncoder()
662 if err := awsAwsjson11_serializeOpDocumentGetRegistryCatalogDataInput(input, jsonEncoder.Value); err != nil {
663 return out, metadata, &smithy.SerializationError{Err: err}
664 }
665
666 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
667 return out, metadata, &smithy.SerializationError{Err: err}
668 }
669
670 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
671 return out, metadata, &smithy.SerializationError{Err: err}
672 }
673 in.Request = request
674
675 return next.HandleSerialize(ctx, in)
676 }
677
678 type awsAwsjson11_serializeOpGetRepositoryCatalogData struct {
679 }
680
681 func (*awsAwsjson11_serializeOpGetRepositoryCatalogData) ID() string {
682 return "OperationSerializer"
683 }
684
685 func (m *awsAwsjson11_serializeOpGetRepositoryCatalogData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
686 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
687 ) {
688 request, ok := in.Request.(*smithyhttp.Request)
689 if !ok {
690 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
691 }
692
693 input, ok := in.Parameters.(*GetRepositoryCatalogDataInput)
694 _ = input
695 if !ok {
696 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
697 }
698
699 operationPath := "/"
700 if len(request.Request.URL.Path) == 0 {
701 request.Request.URL.Path = operationPath
702 } else {
703 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
704 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
705 request.Request.URL.Path += "/"
706 }
707 }
708 request.Request.Method = "POST"
709 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
710 if err != nil {
711 return out, metadata, &smithy.SerializationError{Err: err}
712 }
713 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
714 httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.GetRepositoryCatalogData")
715
716 jsonEncoder := smithyjson.NewEncoder()
717 if err := awsAwsjson11_serializeOpDocumentGetRepositoryCatalogDataInput(input, jsonEncoder.Value); err != nil {
718 return out, metadata, &smithy.SerializationError{Err: err}
719 }
720
721 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
722 return out, metadata, &smithy.SerializationError{Err: err}
723 }
724
725 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
726 return out, metadata, &smithy.SerializationError{Err: err}
727 }
728 in.Request = request
729
730 return next.HandleSerialize(ctx, in)
731 }
732
733 type awsAwsjson11_serializeOpGetRepositoryPolicy struct {
734 }
735
736 func (*awsAwsjson11_serializeOpGetRepositoryPolicy) ID() string {
737 return "OperationSerializer"
738 }
739
740 func (m *awsAwsjson11_serializeOpGetRepositoryPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
741 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
742 ) {
743 request, ok := in.Request.(*smithyhttp.Request)
744 if !ok {
745 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
746 }
747
748 input, ok := in.Parameters.(*GetRepositoryPolicyInput)
749 _ = input
750 if !ok {
751 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
752 }
753
754 operationPath := "/"
755 if len(request.Request.URL.Path) == 0 {
756 request.Request.URL.Path = operationPath
757 } else {
758 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
759 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
760 request.Request.URL.Path += "/"
761 }
762 }
763 request.Request.Method = "POST"
764 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
765 if err != nil {
766 return out, metadata, &smithy.SerializationError{Err: err}
767 }
768 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
769 httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.GetRepositoryPolicy")
770
771 jsonEncoder := smithyjson.NewEncoder()
772 if err := awsAwsjson11_serializeOpDocumentGetRepositoryPolicyInput(input, jsonEncoder.Value); err != nil {
773 return out, metadata, &smithy.SerializationError{Err: err}
774 }
775
776 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
777 return out, metadata, &smithy.SerializationError{Err: err}
778 }
779
780 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
781 return out, metadata, &smithy.SerializationError{Err: err}
782 }
783 in.Request = request
784
785 return next.HandleSerialize(ctx, in)
786 }
787
788 type awsAwsjson11_serializeOpInitiateLayerUpload struct {
789 }
790
791 func (*awsAwsjson11_serializeOpInitiateLayerUpload) ID() string {
792 return "OperationSerializer"
793 }
794
795 func (m *awsAwsjson11_serializeOpInitiateLayerUpload) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
796 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
797 ) {
798 request, ok := in.Request.(*smithyhttp.Request)
799 if !ok {
800 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
801 }
802
803 input, ok := in.Parameters.(*InitiateLayerUploadInput)
804 _ = input
805 if !ok {
806 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
807 }
808
809 operationPath := "/"
810 if len(request.Request.URL.Path) == 0 {
811 request.Request.URL.Path = operationPath
812 } else {
813 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
814 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
815 request.Request.URL.Path += "/"
816 }
817 }
818 request.Request.Method = "POST"
819 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
820 if err != nil {
821 return out, metadata, &smithy.SerializationError{Err: err}
822 }
823 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
824 httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.InitiateLayerUpload")
825
826 jsonEncoder := smithyjson.NewEncoder()
827 if err := awsAwsjson11_serializeOpDocumentInitiateLayerUploadInput(input, jsonEncoder.Value); err != nil {
828 return out, metadata, &smithy.SerializationError{Err: err}
829 }
830
831 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
832 return out, metadata, &smithy.SerializationError{Err: err}
833 }
834
835 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
836 return out, metadata, &smithy.SerializationError{Err: err}
837 }
838 in.Request = request
839
840 return next.HandleSerialize(ctx, in)
841 }
842
843 type awsAwsjson11_serializeOpListTagsForResource struct {
844 }
845
846 func (*awsAwsjson11_serializeOpListTagsForResource) ID() string {
847 return "OperationSerializer"
848 }
849
850 func (m *awsAwsjson11_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
851 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
852 ) {
853 request, ok := in.Request.(*smithyhttp.Request)
854 if !ok {
855 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
856 }
857
858 input, ok := in.Parameters.(*ListTagsForResourceInput)
859 _ = input
860 if !ok {
861 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
862 }
863
864 operationPath := "/"
865 if len(request.Request.URL.Path) == 0 {
866 request.Request.URL.Path = operationPath
867 } else {
868 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
869 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
870 request.Request.URL.Path += "/"
871 }
872 }
873 request.Request.Method = "POST"
874 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
875 if err != nil {
876 return out, metadata, &smithy.SerializationError{Err: err}
877 }
878 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
879 httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.ListTagsForResource")
880
881 jsonEncoder := smithyjson.NewEncoder()
882 if err := awsAwsjson11_serializeOpDocumentListTagsForResourceInput(input, jsonEncoder.Value); err != nil {
883 return out, metadata, &smithy.SerializationError{Err: err}
884 }
885
886 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
887 return out, metadata, &smithy.SerializationError{Err: err}
888 }
889
890 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
891 return out, metadata, &smithy.SerializationError{Err: err}
892 }
893 in.Request = request
894
895 return next.HandleSerialize(ctx, in)
896 }
897
898 type awsAwsjson11_serializeOpPutImage struct {
899 }
900
901 func (*awsAwsjson11_serializeOpPutImage) ID() string {
902 return "OperationSerializer"
903 }
904
905 func (m *awsAwsjson11_serializeOpPutImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
906 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
907 ) {
908 request, ok := in.Request.(*smithyhttp.Request)
909 if !ok {
910 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
911 }
912
913 input, ok := in.Parameters.(*PutImageInput)
914 _ = input
915 if !ok {
916 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
917 }
918
919 operationPath := "/"
920 if len(request.Request.URL.Path) == 0 {
921 request.Request.URL.Path = operationPath
922 } else {
923 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
924 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
925 request.Request.URL.Path += "/"
926 }
927 }
928 request.Request.Method = "POST"
929 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
930 if err != nil {
931 return out, metadata, &smithy.SerializationError{Err: err}
932 }
933 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
934 httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.PutImage")
935
936 jsonEncoder := smithyjson.NewEncoder()
937 if err := awsAwsjson11_serializeOpDocumentPutImageInput(input, jsonEncoder.Value); err != nil {
938 return out, metadata, &smithy.SerializationError{Err: err}
939 }
940
941 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
942 return out, metadata, &smithy.SerializationError{Err: err}
943 }
944
945 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
946 return out, metadata, &smithy.SerializationError{Err: err}
947 }
948 in.Request = request
949
950 return next.HandleSerialize(ctx, in)
951 }
952
953 type awsAwsjson11_serializeOpPutRegistryCatalogData struct {
954 }
955
956 func (*awsAwsjson11_serializeOpPutRegistryCatalogData) ID() string {
957 return "OperationSerializer"
958 }
959
960 func (m *awsAwsjson11_serializeOpPutRegistryCatalogData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
961 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
962 ) {
963 request, ok := in.Request.(*smithyhttp.Request)
964 if !ok {
965 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
966 }
967
968 input, ok := in.Parameters.(*PutRegistryCatalogDataInput)
969 _ = input
970 if !ok {
971 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
972 }
973
974 operationPath := "/"
975 if len(request.Request.URL.Path) == 0 {
976 request.Request.URL.Path = operationPath
977 } else {
978 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
979 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
980 request.Request.URL.Path += "/"
981 }
982 }
983 request.Request.Method = "POST"
984 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
985 if err != nil {
986 return out, metadata, &smithy.SerializationError{Err: err}
987 }
988 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
989 httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.PutRegistryCatalogData")
990
991 jsonEncoder := smithyjson.NewEncoder()
992 if err := awsAwsjson11_serializeOpDocumentPutRegistryCatalogDataInput(input, jsonEncoder.Value); err != nil {
993 return out, metadata, &smithy.SerializationError{Err: err}
994 }
995
996 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
997 return out, metadata, &smithy.SerializationError{Err: err}
998 }
999
1000 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1001 return out, metadata, &smithy.SerializationError{Err: err}
1002 }
1003 in.Request = request
1004
1005 return next.HandleSerialize(ctx, in)
1006 }
1007
1008 type awsAwsjson11_serializeOpPutRepositoryCatalogData struct {
1009 }
1010
1011 func (*awsAwsjson11_serializeOpPutRepositoryCatalogData) ID() string {
1012 return "OperationSerializer"
1013 }
1014
1015 func (m *awsAwsjson11_serializeOpPutRepositoryCatalogData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1016 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1017 ) {
1018 request, ok := in.Request.(*smithyhttp.Request)
1019 if !ok {
1020 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1021 }
1022
1023 input, ok := in.Parameters.(*PutRepositoryCatalogDataInput)
1024 _ = input
1025 if !ok {
1026 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1027 }
1028
1029 operationPath := "/"
1030 if len(request.Request.URL.Path) == 0 {
1031 request.Request.URL.Path = operationPath
1032 } else {
1033 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1034 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1035 request.Request.URL.Path += "/"
1036 }
1037 }
1038 request.Request.Method = "POST"
1039 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1040 if err != nil {
1041 return out, metadata, &smithy.SerializationError{Err: err}
1042 }
1043 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1044 httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.PutRepositoryCatalogData")
1045
1046 jsonEncoder := smithyjson.NewEncoder()
1047 if err := awsAwsjson11_serializeOpDocumentPutRepositoryCatalogDataInput(input, jsonEncoder.Value); err != nil {
1048 return out, metadata, &smithy.SerializationError{Err: err}
1049 }
1050
1051 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1052 return out, metadata, &smithy.SerializationError{Err: err}
1053 }
1054
1055 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1056 return out, metadata, &smithy.SerializationError{Err: err}
1057 }
1058 in.Request = request
1059
1060 return next.HandleSerialize(ctx, in)
1061 }
1062
1063 type awsAwsjson11_serializeOpSetRepositoryPolicy struct {
1064 }
1065
1066 func (*awsAwsjson11_serializeOpSetRepositoryPolicy) ID() string {
1067 return "OperationSerializer"
1068 }
1069
1070 func (m *awsAwsjson11_serializeOpSetRepositoryPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1071 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1072 ) {
1073 request, ok := in.Request.(*smithyhttp.Request)
1074 if !ok {
1075 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1076 }
1077
1078 input, ok := in.Parameters.(*SetRepositoryPolicyInput)
1079 _ = input
1080 if !ok {
1081 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1082 }
1083
1084 operationPath := "/"
1085 if len(request.Request.URL.Path) == 0 {
1086 request.Request.URL.Path = operationPath
1087 } else {
1088 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1089 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1090 request.Request.URL.Path += "/"
1091 }
1092 }
1093 request.Request.Method = "POST"
1094 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1095 if err != nil {
1096 return out, metadata, &smithy.SerializationError{Err: err}
1097 }
1098 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1099 httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.SetRepositoryPolicy")
1100
1101 jsonEncoder := smithyjson.NewEncoder()
1102 if err := awsAwsjson11_serializeOpDocumentSetRepositoryPolicyInput(input, jsonEncoder.Value); err != nil {
1103 return out, metadata, &smithy.SerializationError{Err: err}
1104 }
1105
1106 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1107 return out, metadata, &smithy.SerializationError{Err: err}
1108 }
1109
1110 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1111 return out, metadata, &smithy.SerializationError{Err: err}
1112 }
1113 in.Request = request
1114
1115 return next.HandleSerialize(ctx, in)
1116 }
1117
1118 type awsAwsjson11_serializeOpTagResource struct {
1119 }
1120
1121 func (*awsAwsjson11_serializeOpTagResource) ID() string {
1122 return "OperationSerializer"
1123 }
1124
1125 func (m *awsAwsjson11_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1126 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1127 ) {
1128 request, ok := in.Request.(*smithyhttp.Request)
1129 if !ok {
1130 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1131 }
1132
1133 input, ok := in.Parameters.(*TagResourceInput)
1134 _ = input
1135 if !ok {
1136 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1137 }
1138
1139 operationPath := "/"
1140 if len(request.Request.URL.Path) == 0 {
1141 request.Request.URL.Path = operationPath
1142 } else {
1143 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1144 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1145 request.Request.URL.Path += "/"
1146 }
1147 }
1148 request.Request.Method = "POST"
1149 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1150 if err != nil {
1151 return out, metadata, &smithy.SerializationError{Err: err}
1152 }
1153 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1154 httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.TagResource")
1155
1156 jsonEncoder := smithyjson.NewEncoder()
1157 if err := awsAwsjson11_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil {
1158 return out, metadata, &smithy.SerializationError{Err: err}
1159 }
1160
1161 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1162 return out, metadata, &smithy.SerializationError{Err: err}
1163 }
1164
1165 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1166 return out, metadata, &smithy.SerializationError{Err: err}
1167 }
1168 in.Request = request
1169
1170 return next.HandleSerialize(ctx, in)
1171 }
1172
1173 type awsAwsjson11_serializeOpUntagResource struct {
1174 }
1175
1176 func (*awsAwsjson11_serializeOpUntagResource) ID() string {
1177 return "OperationSerializer"
1178 }
1179
1180 func (m *awsAwsjson11_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1181 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1182 ) {
1183 request, ok := in.Request.(*smithyhttp.Request)
1184 if !ok {
1185 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1186 }
1187
1188 input, ok := in.Parameters.(*UntagResourceInput)
1189 _ = input
1190 if !ok {
1191 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1192 }
1193
1194 operationPath := "/"
1195 if len(request.Request.URL.Path) == 0 {
1196 request.Request.URL.Path = operationPath
1197 } else {
1198 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1199 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1200 request.Request.URL.Path += "/"
1201 }
1202 }
1203 request.Request.Method = "POST"
1204 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1205 if err != nil {
1206 return out, metadata, &smithy.SerializationError{Err: err}
1207 }
1208 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1209 httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.UntagResource")
1210
1211 jsonEncoder := smithyjson.NewEncoder()
1212 if err := awsAwsjson11_serializeOpDocumentUntagResourceInput(input, jsonEncoder.Value); err != nil {
1213 return out, metadata, &smithy.SerializationError{Err: err}
1214 }
1215
1216 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1217 return out, metadata, &smithy.SerializationError{Err: err}
1218 }
1219
1220 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1221 return out, metadata, &smithy.SerializationError{Err: err}
1222 }
1223 in.Request = request
1224
1225 return next.HandleSerialize(ctx, in)
1226 }
1227
1228 type awsAwsjson11_serializeOpUploadLayerPart struct {
1229 }
1230
1231 func (*awsAwsjson11_serializeOpUploadLayerPart) ID() string {
1232 return "OperationSerializer"
1233 }
1234
1235 func (m *awsAwsjson11_serializeOpUploadLayerPart) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1236 out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1237 ) {
1238 request, ok := in.Request.(*smithyhttp.Request)
1239 if !ok {
1240 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1241 }
1242
1243 input, ok := in.Parameters.(*UploadLayerPartInput)
1244 _ = input
1245 if !ok {
1246 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1247 }
1248
1249 operationPath := "/"
1250 if len(request.Request.URL.Path) == 0 {
1251 request.Request.URL.Path = operationPath
1252 } else {
1253 request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
1254 if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
1255 request.Request.URL.Path += "/"
1256 }
1257 }
1258 request.Request.Method = "POST"
1259 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1260 if err != nil {
1261 return out, metadata, &smithy.SerializationError{Err: err}
1262 }
1263 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1264 httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.UploadLayerPart")
1265
1266 jsonEncoder := smithyjson.NewEncoder()
1267 if err := awsAwsjson11_serializeOpDocumentUploadLayerPartInput(input, jsonEncoder.Value); err != nil {
1268 return out, metadata, &smithy.SerializationError{Err: err}
1269 }
1270
1271 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1272 return out, metadata, &smithy.SerializationError{Err: err}
1273 }
1274
1275 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1276 return out, metadata, &smithy.SerializationError{Err: err}
1277 }
1278 in.Request = request
1279
1280 return next.HandleSerialize(ctx, in)
1281 }
1282 func awsAwsjson11_serializeDocumentArchitectureList(v []string, value smithyjson.Value) error {
1283 array := value.Array()
1284 defer array.Close()
1285
1286 for i := range v {
1287 av := array.Value()
1288 av.String(v[i])
1289 }
1290 return nil
1291 }
1292
1293 func awsAwsjson11_serializeDocumentBatchedOperationLayerDigestList(v []string, value smithyjson.Value) error {
1294 array := value.Array()
1295 defer array.Close()
1296
1297 for i := range v {
1298 av := array.Value()
1299 av.String(v[i])
1300 }
1301 return nil
1302 }
1303
1304 func awsAwsjson11_serializeDocumentImageIdentifier(v *types.ImageIdentifier, value smithyjson.Value) error {
1305 object := value.Object()
1306 defer object.Close()
1307
1308 if v.ImageDigest != nil {
1309 ok := object.Key("imageDigest")
1310 ok.String(*v.ImageDigest)
1311 }
1312
1313 if v.ImageTag != nil {
1314 ok := object.Key("imageTag")
1315 ok.String(*v.ImageTag)
1316 }
1317
1318 return nil
1319 }
1320
1321 func awsAwsjson11_serializeDocumentImageIdentifierList(v []types.ImageIdentifier, value smithyjson.Value) error {
1322 array := value.Array()
1323 defer array.Close()
1324
1325 for i := range v {
1326 av := array.Value()
1327 if err := awsAwsjson11_serializeDocumentImageIdentifier(&v[i], av); err != nil {
1328 return err
1329 }
1330 }
1331 return nil
1332 }
1333
1334 func awsAwsjson11_serializeDocumentLayerDigestList(v []string, value smithyjson.Value) error {
1335 array := value.Array()
1336 defer array.Close()
1337
1338 for i := range v {
1339 av := array.Value()
1340 av.String(v[i])
1341 }
1342 return nil
1343 }
1344
1345 func awsAwsjson11_serializeDocumentOperatingSystemList(v []string, value smithyjson.Value) error {
1346 array := value.Array()
1347 defer array.Close()
1348
1349 for i := range v {
1350 av := array.Value()
1351 av.String(v[i])
1352 }
1353 return nil
1354 }
1355
1356 func awsAwsjson11_serializeDocumentRepositoryCatalogDataInput(v *types.RepositoryCatalogDataInput, value smithyjson.Value) error {
1357 object := value.Object()
1358 defer object.Close()
1359
1360 if v.AboutText != nil {
1361 ok := object.Key("aboutText")
1362 ok.String(*v.AboutText)
1363 }
1364
1365 if v.Architectures != nil {
1366 ok := object.Key("architectures")
1367 if err := awsAwsjson11_serializeDocumentArchitectureList(v.Architectures, ok); err != nil {
1368 return err
1369 }
1370 }
1371
1372 if v.Description != nil {
1373 ok := object.Key("description")
1374 ok.String(*v.Description)
1375 }
1376
1377 if v.LogoImageBlob != nil {
1378 ok := object.Key("logoImageBlob")
1379 ok.Base64EncodeBytes(v.LogoImageBlob)
1380 }
1381
1382 if v.OperatingSystems != nil {
1383 ok := object.Key("operatingSystems")
1384 if err := awsAwsjson11_serializeDocumentOperatingSystemList(v.OperatingSystems, ok); err != nil {
1385 return err
1386 }
1387 }
1388
1389 if v.UsageText != nil {
1390 ok := object.Key("usageText")
1391 ok.String(*v.UsageText)
1392 }
1393
1394 return nil
1395 }
1396
1397 func awsAwsjson11_serializeDocumentRepositoryNameList(v []string, value smithyjson.Value) error {
1398 array := value.Array()
1399 defer array.Close()
1400
1401 for i := range v {
1402 av := array.Value()
1403 av.String(v[i])
1404 }
1405 return nil
1406 }
1407
1408 func awsAwsjson11_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error {
1409 object := value.Object()
1410 defer object.Close()
1411
1412 if v.Key != nil {
1413 ok := object.Key("Key")
1414 ok.String(*v.Key)
1415 }
1416
1417 if v.Value != nil {
1418 ok := object.Key("Value")
1419 ok.String(*v.Value)
1420 }
1421
1422 return nil
1423 }
1424
1425 func awsAwsjson11_serializeDocumentTagKeyList(v []string, value smithyjson.Value) error {
1426 array := value.Array()
1427 defer array.Close()
1428
1429 for i := range v {
1430 av := array.Value()
1431 av.String(v[i])
1432 }
1433 return nil
1434 }
1435
1436 func awsAwsjson11_serializeDocumentTagList(v []types.Tag, value smithyjson.Value) error {
1437 array := value.Array()
1438 defer array.Close()
1439
1440 for i := range v {
1441 av := array.Value()
1442 if err := awsAwsjson11_serializeDocumentTag(&v[i], av); err != nil {
1443 return err
1444 }
1445 }
1446 return nil
1447 }
1448
1449 func awsAwsjson11_serializeOpDocumentBatchCheckLayerAvailabilityInput(v *BatchCheckLayerAvailabilityInput, value smithyjson.Value) error {
1450 object := value.Object()
1451 defer object.Close()
1452
1453 if v.LayerDigests != nil {
1454 ok := object.Key("layerDigests")
1455 if err := awsAwsjson11_serializeDocumentBatchedOperationLayerDigestList(v.LayerDigests, ok); err != nil {
1456 return err
1457 }
1458 }
1459
1460 if v.RegistryId != nil {
1461 ok := object.Key("registryId")
1462 ok.String(*v.RegistryId)
1463 }
1464
1465 if v.RepositoryName != nil {
1466 ok := object.Key("repositoryName")
1467 ok.String(*v.RepositoryName)
1468 }
1469
1470 return nil
1471 }
1472
1473 func awsAwsjson11_serializeOpDocumentBatchDeleteImageInput(v *BatchDeleteImageInput, value smithyjson.Value) error {
1474 object := value.Object()
1475 defer object.Close()
1476
1477 if v.ImageIds != nil {
1478 ok := object.Key("imageIds")
1479 if err := awsAwsjson11_serializeDocumentImageIdentifierList(v.ImageIds, ok); err != nil {
1480 return err
1481 }
1482 }
1483
1484 if v.RegistryId != nil {
1485 ok := object.Key("registryId")
1486 ok.String(*v.RegistryId)
1487 }
1488
1489 if v.RepositoryName != nil {
1490 ok := object.Key("repositoryName")
1491 ok.String(*v.RepositoryName)
1492 }
1493
1494 return nil
1495 }
1496
1497 func awsAwsjson11_serializeOpDocumentCompleteLayerUploadInput(v *CompleteLayerUploadInput, value smithyjson.Value) error {
1498 object := value.Object()
1499 defer object.Close()
1500
1501 if v.LayerDigests != nil {
1502 ok := object.Key("layerDigests")
1503 if err := awsAwsjson11_serializeDocumentLayerDigestList(v.LayerDigests, ok); err != nil {
1504 return err
1505 }
1506 }
1507
1508 if v.RegistryId != nil {
1509 ok := object.Key("registryId")
1510 ok.String(*v.RegistryId)
1511 }
1512
1513 if v.RepositoryName != nil {
1514 ok := object.Key("repositoryName")
1515 ok.String(*v.RepositoryName)
1516 }
1517
1518 if v.UploadId != nil {
1519 ok := object.Key("uploadId")
1520 ok.String(*v.UploadId)
1521 }
1522
1523 return nil
1524 }
1525
1526 func awsAwsjson11_serializeOpDocumentCreateRepositoryInput(v *CreateRepositoryInput, value smithyjson.Value) error {
1527 object := value.Object()
1528 defer object.Close()
1529
1530 if v.CatalogData != nil {
1531 ok := object.Key("catalogData")
1532 if err := awsAwsjson11_serializeDocumentRepositoryCatalogDataInput(v.CatalogData, ok); err != nil {
1533 return err
1534 }
1535 }
1536
1537 if v.RepositoryName != nil {
1538 ok := object.Key("repositoryName")
1539 ok.String(*v.RepositoryName)
1540 }
1541
1542 if v.Tags != nil {
1543 ok := object.Key("tags")
1544 if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
1545 return err
1546 }
1547 }
1548
1549 return nil
1550 }
1551
1552 func awsAwsjson11_serializeOpDocumentDeleteRepositoryInput(v *DeleteRepositoryInput, value smithyjson.Value) error {
1553 object := value.Object()
1554 defer object.Close()
1555
1556 if v.Force {
1557 ok := object.Key("force")
1558 ok.Boolean(v.Force)
1559 }
1560
1561 if v.RegistryId != nil {
1562 ok := object.Key("registryId")
1563 ok.String(*v.RegistryId)
1564 }
1565
1566 if v.RepositoryName != nil {
1567 ok := object.Key("repositoryName")
1568 ok.String(*v.RepositoryName)
1569 }
1570
1571 return nil
1572 }
1573
1574 func awsAwsjson11_serializeOpDocumentDeleteRepositoryPolicyInput(v *DeleteRepositoryPolicyInput, value smithyjson.Value) error {
1575 object := value.Object()
1576 defer object.Close()
1577
1578 if v.RegistryId != nil {
1579 ok := object.Key("registryId")
1580 ok.String(*v.RegistryId)
1581 }
1582
1583 if v.RepositoryName != nil {
1584 ok := object.Key("repositoryName")
1585 ok.String(*v.RepositoryName)
1586 }
1587
1588 return nil
1589 }
1590
1591 func awsAwsjson11_serializeOpDocumentDescribeImagesInput(v *DescribeImagesInput, value smithyjson.Value) error {
1592 object := value.Object()
1593 defer object.Close()
1594
1595 if v.ImageIds != nil {
1596 ok := object.Key("imageIds")
1597 if err := awsAwsjson11_serializeDocumentImageIdentifierList(v.ImageIds, ok); err != nil {
1598 return err
1599 }
1600 }
1601
1602 if v.MaxResults != nil {
1603 ok := object.Key("maxResults")
1604 ok.Integer(*v.MaxResults)
1605 }
1606
1607 if v.NextToken != nil {
1608 ok := object.Key("nextToken")
1609 ok.String(*v.NextToken)
1610 }
1611
1612 if v.RegistryId != nil {
1613 ok := object.Key("registryId")
1614 ok.String(*v.RegistryId)
1615 }
1616
1617 if v.RepositoryName != nil {
1618 ok := object.Key("repositoryName")
1619 ok.String(*v.RepositoryName)
1620 }
1621
1622 return nil
1623 }
1624
1625 func awsAwsjson11_serializeOpDocumentDescribeImageTagsInput(v *DescribeImageTagsInput, value smithyjson.Value) error {
1626 object := value.Object()
1627 defer object.Close()
1628
1629 if v.MaxResults != nil {
1630 ok := object.Key("maxResults")
1631 ok.Integer(*v.MaxResults)
1632 }
1633
1634 if v.NextToken != nil {
1635 ok := object.Key("nextToken")
1636 ok.String(*v.NextToken)
1637 }
1638
1639 if v.RegistryId != nil {
1640 ok := object.Key("registryId")
1641 ok.String(*v.RegistryId)
1642 }
1643
1644 if v.RepositoryName != nil {
1645 ok := object.Key("repositoryName")
1646 ok.String(*v.RepositoryName)
1647 }
1648
1649 return nil
1650 }
1651
1652 func awsAwsjson11_serializeOpDocumentDescribeRegistriesInput(v *DescribeRegistriesInput, value smithyjson.Value) error {
1653 object := value.Object()
1654 defer object.Close()
1655
1656 if v.MaxResults != nil {
1657 ok := object.Key("maxResults")
1658 ok.Integer(*v.MaxResults)
1659 }
1660
1661 if v.NextToken != nil {
1662 ok := object.Key("nextToken")
1663 ok.String(*v.NextToken)
1664 }
1665
1666 return nil
1667 }
1668
1669 func awsAwsjson11_serializeOpDocumentDescribeRepositoriesInput(v *DescribeRepositoriesInput, value smithyjson.Value) error {
1670 object := value.Object()
1671 defer object.Close()
1672
1673 if v.MaxResults != nil {
1674 ok := object.Key("maxResults")
1675 ok.Integer(*v.MaxResults)
1676 }
1677
1678 if v.NextToken != nil {
1679 ok := object.Key("nextToken")
1680 ok.String(*v.NextToken)
1681 }
1682
1683 if v.RegistryId != nil {
1684 ok := object.Key("registryId")
1685 ok.String(*v.RegistryId)
1686 }
1687
1688 if v.RepositoryNames != nil {
1689 ok := object.Key("repositoryNames")
1690 if err := awsAwsjson11_serializeDocumentRepositoryNameList(v.RepositoryNames, ok); err != nil {
1691 return err
1692 }
1693 }
1694
1695 return nil
1696 }
1697
1698 func awsAwsjson11_serializeOpDocumentGetAuthorizationTokenInput(v *GetAuthorizationTokenInput, value smithyjson.Value) error {
1699 object := value.Object()
1700 defer object.Close()
1701
1702 return nil
1703 }
1704
1705 func awsAwsjson11_serializeOpDocumentGetRegistryCatalogDataInput(v *GetRegistryCatalogDataInput, value smithyjson.Value) error {
1706 object := value.Object()
1707 defer object.Close()
1708
1709 return nil
1710 }
1711
1712 func awsAwsjson11_serializeOpDocumentGetRepositoryCatalogDataInput(v *GetRepositoryCatalogDataInput, value smithyjson.Value) error {
1713 object := value.Object()
1714 defer object.Close()
1715
1716 if v.RegistryId != nil {
1717 ok := object.Key("registryId")
1718 ok.String(*v.RegistryId)
1719 }
1720
1721 if v.RepositoryName != nil {
1722 ok := object.Key("repositoryName")
1723 ok.String(*v.RepositoryName)
1724 }
1725
1726 return nil
1727 }
1728
1729 func awsAwsjson11_serializeOpDocumentGetRepositoryPolicyInput(v *GetRepositoryPolicyInput, value smithyjson.Value) error {
1730 object := value.Object()
1731 defer object.Close()
1732
1733 if v.RegistryId != nil {
1734 ok := object.Key("registryId")
1735 ok.String(*v.RegistryId)
1736 }
1737
1738 if v.RepositoryName != nil {
1739 ok := object.Key("repositoryName")
1740 ok.String(*v.RepositoryName)
1741 }
1742
1743 return nil
1744 }
1745
1746 func awsAwsjson11_serializeOpDocumentInitiateLayerUploadInput(v *InitiateLayerUploadInput, value smithyjson.Value) error {
1747 object := value.Object()
1748 defer object.Close()
1749
1750 if v.RegistryId != nil {
1751 ok := object.Key("registryId")
1752 ok.String(*v.RegistryId)
1753 }
1754
1755 if v.RepositoryName != nil {
1756 ok := object.Key("repositoryName")
1757 ok.String(*v.RepositoryName)
1758 }
1759
1760 return nil
1761 }
1762
1763 func awsAwsjson11_serializeOpDocumentListTagsForResourceInput(v *ListTagsForResourceInput, value smithyjson.Value) error {
1764 object := value.Object()
1765 defer object.Close()
1766
1767 if v.ResourceArn != nil {
1768 ok := object.Key("resourceArn")
1769 ok.String(*v.ResourceArn)
1770 }
1771
1772 return nil
1773 }
1774
1775 func awsAwsjson11_serializeOpDocumentPutImageInput(v *PutImageInput, value smithyjson.Value) error {
1776 object := value.Object()
1777 defer object.Close()
1778
1779 if v.ImageDigest != nil {
1780 ok := object.Key("imageDigest")
1781 ok.String(*v.ImageDigest)
1782 }
1783
1784 if v.ImageManifest != nil {
1785 ok := object.Key("imageManifest")
1786 ok.String(*v.ImageManifest)
1787 }
1788
1789 if v.ImageManifestMediaType != nil {
1790 ok := object.Key("imageManifestMediaType")
1791 ok.String(*v.ImageManifestMediaType)
1792 }
1793
1794 if v.ImageTag != nil {
1795 ok := object.Key("imageTag")
1796 ok.String(*v.ImageTag)
1797 }
1798
1799 if v.RegistryId != nil {
1800 ok := object.Key("registryId")
1801 ok.String(*v.RegistryId)
1802 }
1803
1804 if v.RepositoryName != nil {
1805 ok := object.Key("repositoryName")
1806 ok.String(*v.RepositoryName)
1807 }
1808
1809 return nil
1810 }
1811
1812 func awsAwsjson11_serializeOpDocumentPutRegistryCatalogDataInput(v *PutRegistryCatalogDataInput, value smithyjson.Value) error {
1813 object := value.Object()
1814 defer object.Close()
1815
1816 if v.DisplayName != nil {
1817 ok := object.Key("displayName")
1818 ok.String(*v.DisplayName)
1819 }
1820
1821 return nil
1822 }
1823
1824 func awsAwsjson11_serializeOpDocumentPutRepositoryCatalogDataInput(v *PutRepositoryCatalogDataInput, value smithyjson.Value) error {
1825 object := value.Object()
1826 defer object.Close()
1827
1828 if v.CatalogData != nil {
1829 ok := object.Key("catalogData")
1830 if err := awsAwsjson11_serializeDocumentRepositoryCatalogDataInput(v.CatalogData, ok); err != nil {
1831 return err
1832 }
1833 }
1834
1835 if v.RegistryId != nil {
1836 ok := object.Key("registryId")
1837 ok.String(*v.RegistryId)
1838 }
1839
1840 if v.RepositoryName != nil {
1841 ok := object.Key("repositoryName")
1842 ok.String(*v.RepositoryName)
1843 }
1844
1845 return nil
1846 }
1847
1848 func awsAwsjson11_serializeOpDocumentSetRepositoryPolicyInput(v *SetRepositoryPolicyInput, value smithyjson.Value) error {
1849 object := value.Object()
1850 defer object.Close()
1851
1852 if v.Force {
1853 ok := object.Key("force")
1854 ok.Boolean(v.Force)
1855 }
1856
1857 if v.PolicyText != nil {
1858 ok := object.Key("policyText")
1859 ok.String(*v.PolicyText)
1860 }
1861
1862 if v.RegistryId != nil {
1863 ok := object.Key("registryId")
1864 ok.String(*v.RegistryId)
1865 }
1866
1867 if v.RepositoryName != nil {
1868 ok := object.Key("repositoryName")
1869 ok.String(*v.RepositoryName)
1870 }
1871
1872 return nil
1873 }
1874
1875 func awsAwsjson11_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
1876 object := value.Object()
1877 defer object.Close()
1878
1879 if v.ResourceArn != nil {
1880 ok := object.Key("resourceArn")
1881 ok.String(*v.ResourceArn)
1882 }
1883
1884 if v.Tags != nil {
1885 ok := object.Key("tags")
1886 if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
1887 return err
1888 }
1889 }
1890
1891 return nil
1892 }
1893
1894 func awsAwsjson11_serializeOpDocumentUntagResourceInput(v *UntagResourceInput, value smithyjson.Value) error {
1895 object := value.Object()
1896 defer object.Close()
1897
1898 if v.ResourceArn != nil {
1899 ok := object.Key("resourceArn")
1900 ok.String(*v.ResourceArn)
1901 }
1902
1903 if v.TagKeys != nil {
1904 ok := object.Key("tagKeys")
1905 if err := awsAwsjson11_serializeDocumentTagKeyList(v.TagKeys, ok); err != nil {
1906 return err
1907 }
1908 }
1909
1910 return nil
1911 }
1912
1913 func awsAwsjson11_serializeOpDocumentUploadLayerPartInput(v *UploadLayerPartInput, value smithyjson.Value) error {
1914 object := value.Object()
1915 defer object.Close()
1916
1917 if v.LayerPartBlob != nil {
1918 ok := object.Key("layerPartBlob")
1919 ok.Base64EncodeBytes(v.LayerPartBlob)
1920 }
1921
1922 if v.PartFirstByte != nil {
1923 ok := object.Key("partFirstByte")
1924 ok.Long(*v.PartFirstByte)
1925 }
1926
1927 if v.PartLastByte != nil {
1928 ok := object.Key("partLastByte")
1929 ok.Long(*v.PartLastByte)
1930 }
1931
1932 if v.RegistryId != nil {
1933 ok := object.Key("registryId")
1934 ok.String(*v.RegistryId)
1935 }
1936
1937 if v.RepositoryName != nil {
1938 ok := object.Key("repositoryName")
1939 ok.String(*v.RepositoryName)
1940 }
1941
1942 if v.UploadId != nil {
1943 ok := object.Key("uploadId")
1944 ok.String(*v.UploadId)
1945 }
1946
1947 return nil
1948 }
1949
View as plain text