Michael McGuinness
b1f8ac453b
feat!: base template * first bit of templating * codeowners * linuxbased * restart * baseline project * add grpc api and basic integration test * startqueue * queueMsg * splitscripts * migrations * queueintegrationtest * gateway
2273 lines
70 KiB
Go
2273 lines
70 KiB
Go
// Code generated by smithy-go-codegen DO NOT EDIT.
|
|
|
|
package sqs
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"github.com/aws/aws-sdk-go-v2/service/sqs/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"
|
|
"github.com/aws/smithy-go/tracing"
|
|
smithyhttp "github.com/aws/smithy-go/transport/http"
|
|
"path"
|
|
)
|
|
|
|
type awsAwsjson10_serializeOpAddPermission struct {
|
|
}
|
|
|
|
func (*awsAwsjson10_serializeOpAddPermission) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson10_serializeOpAddPermission) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
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.(*AddPermissionInput)
|
|
_ = 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.0")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonSQS.AddPermission")
|
|
httpBindingEncoder.SetHeader("X-Amzn-Query-Mode").Boolean(true)
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson10_serializeOpDocumentAddPermissionInput(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
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson10_serializeOpCancelMessageMoveTask struct {
|
|
}
|
|
|
|
func (*awsAwsjson10_serializeOpCancelMessageMoveTask) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson10_serializeOpCancelMessageMoveTask) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
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.(*CancelMessageMoveTaskInput)
|
|
_ = 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.0")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonSQS.CancelMessageMoveTask")
|
|
httpBindingEncoder.SetHeader("X-Amzn-Query-Mode").Boolean(true)
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson10_serializeOpDocumentCancelMessageMoveTaskInput(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
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson10_serializeOpChangeMessageVisibility struct {
|
|
}
|
|
|
|
func (*awsAwsjson10_serializeOpChangeMessageVisibility) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson10_serializeOpChangeMessageVisibility) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
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.(*ChangeMessageVisibilityInput)
|
|
_ = 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.0")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonSQS.ChangeMessageVisibility")
|
|
httpBindingEncoder.SetHeader("X-Amzn-Query-Mode").Boolean(true)
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson10_serializeOpDocumentChangeMessageVisibilityInput(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
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson10_serializeOpChangeMessageVisibilityBatch struct {
|
|
}
|
|
|
|
func (*awsAwsjson10_serializeOpChangeMessageVisibilityBatch) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson10_serializeOpChangeMessageVisibilityBatch) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
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.(*ChangeMessageVisibilityBatchInput)
|
|
_ = 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.0")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonSQS.ChangeMessageVisibilityBatch")
|
|
httpBindingEncoder.SetHeader("X-Amzn-Query-Mode").Boolean(true)
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson10_serializeOpDocumentChangeMessageVisibilityBatchInput(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
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson10_serializeOpCreateQueue struct {
|
|
}
|
|
|
|
func (*awsAwsjson10_serializeOpCreateQueue) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson10_serializeOpCreateQueue) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
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.(*CreateQueueInput)
|
|
_ = 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.0")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonSQS.CreateQueue")
|
|
httpBindingEncoder.SetHeader("X-Amzn-Query-Mode").Boolean(true)
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson10_serializeOpDocumentCreateQueueInput(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
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson10_serializeOpDeleteMessage struct {
|
|
}
|
|
|
|
func (*awsAwsjson10_serializeOpDeleteMessage) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson10_serializeOpDeleteMessage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
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.(*DeleteMessageInput)
|
|
_ = 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.0")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonSQS.DeleteMessage")
|
|
httpBindingEncoder.SetHeader("X-Amzn-Query-Mode").Boolean(true)
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson10_serializeOpDocumentDeleteMessageInput(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
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson10_serializeOpDeleteMessageBatch struct {
|
|
}
|
|
|
|
func (*awsAwsjson10_serializeOpDeleteMessageBatch) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson10_serializeOpDeleteMessageBatch) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
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.(*DeleteMessageBatchInput)
|
|
_ = 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.0")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonSQS.DeleteMessageBatch")
|
|
httpBindingEncoder.SetHeader("X-Amzn-Query-Mode").Boolean(true)
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson10_serializeOpDocumentDeleteMessageBatchInput(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
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson10_serializeOpDeleteQueue struct {
|
|
}
|
|
|
|
func (*awsAwsjson10_serializeOpDeleteQueue) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson10_serializeOpDeleteQueue) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
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.(*DeleteQueueInput)
|
|
_ = 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.0")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonSQS.DeleteQueue")
|
|
httpBindingEncoder.SetHeader("X-Amzn-Query-Mode").Boolean(true)
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson10_serializeOpDocumentDeleteQueueInput(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
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson10_serializeOpGetQueueAttributes struct {
|
|
}
|
|
|
|
func (*awsAwsjson10_serializeOpGetQueueAttributes) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson10_serializeOpGetQueueAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
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.(*GetQueueAttributesInput)
|
|
_ = 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.0")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonSQS.GetQueueAttributes")
|
|
httpBindingEncoder.SetHeader("X-Amzn-Query-Mode").Boolean(true)
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson10_serializeOpDocumentGetQueueAttributesInput(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
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson10_serializeOpGetQueueUrl struct {
|
|
}
|
|
|
|
func (*awsAwsjson10_serializeOpGetQueueUrl) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson10_serializeOpGetQueueUrl) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
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.(*GetQueueUrlInput)
|
|
_ = 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.0")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonSQS.GetQueueUrl")
|
|
httpBindingEncoder.SetHeader("X-Amzn-Query-Mode").Boolean(true)
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson10_serializeOpDocumentGetQueueUrlInput(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
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson10_serializeOpListDeadLetterSourceQueues struct {
|
|
}
|
|
|
|
func (*awsAwsjson10_serializeOpListDeadLetterSourceQueues) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson10_serializeOpListDeadLetterSourceQueues) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
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.(*ListDeadLetterSourceQueuesInput)
|
|
_ = 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.0")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonSQS.ListDeadLetterSourceQueues")
|
|
httpBindingEncoder.SetHeader("X-Amzn-Query-Mode").Boolean(true)
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson10_serializeOpDocumentListDeadLetterSourceQueuesInput(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
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson10_serializeOpListMessageMoveTasks struct {
|
|
}
|
|
|
|
func (*awsAwsjson10_serializeOpListMessageMoveTasks) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson10_serializeOpListMessageMoveTasks) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
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.(*ListMessageMoveTasksInput)
|
|
_ = 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.0")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonSQS.ListMessageMoveTasks")
|
|
httpBindingEncoder.SetHeader("X-Amzn-Query-Mode").Boolean(true)
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson10_serializeOpDocumentListMessageMoveTasksInput(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
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson10_serializeOpListQueues struct {
|
|
}
|
|
|
|
func (*awsAwsjson10_serializeOpListQueues) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson10_serializeOpListQueues) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
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.(*ListQueuesInput)
|
|
_ = 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.0")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonSQS.ListQueues")
|
|
httpBindingEncoder.SetHeader("X-Amzn-Query-Mode").Boolean(true)
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson10_serializeOpDocumentListQueuesInput(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
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson10_serializeOpListQueueTags struct {
|
|
}
|
|
|
|
func (*awsAwsjson10_serializeOpListQueueTags) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson10_serializeOpListQueueTags) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
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.(*ListQueueTagsInput)
|
|
_ = 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.0")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonSQS.ListQueueTags")
|
|
httpBindingEncoder.SetHeader("X-Amzn-Query-Mode").Boolean(true)
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson10_serializeOpDocumentListQueueTagsInput(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
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson10_serializeOpPurgeQueue struct {
|
|
}
|
|
|
|
func (*awsAwsjson10_serializeOpPurgeQueue) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson10_serializeOpPurgeQueue) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
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.(*PurgeQueueInput)
|
|
_ = 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.0")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonSQS.PurgeQueue")
|
|
httpBindingEncoder.SetHeader("X-Amzn-Query-Mode").Boolean(true)
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson10_serializeOpDocumentPurgeQueueInput(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
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson10_serializeOpReceiveMessage struct {
|
|
}
|
|
|
|
func (*awsAwsjson10_serializeOpReceiveMessage) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson10_serializeOpReceiveMessage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
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.(*ReceiveMessageInput)
|
|
_ = 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.0")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonSQS.ReceiveMessage")
|
|
httpBindingEncoder.SetHeader("X-Amzn-Query-Mode").Boolean(true)
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson10_serializeOpDocumentReceiveMessageInput(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
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson10_serializeOpRemovePermission struct {
|
|
}
|
|
|
|
func (*awsAwsjson10_serializeOpRemovePermission) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson10_serializeOpRemovePermission) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
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.(*RemovePermissionInput)
|
|
_ = 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.0")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonSQS.RemovePermission")
|
|
httpBindingEncoder.SetHeader("X-Amzn-Query-Mode").Boolean(true)
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson10_serializeOpDocumentRemovePermissionInput(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
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson10_serializeOpSendMessage struct {
|
|
}
|
|
|
|
func (*awsAwsjson10_serializeOpSendMessage) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson10_serializeOpSendMessage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
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.(*SendMessageInput)
|
|
_ = 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.0")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonSQS.SendMessage")
|
|
httpBindingEncoder.SetHeader("X-Amzn-Query-Mode").Boolean(true)
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson10_serializeOpDocumentSendMessageInput(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
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson10_serializeOpSendMessageBatch struct {
|
|
}
|
|
|
|
func (*awsAwsjson10_serializeOpSendMessageBatch) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson10_serializeOpSendMessageBatch) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
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.(*SendMessageBatchInput)
|
|
_ = 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.0")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonSQS.SendMessageBatch")
|
|
httpBindingEncoder.SetHeader("X-Amzn-Query-Mode").Boolean(true)
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson10_serializeOpDocumentSendMessageBatchInput(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
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson10_serializeOpSetQueueAttributes struct {
|
|
}
|
|
|
|
func (*awsAwsjson10_serializeOpSetQueueAttributes) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson10_serializeOpSetQueueAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
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.(*SetQueueAttributesInput)
|
|
_ = 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.0")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonSQS.SetQueueAttributes")
|
|
httpBindingEncoder.SetHeader("X-Amzn-Query-Mode").Boolean(true)
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson10_serializeOpDocumentSetQueueAttributesInput(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
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson10_serializeOpStartMessageMoveTask struct {
|
|
}
|
|
|
|
func (*awsAwsjson10_serializeOpStartMessageMoveTask) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson10_serializeOpStartMessageMoveTask) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
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.(*StartMessageMoveTaskInput)
|
|
_ = 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.0")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonSQS.StartMessageMoveTask")
|
|
httpBindingEncoder.SetHeader("X-Amzn-Query-Mode").Boolean(true)
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson10_serializeOpDocumentStartMessageMoveTaskInput(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
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson10_serializeOpTagQueue struct {
|
|
}
|
|
|
|
func (*awsAwsjson10_serializeOpTagQueue) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson10_serializeOpTagQueue) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
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.(*TagQueueInput)
|
|
_ = 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.0")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonSQS.TagQueue")
|
|
httpBindingEncoder.SetHeader("X-Amzn-Query-Mode").Boolean(true)
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson10_serializeOpDocumentTagQueueInput(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
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
type awsAwsjson10_serializeOpUntagQueue struct {
|
|
}
|
|
|
|
func (*awsAwsjson10_serializeOpUntagQueue) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsAwsjson10_serializeOpUntagQueue) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
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.(*UntagQueueInput)
|
|
_ = 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.0")
|
|
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonSQS.UntagQueue")
|
|
httpBindingEncoder.SetHeader("X-Amzn-Query-Mode").Boolean(true)
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsAwsjson10_serializeOpDocumentUntagQueueInput(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
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
func awsAwsjson10_serializeDocumentActionNameList(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 awsAwsjson10_serializeDocumentAttributeNameList(v []types.QueueAttributeName, value smithyjson.Value) error {
|
|
array := value.Array()
|
|
defer array.Close()
|
|
|
|
for i := range v {
|
|
av := array.Value()
|
|
av.String(string(v[i]))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeDocumentAWSAccountIdList(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 awsAwsjson10_serializeDocumentBinaryList(v [][]byte, value smithyjson.Value) error {
|
|
array := value.Array()
|
|
defer array.Close()
|
|
|
|
for i := range v {
|
|
av := array.Value()
|
|
if vv := v[i]; vv == nil {
|
|
continue
|
|
}
|
|
av.Base64EncodeBytes(v[i])
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeDocumentChangeMessageVisibilityBatchRequestEntry(v *types.ChangeMessageVisibilityBatchRequestEntry, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.Id != nil {
|
|
ok := object.Key("Id")
|
|
ok.String(*v.Id)
|
|
}
|
|
|
|
if v.ReceiptHandle != nil {
|
|
ok := object.Key("ReceiptHandle")
|
|
ok.String(*v.ReceiptHandle)
|
|
}
|
|
|
|
{
|
|
ok := object.Key("VisibilityTimeout")
|
|
ok.Integer(v.VisibilityTimeout)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeDocumentChangeMessageVisibilityBatchRequestEntryList(v []types.ChangeMessageVisibilityBatchRequestEntry, value smithyjson.Value) error {
|
|
array := value.Array()
|
|
defer array.Close()
|
|
|
|
for i := range v {
|
|
av := array.Value()
|
|
if err := awsAwsjson10_serializeDocumentChangeMessageVisibilityBatchRequestEntry(&v[i], av); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeDocumentDeleteMessageBatchRequestEntry(v *types.DeleteMessageBatchRequestEntry, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.Id != nil {
|
|
ok := object.Key("Id")
|
|
ok.String(*v.Id)
|
|
}
|
|
|
|
if v.ReceiptHandle != nil {
|
|
ok := object.Key("ReceiptHandle")
|
|
ok.String(*v.ReceiptHandle)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeDocumentDeleteMessageBatchRequestEntryList(v []types.DeleteMessageBatchRequestEntry, value smithyjson.Value) error {
|
|
array := value.Array()
|
|
defer array.Close()
|
|
|
|
for i := range v {
|
|
av := array.Value()
|
|
if err := awsAwsjson10_serializeDocumentDeleteMessageBatchRequestEntry(&v[i], av); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeDocumentMessageAttributeNameList(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 awsAwsjson10_serializeDocumentMessageAttributeValue(v *types.MessageAttributeValue, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.BinaryListValues != nil {
|
|
ok := object.Key("BinaryListValues")
|
|
if err := awsAwsjson10_serializeDocumentBinaryList(v.BinaryListValues, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.BinaryValue != nil {
|
|
ok := object.Key("BinaryValue")
|
|
ok.Base64EncodeBytes(v.BinaryValue)
|
|
}
|
|
|
|
if v.DataType != nil {
|
|
ok := object.Key("DataType")
|
|
ok.String(*v.DataType)
|
|
}
|
|
|
|
if v.StringListValues != nil {
|
|
ok := object.Key("StringListValues")
|
|
if err := awsAwsjson10_serializeDocumentStringList(v.StringListValues, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.StringValue != nil {
|
|
ok := object.Key("StringValue")
|
|
ok.String(*v.StringValue)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeDocumentMessageBodyAttributeMap(v map[string]types.MessageAttributeValue, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
for key := range v {
|
|
om := object.Key(key)
|
|
mapVar := v[key]
|
|
if err := awsAwsjson10_serializeDocumentMessageAttributeValue(&mapVar, om); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeDocumentMessageBodySystemAttributeMap(v map[string]types.MessageSystemAttributeValue, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
for key := range v {
|
|
om := object.Key(key)
|
|
mapVar := v[key]
|
|
if err := awsAwsjson10_serializeDocumentMessageSystemAttributeValue(&mapVar, om); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeDocumentMessageSystemAttributeList(v []types.MessageSystemAttributeName, value smithyjson.Value) error {
|
|
array := value.Array()
|
|
defer array.Close()
|
|
|
|
for i := range v {
|
|
av := array.Value()
|
|
av.String(string(v[i]))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeDocumentMessageSystemAttributeValue(v *types.MessageSystemAttributeValue, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.BinaryListValues != nil {
|
|
ok := object.Key("BinaryListValues")
|
|
if err := awsAwsjson10_serializeDocumentBinaryList(v.BinaryListValues, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.BinaryValue != nil {
|
|
ok := object.Key("BinaryValue")
|
|
ok.Base64EncodeBytes(v.BinaryValue)
|
|
}
|
|
|
|
if v.DataType != nil {
|
|
ok := object.Key("DataType")
|
|
ok.String(*v.DataType)
|
|
}
|
|
|
|
if v.StringListValues != nil {
|
|
ok := object.Key("StringListValues")
|
|
if err := awsAwsjson10_serializeDocumentStringList(v.StringListValues, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.StringValue != nil {
|
|
ok := object.Key("StringValue")
|
|
ok.String(*v.StringValue)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeDocumentQueueAttributeMap(v map[string]string, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
for key := range v {
|
|
om := object.Key(key)
|
|
om.String(v[key])
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeDocumentSendMessageBatchRequestEntry(v *types.SendMessageBatchRequestEntry, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.DelaySeconds != 0 {
|
|
ok := object.Key("DelaySeconds")
|
|
ok.Integer(v.DelaySeconds)
|
|
}
|
|
|
|
if v.Id != nil {
|
|
ok := object.Key("Id")
|
|
ok.String(*v.Id)
|
|
}
|
|
|
|
if v.MessageAttributes != nil {
|
|
ok := object.Key("MessageAttributes")
|
|
if err := awsAwsjson10_serializeDocumentMessageBodyAttributeMap(v.MessageAttributes, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.MessageBody != nil {
|
|
ok := object.Key("MessageBody")
|
|
ok.String(*v.MessageBody)
|
|
}
|
|
|
|
if v.MessageDeduplicationId != nil {
|
|
ok := object.Key("MessageDeduplicationId")
|
|
ok.String(*v.MessageDeduplicationId)
|
|
}
|
|
|
|
if v.MessageGroupId != nil {
|
|
ok := object.Key("MessageGroupId")
|
|
ok.String(*v.MessageGroupId)
|
|
}
|
|
|
|
if v.MessageSystemAttributes != nil {
|
|
ok := object.Key("MessageSystemAttributes")
|
|
if err := awsAwsjson10_serializeDocumentMessageBodySystemAttributeMap(v.MessageSystemAttributes, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeDocumentSendMessageBatchRequestEntryList(v []types.SendMessageBatchRequestEntry, value smithyjson.Value) error {
|
|
array := value.Array()
|
|
defer array.Close()
|
|
|
|
for i := range v {
|
|
av := array.Value()
|
|
if err := awsAwsjson10_serializeDocumentSendMessageBatchRequestEntry(&v[i], av); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeDocumentStringList(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 awsAwsjson10_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 awsAwsjson10_serializeDocumentTagMap(v map[string]string, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
for key := range v {
|
|
om := object.Key(key)
|
|
om.String(v[key])
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeOpDocumentAddPermissionInput(v *AddPermissionInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.Actions != nil {
|
|
ok := object.Key("Actions")
|
|
if err := awsAwsjson10_serializeDocumentActionNameList(v.Actions, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.AWSAccountIds != nil {
|
|
ok := object.Key("AWSAccountIds")
|
|
if err := awsAwsjson10_serializeDocumentAWSAccountIdList(v.AWSAccountIds, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.Label != nil {
|
|
ok := object.Key("Label")
|
|
ok.String(*v.Label)
|
|
}
|
|
|
|
if v.QueueUrl != nil {
|
|
ok := object.Key("QueueUrl")
|
|
ok.String(*v.QueueUrl)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeOpDocumentCancelMessageMoveTaskInput(v *CancelMessageMoveTaskInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.TaskHandle != nil {
|
|
ok := object.Key("TaskHandle")
|
|
ok.String(*v.TaskHandle)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeOpDocumentChangeMessageVisibilityBatchInput(v *ChangeMessageVisibilityBatchInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.Entries != nil {
|
|
ok := object.Key("Entries")
|
|
if err := awsAwsjson10_serializeDocumentChangeMessageVisibilityBatchRequestEntryList(v.Entries, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.QueueUrl != nil {
|
|
ok := object.Key("QueueUrl")
|
|
ok.String(*v.QueueUrl)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeOpDocumentChangeMessageVisibilityInput(v *ChangeMessageVisibilityInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.QueueUrl != nil {
|
|
ok := object.Key("QueueUrl")
|
|
ok.String(*v.QueueUrl)
|
|
}
|
|
|
|
if v.ReceiptHandle != nil {
|
|
ok := object.Key("ReceiptHandle")
|
|
ok.String(*v.ReceiptHandle)
|
|
}
|
|
|
|
{
|
|
ok := object.Key("VisibilityTimeout")
|
|
ok.Integer(v.VisibilityTimeout)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeOpDocumentCreateQueueInput(v *CreateQueueInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.Attributes != nil {
|
|
ok := object.Key("Attributes")
|
|
if err := awsAwsjson10_serializeDocumentQueueAttributeMap(v.Attributes, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.QueueName != nil {
|
|
ok := object.Key("QueueName")
|
|
ok.String(*v.QueueName)
|
|
}
|
|
|
|
if v.Tags != nil {
|
|
ok := object.Key("tags")
|
|
if err := awsAwsjson10_serializeDocumentTagMap(v.Tags, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeOpDocumentDeleteMessageBatchInput(v *DeleteMessageBatchInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.Entries != nil {
|
|
ok := object.Key("Entries")
|
|
if err := awsAwsjson10_serializeDocumentDeleteMessageBatchRequestEntryList(v.Entries, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.QueueUrl != nil {
|
|
ok := object.Key("QueueUrl")
|
|
ok.String(*v.QueueUrl)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeOpDocumentDeleteMessageInput(v *DeleteMessageInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.QueueUrl != nil {
|
|
ok := object.Key("QueueUrl")
|
|
ok.String(*v.QueueUrl)
|
|
}
|
|
|
|
if v.ReceiptHandle != nil {
|
|
ok := object.Key("ReceiptHandle")
|
|
ok.String(*v.ReceiptHandle)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeOpDocumentDeleteQueueInput(v *DeleteQueueInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.QueueUrl != nil {
|
|
ok := object.Key("QueueUrl")
|
|
ok.String(*v.QueueUrl)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeOpDocumentGetQueueAttributesInput(v *GetQueueAttributesInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.AttributeNames != nil {
|
|
ok := object.Key("AttributeNames")
|
|
if err := awsAwsjson10_serializeDocumentAttributeNameList(v.AttributeNames, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.QueueUrl != nil {
|
|
ok := object.Key("QueueUrl")
|
|
ok.String(*v.QueueUrl)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeOpDocumentGetQueueUrlInput(v *GetQueueUrlInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.QueueName != nil {
|
|
ok := object.Key("QueueName")
|
|
ok.String(*v.QueueName)
|
|
}
|
|
|
|
if v.QueueOwnerAWSAccountId != nil {
|
|
ok := object.Key("QueueOwnerAWSAccountId")
|
|
ok.String(*v.QueueOwnerAWSAccountId)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeOpDocumentListDeadLetterSourceQueuesInput(v *ListDeadLetterSourceQueuesInput, 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.QueueUrl != nil {
|
|
ok := object.Key("QueueUrl")
|
|
ok.String(*v.QueueUrl)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeOpDocumentListMessageMoveTasksInput(v *ListMessageMoveTasksInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.MaxResults != nil {
|
|
ok := object.Key("MaxResults")
|
|
ok.Integer(*v.MaxResults)
|
|
}
|
|
|
|
if v.SourceArn != nil {
|
|
ok := object.Key("SourceArn")
|
|
ok.String(*v.SourceArn)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeOpDocumentListQueuesInput(v *ListQueuesInput, 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.QueueNamePrefix != nil {
|
|
ok := object.Key("QueueNamePrefix")
|
|
ok.String(*v.QueueNamePrefix)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeOpDocumentListQueueTagsInput(v *ListQueueTagsInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.QueueUrl != nil {
|
|
ok := object.Key("QueueUrl")
|
|
ok.String(*v.QueueUrl)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeOpDocumentPurgeQueueInput(v *PurgeQueueInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.QueueUrl != nil {
|
|
ok := object.Key("QueueUrl")
|
|
ok.String(*v.QueueUrl)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeOpDocumentReceiveMessageInput(v *ReceiveMessageInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.AttributeNames != nil {
|
|
ok := object.Key("AttributeNames")
|
|
if err := awsAwsjson10_serializeDocumentAttributeNameList(v.AttributeNames, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.MaxNumberOfMessages != 0 {
|
|
ok := object.Key("MaxNumberOfMessages")
|
|
ok.Integer(v.MaxNumberOfMessages)
|
|
}
|
|
|
|
if v.MessageAttributeNames != nil {
|
|
ok := object.Key("MessageAttributeNames")
|
|
if err := awsAwsjson10_serializeDocumentMessageAttributeNameList(v.MessageAttributeNames, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.MessageSystemAttributeNames != nil {
|
|
ok := object.Key("MessageSystemAttributeNames")
|
|
if err := awsAwsjson10_serializeDocumentMessageSystemAttributeList(v.MessageSystemAttributeNames, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.QueueUrl != nil {
|
|
ok := object.Key("QueueUrl")
|
|
ok.String(*v.QueueUrl)
|
|
}
|
|
|
|
if v.ReceiveRequestAttemptId != nil {
|
|
ok := object.Key("ReceiveRequestAttemptId")
|
|
ok.String(*v.ReceiveRequestAttemptId)
|
|
}
|
|
|
|
if v.VisibilityTimeout != 0 {
|
|
ok := object.Key("VisibilityTimeout")
|
|
ok.Integer(v.VisibilityTimeout)
|
|
}
|
|
|
|
if v.WaitTimeSeconds != 0 {
|
|
ok := object.Key("WaitTimeSeconds")
|
|
ok.Integer(v.WaitTimeSeconds)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeOpDocumentRemovePermissionInput(v *RemovePermissionInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.Label != nil {
|
|
ok := object.Key("Label")
|
|
ok.String(*v.Label)
|
|
}
|
|
|
|
if v.QueueUrl != nil {
|
|
ok := object.Key("QueueUrl")
|
|
ok.String(*v.QueueUrl)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeOpDocumentSendMessageBatchInput(v *SendMessageBatchInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.Entries != nil {
|
|
ok := object.Key("Entries")
|
|
if err := awsAwsjson10_serializeDocumentSendMessageBatchRequestEntryList(v.Entries, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.QueueUrl != nil {
|
|
ok := object.Key("QueueUrl")
|
|
ok.String(*v.QueueUrl)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeOpDocumentSendMessageInput(v *SendMessageInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.DelaySeconds != 0 {
|
|
ok := object.Key("DelaySeconds")
|
|
ok.Integer(v.DelaySeconds)
|
|
}
|
|
|
|
if v.MessageAttributes != nil {
|
|
ok := object.Key("MessageAttributes")
|
|
if err := awsAwsjson10_serializeDocumentMessageBodyAttributeMap(v.MessageAttributes, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.MessageBody != nil {
|
|
ok := object.Key("MessageBody")
|
|
ok.String(*v.MessageBody)
|
|
}
|
|
|
|
if v.MessageDeduplicationId != nil {
|
|
ok := object.Key("MessageDeduplicationId")
|
|
ok.String(*v.MessageDeduplicationId)
|
|
}
|
|
|
|
if v.MessageGroupId != nil {
|
|
ok := object.Key("MessageGroupId")
|
|
ok.String(*v.MessageGroupId)
|
|
}
|
|
|
|
if v.MessageSystemAttributes != nil {
|
|
ok := object.Key("MessageSystemAttributes")
|
|
if err := awsAwsjson10_serializeDocumentMessageBodySystemAttributeMap(v.MessageSystemAttributes, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.QueueUrl != nil {
|
|
ok := object.Key("QueueUrl")
|
|
ok.String(*v.QueueUrl)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeOpDocumentSetQueueAttributesInput(v *SetQueueAttributesInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.Attributes != nil {
|
|
ok := object.Key("Attributes")
|
|
if err := awsAwsjson10_serializeDocumentQueueAttributeMap(v.Attributes, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v.QueueUrl != nil {
|
|
ok := object.Key("QueueUrl")
|
|
ok.String(*v.QueueUrl)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeOpDocumentStartMessageMoveTaskInput(v *StartMessageMoveTaskInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.DestinationArn != nil {
|
|
ok := object.Key("DestinationArn")
|
|
ok.String(*v.DestinationArn)
|
|
}
|
|
|
|
if v.MaxNumberOfMessagesPerSecond != nil {
|
|
ok := object.Key("MaxNumberOfMessagesPerSecond")
|
|
ok.Integer(*v.MaxNumberOfMessagesPerSecond)
|
|
}
|
|
|
|
if v.SourceArn != nil {
|
|
ok := object.Key("SourceArn")
|
|
ok.String(*v.SourceArn)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeOpDocumentTagQueueInput(v *TagQueueInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.QueueUrl != nil {
|
|
ok := object.Key("QueueUrl")
|
|
ok.String(*v.QueueUrl)
|
|
}
|
|
|
|
if v.Tags != nil {
|
|
ok := object.Key("Tags")
|
|
if err := awsAwsjson10_serializeDocumentTagMap(v.Tags, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsAwsjson10_serializeOpDocumentUntagQueueInput(v *UntagQueueInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.QueueUrl != nil {
|
|
ok := object.Key("QueueUrl")
|
|
ok.String(*v.QueueUrl)
|
|
}
|
|
|
|
if v.TagKeys != nil {
|
|
ok := object.Key("TagKeys")
|
|
if err := awsAwsjson10_serializeDocumentTagKeyList(v.TagKeys, ok); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|