1949 lines
61 KiB
Go
1949 lines
61 KiB
Go
// Code generated by smithy-go-codegen DO NOT EDIT.
|
|
|
|
package ecrpublic
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"github.com/aws/aws-sdk-go-v2/service/ecrpublic/types"
|
|
smithy "github.com/aws/smithy-go"
|
|
"github.com/aws/smithy-go/encoding/httpbinding"
|
|
smithyjson "github.com/aws/smithy-go/encoding/json"
|
|
"github.com/aws/smithy-go/middleware"
|
|
smithyhttp "github.com/aws/smithy-go/transport/http"
|
|
"path"
|
|
)
|
|
|
|
type awsAwsjson11_serializeOpBatchCheckLayerAvailability struct {
|
|
}
|
|
|
|
func (*awsAwsjson11_serializeOpBatchCheckLayerAvailability) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson11_serializeOpBatchCheckLayerAvailability) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*BatchCheckLayerAvailabilityInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
operationPath := "/"
|
|
if len(request.Request.URL.Path) == 0 {
|
|
request.Request.URL.Path = operationPath
|
|
} else {
|
|
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
|
|
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
|
|
request.Request.URL.Path += "/"
|
|
}
|
|
}
|
|
request.Request.Method = "POST"
|
|
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.BatchCheckLayerAvailability")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson11_serializeOpDocumentBatchCheckLayerAvailabilityInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson11_serializeOpBatchDeleteImage struct {
|
|
}
|
|
|
|
func (*awsAwsjson11_serializeOpBatchDeleteImage) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson11_serializeOpBatchDeleteImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*BatchDeleteImageInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
operationPath := "/"
|
|
if len(request.Request.URL.Path) == 0 {
|
|
request.Request.URL.Path = operationPath
|
|
} else {
|
|
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
|
|
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
|
|
request.Request.URL.Path += "/"
|
|
}
|
|
}
|
|
request.Request.Method = "POST"
|
|
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.BatchDeleteImage")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson11_serializeOpDocumentBatchDeleteImageInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson11_serializeOpCompleteLayerUpload struct {
|
|
}
|
|
|
|
func (*awsAwsjson11_serializeOpCompleteLayerUpload) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson11_serializeOpCompleteLayerUpload) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*CompleteLayerUploadInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
operationPath := "/"
|
|
if len(request.Request.URL.Path) == 0 {
|
|
request.Request.URL.Path = operationPath
|
|
} else {
|
|
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
|
|
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
|
|
request.Request.URL.Path += "/"
|
|
}
|
|
}
|
|
request.Request.Method = "POST"
|
|
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.CompleteLayerUpload")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson11_serializeOpDocumentCompleteLayerUploadInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson11_serializeOpCreateRepository struct {
|
|
}
|
|
|
|
func (*awsAwsjson11_serializeOpCreateRepository) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson11_serializeOpCreateRepository) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*CreateRepositoryInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
operationPath := "/"
|
|
if len(request.Request.URL.Path) == 0 {
|
|
request.Request.URL.Path = operationPath
|
|
} else {
|
|
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
|
|
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
|
|
request.Request.URL.Path += "/"
|
|
}
|
|
}
|
|
request.Request.Method = "POST"
|
|
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.CreateRepository")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson11_serializeOpDocumentCreateRepositoryInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson11_serializeOpDeleteRepository struct {
|
|
}
|
|
|
|
func (*awsAwsjson11_serializeOpDeleteRepository) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson11_serializeOpDeleteRepository) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*DeleteRepositoryInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
operationPath := "/"
|
|
if len(request.Request.URL.Path) == 0 {
|
|
request.Request.URL.Path = operationPath
|
|
} else {
|
|
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
|
|
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
|
|
request.Request.URL.Path += "/"
|
|
}
|
|
}
|
|
request.Request.Method = "POST"
|
|
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.DeleteRepository")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson11_serializeOpDocumentDeleteRepositoryInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson11_serializeOpDeleteRepositoryPolicy struct {
|
|
}
|
|
|
|
func (*awsAwsjson11_serializeOpDeleteRepositoryPolicy) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson11_serializeOpDeleteRepositoryPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*DeleteRepositoryPolicyInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
operationPath := "/"
|
|
if len(request.Request.URL.Path) == 0 {
|
|
request.Request.URL.Path = operationPath
|
|
} else {
|
|
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
|
|
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
|
|
request.Request.URL.Path += "/"
|
|
}
|
|
}
|
|
request.Request.Method = "POST"
|
|
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.DeleteRepositoryPolicy")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson11_serializeOpDocumentDeleteRepositoryPolicyInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson11_serializeOpDescribeImages struct {
|
|
}
|
|
|
|
func (*awsAwsjson11_serializeOpDescribeImages) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson11_serializeOpDescribeImages) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*DescribeImagesInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
operationPath := "/"
|
|
if len(request.Request.URL.Path) == 0 {
|
|
request.Request.URL.Path = operationPath
|
|
} else {
|
|
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
|
|
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
|
|
request.Request.URL.Path += "/"
|
|
}
|
|
}
|
|
request.Request.Method = "POST"
|
|
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.DescribeImages")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson11_serializeOpDocumentDescribeImagesInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson11_serializeOpDescribeImageTags struct {
|
|
}
|
|
|
|
func (*awsAwsjson11_serializeOpDescribeImageTags) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson11_serializeOpDescribeImageTags) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*DescribeImageTagsInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
operationPath := "/"
|
|
if len(request.Request.URL.Path) == 0 {
|
|
request.Request.URL.Path = operationPath
|
|
} else {
|
|
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
|
|
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
|
|
request.Request.URL.Path += "/"
|
|
}
|
|
}
|
|
request.Request.Method = "POST"
|
|
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.DescribeImageTags")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson11_serializeOpDocumentDescribeImageTagsInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson11_serializeOpDescribeRegistries struct {
|
|
}
|
|
|
|
func (*awsAwsjson11_serializeOpDescribeRegistries) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson11_serializeOpDescribeRegistries) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*DescribeRegistriesInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
operationPath := "/"
|
|
if len(request.Request.URL.Path) == 0 {
|
|
request.Request.URL.Path = operationPath
|
|
} else {
|
|
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
|
|
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
|
|
request.Request.URL.Path += "/"
|
|
}
|
|
}
|
|
request.Request.Method = "POST"
|
|
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.DescribeRegistries")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson11_serializeOpDocumentDescribeRegistriesInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson11_serializeOpDescribeRepositories struct {
|
|
}
|
|
|
|
func (*awsAwsjson11_serializeOpDescribeRepositories) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson11_serializeOpDescribeRepositories) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*DescribeRepositoriesInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
operationPath := "/"
|
|
if len(request.Request.URL.Path) == 0 {
|
|
request.Request.URL.Path = operationPath
|
|
} else {
|
|
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
|
|
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
|
|
request.Request.URL.Path += "/"
|
|
}
|
|
}
|
|
request.Request.Method = "POST"
|
|
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.DescribeRepositories")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson11_serializeOpDocumentDescribeRepositoriesInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson11_serializeOpGetAuthorizationToken struct {
|
|
}
|
|
|
|
func (*awsAwsjson11_serializeOpGetAuthorizationToken) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson11_serializeOpGetAuthorizationToken) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*GetAuthorizationTokenInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
operationPath := "/"
|
|
if len(request.Request.URL.Path) == 0 {
|
|
request.Request.URL.Path = operationPath
|
|
} else {
|
|
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
|
|
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
|
|
request.Request.URL.Path += "/"
|
|
}
|
|
}
|
|
request.Request.Method = "POST"
|
|
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.GetAuthorizationToken")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson11_serializeOpDocumentGetAuthorizationTokenInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson11_serializeOpGetRegistryCatalogData struct {
|
|
}
|
|
|
|
func (*awsAwsjson11_serializeOpGetRegistryCatalogData) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson11_serializeOpGetRegistryCatalogData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*GetRegistryCatalogDataInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
operationPath := "/"
|
|
if len(request.Request.URL.Path) == 0 {
|
|
request.Request.URL.Path = operationPath
|
|
} else {
|
|
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
|
|
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
|
|
request.Request.URL.Path += "/"
|
|
}
|
|
}
|
|
request.Request.Method = "POST"
|
|
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.GetRegistryCatalogData")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson11_serializeOpDocumentGetRegistryCatalogDataInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson11_serializeOpGetRepositoryCatalogData struct {
|
|
}
|
|
|
|
func (*awsAwsjson11_serializeOpGetRepositoryCatalogData) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson11_serializeOpGetRepositoryCatalogData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*GetRepositoryCatalogDataInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
operationPath := "/"
|
|
if len(request.Request.URL.Path) == 0 {
|
|
request.Request.URL.Path = operationPath
|
|
} else {
|
|
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
|
|
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
|
|
request.Request.URL.Path += "/"
|
|
}
|
|
}
|
|
request.Request.Method = "POST"
|
|
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.GetRepositoryCatalogData")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson11_serializeOpDocumentGetRepositoryCatalogDataInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson11_serializeOpGetRepositoryPolicy struct {
|
|
}
|
|
|
|
func (*awsAwsjson11_serializeOpGetRepositoryPolicy) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson11_serializeOpGetRepositoryPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*GetRepositoryPolicyInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
operationPath := "/"
|
|
if len(request.Request.URL.Path) == 0 {
|
|
request.Request.URL.Path = operationPath
|
|
} else {
|
|
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
|
|
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
|
|
request.Request.URL.Path += "/"
|
|
}
|
|
}
|
|
request.Request.Method = "POST"
|
|
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.GetRepositoryPolicy")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson11_serializeOpDocumentGetRepositoryPolicyInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson11_serializeOpInitiateLayerUpload struct {
|
|
}
|
|
|
|
func (*awsAwsjson11_serializeOpInitiateLayerUpload) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson11_serializeOpInitiateLayerUpload) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*InitiateLayerUploadInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
operationPath := "/"
|
|
if len(request.Request.URL.Path) == 0 {
|
|
request.Request.URL.Path = operationPath
|
|
} else {
|
|
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
|
|
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
|
|
request.Request.URL.Path += "/"
|
|
}
|
|
}
|
|
request.Request.Method = "POST"
|
|
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.InitiateLayerUpload")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson11_serializeOpDocumentInitiateLayerUploadInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson11_serializeOpListTagsForResource struct {
|
|
}
|
|
|
|
func (*awsAwsjson11_serializeOpListTagsForResource) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson11_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*ListTagsForResourceInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
operationPath := "/"
|
|
if len(request.Request.URL.Path) == 0 {
|
|
request.Request.URL.Path = operationPath
|
|
} else {
|
|
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
|
|
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
|
|
request.Request.URL.Path += "/"
|
|
}
|
|
}
|
|
request.Request.Method = "POST"
|
|
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.ListTagsForResource")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson11_serializeOpDocumentListTagsForResourceInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson11_serializeOpPutImage struct {
|
|
}
|
|
|
|
func (*awsAwsjson11_serializeOpPutImage) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson11_serializeOpPutImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*PutImageInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
operationPath := "/"
|
|
if len(request.Request.URL.Path) == 0 {
|
|
request.Request.URL.Path = operationPath
|
|
} else {
|
|
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
|
|
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
|
|
request.Request.URL.Path += "/"
|
|
}
|
|
}
|
|
request.Request.Method = "POST"
|
|
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.PutImage")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson11_serializeOpDocumentPutImageInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson11_serializeOpPutRegistryCatalogData struct {
|
|
}
|
|
|
|
func (*awsAwsjson11_serializeOpPutRegistryCatalogData) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson11_serializeOpPutRegistryCatalogData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*PutRegistryCatalogDataInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
operationPath := "/"
|
|
if len(request.Request.URL.Path) == 0 {
|
|
request.Request.URL.Path = operationPath
|
|
} else {
|
|
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
|
|
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
|
|
request.Request.URL.Path += "/"
|
|
}
|
|
}
|
|
request.Request.Method = "POST"
|
|
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.PutRegistryCatalogData")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson11_serializeOpDocumentPutRegistryCatalogDataInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson11_serializeOpPutRepositoryCatalogData struct {
|
|
}
|
|
|
|
func (*awsAwsjson11_serializeOpPutRepositoryCatalogData) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson11_serializeOpPutRepositoryCatalogData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*PutRepositoryCatalogDataInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
operationPath := "/"
|
|
if len(request.Request.URL.Path) == 0 {
|
|
request.Request.URL.Path = operationPath
|
|
} else {
|
|
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
|
|
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
|
|
request.Request.URL.Path += "/"
|
|
}
|
|
}
|
|
request.Request.Method = "POST"
|
|
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.PutRepositoryCatalogData")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson11_serializeOpDocumentPutRepositoryCatalogDataInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson11_serializeOpSetRepositoryPolicy struct {
|
|
}
|
|
|
|
func (*awsAwsjson11_serializeOpSetRepositoryPolicy) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson11_serializeOpSetRepositoryPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*SetRepositoryPolicyInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
operationPath := "/"
|
|
if len(request.Request.URL.Path) == 0 {
|
|
request.Request.URL.Path = operationPath
|
|
} else {
|
|
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
|
|
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
|
|
request.Request.URL.Path += "/"
|
|
}
|
|
}
|
|
request.Request.Method = "POST"
|
|
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.SetRepositoryPolicy")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson11_serializeOpDocumentSetRepositoryPolicyInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson11_serializeOpTagResource struct {
|
|
}
|
|
|
|
func (*awsAwsjson11_serializeOpTagResource) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson11_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*TagResourceInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
operationPath := "/"
|
|
if len(request.Request.URL.Path) == 0 {
|
|
request.Request.URL.Path = operationPath
|
|
} else {
|
|
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
|
|
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
|
|
request.Request.URL.Path += "/"
|
|
}
|
|
}
|
|
request.Request.Method = "POST"
|
|
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.TagResource")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson11_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson11_serializeOpUntagResource struct {
|
|
}
|
|
|
|
func (*awsAwsjson11_serializeOpUntagResource) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson11_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*UntagResourceInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
operationPath := "/"
|
|
if len(request.Request.URL.Path) == 0 {
|
|
request.Request.URL.Path = operationPath
|
|
} else {
|
|
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
|
|
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
|
|
request.Request.URL.Path += "/"
|
|
}
|
|
}
|
|
request.Request.Method = "POST"
|
|
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.UntagResource")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson11_serializeOpDocumentUntagResourceInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson11_serializeOpUploadLayerPart struct {
|
|
}
|
|
|
|
func (*awsAwsjson11_serializeOpUploadLayerPart) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson11_serializeOpUploadLayerPart) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*UploadLayerPartInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
operationPath := "/"
|
|
if len(request.Request.URL.Path) == 0 {
|
|
request.Request.URL.Path = operationPath
|
|
} else {
|
|
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
|
|
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
|
|
request.Request.URL.Path += "/"
|
|
}
|
|
}
|
|
request.Request.Method = "POST"
|
|
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("SpencerFrontendService.UploadLayerPart")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson11_serializeOpDocumentUploadLayerPartInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
func awsAwsjson11_serializeDocumentArchitectureList(v []string, value smithyjson.Value) error {
|
|
array := value.Array()
|
|
defer array.Close()
|
|
|
|
for i := range v {
|
|
av := array.Value()
|
|
av.String(v[i])
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeDocumentBatchedOperationLayerDigestList(v []string, value smithyjson.Value) error {
|
|
array := value.Array()
|
|
defer array.Close()
|
|
|
|
for i := range v {
|
|
av := array.Value()
|
|
av.String(v[i])
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeDocumentImageIdentifier(v *types.ImageIdentifier, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.ImageDigest != nil {
|
|
ok := object.Key("imageDigest")
|
|
ok.String(*v.ImageDigest)
|
|
}
|
|
|
|
if v.ImageTag != nil {
|
|
ok := object.Key("imageTag")
|
|
ok.String(*v.ImageTag)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeDocumentImageIdentifierList(v []types.ImageIdentifier, value smithyjson.Value) error {
|
|
array := value.Array()
|
|
defer array.Close()
|
|
|
|
for i := range v {
|
|
av := array.Value()
|
|
if err := awsAwsjson11_serializeDocumentImageIdentifier(&v[i], av); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeDocumentLayerDigestList(v []string, value smithyjson.Value) error {
|
|
array := value.Array()
|
|
defer array.Close()
|
|
|
|
for i := range v {
|
|
av := array.Value()
|
|
av.String(v[i])
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeDocumentOperatingSystemList(v []string, value smithyjson.Value) error {
|
|
array := value.Array()
|
|
defer array.Close()
|
|
|
|
for i := range v {
|
|
av := array.Value()
|
|
av.String(v[i])
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeDocumentRepositoryCatalogDataInput(v *types.RepositoryCatalogDataInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.AboutText != nil {
|
|
ok := object.Key("aboutText")
|
|
ok.String(*v.AboutText)
|
|
}
|
|
|
|
if v.Architectures != nil {
|
|
ok := object.Key("architectures")
|
|
if err := awsAwsjson11_serializeDocumentArchitectureList(v.Architectures, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.Description != nil {
|
|
ok := object.Key("description")
|
|
ok.String(*v.Description)
|
|
}
|
|
|
|
if v.LogoImageBlob != nil {
|
|
ok := object.Key("logoImageBlob")
|
|
ok.Base64EncodeBytes(v.LogoImageBlob)
|
|
}
|
|
|
|
if v.OperatingSystems != nil {
|
|
ok := object.Key("operatingSystems")
|
|
if err := awsAwsjson11_serializeDocumentOperatingSystemList(v.OperatingSystems, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.UsageText != nil {
|
|
ok := object.Key("usageText")
|
|
ok.String(*v.UsageText)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeDocumentRepositoryNameList(v []string, value smithyjson.Value) error {
|
|
array := value.Array()
|
|
defer array.Close()
|
|
|
|
for i := range v {
|
|
av := array.Value()
|
|
av.String(v[i])
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.Key != nil {
|
|
ok := object.Key("Key")
|
|
ok.String(*v.Key)
|
|
}
|
|
|
|
if v.Value != nil {
|
|
ok := object.Key("Value")
|
|
ok.String(*v.Value)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeDocumentTagKeyList(v []string, value smithyjson.Value) error {
|
|
array := value.Array()
|
|
defer array.Close()
|
|
|
|
for i := range v {
|
|
av := array.Value()
|
|
av.String(v[i])
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeDocumentTagList(v []types.Tag, value smithyjson.Value) error {
|
|
array := value.Array()
|
|
defer array.Close()
|
|
|
|
for i := range v {
|
|
av := array.Value()
|
|
if err := awsAwsjson11_serializeDocumentTag(&v[i], av); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeOpDocumentBatchCheckLayerAvailabilityInput(v *BatchCheckLayerAvailabilityInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.LayerDigests != nil {
|
|
ok := object.Key("layerDigests")
|
|
if err := awsAwsjson11_serializeDocumentBatchedOperationLayerDigestList(v.LayerDigests, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.RegistryId != nil {
|
|
ok := object.Key("registryId")
|
|
ok.String(*v.RegistryId)
|
|
}
|
|
|
|
if v.RepositoryName != nil {
|
|
ok := object.Key("repositoryName")
|
|
ok.String(*v.RepositoryName)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeOpDocumentBatchDeleteImageInput(v *BatchDeleteImageInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.ImageIds != nil {
|
|
ok := object.Key("imageIds")
|
|
if err := awsAwsjson11_serializeDocumentImageIdentifierList(v.ImageIds, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.RegistryId != nil {
|
|
ok := object.Key("registryId")
|
|
ok.String(*v.RegistryId)
|
|
}
|
|
|
|
if v.RepositoryName != nil {
|
|
ok := object.Key("repositoryName")
|
|
ok.String(*v.RepositoryName)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeOpDocumentCompleteLayerUploadInput(v *CompleteLayerUploadInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.LayerDigests != nil {
|
|
ok := object.Key("layerDigests")
|
|
if err := awsAwsjson11_serializeDocumentLayerDigestList(v.LayerDigests, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.RegistryId != nil {
|
|
ok := object.Key("registryId")
|
|
ok.String(*v.RegistryId)
|
|
}
|
|
|
|
if v.RepositoryName != nil {
|
|
ok := object.Key("repositoryName")
|
|
ok.String(*v.RepositoryName)
|
|
}
|
|
|
|
if v.UploadId != nil {
|
|
ok := object.Key("uploadId")
|
|
ok.String(*v.UploadId)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeOpDocumentCreateRepositoryInput(v *CreateRepositoryInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.CatalogData != nil {
|
|
ok := object.Key("catalogData")
|
|
if err := awsAwsjson11_serializeDocumentRepositoryCatalogDataInput(v.CatalogData, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.RepositoryName != nil {
|
|
ok := object.Key("repositoryName")
|
|
ok.String(*v.RepositoryName)
|
|
}
|
|
|
|
if v.Tags != nil {
|
|
ok := object.Key("tags")
|
|
if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeOpDocumentDeleteRepositoryInput(v *DeleteRepositoryInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.Force {
|
|
ok := object.Key("force")
|
|
ok.Boolean(v.Force)
|
|
}
|
|
|
|
if v.RegistryId != nil {
|
|
ok := object.Key("registryId")
|
|
ok.String(*v.RegistryId)
|
|
}
|
|
|
|
if v.RepositoryName != nil {
|
|
ok := object.Key("repositoryName")
|
|
ok.String(*v.RepositoryName)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeOpDocumentDeleteRepositoryPolicyInput(v *DeleteRepositoryPolicyInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.RegistryId != nil {
|
|
ok := object.Key("registryId")
|
|
ok.String(*v.RegistryId)
|
|
}
|
|
|
|
if v.RepositoryName != nil {
|
|
ok := object.Key("repositoryName")
|
|
ok.String(*v.RepositoryName)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeOpDocumentDescribeImagesInput(v *DescribeImagesInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.ImageIds != nil {
|
|
ok := object.Key("imageIds")
|
|
if err := awsAwsjson11_serializeDocumentImageIdentifierList(v.ImageIds, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.MaxResults != nil {
|
|
ok := object.Key("maxResults")
|
|
ok.Integer(*v.MaxResults)
|
|
}
|
|
|
|
if v.NextToken != nil {
|
|
ok := object.Key("nextToken")
|
|
ok.String(*v.NextToken)
|
|
}
|
|
|
|
if v.RegistryId != nil {
|
|
ok := object.Key("registryId")
|
|
ok.String(*v.RegistryId)
|
|
}
|
|
|
|
if v.RepositoryName != nil {
|
|
ok := object.Key("repositoryName")
|
|
ok.String(*v.RepositoryName)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeOpDocumentDescribeImageTagsInput(v *DescribeImageTagsInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.MaxResults != nil {
|
|
ok := object.Key("maxResults")
|
|
ok.Integer(*v.MaxResults)
|
|
}
|
|
|
|
if v.NextToken != nil {
|
|
ok := object.Key("nextToken")
|
|
ok.String(*v.NextToken)
|
|
}
|
|
|
|
if v.RegistryId != nil {
|
|
ok := object.Key("registryId")
|
|
ok.String(*v.RegistryId)
|
|
}
|
|
|
|
if v.RepositoryName != nil {
|
|
ok := object.Key("repositoryName")
|
|
ok.String(*v.RepositoryName)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeOpDocumentDescribeRegistriesInput(v *DescribeRegistriesInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.MaxResults != nil {
|
|
ok := object.Key("maxResults")
|
|
ok.Integer(*v.MaxResults)
|
|
}
|
|
|
|
if v.NextToken != nil {
|
|
ok := object.Key("nextToken")
|
|
ok.String(*v.NextToken)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeOpDocumentDescribeRepositoriesInput(v *DescribeRepositoriesInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.MaxResults != nil {
|
|
ok := object.Key("maxResults")
|
|
ok.Integer(*v.MaxResults)
|
|
}
|
|
|
|
if v.NextToken != nil {
|
|
ok := object.Key("nextToken")
|
|
ok.String(*v.NextToken)
|
|
}
|
|
|
|
if v.RegistryId != nil {
|
|
ok := object.Key("registryId")
|
|
ok.String(*v.RegistryId)
|
|
}
|
|
|
|
if v.RepositoryNames != nil {
|
|
ok := object.Key("repositoryNames")
|
|
if err := awsAwsjson11_serializeDocumentRepositoryNameList(v.RepositoryNames, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeOpDocumentGetAuthorizationTokenInput(v *GetAuthorizationTokenInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeOpDocumentGetRegistryCatalogDataInput(v *GetRegistryCatalogDataInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeOpDocumentGetRepositoryCatalogDataInput(v *GetRepositoryCatalogDataInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.RegistryId != nil {
|
|
ok := object.Key("registryId")
|
|
ok.String(*v.RegistryId)
|
|
}
|
|
|
|
if v.RepositoryName != nil {
|
|
ok := object.Key("repositoryName")
|
|
ok.String(*v.RepositoryName)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeOpDocumentGetRepositoryPolicyInput(v *GetRepositoryPolicyInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.RegistryId != nil {
|
|
ok := object.Key("registryId")
|
|
ok.String(*v.RegistryId)
|
|
}
|
|
|
|
if v.RepositoryName != nil {
|
|
ok := object.Key("repositoryName")
|
|
ok.String(*v.RepositoryName)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeOpDocumentInitiateLayerUploadInput(v *InitiateLayerUploadInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.RegistryId != nil {
|
|
ok := object.Key("registryId")
|
|
ok.String(*v.RegistryId)
|
|
}
|
|
|
|
if v.RepositoryName != nil {
|
|
ok := object.Key("repositoryName")
|
|
ok.String(*v.RepositoryName)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeOpDocumentListTagsForResourceInput(v *ListTagsForResourceInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.ResourceArn != nil {
|
|
ok := object.Key("resourceArn")
|
|
ok.String(*v.ResourceArn)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeOpDocumentPutImageInput(v *PutImageInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.ImageDigest != nil {
|
|
ok := object.Key("imageDigest")
|
|
ok.String(*v.ImageDigest)
|
|
}
|
|
|
|
if v.ImageManifest != nil {
|
|
ok := object.Key("imageManifest")
|
|
ok.String(*v.ImageManifest)
|
|
}
|
|
|
|
if v.ImageManifestMediaType != nil {
|
|
ok := object.Key("imageManifestMediaType")
|
|
ok.String(*v.ImageManifestMediaType)
|
|
}
|
|
|
|
if v.ImageTag != nil {
|
|
ok := object.Key("imageTag")
|
|
ok.String(*v.ImageTag)
|
|
}
|
|
|
|
if v.RegistryId != nil {
|
|
ok := object.Key("registryId")
|
|
ok.String(*v.RegistryId)
|
|
}
|
|
|
|
if v.RepositoryName != nil {
|
|
ok := object.Key("repositoryName")
|
|
ok.String(*v.RepositoryName)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeOpDocumentPutRegistryCatalogDataInput(v *PutRegistryCatalogDataInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.DisplayName != nil {
|
|
ok := object.Key("displayName")
|
|
ok.String(*v.DisplayName)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeOpDocumentPutRepositoryCatalogDataInput(v *PutRepositoryCatalogDataInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.CatalogData != nil {
|
|
ok := object.Key("catalogData")
|
|
if err := awsAwsjson11_serializeDocumentRepositoryCatalogDataInput(v.CatalogData, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.RegistryId != nil {
|
|
ok := object.Key("registryId")
|
|
ok.String(*v.RegistryId)
|
|
}
|
|
|
|
if v.RepositoryName != nil {
|
|
ok := object.Key("repositoryName")
|
|
ok.String(*v.RepositoryName)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeOpDocumentSetRepositoryPolicyInput(v *SetRepositoryPolicyInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.Force {
|
|
ok := object.Key("force")
|
|
ok.Boolean(v.Force)
|
|
}
|
|
|
|
if v.PolicyText != nil {
|
|
ok := object.Key("policyText")
|
|
ok.String(*v.PolicyText)
|
|
}
|
|
|
|
if v.RegistryId != nil {
|
|
ok := object.Key("registryId")
|
|
ok.String(*v.RegistryId)
|
|
}
|
|
|
|
if v.RepositoryName != nil {
|
|
ok := object.Key("repositoryName")
|
|
ok.String(*v.RepositoryName)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.ResourceArn != nil {
|
|
ok := object.Key("resourceArn")
|
|
ok.String(*v.ResourceArn)
|
|
}
|
|
|
|
if v.Tags != nil {
|
|
ok := object.Key("tags")
|
|
if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeOpDocumentUntagResourceInput(v *UntagResourceInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.ResourceArn != nil {
|
|
ok := object.Key("resourceArn")
|
|
ok.String(*v.ResourceArn)
|
|
}
|
|
|
|
if v.TagKeys != nil {
|
|
ok := object.Key("tagKeys")
|
|
if err := awsAwsjson11_serializeDocumentTagKeyList(v.TagKeys, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson11_serializeOpDocumentUploadLayerPartInput(v *UploadLayerPartInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.LayerPartBlob != nil {
|
|
ok := object.Key("layerPartBlob")
|
|
ok.Base64EncodeBytes(v.LayerPartBlob)
|
|
}
|
|
|
|
if v.PartFirstByte != nil {
|
|
ok := object.Key("partFirstByte")
|
|
ok.Long(*v.PartFirstByte)
|
|
}
|
|
|
|
if v.PartLastByte != nil {
|
|
ok := object.Key("partLastByte")
|
|
ok.Long(*v.PartLastByte)
|
|
}
|
|
|
|
if v.RegistryId != nil {
|
|
ok := object.Key("registryId")
|
|
ok.String(*v.RegistryId)
|
|
}
|
|
|
|
if v.RepositoryName != nil {
|
|
ok := object.Key("repositoryName")
|
|
ok.String(*v.RepositoryName)
|
|
}
|
|
|
|
if v.UploadId != nil {
|
|
ok := object.Key("uploadId")
|
|
ok.String(*v.UploadId)
|
|
}
|
|
|
|
return nil
|
|
}
|