// Code generated by smithy-go-codegen DO NOT EDIT.

package rds

import (
	"bytes"
	"context"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/aws/protocol/query"
	"github.com/aws/aws-sdk-go-v2/service/rds/types"
	smithy "github.com/aws/smithy-go"
	"github.com/aws/smithy-go/encoding/httpbinding"
	"github.com/aws/smithy-go/middleware"
	smithytime "github.com/aws/smithy-go/time"
	"github.com/aws/smithy-go/tracing"
	smithyhttp "github.com/aws/smithy-go/transport/http"
	"math"
	"path"
	"sort"
)

type awsAwsquery_serializeOpAddRoleToDBCluster struct {
}

func (*awsAwsquery_serializeOpAddRoleToDBCluster) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpAddRoleToDBCluster) 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.(*AddRoleToDBClusterInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("AddRoleToDBCluster")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentAddRoleToDBClusterInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpAddRoleToDBInstance struct {
}

func (*awsAwsquery_serializeOpAddRoleToDBInstance) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpAddRoleToDBInstance) 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.(*AddRoleToDBInstanceInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("AddRoleToDBInstance")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentAddRoleToDBInstanceInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpAddSourceIdentifierToSubscription struct {
}

func (*awsAwsquery_serializeOpAddSourceIdentifierToSubscription) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpAddSourceIdentifierToSubscription) 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.(*AddSourceIdentifierToSubscriptionInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("AddSourceIdentifierToSubscription")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentAddSourceIdentifierToSubscriptionInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpAddTagsToResource struct {
}

func (*awsAwsquery_serializeOpAddTagsToResource) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpAddTagsToResource) 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.(*AddTagsToResourceInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("AddTagsToResource")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentAddTagsToResourceInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpApplyPendingMaintenanceAction struct {
}

func (*awsAwsquery_serializeOpApplyPendingMaintenanceAction) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpApplyPendingMaintenanceAction) 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.(*ApplyPendingMaintenanceActionInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ApplyPendingMaintenanceAction")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentApplyPendingMaintenanceActionInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpAuthorizeDBSecurityGroupIngress struct {
}

func (*awsAwsquery_serializeOpAuthorizeDBSecurityGroupIngress) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpAuthorizeDBSecurityGroupIngress) 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.(*AuthorizeDBSecurityGroupIngressInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("AuthorizeDBSecurityGroupIngress")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentAuthorizeDBSecurityGroupIngressInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpBacktrackDBCluster struct {
}

func (*awsAwsquery_serializeOpBacktrackDBCluster) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpBacktrackDBCluster) 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.(*BacktrackDBClusterInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("BacktrackDBCluster")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentBacktrackDBClusterInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpCancelExportTask struct {
}

func (*awsAwsquery_serializeOpCancelExportTask) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpCancelExportTask) 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.(*CancelExportTaskInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CancelExportTask")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentCancelExportTaskInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpCopyDBClusterParameterGroup struct {
}

func (*awsAwsquery_serializeOpCopyDBClusterParameterGroup) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpCopyDBClusterParameterGroup) 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.(*CopyDBClusterParameterGroupInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CopyDBClusterParameterGroup")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentCopyDBClusterParameterGroupInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpCopyDBClusterSnapshot struct {
}

func (*awsAwsquery_serializeOpCopyDBClusterSnapshot) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpCopyDBClusterSnapshot) 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.(*CopyDBClusterSnapshotInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CopyDBClusterSnapshot")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentCopyDBClusterSnapshotInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpCopyDBParameterGroup struct {
}

func (*awsAwsquery_serializeOpCopyDBParameterGroup) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpCopyDBParameterGroup) 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.(*CopyDBParameterGroupInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CopyDBParameterGroup")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentCopyDBParameterGroupInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpCopyDBSnapshot struct {
}

func (*awsAwsquery_serializeOpCopyDBSnapshot) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpCopyDBSnapshot) 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.(*CopyDBSnapshotInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CopyDBSnapshot")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentCopyDBSnapshotInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpCopyOptionGroup struct {
}

func (*awsAwsquery_serializeOpCopyOptionGroup) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpCopyOptionGroup) 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.(*CopyOptionGroupInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CopyOptionGroup")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentCopyOptionGroupInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpCreateBlueGreenDeployment struct {
}

func (*awsAwsquery_serializeOpCreateBlueGreenDeployment) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpCreateBlueGreenDeployment) 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.(*CreateBlueGreenDeploymentInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CreateBlueGreenDeployment")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentCreateBlueGreenDeploymentInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpCreateCustomDBEngineVersion struct {
}

func (*awsAwsquery_serializeOpCreateCustomDBEngineVersion) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpCreateCustomDBEngineVersion) 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.(*CreateCustomDBEngineVersionInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CreateCustomDBEngineVersion")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentCreateCustomDBEngineVersionInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpCreateDBCluster struct {
}

func (*awsAwsquery_serializeOpCreateDBCluster) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpCreateDBCluster) 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.(*CreateDBClusterInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CreateDBCluster")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentCreateDBClusterInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpCreateDBClusterEndpoint struct {
}

func (*awsAwsquery_serializeOpCreateDBClusterEndpoint) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpCreateDBClusterEndpoint) 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.(*CreateDBClusterEndpointInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CreateDBClusterEndpoint")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentCreateDBClusterEndpointInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpCreateDBClusterParameterGroup struct {
}

func (*awsAwsquery_serializeOpCreateDBClusterParameterGroup) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpCreateDBClusterParameterGroup) 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.(*CreateDBClusterParameterGroupInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CreateDBClusterParameterGroup")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentCreateDBClusterParameterGroupInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpCreateDBClusterSnapshot struct {
}

func (*awsAwsquery_serializeOpCreateDBClusterSnapshot) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpCreateDBClusterSnapshot) 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.(*CreateDBClusterSnapshotInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CreateDBClusterSnapshot")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentCreateDBClusterSnapshotInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpCreateDBInstance struct {
}

func (*awsAwsquery_serializeOpCreateDBInstance) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpCreateDBInstance) 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.(*CreateDBInstanceInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CreateDBInstance")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentCreateDBInstanceInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpCreateDBInstanceReadReplica struct {
}

func (*awsAwsquery_serializeOpCreateDBInstanceReadReplica) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpCreateDBInstanceReadReplica) 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.(*CreateDBInstanceReadReplicaInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CreateDBInstanceReadReplica")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentCreateDBInstanceReadReplicaInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpCreateDBParameterGroup struct {
}

func (*awsAwsquery_serializeOpCreateDBParameterGroup) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpCreateDBParameterGroup) 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.(*CreateDBParameterGroupInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CreateDBParameterGroup")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentCreateDBParameterGroupInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpCreateDBProxy struct {
}

func (*awsAwsquery_serializeOpCreateDBProxy) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpCreateDBProxy) 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.(*CreateDBProxyInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CreateDBProxy")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentCreateDBProxyInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpCreateDBProxyEndpoint struct {
}

func (*awsAwsquery_serializeOpCreateDBProxyEndpoint) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpCreateDBProxyEndpoint) 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.(*CreateDBProxyEndpointInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CreateDBProxyEndpoint")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentCreateDBProxyEndpointInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpCreateDBSecurityGroup struct {
}

func (*awsAwsquery_serializeOpCreateDBSecurityGroup) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpCreateDBSecurityGroup) 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.(*CreateDBSecurityGroupInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CreateDBSecurityGroup")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentCreateDBSecurityGroupInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpCreateDBShardGroup struct {
}

func (*awsAwsquery_serializeOpCreateDBShardGroup) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpCreateDBShardGroup) 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.(*CreateDBShardGroupInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CreateDBShardGroup")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentCreateDBShardGroupInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpCreateDBSnapshot struct {
}

func (*awsAwsquery_serializeOpCreateDBSnapshot) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpCreateDBSnapshot) 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.(*CreateDBSnapshotInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CreateDBSnapshot")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentCreateDBSnapshotInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpCreateDBSubnetGroup struct {
}

func (*awsAwsquery_serializeOpCreateDBSubnetGroup) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpCreateDBSubnetGroup) 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.(*CreateDBSubnetGroupInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CreateDBSubnetGroup")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentCreateDBSubnetGroupInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpCreateEventSubscription struct {
}

func (*awsAwsquery_serializeOpCreateEventSubscription) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpCreateEventSubscription) 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.(*CreateEventSubscriptionInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CreateEventSubscription")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentCreateEventSubscriptionInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpCreateGlobalCluster struct {
}

func (*awsAwsquery_serializeOpCreateGlobalCluster) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpCreateGlobalCluster) 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.(*CreateGlobalClusterInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CreateGlobalCluster")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentCreateGlobalClusterInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpCreateIntegration struct {
}

func (*awsAwsquery_serializeOpCreateIntegration) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpCreateIntegration) 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.(*CreateIntegrationInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CreateIntegration")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentCreateIntegrationInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpCreateOptionGroup struct {
}

func (*awsAwsquery_serializeOpCreateOptionGroup) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpCreateOptionGroup) 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.(*CreateOptionGroupInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CreateOptionGroup")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentCreateOptionGroupInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpCreateTenantDatabase struct {
}

func (*awsAwsquery_serializeOpCreateTenantDatabase) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpCreateTenantDatabase) 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.(*CreateTenantDatabaseInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CreateTenantDatabase")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentCreateTenantDatabaseInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDeleteBlueGreenDeployment struct {
}

func (*awsAwsquery_serializeOpDeleteBlueGreenDeployment) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDeleteBlueGreenDeployment) 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.(*DeleteBlueGreenDeploymentInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeleteBlueGreenDeployment")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDeleteBlueGreenDeploymentInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDeleteCustomDBEngineVersion struct {
}

func (*awsAwsquery_serializeOpDeleteCustomDBEngineVersion) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDeleteCustomDBEngineVersion) 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.(*DeleteCustomDBEngineVersionInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeleteCustomDBEngineVersion")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDeleteCustomDBEngineVersionInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDeleteDBCluster struct {
}

func (*awsAwsquery_serializeOpDeleteDBCluster) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDeleteDBCluster) 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.(*DeleteDBClusterInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeleteDBCluster")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDeleteDBClusterInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDeleteDBClusterAutomatedBackup struct {
}

func (*awsAwsquery_serializeOpDeleteDBClusterAutomatedBackup) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDeleteDBClusterAutomatedBackup) 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.(*DeleteDBClusterAutomatedBackupInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeleteDBClusterAutomatedBackup")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDeleteDBClusterAutomatedBackupInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDeleteDBClusterEndpoint struct {
}

func (*awsAwsquery_serializeOpDeleteDBClusterEndpoint) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDeleteDBClusterEndpoint) 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.(*DeleteDBClusterEndpointInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeleteDBClusterEndpoint")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDeleteDBClusterEndpointInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDeleteDBClusterParameterGroup struct {
}

func (*awsAwsquery_serializeOpDeleteDBClusterParameterGroup) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDeleteDBClusterParameterGroup) 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.(*DeleteDBClusterParameterGroupInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeleteDBClusterParameterGroup")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDeleteDBClusterParameterGroupInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDeleteDBClusterSnapshot struct {
}

func (*awsAwsquery_serializeOpDeleteDBClusterSnapshot) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDeleteDBClusterSnapshot) 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.(*DeleteDBClusterSnapshotInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeleteDBClusterSnapshot")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDeleteDBClusterSnapshotInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDeleteDBInstance struct {
}

func (*awsAwsquery_serializeOpDeleteDBInstance) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDeleteDBInstance) 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.(*DeleteDBInstanceInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeleteDBInstance")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDeleteDBInstanceInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDeleteDBInstanceAutomatedBackup struct {
}

func (*awsAwsquery_serializeOpDeleteDBInstanceAutomatedBackup) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDeleteDBInstanceAutomatedBackup) 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.(*DeleteDBInstanceAutomatedBackupInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeleteDBInstanceAutomatedBackup")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDeleteDBInstanceAutomatedBackupInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDeleteDBParameterGroup struct {
}

func (*awsAwsquery_serializeOpDeleteDBParameterGroup) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDeleteDBParameterGroup) 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.(*DeleteDBParameterGroupInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeleteDBParameterGroup")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDeleteDBParameterGroupInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDeleteDBProxy struct {
}

func (*awsAwsquery_serializeOpDeleteDBProxy) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDeleteDBProxy) 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.(*DeleteDBProxyInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeleteDBProxy")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDeleteDBProxyInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDeleteDBProxyEndpoint struct {
}

func (*awsAwsquery_serializeOpDeleteDBProxyEndpoint) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDeleteDBProxyEndpoint) 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.(*DeleteDBProxyEndpointInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeleteDBProxyEndpoint")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDeleteDBProxyEndpointInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDeleteDBSecurityGroup struct {
}

func (*awsAwsquery_serializeOpDeleteDBSecurityGroup) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDeleteDBSecurityGroup) 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.(*DeleteDBSecurityGroupInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeleteDBSecurityGroup")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDeleteDBSecurityGroupInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDeleteDBShardGroup struct {
}

func (*awsAwsquery_serializeOpDeleteDBShardGroup) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDeleteDBShardGroup) 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.(*DeleteDBShardGroupInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeleteDBShardGroup")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDeleteDBShardGroupInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDeleteDBSnapshot struct {
}

func (*awsAwsquery_serializeOpDeleteDBSnapshot) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDeleteDBSnapshot) 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.(*DeleteDBSnapshotInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeleteDBSnapshot")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDeleteDBSnapshotInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDeleteDBSubnetGroup struct {
}

func (*awsAwsquery_serializeOpDeleteDBSubnetGroup) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDeleteDBSubnetGroup) 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.(*DeleteDBSubnetGroupInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeleteDBSubnetGroup")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDeleteDBSubnetGroupInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDeleteEventSubscription struct {
}

func (*awsAwsquery_serializeOpDeleteEventSubscription) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDeleteEventSubscription) 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.(*DeleteEventSubscriptionInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeleteEventSubscription")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDeleteEventSubscriptionInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDeleteGlobalCluster struct {
}

func (*awsAwsquery_serializeOpDeleteGlobalCluster) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDeleteGlobalCluster) 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.(*DeleteGlobalClusterInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeleteGlobalCluster")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDeleteGlobalClusterInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDeleteIntegration struct {
}

func (*awsAwsquery_serializeOpDeleteIntegration) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDeleteIntegration) 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.(*DeleteIntegrationInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeleteIntegration")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDeleteIntegrationInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDeleteOptionGroup struct {
}

func (*awsAwsquery_serializeOpDeleteOptionGroup) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDeleteOptionGroup) 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.(*DeleteOptionGroupInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeleteOptionGroup")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDeleteOptionGroupInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDeleteTenantDatabase struct {
}

func (*awsAwsquery_serializeOpDeleteTenantDatabase) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDeleteTenantDatabase) 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.(*DeleteTenantDatabaseInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeleteTenantDatabase")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDeleteTenantDatabaseInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDeregisterDBProxyTargets struct {
}

func (*awsAwsquery_serializeOpDeregisterDBProxyTargets) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDeregisterDBProxyTargets) 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.(*DeregisterDBProxyTargetsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeregisterDBProxyTargets")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDeregisterDBProxyTargetsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeAccountAttributes struct {
}

func (*awsAwsquery_serializeOpDescribeAccountAttributes) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeAccountAttributes) 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.(*DescribeAccountAttributesInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeAccountAttributes")
	body.Key("Version").String("2014-10-31")

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeBlueGreenDeployments struct {
}

func (*awsAwsquery_serializeOpDescribeBlueGreenDeployments) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeBlueGreenDeployments) 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.(*DescribeBlueGreenDeploymentsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeBlueGreenDeployments")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeBlueGreenDeploymentsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeCertificates struct {
}

func (*awsAwsquery_serializeOpDescribeCertificates) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeCertificates) 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.(*DescribeCertificatesInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeCertificates")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeCertificatesInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeDBClusterAutomatedBackups struct {
}

func (*awsAwsquery_serializeOpDescribeDBClusterAutomatedBackups) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeDBClusterAutomatedBackups) 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.(*DescribeDBClusterAutomatedBackupsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeDBClusterAutomatedBackups")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeDBClusterAutomatedBackupsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeDBClusterBacktracks struct {
}

func (*awsAwsquery_serializeOpDescribeDBClusterBacktracks) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeDBClusterBacktracks) 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.(*DescribeDBClusterBacktracksInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeDBClusterBacktracks")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeDBClusterBacktracksInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeDBClusterEndpoints struct {
}

func (*awsAwsquery_serializeOpDescribeDBClusterEndpoints) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeDBClusterEndpoints) 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.(*DescribeDBClusterEndpointsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeDBClusterEndpoints")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeDBClusterEndpointsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeDBClusterParameterGroups struct {
}

func (*awsAwsquery_serializeOpDescribeDBClusterParameterGroups) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeDBClusterParameterGroups) 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.(*DescribeDBClusterParameterGroupsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeDBClusterParameterGroups")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeDBClusterParameterGroupsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeDBClusterParameters struct {
}

func (*awsAwsquery_serializeOpDescribeDBClusterParameters) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeDBClusterParameters) 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.(*DescribeDBClusterParametersInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeDBClusterParameters")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeDBClusterParametersInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeDBClusters struct {
}

func (*awsAwsquery_serializeOpDescribeDBClusters) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeDBClusters) 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.(*DescribeDBClustersInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeDBClusters")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeDBClustersInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeDBClusterSnapshotAttributes struct {
}

func (*awsAwsquery_serializeOpDescribeDBClusterSnapshotAttributes) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeDBClusterSnapshotAttributes) 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.(*DescribeDBClusterSnapshotAttributesInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeDBClusterSnapshotAttributes")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeDBClusterSnapshotAttributesInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeDBClusterSnapshots struct {
}

func (*awsAwsquery_serializeOpDescribeDBClusterSnapshots) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeDBClusterSnapshots) 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.(*DescribeDBClusterSnapshotsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeDBClusterSnapshots")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeDBClusterSnapshotsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeDBEngineVersions struct {
}

func (*awsAwsquery_serializeOpDescribeDBEngineVersions) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeDBEngineVersions) 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.(*DescribeDBEngineVersionsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeDBEngineVersions")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeDBEngineVersionsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeDBInstanceAutomatedBackups struct {
}

func (*awsAwsquery_serializeOpDescribeDBInstanceAutomatedBackups) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeDBInstanceAutomatedBackups) 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.(*DescribeDBInstanceAutomatedBackupsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeDBInstanceAutomatedBackups")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeDBInstanceAutomatedBackupsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeDBInstances struct {
}

func (*awsAwsquery_serializeOpDescribeDBInstances) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeDBInstances) 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.(*DescribeDBInstancesInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeDBInstances")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeDBInstancesInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeDBLogFiles struct {
}

func (*awsAwsquery_serializeOpDescribeDBLogFiles) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeDBLogFiles) 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.(*DescribeDBLogFilesInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeDBLogFiles")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeDBLogFilesInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeDBMajorEngineVersions struct {
}

func (*awsAwsquery_serializeOpDescribeDBMajorEngineVersions) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeDBMajorEngineVersions) 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.(*DescribeDBMajorEngineVersionsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeDBMajorEngineVersions")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeDBMajorEngineVersionsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeDBParameterGroups struct {
}

func (*awsAwsquery_serializeOpDescribeDBParameterGroups) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeDBParameterGroups) 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.(*DescribeDBParameterGroupsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeDBParameterGroups")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeDBParameterGroupsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeDBParameters struct {
}

func (*awsAwsquery_serializeOpDescribeDBParameters) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeDBParameters) 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.(*DescribeDBParametersInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeDBParameters")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeDBParametersInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeDBProxies struct {
}

func (*awsAwsquery_serializeOpDescribeDBProxies) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeDBProxies) 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.(*DescribeDBProxiesInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeDBProxies")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeDBProxiesInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeDBProxyEndpoints struct {
}

func (*awsAwsquery_serializeOpDescribeDBProxyEndpoints) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeDBProxyEndpoints) 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.(*DescribeDBProxyEndpointsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeDBProxyEndpoints")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeDBProxyEndpointsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeDBProxyTargetGroups struct {
}

func (*awsAwsquery_serializeOpDescribeDBProxyTargetGroups) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeDBProxyTargetGroups) 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.(*DescribeDBProxyTargetGroupsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeDBProxyTargetGroups")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeDBProxyTargetGroupsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeDBProxyTargets struct {
}

func (*awsAwsquery_serializeOpDescribeDBProxyTargets) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeDBProxyTargets) 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.(*DescribeDBProxyTargetsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeDBProxyTargets")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeDBProxyTargetsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeDBRecommendations struct {
}

func (*awsAwsquery_serializeOpDescribeDBRecommendations) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeDBRecommendations) 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.(*DescribeDBRecommendationsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeDBRecommendations")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeDBRecommendationsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeDBSecurityGroups struct {
}

func (*awsAwsquery_serializeOpDescribeDBSecurityGroups) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeDBSecurityGroups) 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.(*DescribeDBSecurityGroupsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeDBSecurityGroups")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeDBSecurityGroupsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeDBShardGroups struct {
}

func (*awsAwsquery_serializeOpDescribeDBShardGroups) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeDBShardGroups) 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.(*DescribeDBShardGroupsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeDBShardGroups")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeDBShardGroupsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeDBSnapshotAttributes struct {
}

func (*awsAwsquery_serializeOpDescribeDBSnapshotAttributes) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeDBSnapshotAttributes) 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.(*DescribeDBSnapshotAttributesInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeDBSnapshotAttributes")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeDBSnapshotAttributesInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeDBSnapshots struct {
}

func (*awsAwsquery_serializeOpDescribeDBSnapshots) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeDBSnapshots) 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.(*DescribeDBSnapshotsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeDBSnapshots")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeDBSnapshotsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeDBSnapshotTenantDatabases struct {
}

func (*awsAwsquery_serializeOpDescribeDBSnapshotTenantDatabases) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeDBSnapshotTenantDatabases) 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.(*DescribeDBSnapshotTenantDatabasesInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeDBSnapshotTenantDatabases")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeDBSnapshotTenantDatabasesInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeDBSubnetGroups struct {
}

func (*awsAwsquery_serializeOpDescribeDBSubnetGroups) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeDBSubnetGroups) 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.(*DescribeDBSubnetGroupsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeDBSubnetGroups")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeDBSubnetGroupsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeEngineDefaultClusterParameters struct {
}

func (*awsAwsquery_serializeOpDescribeEngineDefaultClusterParameters) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeEngineDefaultClusterParameters) 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.(*DescribeEngineDefaultClusterParametersInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeEngineDefaultClusterParameters")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeEngineDefaultClusterParametersInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeEngineDefaultParameters struct {
}

func (*awsAwsquery_serializeOpDescribeEngineDefaultParameters) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeEngineDefaultParameters) 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.(*DescribeEngineDefaultParametersInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeEngineDefaultParameters")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeEngineDefaultParametersInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeEventCategories struct {
}

func (*awsAwsquery_serializeOpDescribeEventCategories) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeEventCategories) 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.(*DescribeEventCategoriesInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeEventCategories")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeEventCategoriesInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeEvents struct {
}

func (*awsAwsquery_serializeOpDescribeEvents) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeEvents) 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.(*DescribeEventsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeEvents")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeEventsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeEventSubscriptions struct {
}

func (*awsAwsquery_serializeOpDescribeEventSubscriptions) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeEventSubscriptions) 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.(*DescribeEventSubscriptionsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeEventSubscriptions")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeEventSubscriptionsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeExportTasks struct {
}

func (*awsAwsquery_serializeOpDescribeExportTasks) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeExportTasks) 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.(*DescribeExportTasksInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeExportTasks")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeExportTasksInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeGlobalClusters struct {
}

func (*awsAwsquery_serializeOpDescribeGlobalClusters) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeGlobalClusters) 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.(*DescribeGlobalClustersInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeGlobalClusters")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeGlobalClustersInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeIntegrations struct {
}

func (*awsAwsquery_serializeOpDescribeIntegrations) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeIntegrations) 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.(*DescribeIntegrationsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeIntegrations")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeIntegrationsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeOptionGroupOptions struct {
}

func (*awsAwsquery_serializeOpDescribeOptionGroupOptions) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeOptionGroupOptions) 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.(*DescribeOptionGroupOptionsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeOptionGroupOptions")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeOptionGroupOptionsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeOptionGroups struct {
}

func (*awsAwsquery_serializeOpDescribeOptionGroups) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeOptionGroups) 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.(*DescribeOptionGroupsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeOptionGroups")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeOptionGroupsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeOrderableDBInstanceOptions struct {
}

func (*awsAwsquery_serializeOpDescribeOrderableDBInstanceOptions) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeOrderableDBInstanceOptions) 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.(*DescribeOrderableDBInstanceOptionsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeOrderableDBInstanceOptions")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeOrderableDBInstanceOptionsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribePendingMaintenanceActions struct {
}

func (*awsAwsquery_serializeOpDescribePendingMaintenanceActions) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribePendingMaintenanceActions) 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.(*DescribePendingMaintenanceActionsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribePendingMaintenanceActions")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribePendingMaintenanceActionsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeReservedDBInstances struct {
}

func (*awsAwsquery_serializeOpDescribeReservedDBInstances) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeReservedDBInstances) 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.(*DescribeReservedDBInstancesInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeReservedDBInstances")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeReservedDBInstancesInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeReservedDBInstancesOfferings struct {
}

func (*awsAwsquery_serializeOpDescribeReservedDBInstancesOfferings) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeReservedDBInstancesOfferings) 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.(*DescribeReservedDBInstancesOfferingsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeReservedDBInstancesOfferings")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeReservedDBInstancesOfferingsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeServerlessV2PlatformVersions struct {
}

func (*awsAwsquery_serializeOpDescribeServerlessV2PlatformVersions) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeServerlessV2PlatformVersions) 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.(*DescribeServerlessV2PlatformVersionsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeServerlessV2PlatformVersions")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeServerlessV2PlatformVersionsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeSourceRegions struct {
}

func (*awsAwsquery_serializeOpDescribeSourceRegions) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeSourceRegions) 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.(*DescribeSourceRegionsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeSourceRegions")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeSourceRegionsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeTenantDatabases struct {
}

func (*awsAwsquery_serializeOpDescribeTenantDatabases) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeTenantDatabases) 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.(*DescribeTenantDatabasesInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeTenantDatabases")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeTenantDatabasesInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDescribeValidDBInstanceModifications struct {
}

func (*awsAwsquery_serializeOpDescribeValidDBInstanceModifications) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDescribeValidDBInstanceModifications) 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.(*DescribeValidDBInstanceModificationsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeValidDBInstanceModifications")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDescribeValidDBInstanceModificationsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDisableHttpEndpoint struct {
}

func (*awsAwsquery_serializeOpDisableHttpEndpoint) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDisableHttpEndpoint) 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.(*DisableHttpEndpointInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DisableHttpEndpoint")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDisableHttpEndpointInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpDownloadDBLogFilePortion struct {
}

func (*awsAwsquery_serializeOpDownloadDBLogFilePortion) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpDownloadDBLogFilePortion) 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.(*DownloadDBLogFilePortionInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DownloadDBLogFilePortion")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentDownloadDBLogFilePortionInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpEnableHttpEndpoint struct {
}

func (*awsAwsquery_serializeOpEnableHttpEndpoint) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpEnableHttpEndpoint) 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.(*EnableHttpEndpointInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("EnableHttpEndpoint")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentEnableHttpEndpointInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpFailoverDBCluster struct {
}

func (*awsAwsquery_serializeOpFailoverDBCluster) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpFailoverDBCluster) 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.(*FailoverDBClusterInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("FailoverDBCluster")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentFailoverDBClusterInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpFailoverGlobalCluster struct {
}

func (*awsAwsquery_serializeOpFailoverGlobalCluster) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpFailoverGlobalCluster) 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.(*FailoverGlobalClusterInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("FailoverGlobalCluster")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentFailoverGlobalClusterInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpListTagsForResource struct {
}

func (*awsAwsquery_serializeOpListTagsForResource) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpListTagsForResource) 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.(*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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ListTagsForResource")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentListTagsForResourceInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpModifyActivityStream struct {
}

func (*awsAwsquery_serializeOpModifyActivityStream) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpModifyActivityStream) 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.(*ModifyActivityStreamInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ModifyActivityStream")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentModifyActivityStreamInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpModifyCertificates struct {
}

func (*awsAwsquery_serializeOpModifyCertificates) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpModifyCertificates) 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.(*ModifyCertificatesInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ModifyCertificates")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentModifyCertificatesInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpModifyCurrentDBClusterCapacity struct {
}

func (*awsAwsquery_serializeOpModifyCurrentDBClusterCapacity) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpModifyCurrentDBClusterCapacity) 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.(*ModifyCurrentDBClusterCapacityInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ModifyCurrentDBClusterCapacity")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentModifyCurrentDBClusterCapacityInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpModifyCustomDBEngineVersion struct {
}

func (*awsAwsquery_serializeOpModifyCustomDBEngineVersion) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpModifyCustomDBEngineVersion) 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.(*ModifyCustomDBEngineVersionInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ModifyCustomDBEngineVersion")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentModifyCustomDBEngineVersionInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpModifyDBCluster struct {
}

func (*awsAwsquery_serializeOpModifyDBCluster) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpModifyDBCluster) 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.(*ModifyDBClusterInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ModifyDBCluster")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentModifyDBClusterInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpModifyDBClusterEndpoint struct {
}

func (*awsAwsquery_serializeOpModifyDBClusterEndpoint) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpModifyDBClusterEndpoint) 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.(*ModifyDBClusterEndpointInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ModifyDBClusterEndpoint")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentModifyDBClusterEndpointInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpModifyDBClusterParameterGroup struct {
}

func (*awsAwsquery_serializeOpModifyDBClusterParameterGroup) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpModifyDBClusterParameterGroup) 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.(*ModifyDBClusterParameterGroupInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ModifyDBClusterParameterGroup")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentModifyDBClusterParameterGroupInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpModifyDBClusterSnapshotAttribute struct {
}

func (*awsAwsquery_serializeOpModifyDBClusterSnapshotAttribute) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpModifyDBClusterSnapshotAttribute) 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.(*ModifyDBClusterSnapshotAttributeInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ModifyDBClusterSnapshotAttribute")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentModifyDBClusterSnapshotAttributeInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpModifyDBInstance struct {
}

func (*awsAwsquery_serializeOpModifyDBInstance) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpModifyDBInstance) 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.(*ModifyDBInstanceInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ModifyDBInstance")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentModifyDBInstanceInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpModifyDBParameterGroup struct {
}

func (*awsAwsquery_serializeOpModifyDBParameterGroup) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpModifyDBParameterGroup) 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.(*ModifyDBParameterGroupInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ModifyDBParameterGroup")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentModifyDBParameterGroupInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpModifyDBProxy struct {
}

func (*awsAwsquery_serializeOpModifyDBProxy) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpModifyDBProxy) 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.(*ModifyDBProxyInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ModifyDBProxy")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentModifyDBProxyInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpModifyDBProxyEndpoint struct {
}

func (*awsAwsquery_serializeOpModifyDBProxyEndpoint) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpModifyDBProxyEndpoint) 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.(*ModifyDBProxyEndpointInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ModifyDBProxyEndpoint")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentModifyDBProxyEndpointInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpModifyDBProxyTargetGroup struct {
}

func (*awsAwsquery_serializeOpModifyDBProxyTargetGroup) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpModifyDBProxyTargetGroup) 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.(*ModifyDBProxyTargetGroupInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ModifyDBProxyTargetGroup")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentModifyDBProxyTargetGroupInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpModifyDBRecommendation struct {
}

func (*awsAwsquery_serializeOpModifyDBRecommendation) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpModifyDBRecommendation) 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.(*ModifyDBRecommendationInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ModifyDBRecommendation")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentModifyDBRecommendationInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpModifyDBShardGroup struct {
}

func (*awsAwsquery_serializeOpModifyDBShardGroup) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpModifyDBShardGroup) 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.(*ModifyDBShardGroupInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ModifyDBShardGroup")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentModifyDBShardGroupInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpModifyDBSnapshot struct {
}

func (*awsAwsquery_serializeOpModifyDBSnapshot) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpModifyDBSnapshot) 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.(*ModifyDBSnapshotInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ModifyDBSnapshot")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentModifyDBSnapshotInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpModifyDBSnapshotAttribute struct {
}

func (*awsAwsquery_serializeOpModifyDBSnapshotAttribute) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpModifyDBSnapshotAttribute) 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.(*ModifyDBSnapshotAttributeInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ModifyDBSnapshotAttribute")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentModifyDBSnapshotAttributeInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpModifyDBSubnetGroup struct {
}

func (*awsAwsquery_serializeOpModifyDBSubnetGroup) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpModifyDBSubnetGroup) 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.(*ModifyDBSubnetGroupInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ModifyDBSubnetGroup")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentModifyDBSubnetGroupInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpModifyEventSubscription struct {
}

func (*awsAwsquery_serializeOpModifyEventSubscription) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpModifyEventSubscription) 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.(*ModifyEventSubscriptionInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ModifyEventSubscription")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentModifyEventSubscriptionInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpModifyGlobalCluster struct {
}

func (*awsAwsquery_serializeOpModifyGlobalCluster) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpModifyGlobalCluster) 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.(*ModifyGlobalClusterInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ModifyGlobalCluster")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentModifyGlobalClusterInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpModifyIntegration struct {
}

func (*awsAwsquery_serializeOpModifyIntegration) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpModifyIntegration) 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.(*ModifyIntegrationInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ModifyIntegration")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentModifyIntegrationInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpModifyOptionGroup struct {
}

func (*awsAwsquery_serializeOpModifyOptionGroup) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpModifyOptionGroup) 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.(*ModifyOptionGroupInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ModifyOptionGroup")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentModifyOptionGroupInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpModifyTenantDatabase struct {
}

func (*awsAwsquery_serializeOpModifyTenantDatabase) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpModifyTenantDatabase) 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.(*ModifyTenantDatabaseInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ModifyTenantDatabase")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentModifyTenantDatabaseInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpPromoteReadReplica struct {
}

func (*awsAwsquery_serializeOpPromoteReadReplica) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpPromoteReadReplica) 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.(*PromoteReadReplicaInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("PromoteReadReplica")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentPromoteReadReplicaInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpPromoteReadReplicaDBCluster struct {
}

func (*awsAwsquery_serializeOpPromoteReadReplicaDBCluster) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpPromoteReadReplicaDBCluster) 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.(*PromoteReadReplicaDBClusterInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("PromoteReadReplicaDBCluster")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentPromoteReadReplicaDBClusterInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpPurchaseReservedDBInstancesOffering struct {
}

func (*awsAwsquery_serializeOpPurchaseReservedDBInstancesOffering) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpPurchaseReservedDBInstancesOffering) 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.(*PurchaseReservedDBInstancesOfferingInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("PurchaseReservedDBInstancesOffering")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentPurchaseReservedDBInstancesOfferingInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpRebootDBCluster struct {
}

func (*awsAwsquery_serializeOpRebootDBCluster) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpRebootDBCluster) 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.(*RebootDBClusterInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("RebootDBCluster")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentRebootDBClusterInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpRebootDBInstance struct {
}

func (*awsAwsquery_serializeOpRebootDBInstance) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpRebootDBInstance) 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.(*RebootDBInstanceInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("RebootDBInstance")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentRebootDBInstanceInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpRebootDBShardGroup struct {
}

func (*awsAwsquery_serializeOpRebootDBShardGroup) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpRebootDBShardGroup) 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.(*RebootDBShardGroupInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("RebootDBShardGroup")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentRebootDBShardGroupInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpRegisterDBProxyTargets struct {
}

func (*awsAwsquery_serializeOpRegisterDBProxyTargets) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpRegisterDBProxyTargets) 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.(*RegisterDBProxyTargetsInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("RegisterDBProxyTargets")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentRegisterDBProxyTargetsInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpRemoveFromGlobalCluster struct {
}

func (*awsAwsquery_serializeOpRemoveFromGlobalCluster) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpRemoveFromGlobalCluster) 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.(*RemoveFromGlobalClusterInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("RemoveFromGlobalCluster")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentRemoveFromGlobalClusterInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpRemoveRoleFromDBCluster struct {
}

func (*awsAwsquery_serializeOpRemoveRoleFromDBCluster) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpRemoveRoleFromDBCluster) 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.(*RemoveRoleFromDBClusterInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("RemoveRoleFromDBCluster")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentRemoveRoleFromDBClusterInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpRemoveRoleFromDBInstance struct {
}

func (*awsAwsquery_serializeOpRemoveRoleFromDBInstance) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpRemoveRoleFromDBInstance) 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.(*RemoveRoleFromDBInstanceInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("RemoveRoleFromDBInstance")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentRemoveRoleFromDBInstanceInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpRemoveSourceIdentifierFromSubscription struct {
}

func (*awsAwsquery_serializeOpRemoveSourceIdentifierFromSubscription) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpRemoveSourceIdentifierFromSubscription) 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.(*RemoveSourceIdentifierFromSubscriptionInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("RemoveSourceIdentifierFromSubscription")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentRemoveSourceIdentifierFromSubscriptionInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpRemoveTagsFromResource struct {
}

func (*awsAwsquery_serializeOpRemoveTagsFromResource) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpRemoveTagsFromResource) 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.(*RemoveTagsFromResourceInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("RemoveTagsFromResource")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentRemoveTagsFromResourceInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpResetDBClusterParameterGroup struct {
}

func (*awsAwsquery_serializeOpResetDBClusterParameterGroup) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpResetDBClusterParameterGroup) 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.(*ResetDBClusterParameterGroupInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ResetDBClusterParameterGroup")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentResetDBClusterParameterGroupInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpResetDBParameterGroup struct {
}

func (*awsAwsquery_serializeOpResetDBParameterGroup) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpResetDBParameterGroup) 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.(*ResetDBParameterGroupInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ResetDBParameterGroup")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentResetDBParameterGroupInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpRestoreDBClusterFromS3 struct {
}

func (*awsAwsquery_serializeOpRestoreDBClusterFromS3) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpRestoreDBClusterFromS3) 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.(*RestoreDBClusterFromS3Input)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("RestoreDBClusterFromS3")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentRestoreDBClusterFromS3Input(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpRestoreDBClusterFromSnapshot struct {
}

func (*awsAwsquery_serializeOpRestoreDBClusterFromSnapshot) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpRestoreDBClusterFromSnapshot) 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.(*RestoreDBClusterFromSnapshotInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("RestoreDBClusterFromSnapshot")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentRestoreDBClusterFromSnapshotInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpRestoreDBClusterToPointInTime struct {
}

func (*awsAwsquery_serializeOpRestoreDBClusterToPointInTime) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpRestoreDBClusterToPointInTime) 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.(*RestoreDBClusterToPointInTimeInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("RestoreDBClusterToPointInTime")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentRestoreDBClusterToPointInTimeInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpRestoreDBInstanceFromDBSnapshot struct {
}

func (*awsAwsquery_serializeOpRestoreDBInstanceFromDBSnapshot) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpRestoreDBInstanceFromDBSnapshot) 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.(*RestoreDBInstanceFromDBSnapshotInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("RestoreDBInstanceFromDBSnapshot")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentRestoreDBInstanceFromDBSnapshotInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpRestoreDBInstanceFromS3 struct {
}

func (*awsAwsquery_serializeOpRestoreDBInstanceFromS3) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpRestoreDBInstanceFromS3) 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.(*RestoreDBInstanceFromS3Input)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("RestoreDBInstanceFromS3")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentRestoreDBInstanceFromS3Input(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpRestoreDBInstanceToPointInTime struct {
}

func (*awsAwsquery_serializeOpRestoreDBInstanceToPointInTime) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpRestoreDBInstanceToPointInTime) 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.(*RestoreDBInstanceToPointInTimeInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("RestoreDBInstanceToPointInTime")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentRestoreDBInstanceToPointInTimeInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpRevokeDBSecurityGroupIngress struct {
}

func (*awsAwsquery_serializeOpRevokeDBSecurityGroupIngress) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpRevokeDBSecurityGroupIngress) 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.(*RevokeDBSecurityGroupIngressInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("RevokeDBSecurityGroupIngress")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentRevokeDBSecurityGroupIngressInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpStartActivityStream struct {
}

func (*awsAwsquery_serializeOpStartActivityStream) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpStartActivityStream) 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.(*StartActivityStreamInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("StartActivityStream")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentStartActivityStreamInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpStartDBCluster struct {
}

func (*awsAwsquery_serializeOpStartDBCluster) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpStartDBCluster) 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.(*StartDBClusterInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("StartDBCluster")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentStartDBClusterInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpStartDBInstance struct {
}

func (*awsAwsquery_serializeOpStartDBInstance) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpStartDBInstance) 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.(*StartDBInstanceInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("StartDBInstance")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentStartDBInstanceInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpStartDBInstanceAutomatedBackupsReplication struct {
}

func (*awsAwsquery_serializeOpStartDBInstanceAutomatedBackupsReplication) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpStartDBInstanceAutomatedBackupsReplication) 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.(*StartDBInstanceAutomatedBackupsReplicationInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("StartDBInstanceAutomatedBackupsReplication")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentStartDBInstanceAutomatedBackupsReplicationInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpStartExportTask struct {
}

func (*awsAwsquery_serializeOpStartExportTask) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpStartExportTask) 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.(*StartExportTaskInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("StartExportTask")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentStartExportTaskInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpStopActivityStream struct {
}

func (*awsAwsquery_serializeOpStopActivityStream) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpStopActivityStream) 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.(*StopActivityStreamInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("StopActivityStream")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentStopActivityStreamInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpStopDBCluster struct {
}

func (*awsAwsquery_serializeOpStopDBCluster) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpStopDBCluster) 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.(*StopDBClusterInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("StopDBCluster")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentStopDBClusterInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpStopDBInstance struct {
}

func (*awsAwsquery_serializeOpStopDBInstance) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpStopDBInstance) 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.(*StopDBInstanceInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("StopDBInstance")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentStopDBInstanceInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpStopDBInstanceAutomatedBackupsReplication struct {
}

func (*awsAwsquery_serializeOpStopDBInstanceAutomatedBackupsReplication) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpStopDBInstanceAutomatedBackupsReplication) 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.(*StopDBInstanceAutomatedBackupsReplicationInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("StopDBInstanceAutomatedBackupsReplication")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentStopDBInstanceAutomatedBackupsReplicationInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpSwitchoverBlueGreenDeployment struct {
}

func (*awsAwsquery_serializeOpSwitchoverBlueGreenDeployment) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpSwitchoverBlueGreenDeployment) 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.(*SwitchoverBlueGreenDeploymentInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("SwitchoverBlueGreenDeployment")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentSwitchoverBlueGreenDeploymentInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpSwitchoverGlobalCluster struct {
}

func (*awsAwsquery_serializeOpSwitchoverGlobalCluster) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpSwitchoverGlobalCluster) 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.(*SwitchoverGlobalClusterInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("SwitchoverGlobalCluster")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentSwitchoverGlobalClusterInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeOpSwitchoverReadReplica struct {
}

func (*awsAwsquery_serializeOpSwitchoverReadReplica) ID() string {
	return "OperationSerializer"
}

func (m *awsAwsquery_serializeOpSwitchoverReadReplica) 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.(*SwitchoverReadReplicaInput)
	_ = 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-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("SwitchoverReadReplica")
	body.Key("Version").String("2014-10-31")

	if err := awsAwsquery_serializeOpDocumentSwitchoverReadReplicaInput(input, bodyEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	err = bodyEncoder.Encode()
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(bodyWriter.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 awsAwsquery_serializeDocumentAdditionalStorageVolume(v *types.AdditionalStorageVolume, value query.Value) error {
	object := value.Object()
	_ = object

	if v.AllocatedStorage != nil {
		objectKey := object.Key("AllocatedStorage")
		objectKey.Integer(*v.AllocatedStorage)
	}

	if v.IOPS != nil {
		objectKey := object.Key("IOPS")
		objectKey.Integer(*v.IOPS)
	}

	if v.MaxAllocatedStorage != nil {
		objectKey := object.Key("MaxAllocatedStorage")
		objectKey.Integer(*v.MaxAllocatedStorage)
	}

	if v.StorageThroughput != nil {
		objectKey := object.Key("StorageThroughput")
		objectKey.Integer(*v.StorageThroughput)
	}

	if v.StorageType != nil {
		objectKey := object.Key("StorageType")
		objectKey.String(*v.StorageType)
	}

	if v.VolumeName != nil {
		objectKey := object.Key("VolumeName")
		objectKey.String(*v.VolumeName)
	}

	return nil
}

func awsAwsquery_serializeDocumentAdditionalStorageVolumesList(v []types.AdditionalStorageVolume, value query.Value) error {
	array := value.Array("member")

	for i := range v {
		av := array.Value()
		if err := awsAwsquery_serializeDocumentAdditionalStorageVolume(&v[i], av); err != nil {
			return err
		}
	}
	return nil
}

func awsAwsquery_serializeDocumentAttributeValueList(v []string, value query.Value) error {
	array := value.Array("AttributeValue")

	for i := range v {
		av := array.Value()
		av.String(v[i])
	}
	return nil
}

func awsAwsquery_serializeDocumentAvailabilityZones(v []string, value query.Value) error {
	array := value.Array("AvailabilityZone")

	for i := range v {
		av := array.Value()
		av.String(v[i])
	}
	return nil
}

func awsAwsquery_serializeDocumentCloudwatchLogsExportConfiguration(v *types.CloudwatchLogsExportConfiguration, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DisableLogTypes != nil {
		objectKey := object.Key("DisableLogTypes")
		if err := awsAwsquery_serializeDocumentLogTypeList(v.DisableLogTypes, objectKey); err != nil {
			return err
		}
	}

	if v.EnableLogTypes != nil {
		objectKey := object.Key("EnableLogTypes")
		if err := awsAwsquery_serializeDocumentLogTypeList(v.EnableLogTypes, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeDocumentConnectionPoolConfiguration(v *types.ConnectionPoolConfiguration, value query.Value) error {
	object := value.Object()
	_ = object

	if v.ConnectionBorrowTimeout != nil {
		objectKey := object.Key("ConnectionBorrowTimeout")
		objectKey.Integer(*v.ConnectionBorrowTimeout)
	}

	if v.InitQuery != nil {
		objectKey := object.Key("InitQuery")
		objectKey.String(*v.InitQuery)
	}

	if v.MaxConnectionsPercent != nil {
		objectKey := object.Key("MaxConnectionsPercent")
		objectKey.Integer(*v.MaxConnectionsPercent)
	}

	if v.MaxIdleConnectionsPercent != nil {
		objectKey := object.Key("MaxIdleConnectionsPercent")
		objectKey.Integer(*v.MaxIdleConnectionsPercent)
	}

	if v.SessionPinningFilters != nil {
		objectKey := object.Key("SessionPinningFilters")
		if err := awsAwsquery_serializeDocumentStringList(v.SessionPinningFilters, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeDocumentDBSecurityGroupNameList(v []string, value query.Value) error {
	array := value.Array("DBSecurityGroupName")

	for i := range v {
		av := array.Value()
		av.String(v[i])
	}
	return nil
}

func awsAwsquery_serializeDocumentEncryptionContextMap(v map[string]string, value query.Value) error {
	if len(v) == 0 {
		return nil
	}
	object := value.Map("key", "value")

	keys := make([]string, 0, len(v))
	for key := range v {
		keys = append(keys, key)
	}
	sort.Strings(keys)

	for _, key := range keys {
		om := object.Key(key)
		om.String(v[key])
	}
	return nil
}

func awsAwsquery_serializeDocumentEngineModeList(v []string, value query.Value) error {
	array := value.Array("member")

	for i := range v {
		av := array.Value()
		av.String(v[i])
	}
	return nil
}

func awsAwsquery_serializeDocumentEventCategoriesList(v []string, value query.Value) error {
	array := value.Array("EventCategory")

	for i := range v {
		av := array.Value()
		av.String(v[i])
	}
	return nil
}

func awsAwsquery_serializeDocumentFilter(v *types.Filter, value query.Value) error {
	object := value.Object()
	_ = object

	if v.Name != nil {
		objectKey := object.Key("Name")
		objectKey.String(*v.Name)
	}

	if v.Values != nil {
		objectKey := object.Key("Values")
		if err := awsAwsquery_serializeDocumentFilterValueList(v.Values, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeDocumentFilterList(v []types.Filter, value query.Value) error {
	array := value.Array("Filter")

	for i := range v {
		av := array.Value()
		if err := awsAwsquery_serializeDocumentFilter(&v[i], av); err != nil {
			return err
		}
	}
	return nil
}

func awsAwsquery_serializeDocumentFilterValueList(v []string, value query.Value) error {
	array := value.Array("Value")

	for i := range v {
		av := array.Value()
		av.String(v[i])
	}
	return nil
}

func awsAwsquery_serializeDocumentKeyList(v []string, value query.Value) error {
	array := value.Array("member")

	for i := range v {
		av := array.Value()
		av.String(v[i])
	}
	return nil
}

func awsAwsquery_serializeDocumentLogTypeList(v []string, value query.Value) error {
	array := value.Array("member")

	for i := range v {
		av := array.Value()
		av.String(v[i])
	}
	return nil
}

func awsAwsquery_serializeDocumentModifyAdditionalStorageVolume(v *types.ModifyAdditionalStorageVolume, value query.Value) error {
	object := value.Object()
	_ = object

	if v.AllocatedStorage != nil {
		objectKey := object.Key("AllocatedStorage")
		objectKey.Integer(*v.AllocatedStorage)
	}

	if v.IOPS != nil {
		objectKey := object.Key("IOPS")
		objectKey.Integer(*v.IOPS)
	}

	if v.MaxAllocatedStorage != nil {
		objectKey := object.Key("MaxAllocatedStorage")
		objectKey.Integer(*v.MaxAllocatedStorage)
	}

	if v.SetForDelete != nil {
		objectKey := object.Key("SetForDelete")
		objectKey.Boolean(*v.SetForDelete)
	}

	if v.StorageThroughput != nil {
		objectKey := object.Key("StorageThroughput")
		objectKey.Integer(*v.StorageThroughput)
	}

	if v.StorageType != nil {
		objectKey := object.Key("StorageType")
		objectKey.String(*v.StorageType)
	}

	if v.VolumeName != nil {
		objectKey := object.Key("VolumeName")
		objectKey.String(*v.VolumeName)
	}

	return nil
}

func awsAwsquery_serializeDocumentModifyAdditionalStorageVolumesList(v []types.ModifyAdditionalStorageVolume, value query.Value) error {
	array := value.Array("member")

	for i := range v {
		av := array.Value()
		if err := awsAwsquery_serializeDocumentModifyAdditionalStorageVolume(&v[i], av); err != nil {
			return err
		}
	}
	return nil
}

func awsAwsquery_serializeDocumentOptionConfiguration(v *types.OptionConfiguration, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBSecurityGroupMemberships != nil {
		objectKey := object.Key("DBSecurityGroupMemberships")
		if err := awsAwsquery_serializeDocumentDBSecurityGroupNameList(v.DBSecurityGroupMemberships, objectKey); err != nil {
			return err
		}
	}

	if v.OptionName != nil {
		objectKey := object.Key("OptionName")
		objectKey.String(*v.OptionName)
	}

	if v.OptionSettings != nil {
		objectKey := object.Key("OptionSettings")
		if err := awsAwsquery_serializeDocumentOptionSettingsList(v.OptionSettings, objectKey); err != nil {
			return err
		}
	}

	if v.OptionVersion != nil {
		objectKey := object.Key("OptionVersion")
		objectKey.String(*v.OptionVersion)
	}

	if v.Port != nil {
		objectKey := object.Key("Port")
		objectKey.Integer(*v.Port)
	}

	if v.VpcSecurityGroupMemberships != nil {
		objectKey := object.Key("VpcSecurityGroupMemberships")
		if err := awsAwsquery_serializeDocumentVpcSecurityGroupIdList(v.VpcSecurityGroupMemberships, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeDocumentOptionConfigurationList(v []types.OptionConfiguration, value query.Value) error {
	array := value.Array("OptionConfiguration")

	for i := range v {
		av := array.Value()
		if err := awsAwsquery_serializeDocumentOptionConfiguration(&v[i], av); err != nil {
			return err
		}
	}
	return nil
}

func awsAwsquery_serializeDocumentOptionNamesList(v []string, value query.Value) error {
	array := value.Array("member")

	for i := range v {
		av := array.Value()
		av.String(v[i])
	}
	return nil
}

func awsAwsquery_serializeDocumentOptionSetting(v *types.OptionSetting, value query.Value) error {
	object := value.Object()
	_ = object

	if v.AllowedValues != nil {
		objectKey := object.Key("AllowedValues")
		objectKey.String(*v.AllowedValues)
	}

	if v.ApplyType != nil {
		objectKey := object.Key("ApplyType")
		objectKey.String(*v.ApplyType)
	}

	if v.DataType != nil {
		objectKey := object.Key("DataType")
		objectKey.String(*v.DataType)
	}

	if v.DefaultValue != nil {
		objectKey := object.Key("DefaultValue")
		objectKey.String(*v.DefaultValue)
	}

	if v.Description != nil {
		objectKey := object.Key("Description")
		objectKey.String(*v.Description)
	}

	if v.IsCollection != nil {
		objectKey := object.Key("IsCollection")
		objectKey.Boolean(*v.IsCollection)
	}

	if v.IsModifiable != nil {
		objectKey := object.Key("IsModifiable")
		objectKey.Boolean(*v.IsModifiable)
	}

	if v.Name != nil {
		objectKey := object.Key("Name")
		objectKey.String(*v.Name)
	}

	if v.Value != nil {
		objectKey := object.Key("Value")
		objectKey.String(*v.Value)
	}

	return nil
}

func awsAwsquery_serializeDocumentOptionSettingsList(v []types.OptionSetting, value query.Value) error {
	array := value.Array("OptionSetting")

	for i := range v {
		av := array.Value()
		if err := awsAwsquery_serializeDocumentOptionSetting(&v[i], av); err != nil {
			return err
		}
	}
	return nil
}

func awsAwsquery_serializeDocumentParameter(v *types.Parameter, value query.Value) error {
	object := value.Object()
	_ = object

	if v.AllowedValues != nil {
		objectKey := object.Key("AllowedValues")
		objectKey.String(*v.AllowedValues)
	}

	if len(v.ApplyMethod) > 0 {
		objectKey := object.Key("ApplyMethod")
		objectKey.String(string(v.ApplyMethod))
	}

	if v.ApplyType != nil {
		objectKey := object.Key("ApplyType")
		objectKey.String(*v.ApplyType)
	}

	if v.DataType != nil {
		objectKey := object.Key("DataType")
		objectKey.String(*v.DataType)
	}

	if v.Description != nil {
		objectKey := object.Key("Description")
		objectKey.String(*v.Description)
	}

	if v.IsModifiable != nil {
		objectKey := object.Key("IsModifiable")
		objectKey.Boolean(*v.IsModifiable)
	}

	if v.MinimumEngineVersion != nil {
		objectKey := object.Key("MinimumEngineVersion")
		objectKey.String(*v.MinimumEngineVersion)
	}

	if v.ParameterName != nil {
		objectKey := object.Key("ParameterName")
		objectKey.String(*v.ParameterName)
	}

	if v.ParameterValue != nil {
		objectKey := object.Key("ParameterValue")
		objectKey.String(*v.ParameterValue)
	}

	if v.Source != nil {
		objectKey := object.Key("Source")
		objectKey.String(*v.Source)
	}

	if v.SupportedEngineModes != nil {
		objectKey := object.Key("SupportedEngineModes")
		if err := awsAwsquery_serializeDocumentEngineModeList(v.SupportedEngineModes, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeDocumentParametersList(v []types.Parameter, value query.Value) error {
	array := value.Array("Parameter")

	for i := range v {
		av := array.Value()
		if err := awsAwsquery_serializeDocumentParameter(&v[i], av); err != nil {
			return err
		}
	}
	return nil
}

func awsAwsquery_serializeDocumentProcessorFeature(v *types.ProcessorFeature, value query.Value) error {
	object := value.Object()
	_ = object

	if v.Name != nil {
		objectKey := object.Key("Name")
		objectKey.String(*v.Name)
	}

	if v.Value != nil {
		objectKey := object.Key("Value")
		objectKey.String(*v.Value)
	}

	return nil
}

func awsAwsquery_serializeDocumentProcessorFeatureList(v []types.ProcessorFeature, value query.Value) error {
	array := value.Array("ProcessorFeature")

	for i := range v {
		av := array.Value()
		if err := awsAwsquery_serializeDocumentProcessorFeature(&v[i], av); err != nil {
			return err
		}
	}
	return nil
}

func awsAwsquery_serializeDocumentRdsCustomClusterConfiguration(v *types.RdsCustomClusterConfiguration, value query.Value) error {
	object := value.Object()
	_ = object

	if v.InterconnectSubnetId != nil {
		objectKey := object.Key("InterconnectSubnetId")
		objectKey.String(*v.InterconnectSubnetId)
	}

	if len(v.ReplicaMode) > 0 {
		objectKey := object.Key("ReplicaMode")
		objectKey.String(string(v.ReplicaMode))
	}

	if v.TransitGatewayMulticastDomainId != nil {
		objectKey := object.Key("TransitGatewayMulticastDomainId")
		objectKey.String(*v.TransitGatewayMulticastDomainId)
	}

	return nil
}

func awsAwsquery_serializeDocumentRecommendedActionUpdate(v *types.RecommendedActionUpdate, value query.Value) error {
	object := value.Object()
	_ = object

	if v.ActionId != nil {
		objectKey := object.Key("ActionId")
		objectKey.String(*v.ActionId)
	}

	if v.Status != nil {
		objectKey := object.Key("Status")
		objectKey.String(*v.Status)
	}

	return nil
}

func awsAwsquery_serializeDocumentRecommendedActionUpdateList(v []types.RecommendedActionUpdate, value query.Value) error {
	array := value.Array("member")

	for i := range v {
		av := array.Value()
		if err := awsAwsquery_serializeDocumentRecommendedActionUpdate(&v[i], av); err != nil {
			return err
		}
	}
	return nil
}

func awsAwsquery_serializeDocumentScalingConfiguration(v *types.ScalingConfiguration, value query.Value) error {
	object := value.Object()
	_ = object

	if v.AutoPause != nil {
		objectKey := object.Key("AutoPause")
		objectKey.Boolean(*v.AutoPause)
	}

	if v.MaxCapacity != nil {
		objectKey := object.Key("MaxCapacity")
		objectKey.Integer(*v.MaxCapacity)
	}

	if v.MinCapacity != nil {
		objectKey := object.Key("MinCapacity")
		objectKey.Integer(*v.MinCapacity)
	}

	if v.SecondsBeforeTimeout != nil {
		objectKey := object.Key("SecondsBeforeTimeout")
		objectKey.Integer(*v.SecondsBeforeTimeout)
	}

	if v.SecondsUntilAutoPause != nil {
		objectKey := object.Key("SecondsUntilAutoPause")
		objectKey.Integer(*v.SecondsUntilAutoPause)
	}

	if v.TimeoutAction != nil {
		objectKey := object.Key("TimeoutAction")
		objectKey.String(*v.TimeoutAction)
	}

	return nil
}

func awsAwsquery_serializeDocumentServerlessV2ScalingConfiguration(v *types.ServerlessV2ScalingConfiguration, value query.Value) error {
	object := value.Object()
	_ = object

	if v.MaxCapacity != nil {
		objectKey := object.Key("MaxCapacity")
		switch {
		case math.IsNaN(*v.MaxCapacity):
			objectKey.String("NaN")

		case math.IsInf(*v.MaxCapacity, 1):
			objectKey.String("Infinity")

		case math.IsInf(*v.MaxCapacity, -1):
			objectKey.String("-Infinity")

		default:
			objectKey.Double(*v.MaxCapacity)

		}
	}

	if v.MinCapacity != nil {
		objectKey := object.Key("MinCapacity")
		switch {
		case math.IsNaN(*v.MinCapacity):
			objectKey.String("NaN")

		case math.IsInf(*v.MinCapacity, 1):
			objectKey.String("Infinity")

		case math.IsInf(*v.MinCapacity, -1):
			objectKey.String("-Infinity")

		default:
			objectKey.Double(*v.MinCapacity)

		}
	}

	if v.SecondsUntilAutoPause != nil {
		objectKey := object.Key("SecondsUntilAutoPause")
		objectKey.Integer(*v.SecondsUntilAutoPause)
	}

	return nil
}

func awsAwsquery_serializeDocumentSourceIdsList(v []string, value query.Value) error {
	array := value.Array("SourceId")

	for i := range v {
		av := array.Value()
		av.String(v[i])
	}
	return nil
}

func awsAwsquery_serializeDocumentStringList(v []string, value query.Value) error {
	array := value.Array("member")

	for i := range v {
		av := array.Value()
		av.String(v[i])
	}
	return nil
}

func awsAwsquery_serializeDocumentSubnetIdentifierList(v []string, value query.Value) error {
	array := value.Array("SubnetIdentifier")

	for i := range v {
		av := array.Value()
		av.String(v[i])
	}
	return nil
}

func awsAwsquery_serializeDocumentTag(v *types.Tag, value query.Value) error {
	object := value.Object()
	_ = object

	if v.Key != nil {
		objectKey := object.Key("Key")
		objectKey.String(*v.Key)
	}

	if v.Value != nil {
		objectKey := object.Key("Value")
		objectKey.String(*v.Value)
	}

	return nil
}

func awsAwsquery_serializeDocumentTagList(v []types.Tag, value query.Value) error {
	array := value.Array("Tag")

	for i := range v {
		av := array.Value()
		if err := awsAwsquery_serializeDocumentTag(&v[i], av); err != nil {
			return err
		}
	}
	return nil
}

func awsAwsquery_serializeDocumentTagSpecification(v *types.TagSpecification, value query.Value) error {
	object := value.Object()
	_ = object

	if v.ResourceType != nil {
		objectKey := object.Key("ResourceType")
		objectKey.String(*v.ResourceType)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeDocumentTagSpecificationList(v []types.TagSpecification, value query.Value) error {
	array := value.Array("item")

	for i := range v {
		av := array.Value()
		if err := awsAwsquery_serializeDocumentTagSpecification(&v[i], av); err != nil {
			return err
		}
	}
	return nil
}

func awsAwsquery_serializeDocumentUserAuthConfig(v *types.UserAuthConfig, value query.Value) error {
	object := value.Object()
	_ = object

	if len(v.AuthScheme) > 0 {
		objectKey := object.Key("AuthScheme")
		objectKey.String(string(v.AuthScheme))
	}

	if len(v.ClientPasswordAuthType) > 0 {
		objectKey := object.Key("ClientPasswordAuthType")
		objectKey.String(string(v.ClientPasswordAuthType))
	}

	if v.Description != nil {
		objectKey := object.Key("Description")
		objectKey.String(*v.Description)
	}

	if len(v.IAMAuth) > 0 {
		objectKey := object.Key("IAMAuth")
		objectKey.String(string(v.IAMAuth))
	}

	if v.SecretArn != nil {
		objectKey := object.Key("SecretArn")
		objectKey.String(*v.SecretArn)
	}

	if v.UserName != nil {
		objectKey := object.Key("UserName")
		objectKey.String(*v.UserName)
	}

	return nil
}

func awsAwsquery_serializeDocumentUserAuthConfigList(v []types.UserAuthConfig, value query.Value) error {
	array := value.Array("member")

	for i := range v {
		av := array.Value()
		if err := awsAwsquery_serializeDocumentUserAuthConfig(&v[i], av); err != nil {
			return err
		}
	}
	return nil
}

func awsAwsquery_serializeDocumentVpcSecurityGroupIdList(v []string, value query.Value) error {
	array := value.Array("VpcSecurityGroupId")

	for i := range v {
		av := array.Value()
		av.String(v[i])
	}
	return nil
}

func awsAwsquery_serializeOpDocumentAddRoleToDBClusterInput(v *AddRoleToDBClusterInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBClusterIdentifier != nil {
		objectKey := object.Key("DBClusterIdentifier")
		objectKey.String(*v.DBClusterIdentifier)
	}

	if v.FeatureName != nil {
		objectKey := object.Key("FeatureName")
		objectKey.String(*v.FeatureName)
	}

	if v.RoleArn != nil {
		objectKey := object.Key("RoleArn")
		objectKey.String(*v.RoleArn)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentAddRoleToDBInstanceInput(v *AddRoleToDBInstanceInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBInstanceIdentifier != nil {
		objectKey := object.Key("DBInstanceIdentifier")
		objectKey.String(*v.DBInstanceIdentifier)
	}

	if v.FeatureName != nil {
		objectKey := object.Key("FeatureName")
		objectKey.String(*v.FeatureName)
	}

	if v.RoleArn != nil {
		objectKey := object.Key("RoleArn")
		objectKey.String(*v.RoleArn)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentAddSourceIdentifierToSubscriptionInput(v *AddSourceIdentifierToSubscriptionInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.SourceIdentifier != nil {
		objectKey := object.Key("SourceIdentifier")
		objectKey.String(*v.SourceIdentifier)
	}

	if v.SubscriptionName != nil {
		objectKey := object.Key("SubscriptionName")
		objectKey.String(*v.SubscriptionName)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentAddTagsToResourceInput(v *AddTagsToResourceInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.ResourceName != nil {
		objectKey := object.Key("ResourceName")
		objectKey.String(*v.ResourceName)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentApplyPendingMaintenanceActionInput(v *ApplyPendingMaintenanceActionInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.ApplyAction != nil {
		objectKey := object.Key("ApplyAction")
		objectKey.String(*v.ApplyAction)
	}

	if v.OptInType != nil {
		objectKey := object.Key("OptInType")
		objectKey.String(*v.OptInType)
	}

	if v.ResourceIdentifier != nil {
		objectKey := object.Key("ResourceIdentifier")
		objectKey.String(*v.ResourceIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentAuthorizeDBSecurityGroupIngressInput(v *AuthorizeDBSecurityGroupIngressInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.CIDRIP != nil {
		objectKey := object.Key("CIDRIP")
		objectKey.String(*v.CIDRIP)
	}

	if v.DBSecurityGroupName != nil {
		objectKey := object.Key("DBSecurityGroupName")
		objectKey.String(*v.DBSecurityGroupName)
	}

	if v.EC2SecurityGroupId != nil {
		objectKey := object.Key("EC2SecurityGroupId")
		objectKey.String(*v.EC2SecurityGroupId)
	}

	if v.EC2SecurityGroupName != nil {
		objectKey := object.Key("EC2SecurityGroupName")
		objectKey.String(*v.EC2SecurityGroupName)
	}

	if v.EC2SecurityGroupOwnerId != nil {
		objectKey := object.Key("EC2SecurityGroupOwnerId")
		objectKey.String(*v.EC2SecurityGroupOwnerId)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentBacktrackDBClusterInput(v *BacktrackDBClusterInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.BacktrackTo != nil {
		objectKey := object.Key("BacktrackTo")
		objectKey.String(smithytime.FormatDateTime(*v.BacktrackTo))
	}

	if v.DBClusterIdentifier != nil {
		objectKey := object.Key("DBClusterIdentifier")
		objectKey.String(*v.DBClusterIdentifier)
	}

	if v.Force != nil {
		objectKey := object.Key("Force")
		objectKey.Boolean(*v.Force)
	}

	if v.UseEarliestTimeOnPointInTimeUnavailable != nil {
		objectKey := object.Key("UseEarliestTimeOnPointInTimeUnavailable")
		objectKey.Boolean(*v.UseEarliestTimeOnPointInTimeUnavailable)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCancelExportTaskInput(v *CancelExportTaskInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.ExportTaskIdentifier != nil {
		objectKey := object.Key("ExportTaskIdentifier")
		objectKey.String(*v.ExportTaskIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCopyDBClusterParameterGroupInput(v *CopyDBClusterParameterGroupInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.SourceDBClusterParameterGroupIdentifier != nil {
		objectKey := object.Key("SourceDBClusterParameterGroupIdentifier")
		objectKey.String(*v.SourceDBClusterParameterGroupIdentifier)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	if v.TargetDBClusterParameterGroupDescription != nil {
		objectKey := object.Key("TargetDBClusterParameterGroupDescription")
		objectKey.String(*v.TargetDBClusterParameterGroupDescription)
	}

	if v.TargetDBClusterParameterGroupIdentifier != nil {
		objectKey := object.Key("TargetDBClusterParameterGroupIdentifier")
		objectKey.String(*v.TargetDBClusterParameterGroupIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCopyDBClusterSnapshotInput(v *CopyDBClusterSnapshotInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.CopyTags != nil {
		objectKey := object.Key("CopyTags")
		objectKey.Boolean(*v.CopyTags)
	}

	if v.destinationRegion != nil {
		objectKey := object.Key("DestinationRegion")
		objectKey.String(*v.destinationRegion)
	}

	if v.KmsKeyId != nil {
		objectKey := object.Key("KmsKeyId")
		objectKey.String(*v.KmsKeyId)
	}

	if v.PreSignedUrl != nil {
		objectKey := object.Key("PreSignedUrl")
		objectKey.String(*v.PreSignedUrl)
	}

	if v.SourceDBClusterSnapshotIdentifier != nil {
		objectKey := object.Key("SourceDBClusterSnapshotIdentifier")
		objectKey.String(*v.SourceDBClusterSnapshotIdentifier)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	if v.TargetDBClusterSnapshotIdentifier != nil {
		objectKey := object.Key("TargetDBClusterSnapshotIdentifier")
		objectKey.String(*v.TargetDBClusterSnapshotIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCopyDBParameterGroupInput(v *CopyDBParameterGroupInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.SourceDBParameterGroupIdentifier != nil {
		objectKey := object.Key("SourceDBParameterGroupIdentifier")
		objectKey.String(*v.SourceDBParameterGroupIdentifier)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	if v.TargetDBParameterGroupDescription != nil {
		objectKey := object.Key("TargetDBParameterGroupDescription")
		objectKey.String(*v.TargetDBParameterGroupDescription)
	}

	if v.TargetDBParameterGroupIdentifier != nil {
		objectKey := object.Key("TargetDBParameterGroupIdentifier")
		objectKey.String(*v.TargetDBParameterGroupIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCopyDBSnapshotInput(v *CopyDBSnapshotInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.CopyOptionGroup != nil {
		objectKey := object.Key("CopyOptionGroup")
		objectKey.Boolean(*v.CopyOptionGroup)
	}

	if v.CopyTags != nil {
		objectKey := object.Key("CopyTags")
		objectKey.Boolean(*v.CopyTags)
	}

	if v.destinationRegion != nil {
		objectKey := object.Key("DestinationRegion")
		objectKey.String(*v.destinationRegion)
	}

	if v.KmsKeyId != nil {
		objectKey := object.Key("KmsKeyId")
		objectKey.String(*v.KmsKeyId)
	}

	if v.OptionGroupName != nil {
		objectKey := object.Key("OptionGroupName")
		objectKey.String(*v.OptionGroupName)
	}

	if v.PreSignedUrl != nil {
		objectKey := object.Key("PreSignedUrl")
		objectKey.String(*v.PreSignedUrl)
	}

	if v.SnapshotAvailabilityZone != nil {
		objectKey := object.Key("SnapshotAvailabilityZone")
		objectKey.String(*v.SnapshotAvailabilityZone)
	}

	if v.SnapshotTarget != nil {
		objectKey := object.Key("SnapshotTarget")
		objectKey.String(*v.SnapshotTarget)
	}

	if v.SourceDBSnapshotIdentifier != nil {
		objectKey := object.Key("SourceDBSnapshotIdentifier")
		objectKey.String(*v.SourceDBSnapshotIdentifier)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	if v.TargetCustomAvailabilityZone != nil {
		objectKey := object.Key("TargetCustomAvailabilityZone")
		objectKey.String(*v.TargetCustomAvailabilityZone)
	}

	if v.TargetDBSnapshotIdentifier != nil {
		objectKey := object.Key("TargetDBSnapshotIdentifier")
		objectKey.String(*v.TargetDBSnapshotIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCopyOptionGroupInput(v *CopyOptionGroupInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.SourceOptionGroupIdentifier != nil {
		objectKey := object.Key("SourceOptionGroupIdentifier")
		objectKey.String(*v.SourceOptionGroupIdentifier)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	if v.TargetOptionGroupDescription != nil {
		objectKey := object.Key("TargetOptionGroupDescription")
		objectKey.String(*v.TargetOptionGroupDescription)
	}

	if v.TargetOptionGroupIdentifier != nil {
		objectKey := object.Key("TargetOptionGroupIdentifier")
		objectKey.String(*v.TargetOptionGroupIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCreateBlueGreenDeploymentInput(v *CreateBlueGreenDeploymentInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.BlueGreenDeploymentName != nil {
		objectKey := object.Key("BlueGreenDeploymentName")
		objectKey.String(*v.BlueGreenDeploymentName)
	}

	if v.Source != nil {
		objectKey := object.Key("Source")
		objectKey.String(*v.Source)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	if v.TargetAllocatedStorage != nil {
		objectKey := object.Key("TargetAllocatedStorage")
		objectKey.Integer(*v.TargetAllocatedStorage)
	}

	if v.TargetDBClusterParameterGroupName != nil {
		objectKey := object.Key("TargetDBClusterParameterGroupName")
		objectKey.String(*v.TargetDBClusterParameterGroupName)
	}

	if v.TargetDBInstanceClass != nil {
		objectKey := object.Key("TargetDBInstanceClass")
		objectKey.String(*v.TargetDBInstanceClass)
	}

	if v.TargetDBParameterGroupName != nil {
		objectKey := object.Key("TargetDBParameterGroupName")
		objectKey.String(*v.TargetDBParameterGroupName)
	}

	if v.TargetEngineVersion != nil {
		objectKey := object.Key("TargetEngineVersion")
		objectKey.String(*v.TargetEngineVersion)
	}

	if v.TargetIops != nil {
		objectKey := object.Key("TargetIops")
		objectKey.Integer(*v.TargetIops)
	}

	if v.TargetStorageThroughput != nil {
		objectKey := object.Key("TargetStorageThroughput")
		objectKey.Integer(*v.TargetStorageThroughput)
	}

	if v.TargetStorageType != nil {
		objectKey := object.Key("TargetStorageType")
		objectKey.String(*v.TargetStorageType)
	}

	if v.UpgradeTargetStorageConfig != nil {
		objectKey := object.Key("UpgradeTargetStorageConfig")
		objectKey.Boolean(*v.UpgradeTargetStorageConfig)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCreateCustomDBEngineVersionInput(v *CreateCustomDBEngineVersionInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DatabaseInstallationFiles != nil {
		objectKey := object.Key("DatabaseInstallationFiles")
		if err := awsAwsquery_serializeDocumentStringList(v.DatabaseInstallationFiles, objectKey); err != nil {
			return err
		}
	}

	if v.DatabaseInstallationFilesS3BucketName != nil {
		objectKey := object.Key("DatabaseInstallationFilesS3BucketName")
		objectKey.String(*v.DatabaseInstallationFilesS3BucketName)
	}

	if v.DatabaseInstallationFilesS3Prefix != nil {
		objectKey := object.Key("DatabaseInstallationFilesS3Prefix")
		objectKey.String(*v.DatabaseInstallationFilesS3Prefix)
	}

	if v.Description != nil {
		objectKey := object.Key("Description")
		objectKey.String(*v.Description)
	}

	if v.Engine != nil {
		objectKey := object.Key("Engine")
		objectKey.String(*v.Engine)
	}

	if v.EngineVersion != nil {
		objectKey := object.Key("EngineVersion")
		objectKey.String(*v.EngineVersion)
	}

	if v.ImageId != nil {
		objectKey := object.Key("ImageId")
		objectKey.String(*v.ImageId)
	}

	if v.KMSKeyId != nil {
		objectKey := object.Key("KMSKeyId")
		objectKey.String(*v.KMSKeyId)
	}

	if v.Manifest != nil {
		objectKey := object.Key("Manifest")
		objectKey.String(*v.Manifest)
	}

	if v.SourceCustomDbEngineVersionIdentifier != nil {
		objectKey := object.Key("SourceCustomDbEngineVersionIdentifier")
		objectKey.String(*v.SourceCustomDbEngineVersionIdentifier)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	if v.UseAwsProvidedLatestImage != nil {
		objectKey := object.Key("UseAwsProvidedLatestImage")
		objectKey.Boolean(*v.UseAwsProvidedLatestImage)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCreateDBClusterEndpointInput(v *CreateDBClusterEndpointInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBClusterEndpointIdentifier != nil {
		objectKey := object.Key("DBClusterEndpointIdentifier")
		objectKey.String(*v.DBClusterEndpointIdentifier)
	}

	if v.DBClusterIdentifier != nil {
		objectKey := object.Key("DBClusterIdentifier")
		objectKey.String(*v.DBClusterIdentifier)
	}

	if v.EndpointType != nil {
		objectKey := object.Key("EndpointType")
		objectKey.String(*v.EndpointType)
	}

	if v.ExcludedMembers != nil {
		objectKey := object.Key("ExcludedMembers")
		if err := awsAwsquery_serializeDocumentStringList(v.ExcludedMembers, objectKey); err != nil {
			return err
		}
	}

	if v.StaticMembers != nil {
		objectKey := object.Key("StaticMembers")
		if err := awsAwsquery_serializeDocumentStringList(v.StaticMembers, objectKey); err != nil {
			return err
		}
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCreateDBClusterInput(v *CreateDBClusterInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.AllocatedStorage != nil {
		objectKey := object.Key("AllocatedStorage")
		objectKey.Integer(*v.AllocatedStorage)
	}

	if v.AutoMinorVersionUpgrade != nil {
		objectKey := object.Key("AutoMinorVersionUpgrade")
		objectKey.Boolean(*v.AutoMinorVersionUpgrade)
	}

	if v.AvailabilityZones != nil {
		objectKey := object.Key("AvailabilityZones")
		if err := awsAwsquery_serializeDocumentAvailabilityZones(v.AvailabilityZones, objectKey); err != nil {
			return err
		}
	}

	if v.BacktrackWindow != nil {
		objectKey := object.Key("BacktrackWindow")
		objectKey.Long(*v.BacktrackWindow)
	}

	if v.BackupRetentionPeriod != nil {
		objectKey := object.Key("BackupRetentionPeriod")
		objectKey.Integer(*v.BackupRetentionPeriod)
	}

	if v.CACertificateIdentifier != nil {
		objectKey := object.Key("CACertificateIdentifier")
		objectKey.String(*v.CACertificateIdentifier)
	}

	if v.CharacterSetName != nil {
		objectKey := object.Key("CharacterSetName")
		objectKey.String(*v.CharacterSetName)
	}

	if len(v.ClusterScalabilityType) > 0 {
		objectKey := object.Key("ClusterScalabilityType")
		objectKey.String(string(v.ClusterScalabilityType))
	}

	if v.CopyTagsToSnapshot != nil {
		objectKey := object.Key("CopyTagsToSnapshot")
		objectKey.Boolean(*v.CopyTagsToSnapshot)
	}

	if len(v.DatabaseInsightsMode) > 0 {
		objectKey := object.Key("DatabaseInsightsMode")
		objectKey.String(string(v.DatabaseInsightsMode))
	}

	if v.DatabaseName != nil {
		objectKey := object.Key("DatabaseName")
		objectKey.String(*v.DatabaseName)
	}

	if v.DBClusterIdentifier != nil {
		objectKey := object.Key("DBClusterIdentifier")
		objectKey.String(*v.DBClusterIdentifier)
	}

	if v.DBClusterInstanceClass != nil {
		objectKey := object.Key("DBClusterInstanceClass")
		objectKey.String(*v.DBClusterInstanceClass)
	}

	if v.DBClusterParameterGroupName != nil {
		objectKey := object.Key("DBClusterParameterGroupName")
		objectKey.String(*v.DBClusterParameterGroupName)
	}

	if v.DBSubnetGroupName != nil {
		objectKey := object.Key("DBSubnetGroupName")
		objectKey.String(*v.DBSubnetGroupName)
	}

	if v.DBSystemId != nil {
		objectKey := object.Key("DBSystemId")
		objectKey.String(*v.DBSystemId)
	}

	if v.DeletionProtection != nil {
		objectKey := object.Key("DeletionProtection")
		objectKey.Boolean(*v.DeletionProtection)
	}

	if v.destinationRegion != nil {
		objectKey := object.Key("DestinationRegion")
		objectKey.String(*v.destinationRegion)
	}

	if v.Domain != nil {
		objectKey := object.Key("Domain")
		objectKey.String(*v.Domain)
	}

	if v.DomainIAMRoleName != nil {
		objectKey := object.Key("DomainIAMRoleName")
		objectKey.String(*v.DomainIAMRoleName)
	}

	if v.EnableCloudwatchLogsExports != nil {
		objectKey := object.Key("EnableCloudwatchLogsExports")
		if err := awsAwsquery_serializeDocumentLogTypeList(v.EnableCloudwatchLogsExports, objectKey); err != nil {
			return err
		}
	}

	if v.EnableGlobalWriteForwarding != nil {
		objectKey := object.Key("EnableGlobalWriteForwarding")
		objectKey.Boolean(*v.EnableGlobalWriteForwarding)
	}

	if v.EnableHttpEndpoint != nil {
		objectKey := object.Key("EnableHttpEndpoint")
		objectKey.Boolean(*v.EnableHttpEndpoint)
	}

	if v.EnableIAMDatabaseAuthentication != nil {
		objectKey := object.Key("EnableIAMDatabaseAuthentication")
		objectKey.Boolean(*v.EnableIAMDatabaseAuthentication)
	}

	if v.EnableLimitlessDatabase != nil {
		objectKey := object.Key("EnableLimitlessDatabase")
		objectKey.Boolean(*v.EnableLimitlessDatabase)
	}

	if v.EnableLocalWriteForwarding != nil {
		objectKey := object.Key("EnableLocalWriteForwarding")
		objectKey.Boolean(*v.EnableLocalWriteForwarding)
	}

	if v.EnablePerformanceInsights != nil {
		objectKey := object.Key("EnablePerformanceInsights")
		objectKey.Boolean(*v.EnablePerformanceInsights)
	}

	if v.Engine != nil {
		objectKey := object.Key("Engine")
		objectKey.String(*v.Engine)
	}

	if v.EngineLifecycleSupport != nil {
		objectKey := object.Key("EngineLifecycleSupport")
		objectKey.String(*v.EngineLifecycleSupport)
	}

	if v.EngineMode != nil {
		objectKey := object.Key("EngineMode")
		objectKey.String(*v.EngineMode)
	}

	if v.EngineVersion != nil {
		objectKey := object.Key("EngineVersion")
		objectKey.String(*v.EngineVersion)
	}

	if v.GlobalClusterIdentifier != nil {
		objectKey := object.Key("GlobalClusterIdentifier")
		objectKey.String(*v.GlobalClusterIdentifier)
	}

	if v.Iops != nil {
		objectKey := object.Key("Iops")
		objectKey.Integer(*v.Iops)
	}

	if v.KmsKeyId != nil {
		objectKey := object.Key("KmsKeyId")
		objectKey.String(*v.KmsKeyId)
	}

	if v.ManageMasterUserPassword != nil {
		objectKey := object.Key("ManageMasterUserPassword")
		objectKey.Boolean(*v.ManageMasterUserPassword)
	}

	if len(v.MasterUserAuthenticationType) > 0 {
		objectKey := object.Key("MasterUserAuthenticationType")
		objectKey.String(string(v.MasterUserAuthenticationType))
	}

	if v.MasterUsername != nil {
		objectKey := object.Key("MasterUsername")
		objectKey.String(*v.MasterUsername)
	}

	if v.MasterUserPassword != nil {
		objectKey := object.Key("MasterUserPassword")
		objectKey.String(*v.MasterUserPassword)
	}

	if v.MasterUserSecretKmsKeyId != nil {
		objectKey := object.Key("MasterUserSecretKmsKeyId")
		objectKey.String(*v.MasterUserSecretKmsKeyId)
	}

	if v.MonitoringInterval != nil {
		objectKey := object.Key("MonitoringInterval")
		objectKey.Integer(*v.MonitoringInterval)
	}

	if v.MonitoringRoleArn != nil {
		objectKey := object.Key("MonitoringRoleArn")
		objectKey.String(*v.MonitoringRoleArn)
	}

	if v.NetworkType != nil {
		objectKey := object.Key("NetworkType")
		objectKey.String(*v.NetworkType)
	}

	if v.OptionGroupName != nil {
		objectKey := object.Key("OptionGroupName")
		objectKey.String(*v.OptionGroupName)
	}

	if v.PerformanceInsightsKMSKeyId != nil {
		objectKey := object.Key("PerformanceInsightsKMSKeyId")
		objectKey.String(*v.PerformanceInsightsKMSKeyId)
	}

	if v.PerformanceInsightsRetentionPeriod != nil {
		objectKey := object.Key("PerformanceInsightsRetentionPeriod")
		objectKey.Integer(*v.PerformanceInsightsRetentionPeriod)
	}

	if v.Port != nil {
		objectKey := object.Key("Port")
		objectKey.Integer(*v.Port)
	}

	if v.PreferredBackupWindow != nil {
		objectKey := object.Key("PreferredBackupWindow")
		objectKey.String(*v.PreferredBackupWindow)
	}

	if v.PreferredMaintenanceWindow != nil {
		objectKey := object.Key("PreferredMaintenanceWindow")
		objectKey.String(*v.PreferredMaintenanceWindow)
	}

	if v.PreSignedUrl != nil {
		objectKey := object.Key("PreSignedUrl")
		objectKey.String(*v.PreSignedUrl)
	}

	if v.PubliclyAccessible != nil {
		objectKey := object.Key("PubliclyAccessible")
		objectKey.Boolean(*v.PubliclyAccessible)
	}

	if v.RdsCustomClusterConfiguration != nil {
		objectKey := object.Key("RdsCustomClusterConfiguration")
		if err := awsAwsquery_serializeDocumentRdsCustomClusterConfiguration(v.RdsCustomClusterConfiguration, objectKey); err != nil {
			return err
		}
	}

	if v.ReplicationSourceIdentifier != nil {
		objectKey := object.Key("ReplicationSourceIdentifier")
		objectKey.String(*v.ReplicationSourceIdentifier)
	}

	if v.ScalingConfiguration != nil {
		objectKey := object.Key("ScalingConfiguration")
		if err := awsAwsquery_serializeDocumentScalingConfiguration(v.ScalingConfiguration, objectKey); err != nil {
			return err
		}
	}

	if v.ServerlessV2ScalingConfiguration != nil {
		objectKey := object.Key("ServerlessV2ScalingConfiguration")
		if err := awsAwsquery_serializeDocumentServerlessV2ScalingConfiguration(v.ServerlessV2ScalingConfiguration, objectKey); err != nil {
			return err
		}
	}

	if v.StorageEncrypted != nil {
		objectKey := object.Key("StorageEncrypted")
		objectKey.Boolean(*v.StorageEncrypted)
	}

	if v.StorageType != nil {
		objectKey := object.Key("StorageType")
		objectKey.String(*v.StorageType)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	if v.TagSpecifications != nil {
		objectKey := object.Key("TagSpecifications")
		if err := awsAwsquery_serializeDocumentTagSpecificationList(v.TagSpecifications, objectKey); err != nil {
			return err
		}
	}

	if v.VpcSecurityGroupIds != nil {
		objectKey := object.Key("VpcSecurityGroupIds")
		if err := awsAwsquery_serializeDocumentVpcSecurityGroupIdList(v.VpcSecurityGroupIds, objectKey); err != nil {
			return err
		}
	}

	if v.WithExpressConfiguration != nil {
		objectKey := object.Key("WithExpressConfiguration")
		objectKey.Boolean(*v.WithExpressConfiguration)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCreateDBClusterParameterGroupInput(v *CreateDBClusterParameterGroupInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBClusterParameterGroupName != nil {
		objectKey := object.Key("DBClusterParameterGroupName")
		objectKey.String(*v.DBClusterParameterGroupName)
	}

	if v.DBParameterGroupFamily != nil {
		objectKey := object.Key("DBParameterGroupFamily")
		objectKey.String(*v.DBParameterGroupFamily)
	}

	if v.Description != nil {
		objectKey := object.Key("Description")
		objectKey.String(*v.Description)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCreateDBClusterSnapshotInput(v *CreateDBClusterSnapshotInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBClusterIdentifier != nil {
		objectKey := object.Key("DBClusterIdentifier")
		objectKey.String(*v.DBClusterIdentifier)
	}

	if v.DBClusterSnapshotIdentifier != nil {
		objectKey := object.Key("DBClusterSnapshotIdentifier")
		objectKey.String(*v.DBClusterSnapshotIdentifier)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCreateDBInstanceInput(v *CreateDBInstanceInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.AdditionalStorageVolumes != nil {
		objectKey := object.Key("AdditionalStorageVolumes")
		if err := awsAwsquery_serializeDocumentAdditionalStorageVolumesList(v.AdditionalStorageVolumes, objectKey); err != nil {
			return err
		}
	}

	if v.AllocatedStorage != nil {
		objectKey := object.Key("AllocatedStorage")
		objectKey.Integer(*v.AllocatedStorage)
	}

	if v.AutoMinorVersionUpgrade != nil {
		objectKey := object.Key("AutoMinorVersionUpgrade")
		objectKey.Boolean(*v.AutoMinorVersionUpgrade)
	}

	if v.AvailabilityZone != nil {
		objectKey := object.Key("AvailabilityZone")
		objectKey.String(*v.AvailabilityZone)
	}

	if v.BackupRetentionPeriod != nil {
		objectKey := object.Key("BackupRetentionPeriod")
		objectKey.Integer(*v.BackupRetentionPeriod)
	}

	if v.BackupTarget != nil {
		objectKey := object.Key("BackupTarget")
		objectKey.String(*v.BackupTarget)
	}

	if v.CACertificateIdentifier != nil {
		objectKey := object.Key("CACertificateIdentifier")
		objectKey.String(*v.CACertificateIdentifier)
	}

	if v.CharacterSetName != nil {
		objectKey := object.Key("CharacterSetName")
		objectKey.String(*v.CharacterSetName)
	}

	if v.CopyTagsToSnapshot != nil {
		objectKey := object.Key("CopyTagsToSnapshot")
		objectKey.Boolean(*v.CopyTagsToSnapshot)
	}

	if v.CustomIamInstanceProfile != nil {
		objectKey := object.Key("CustomIamInstanceProfile")
		objectKey.String(*v.CustomIamInstanceProfile)
	}

	if len(v.DatabaseInsightsMode) > 0 {
		objectKey := object.Key("DatabaseInsightsMode")
		objectKey.String(string(v.DatabaseInsightsMode))
	}

	if v.DBClusterIdentifier != nil {
		objectKey := object.Key("DBClusterIdentifier")
		objectKey.String(*v.DBClusterIdentifier)
	}

	if v.DBInstanceClass != nil {
		objectKey := object.Key("DBInstanceClass")
		objectKey.String(*v.DBInstanceClass)
	}

	if v.DBInstanceIdentifier != nil {
		objectKey := object.Key("DBInstanceIdentifier")
		objectKey.String(*v.DBInstanceIdentifier)
	}

	if v.DBName != nil {
		objectKey := object.Key("DBName")
		objectKey.String(*v.DBName)
	}

	if v.DBParameterGroupName != nil {
		objectKey := object.Key("DBParameterGroupName")
		objectKey.String(*v.DBParameterGroupName)
	}

	if v.DBSecurityGroups != nil {
		objectKey := object.Key("DBSecurityGroups")
		if err := awsAwsquery_serializeDocumentDBSecurityGroupNameList(v.DBSecurityGroups, objectKey); err != nil {
			return err
		}
	}

	if v.DBSubnetGroupName != nil {
		objectKey := object.Key("DBSubnetGroupName")
		objectKey.String(*v.DBSubnetGroupName)
	}

	if v.DBSystemId != nil {
		objectKey := object.Key("DBSystemId")
		objectKey.String(*v.DBSystemId)
	}

	if v.DedicatedLogVolume != nil {
		objectKey := object.Key("DedicatedLogVolume")
		objectKey.Boolean(*v.DedicatedLogVolume)
	}

	if v.DeletionProtection != nil {
		objectKey := object.Key("DeletionProtection")
		objectKey.Boolean(*v.DeletionProtection)
	}

	if v.Domain != nil {
		objectKey := object.Key("Domain")
		objectKey.String(*v.Domain)
	}

	if v.DomainAuthSecretArn != nil {
		objectKey := object.Key("DomainAuthSecretArn")
		objectKey.String(*v.DomainAuthSecretArn)
	}

	if v.DomainDnsIps != nil {
		objectKey := object.Key("DomainDnsIps")
		if err := awsAwsquery_serializeDocumentStringList(v.DomainDnsIps, objectKey); err != nil {
			return err
		}
	}

	if v.DomainFqdn != nil {
		objectKey := object.Key("DomainFqdn")
		objectKey.String(*v.DomainFqdn)
	}

	if v.DomainIAMRoleName != nil {
		objectKey := object.Key("DomainIAMRoleName")
		objectKey.String(*v.DomainIAMRoleName)
	}

	if v.DomainOu != nil {
		objectKey := object.Key("DomainOu")
		objectKey.String(*v.DomainOu)
	}

	if v.EnableCloudwatchLogsExports != nil {
		objectKey := object.Key("EnableCloudwatchLogsExports")
		if err := awsAwsquery_serializeDocumentLogTypeList(v.EnableCloudwatchLogsExports, objectKey); err != nil {
			return err
		}
	}

	if v.EnableCustomerOwnedIp != nil {
		objectKey := object.Key("EnableCustomerOwnedIp")
		objectKey.Boolean(*v.EnableCustomerOwnedIp)
	}

	if v.EnableIAMDatabaseAuthentication != nil {
		objectKey := object.Key("EnableIAMDatabaseAuthentication")
		objectKey.Boolean(*v.EnableIAMDatabaseAuthentication)
	}

	if v.EnablePerformanceInsights != nil {
		objectKey := object.Key("EnablePerformanceInsights")
		objectKey.Boolean(*v.EnablePerformanceInsights)
	}

	if v.Engine != nil {
		objectKey := object.Key("Engine")
		objectKey.String(*v.Engine)
	}

	if v.EngineLifecycleSupport != nil {
		objectKey := object.Key("EngineLifecycleSupport")
		objectKey.String(*v.EngineLifecycleSupport)
	}

	if v.EngineVersion != nil {
		objectKey := object.Key("EngineVersion")
		objectKey.String(*v.EngineVersion)
	}

	if v.Iops != nil {
		objectKey := object.Key("Iops")
		objectKey.Integer(*v.Iops)
	}

	if v.KmsKeyId != nil {
		objectKey := object.Key("KmsKeyId")
		objectKey.String(*v.KmsKeyId)
	}

	if v.LicenseModel != nil {
		objectKey := object.Key("LicenseModel")
		objectKey.String(*v.LicenseModel)
	}

	if v.ManageMasterUserPassword != nil {
		objectKey := object.Key("ManageMasterUserPassword")
		objectKey.Boolean(*v.ManageMasterUserPassword)
	}

	if len(v.MasterUserAuthenticationType) > 0 {
		objectKey := object.Key("MasterUserAuthenticationType")
		objectKey.String(string(v.MasterUserAuthenticationType))
	}

	if v.MasterUsername != nil {
		objectKey := object.Key("MasterUsername")
		objectKey.String(*v.MasterUsername)
	}

	if v.MasterUserPassword != nil {
		objectKey := object.Key("MasterUserPassword")
		objectKey.String(*v.MasterUserPassword)
	}

	if v.MasterUserSecretKmsKeyId != nil {
		objectKey := object.Key("MasterUserSecretKmsKeyId")
		objectKey.String(*v.MasterUserSecretKmsKeyId)
	}

	if v.MaxAllocatedStorage != nil {
		objectKey := object.Key("MaxAllocatedStorage")
		objectKey.Integer(*v.MaxAllocatedStorage)
	}

	if v.MonitoringInterval != nil {
		objectKey := object.Key("MonitoringInterval")
		objectKey.Integer(*v.MonitoringInterval)
	}

	if v.MonitoringRoleArn != nil {
		objectKey := object.Key("MonitoringRoleArn")
		objectKey.String(*v.MonitoringRoleArn)
	}

	if v.MultiAZ != nil {
		objectKey := object.Key("MultiAZ")
		objectKey.Boolean(*v.MultiAZ)
	}

	if v.MultiTenant != nil {
		objectKey := object.Key("MultiTenant")
		objectKey.Boolean(*v.MultiTenant)
	}

	if v.NcharCharacterSetName != nil {
		objectKey := object.Key("NcharCharacterSetName")
		objectKey.String(*v.NcharCharacterSetName)
	}

	if v.NetworkType != nil {
		objectKey := object.Key("NetworkType")
		objectKey.String(*v.NetworkType)
	}

	if v.OptionGroupName != nil {
		objectKey := object.Key("OptionGroupName")
		objectKey.String(*v.OptionGroupName)
	}

	if v.PerformanceInsightsKMSKeyId != nil {
		objectKey := object.Key("PerformanceInsightsKMSKeyId")
		objectKey.String(*v.PerformanceInsightsKMSKeyId)
	}

	if v.PerformanceInsightsRetentionPeriod != nil {
		objectKey := object.Key("PerformanceInsightsRetentionPeriod")
		objectKey.Integer(*v.PerformanceInsightsRetentionPeriod)
	}

	if v.Port != nil {
		objectKey := object.Key("Port")
		objectKey.Integer(*v.Port)
	}

	if v.PreferredBackupWindow != nil {
		objectKey := object.Key("PreferredBackupWindow")
		objectKey.String(*v.PreferredBackupWindow)
	}

	if v.PreferredMaintenanceWindow != nil {
		objectKey := object.Key("PreferredMaintenanceWindow")
		objectKey.String(*v.PreferredMaintenanceWindow)
	}

	if v.ProcessorFeatures != nil {
		objectKey := object.Key("ProcessorFeatures")
		if err := awsAwsquery_serializeDocumentProcessorFeatureList(v.ProcessorFeatures, objectKey); err != nil {
			return err
		}
	}

	if v.PromotionTier != nil {
		objectKey := object.Key("PromotionTier")
		objectKey.Integer(*v.PromotionTier)
	}

	if v.PubliclyAccessible != nil {
		objectKey := object.Key("PubliclyAccessible")
		objectKey.Boolean(*v.PubliclyAccessible)
	}

	if v.StorageEncrypted != nil {
		objectKey := object.Key("StorageEncrypted")
		objectKey.Boolean(*v.StorageEncrypted)
	}

	if v.StorageThroughput != nil {
		objectKey := object.Key("StorageThroughput")
		objectKey.Integer(*v.StorageThroughput)
	}

	if v.StorageType != nil {
		objectKey := object.Key("StorageType")
		objectKey.String(*v.StorageType)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	if v.TagSpecifications != nil {
		objectKey := object.Key("TagSpecifications")
		if err := awsAwsquery_serializeDocumentTagSpecificationList(v.TagSpecifications, objectKey); err != nil {
			return err
		}
	}

	if v.TdeCredentialArn != nil {
		objectKey := object.Key("TdeCredentialArn")
		objectKey.String(*v.TdeCredentialArn)
	}

	if v.TdeCredentialPassword != nil {
		objectKey := object.Key("TdeCredentialPassword")
		objectKey.String(*v.TdeCredentialPassword)
	}

	if v.Timezone != nil {
		objectKey := object.Key("Timezone")
		objectKey.String(*v.Timezone)
	}

	if v.VpcSecurityGroupIds != nil {
		objectKey := object.Key("VpcSecurityGroupIds")
		if err := awsAwsquery_serializeDocumentVpcSecurityGroupIdList(v.VpcSecurityGroupIds, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCreateDBInstanceReadReplicaInput(v *CreateDBInstanceReadReplicaInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.AdditionalStorageVolumes != nil {
		objectKey := object.Key("AdditionalStorageVolumes")
		if err := awsAwsquery_serializeDocumentAdditionalStorageVolumesList(v.AdditionalStorageVolumes, objectKey); err != nil {
			return err
		}
	}

	if v.AllocatedStorage != nil {
		objectKey := object.Key("AllocatedStorage")
		objectKey.Integer(*v.AllocatedStorage)
	}

	if v.AutoMinorVersionUpgrade != nil {
		objectKey := object.Key("AutoMinorVersionUpgrade")
		objectKey.Boolean(*v.AutoMinorVersionUpgrade)
	}

	if v.AvailabilityZone != nil {
		objectKey := object.Key("AvailabilityZone")
		objectKey.String(*v.AvailabilityZone)
	}

	if v.BackupTarget != nil {
		objectKey := object.Key("BackupTarget")
		objectKey.String(*v.BackupTarget)
	}

	if v.CACertificateIdentifier != nil {
		objectKey := object.Key("CACertificateIdentifier")
		objectKey.String(*v.CACertificateIdentifier)
	}

	if v.CopyTagsToSnapshot != nil {
		objectKey := object.Key("CopyTagsToSnapshot")
		objectKey.Boolean(*v.CopyTagsToSnapshot)
	}

	if v.CustomIamInstanceProfile != nil {
		objectKey := object.Key("CustomIamInstanceProfile")
		objectKey.String(*v.CustomIamInstanceProfile)
	}

	if len(v.DatabaseInsightsMode) > 0 {
		objectKey := object.Key("DatabaseInsightsMode")
		objectKey.String(string(v.DatabaseInsightsMode))
	}

	if v.DBInstanceClass != nil {
		objectKey := object.Key("DBInstanceClass")
		objectKey.String(*v.DBInstanceClass)
	}

	if v.DBInstanceIdentifier != nil {
		objectKey := object.Key("DBInstanceIdentifier")
		objectKey.String(*v.DBInstanceIdentifier)
	}

	if v.DBParameterGroupName != nil {
		objectKey := object.Key("DBParameterGroupName")
		objectKey.String(*v.DBParameterGroupName)
	}

	if v.DBSubnetGroupName != nil {
		objectKey := object.Key("DBSubnetGroupName")
		objectKey.String(*v.DBSubnetGroupName)
	}

	if v.DedicatedLogVolume != nil {
		objectKey := object.Key("DedicatedLogVolume")
		objectKey.Boolean(*v.DedicatedLogVolume)
	}

	if v.DeletionProtection != nil {
		objectKey := object.Key("DeletionProtection")
		objectKey.Boolean(*v.DeletionProtection)
	}

	if v.destinationRegion != nil {
		objectKey := object.Key("DestinationRegion")
		objectKey.String(*v.destinationRegion)
	}

	if v.Domain != nil {
		objectKey := object.Key("Domain")
		objectKey.String(*v.Domain)
	}

	if v.DomainAuthSecretArn != nil {
		objectKey := object.Key("DomainAuthSecretArn")
		objectKey.String(*v.DomainAuthSecretArn)
	}

	if v.DomainDnsIps != nil {
		objectKey := object.Key("DomainDnsIps")
		if err := awsAwsquery_serializeDocumentStringList(v.DomainDnsIps, objectKey); err != nil {
			return err
		}
	}

	if v.DomainFqdn != nil {
		objectKey := object.Key("DomainFqdn")
		objectKey.String(*v.DomainFqdn)
	}

	if v.DomainIAMRoleName != nil {
		objectKey := object.Key("DomainIAMRoleName")
		objectKey.String(*v.DomainIAMRoleName)
	}

	if v.DomainOu != nil {
		objectKey := object.Key("DomainOu")
		objectKey.String(*v.DomainOu)
	}

	if v.EnableCloudwatchLogsExports != nil {
		objectKey := object.Key("EnableCloudwatchLogsExports")
		if err := awsAwsquery_serializeDocumentLogTypeList(v.EnableCloudwatchLogsExports, objectKey); err != nil {
			return err
		}
	}

	if v.EnableCustomerOwnedIp != nil {
		objectKey := object.Key("EnableCustomerOwnedIp")
		objectKey.Boolean(*v.EnableCustomerOwnedIp)
	}

	if v.EnableIAMDatabaseAuthentication != nil {
		objectKey := object.Key("EnableIAMDatabaseAuthentication")
		objectKey.Boolean(*v.EnableIAMDatabaseAuthentication)
	}

	if v.EnablePerformanceInsights != nil {
		objectKey := object.Key("EnablePerformanceInsights")
		objectKey.Boolean(*v.EnablePerformanceInsights)
	}

	if v.Iops != nil {
		objectKey := object.Key("Iops")
		objectKey.Integer(*v.Iops)
	}

	if v.KmsKeyId != nil {
		objectKey := object.Key("KmsKeyId")
		objectKey.String(*v.KmsKeyId)
	}

	if v.MaxAllocatedStorage != nil {
		objectKey := object.Key("MaxAllocatedStorage")
		objectKey.Integer(*v.MaxAllocatedStorage)
	}

	if v.MonitoringInterval != nil {
		objectKey := object.Key("MonitoringInterval")
		objectKey.Integer(*v.MonitoringInterval)
	}

	if v.MonitoringRoleArn != nil {
		objectKey := object.Key("MonitoringRoleArn")
		objectKey.String(*v.MonitoringRoleArn)
	}

	if v.MultiAZ != nil {
		objectKey := object.Key("MultiAZ")
		objectKey.Boolean(*v.MultiAZ)
	}

	if v.NetworkType != nil {
		objectKey := object.Key("NetworkType")
		objectKey.String(*v.NetworkType)
	}

	if v.OptionGroupName != nil {
		objectKey := object.Key("OptionGroupName")
		objectKey.String(*v.OptionGroupName)
	}

	if v.PerformanceInsightsKMSKeyId != nil {
		objectKey := object.Key("PerformanceInsightsKMSKeyId")
		objectKey.String(*v.PerformanceInsightsKMSKeyId)
	}

	if v.PerformanceInsightsRetentionPeriod != nil {
		objectKey := object.Key("PerformanceInsightsRetentionPeriod")
		objectKey.Integer(*v.PerformanceInsightsRetentionPeriod)
	}

	if v.Port != nil {
		objectKey := object.Key("Port")
		objectKey.Integer(*v.Port)
	}

	if v.PreSignedUrl != nil {
		objectKey := object.Key("PreSignedUrl")
		objectKey.String(*v.PreSignedUrl)
	}

	if v.ProcessorFeatures != nil {
		objectKey := object.Key("ProcessorFeatures")
		if err := awsAwsquery_serializeDocumentProcessorFeatureList(v.ProcessorFeatures, objectKey); err != nil {
			return err
		}
	}

	if v.PubliclyAccessible != nil {
		objectKey := object.Key("PubliclyAccessible")
		objectKey.Boolean(*v.PubliclyAccessible)
	}

	if len(v.ReplicaMode) > 0 {
		objectKey := object.Key("ReplicaMode")
		objectKey.String(string(v.ReplicaMode))
	}

	if v.SourceDBClusterIdentifier != nil {
		objectKey := object.Key("SourceDBClusterIdentifier")
		objectKey.String(*v.SourceDBClusterIdentifier)
	}

	if v.SourceDBInstanceIdentifier != nil {
		objectKey := object.Key("SourceDBInstanceIdentifier")
		objectKey.String(*v.SourceDBInstanceIdentifier)
	}

	if v.StorageThroughput != nil {
		objectKey := object.Key("StorageThroughput")
		objectKey.Integer(*v.StorageThroughput)
	}

	if v.StorageType != nil {
		objectKey := object.Key("StorageType")
		objectKey.String(*v.StorageType)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	if v.TagSpecifications != nil {
		objectKey := object.Key("TagSpecifications")
		if err := awsAwsquery_serializeDocumentTagSpecificationList(v.TagSpecifications, objectKey); err != nil {
			return err
		}
	}

	if v.UpgradeStorageConfig != nil {
		objectKey := object.Key("UpgradeStorageConfig")
		objectKey.Boolean(*v.UpgradeStorageConfig)
	}

	if v.UseDefaultProcessorFeatures != nil {
		objectKey := object.Key("UseDefaultProcessorFeatures")
		objectKey.Boolean(*v.UseDefaultProcessorFeatures)
	}

	if v.VpcSecurityGroupIds != nil {
		objectKey := object.Key("VpcSecurityGroupIds")
		if err := awsAwsquery_serializeDocumentVpcSecurityGroupIdList(v.VpcSecurityGroupIds, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCreateDBParameterGroupInput(v *CreateDBParameterGroupInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBParameterGroupFamily != nil {
		objectKey := object.Key("DBParameterGroupFamily")
		objectKey.String(*v.DBParameterGroupFamily)
	}

	if v.DBParameterGroupName != nil {
		objectKey := object.Key("DBParameterGroupName")
		objectKey.String(*v.DBParameterGroupName)
	}

	if v.Description != nil {
		objectKey := object.Key("Description")
		objectKey.String(*v.Description)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCreateDBProxyEndpointInput(v *CreateDBProxyEndpointInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBProxyEndpointName != nil {
		objectKey := object.Key("DBProxyEndpointName")
		objectKey.String(*v.DBProxyEndpointName)
	}

	if v.DBProxyName != nil {
		objectKey := object.Key("DBProxyName")
		objectKey.String(*v.DBProxyName)
	}

	if len(v.EndpointNetworkType) > 0 {
		objectKey := object.Key("EndpointNetworkType")
		objectKey.String(string(v.EndpointNetworkType))
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	if len(v.TargetRole) > 0 {
		objectKey := object.Key("TargetRole")
		objectKey.String(string(v.TargetRole))
	}

	if v.VpcSecurityGroupIds != nil {
		objectKey := object.Key("VpcSecurityGroupIds")
		if err := awsAwsquery_serializeDocumentStringList(v.VpcSecurityGroupIds, objectKey); err != nil {
			return err
		}
	}

	if v.VpcSubnetIds != nil {
		objectKey := object.Key("VpcSubnetIds")
		if err := awsAwsquery_serializeDocumentStringList(v.VpcSubnetIds, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCreateDBProxyInput(v *CreateDBProxyInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.Auth != nil {
		objectKey := object.Key("Auth")
		if err := awsAwsquery_serializeDocumentUserAuthConfigList(v.Auth, objectKey); err != nil {
			return err
		}
	}

	if v.DBProxyName != nil {
		objectKey := object.Key("DBProxyName")
		objectKey.String(*v.DBProxyName)
	}

	if v.DebugLogging != nil {
		objectKey := object.Key("DebugLogging")
		objectKey.Boolean(*v.DebugLogging)
	}

	if len(v.DefaultAuthScheme) > 0 {
		objectKey := object.Key("DefaultAuthScheme")
		objectKey.String(string(v.DefaultAuthScheme))
	}

	if len(v.EndpointNetworkType) > 0 {
		objectKey := object.Key("EndpointNetworkType")
		objectKey.String(string(v.EndpointNetworkType))
	}

	if len(v.EngineFamily) > 0 {
		objectKey := object.Key("EngineFamily")
		objectKey.String(string(v.EngineFamily))
	}

	if v.IdleClientTimeout != nil {
		objectKey := object.Key("IdleClientTimeout")
		objectKey.Integer(*v.IdleClientTimeout)
	}

	if v.RequireTLS != nil {
		objectKey := object.Key("RequireTLS")
		objectKey.Boolean(*v.RequireTLS)
	}

	if v.RoleArn != nil {
		objectKey := object.Key("RoleArn")
		objectKey.String(*v.RoleArn)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	if len(v.TargetConnectionNetworkType) > 0 {
		objectKey := object.Key("TargetConnectionNetworkType")
		objectKey.String(string(v.TargetConnectionNetworkType))
	}

	if v.VpcSecurityGroupIds != nil {
		objectKey := object.Key("VpcSecurityGroupIds")
		if err := awsAwsquery_serializeDocumentStringList(v.VpcSecurityGroupIds, objectKey); err != nil {
			return err
		}
	}

	if v.VpcSubnetIds != nil {
		objectKey := object.Key("VpcSubnetIds")
		if err := awsAwsquery_serializeDocumentStringList(v.VpcSubnetIds, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCreateDBSecurityGroupInput(v *CreateDBSecurityGroupInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBSecurityGroupDescription != nil {
		objectKey := object.Key("DBSecurityGroupDescription")
		objectKey.String(*v.DBSecurityGroupDescription)
	}

	if v.DBSecurityGroupName != nil {
		objectKey := object.Key("DBSecurityGroupName")
		objectKey.String(*v.DBSecurityGroupName)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCreateDBShardGroupInput(v *CreateDBShardGroupInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.ComputeRedundancy != nil {
		objectKey := object.Key("ComputeRedundancy")
		objectKey.Integer(*v.ComputeRedundancy)
	}

	if v.DBClusterIdentifier != nil {
		objectKey := object.Key("DBClusterIdentifier")
		objectKey.String(*v.DBClusterIdentifier)
	}

	if v.DBShardGroupIdentifier != nil {
		objectKey := object.Key("DBShardGroupIdentifier")
		objectKey.String(*v.DBShardGroupIdentifier)
	}

	if v.MaxACU != nil {
		objectKey := object.Key("MaxACU")
		switch {
		case math.IsNaN(*v.MaxACU):
			objectKey.String("NaN")

		case math.IsInf(*v.MaxACU, 1):
			objectKey.String("Infinity")

		case math.IsInf(*v.MaxACU, -1):
			objectKey.String("-Infinity")

		default:
			objectKey.Double(*v.MaxACU)

		}
	}

	if v.MinACU != nil {
		objectKey := object.Key("MinACU")
		switch {
		case math.IsNaN(*v.MinACU):
			objectKey.String("NaN")

		case math.IsInf(*v.MinACU, 1):
			objectKey.String("Infinity")

		case math.IsInf(*v.MinACU, -1):
			objectKey.String("-Infinity")

		default:
			objectKey.Double(*v.MinACU)

		}
	}

	if v.PubliclyAccessible != nil {
		objectKey := object.Key("PubliclyAccessible")
		objectKey.Boolean(*v.PubliclyAccessible)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCreateDBSnapshotInput(v *CreateDBSnapshotInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBInstanceIdentifier != nil {
		objectKey := object.Key("DBInstanceIdentifier")
		objectKey.String(*v.DBInstanceIdentifier)
	}

	if v.DBSnapshotIdentifier != nil {
		objectKey := object.Key("DBSnapshotIdentifier")
		objectKey.String(*v.DBSnapshotIdentifier)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCreateDBSubnetGroupInput(v *CreateDBSubnetGroupInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBSubnetGroupDescription != nil {
		objectKey := object.Key("DBSubnetGroupDescription")
		objectKey.String(*v.DBSubnetGroupDescription)
	}

	if v.DBSubnetGroupName != nil {
		objectKey := object.Key("DBSubnetGroupName")
		objectKey.String(*v.DBSubnetGroupName)
	}

	if v.SubnetIds != nil {
		objectKey := object.Key("SubnetIds")
		if err := awsAwsquery_serializeDocumentSubnetIdentifierList(v.SubnetIds, objectKey); err != nil {
			return err
		}
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCreateEventSubscriptionInput(v *CreateEventSubscriptionInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.Enabled != nil {
		objectKey := object.Key("Enabled")
		objectKey.Boolean(*v.Enabled)
	}

	if v.EventCategories != nil {
		objectKey := object.Key("EventCategories")
		if err := awsAwsquery_serializeDocumentEventCategoriesList(v.EventCategories, objectKey); err != nil {
			return err
		}
	}

	if v.SnsTopicArn != nil {
		objectKey := object.Key("SnsTopicArn")
		objectKey.String(*v.SnsTopicArn)
	}

	if v.SourceIds != nil {
		objectKey := object.Key("SourceIds")
		if err := awsAwsquery_serializeDocumentSourceIdsList(v.SourceIds, objectKey); err != nil {
			return err
		}
	}

	if v.SourceType != nil {
		objectKey := object.Key("SourceType")
		objectKey.String(*v.SourceType)
	}

	if v.SubscriptionName != nil {
		objectKey := object.Key("SubscriptionName")
		objectKey.String(*v.SubscriptionName)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCreateGlobalClusterInput(v *CreateGlobalClusterInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DatabaseName != nil {
		objectKey := object.Key("DatabaseName")
		objectKey.String(*v.DatabaseName)
	}

	if v.DeletionProtection != nil {
		objectKey := object.Key("DeletionProtection")
		objectKey.Boolean(*v.DeletionProtection)
	}

	if v.Engine != nil {
		objectKey := object.Key("Engine")
		objectKey.String(*v.Engine)
	}

	if v.EngineLifecycleSupport != nil {
		objectKey := object.Key("EngineLifecycleSupport")
		objectKey.String(*v.EngineLifecycleSupport)
	}

	if v.EngineVersion != nil {
		objectKey := object.Key("EngineVersion")
		objectKey.String(*v.EngineVersion)
	}

	if v.GlobalClusterIdentifier != nil {
		objectKey := object.Key("GlobalClusterIdentifier")
		objectKey.String(*v.GlobalClusterIdentifier)
	}

	if v.SourceDBClusterIdentifier != nil {
		objectKey := object.Key("SourceDBClusterIdentifier")
		objectKey.String(*v.SourceDBClusterIdentifier)
	}

	if v.StorageEncrypted != nil {
		objectKey := object.Key("StorageEncrypted")
		objectKey.Boolean(*v.StorageEncrypted)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCreateIntegrationInput(v *CreateIntegrationInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.AdditionalEncryptionContext != nil {
		objectKey := object.Key("AdditionalEncryptionContext")
		if err := awsAwsquery_serializeDocumentEncryptionContextMap(v.AdditionalEncryptionContext, objectKey); err != nil {
			return err
		}
	}

	if v.DataFilter != nil {
		objectKey := object.Key("DataFilter")
		objectKey.String(*v.DataFilter)
	}

	if v.Description != nil {
		objectKey := object.Key("Description")
		objectKey.String(*v.Description)
	}

	if v.IntegrationName != nil {
		objectKey := object.Key("IntegrationName")
		objectKey.String(*v.IntegrationName)
	}

	if v.KMSKeyId != nil {
		objectKey := object.Key("KMSKeyId")
		objectKey.String(*v.KMSKeyId)
	}

	if v.SourceArn != nil {
		objectKey := object.Key("SourceArn")
		objectKey.String(*v.SourceArn)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	if v.TargetArn != nil {
		objectKey := object.Key("TargetArn")
		objectKey.String(*v.TargetArn)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCreateOptionGroupInput(v *CreateOptionGroupInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.EngineName != nil {
		objectKey := object.Key("EngineName")
		objectKey.String(*v.EngineName)
	}

	if v.MajorEngineVersion != nil {
		objectKey := object.Key("MajorEngineVersion")
		objectKey.String(*v.MajorEngineVersion)
	}

	if v.OptionGroupDescription != nil {
		objectKey := object.Key("OptionGroupDescription")
		objectKey.String(*v.OptionGroupDescription)
	}

	if v.OptionGroupName != nil {
		objectKey := object.Key("OptionGroupName")
		objectKey.String(*v.OptionGroupName)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCreateTenantDatabaseInput(v *CreateTenantDatabaseInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.CharacterSetName != nil {
		objectKey := object.Key("CharacterSetName")
		objectKey.String(*v.CharacterSetName)
	}

	if v.DBInstanceIdentifier != nil {
		objectKey := object.Key("DBInstanceIdentifier")
		objectKey.String(*v.DBInstanceIdentifier)
	}

	if v.ManageMasterUserPassword != nil {
		objectKey := object.Key("ManageMasterUserPassword")
		objectKey.Boolean(*v.ManageMasterUserPassword)
	}

	if v.MasterUsername != nil {
		objectKey := object.Key("MasterUsername")
		objectKey.String(*v.MasterUsername)
	}

	if v.MasterUserPassword != nil {
		objectKey := object.Key("MasterUserPassword")
		objectKey.String(*v.MasterUserPassword)
	}

	if v.MasterUserSecretKmsKeyId != nil {
		objectKey := object.Key("MasterUserSecretKmsKeyId")
		objectKey.String(*v.MasterUserSecretKmsKeyId)
	}

	if v.NcharCharacterSetName != nil {
		objectKey := object.Key("NcharCharacterSetName")
		objectKey.String(*v.NcharCharacterSetName)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	if v.TenantDBName != nil {
		objectKey := object.Key("TenantDBName")
		objectKey.String(*v.TenantDBName)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDeleteBlueGreenDeploymentInput(v *DeleteBlueGreenDeploymentInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.BlueGreenDeploymentIdentifier != nil {
		objectKey := object.Key("BlueGreenDeploymentIdentifier")
		objectKey.String(*v.BlueGreenDeploymentIdentifier)
	}

	if v.DeleteTarget != nil {
		objectKey := object.Key("DeleteTarget")
		objectKey.Boolean(*v.DeleteTarget)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDeleteCustomDBEngineVersionInput(v *DeleteCustomDBEngineVersionInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.Engine != nil {
		objectKey := object.Key("Engine")
		objectKey.String(*v.Engine)
	}

	if v.EngineVersion != nil {
		objectKey := object.Key("EngineVersion")
		objectKey.String(*v.EngineVersion)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDeleteDBClusterAutomatedBackupInput(v *DeleteDBClusterAutomatedBackupInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DbClusterResourceId != nil {
		objectKey := object.Key("DbClusterResourceId")
		objectKey.String(*v.DbClusterResourceId)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDeleteDBClusterEndpointInput(v *DeleteDBClusterEndpointInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBClusterEndpointIdentifier != nil {
		objectKey := object.Key("DBClusterEndpointIdentifier")
		objectKey.String(*v.DBClusterEndpointIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDeleteDBClusterInput(v *DeleteDBClusterInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBClusterIdentifier != nil {
		objectKey := object.Key("DBClusterIdentifier")
		objectKey.String(*v.DBClusterIdentifier)
	}

	if v.DeleteAutomatedBackups != nil {
		objectKey := object.Key("DeleteAutomatedBackups")
		objectKey.Boolean(*v.DeleteAutomatedBackups)
	}

	if v.FinalDBSnapshotIdentifier != nil {
		objectKey := object.Key("FinalDBSnapshotIdentifier")
		objectKey.String(*v.FinalDBSnapshotIdentifier)
	}

	if v.SkipFinalSnapshot != nil {
		objectKey := object.Key("SkipFinalSnapshot")
		objectKey.Boolean(*v.SkipFinalSnapshot)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDeleteDBClusterParameterGroupInput(v *DeleteDBClusterParameterGroupInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBClusterParameterGroupName != nil {
		objectKey := object.Key("DBClusterParameterGroupName")
		objectKey.String(*v.DBClusterParameterGroupName)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDeleteDBClusterSnapshotInput(v *DeleteDBClusterSnapshotInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBClusterSnapshotIdentifier != nil {
		objectKey := object.Key("DBClusterSnapshotIdentifier")
		objectKey.String(*v.DBClusterSnapshotIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDeleteDBInstanceAutomatedBackupInput(v *DeleteDBInstanceAutomatedBackupInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBInstanceAutomatedBackupsArn != nil {
		objectKey := object.Key("DBInstanceAutomatedBackupsArn")
		objectKey.String(*v.DBInstanceAutomatedBackupsArn)
	}

	if v.DbiResourceId != nil {
		objectKey := object.Key("DbiResourceId")
		objectKey.String(*v.DbiResourceId)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDeleteDBInstanceInput(v *DeleteDBInstanceInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBInstanceIdentifier != nil {
		objectKey := object.Key("DBInstanceIdentifier")
		objectKey.String(*v.DBInstanceIdentifier)
	}

	if v.DeleteAutomatedBackups != nil {
		objectKey := object.Key("DeleteAutomatedBackups")
		objectKey.Boolean(*v.DeleteAutomatedBackups)
	}

	if v.FinalDBSnapshotIdentifier != nil {
		objectKey := object.Key("FinalDBSnapshotIdentifier")
		objectKey.String(*v.FinalDBSnapshotIdentifier)
	}

	if v.SkipFinalSnapshot != nil {
		objectKey := object.Key("SkipFinalSnapshot")
		objectKey.Boolean(*v.SkipFinalSnapshot)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDeleteDBParameterGroupInput(v *DeleteDBParameterGroupInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBParameterGroupName != nil {
		objectKey := object.Key("DBParameterGroupName")
		objectKey.String(*v.DBParameterGroupName)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDeleteDBProxyEndpointInput(v *DeleteDBProxyEndpointInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBProxyEndpointName != nil {
		objectKey := object.Key("DBProxyEndpointName")
		objectKey.String(*v.DBProxyEndpointName)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDeleteDBProxyInput(v *DeleteDBProxyInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBProxyName != nil {
		objectKey := object.Key("DBProxyName")
		objectKey.String(*v.DBProxyName)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDeleteDBSecurityGroupInput(v *DeleteDBSecurityGroupInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBSecurityGroupName != nil {
		objectKey := object.Key("DBSecurityGroupName")
		objectKey.String(*v.DBSecurityGroupName)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDeleteDBShardGroupInput(v *DeleteDBShardGroupInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBShardGroupIdentifier != nil {
		objectKey := object.Key("DBShardGroupIdentifier")
		objectKey.String(*v.DBShardGroupIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDeleteDBSnapshotInput(v *DeleteDBSnapshotInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBSnapshotIdentifier != nil {
		objectKey := object.Key("DBSnapshotIdentifier")
		objectKey.String(*v.DBSnapshotIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDeleteDBSubnetGroupInput(v *DeleteDBSubnetGroupInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBSubnetGroupName != nil {
		objectKey := object.Key("DBSubnetGroupName")
		objectKey.String(*v.DBSubnetGroupName)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDeleteEventSubscriptionInput(v *DeleteEventSubscriptionInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.SubscriptionName != nil {
		objectKey := object.Key("SubscriptionName")
		objectKey.String(*v.SubscriptionName)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDeleteGlobalClusterInput(v *DeleteGlobalClusterInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.GlobalClusterIdentifier != nil {
		objectKey := object.Key("GlobalClusterIdentifier")
		objectKey.String(*v.GlobalClusterIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDeleteIntegrationInput(v *DeleteIntegrationInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.IntegrationIdentifier != nil {
		objectKey := object.Key("IntegrationIdentifier")
		objectKey.String(*v.IntegrationIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDeleteOptionGroupInput(v *DeleteOptionGroupInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.OptionGroupName != nil {
		objectKey := object.Key("OptionGroupName")
		objectKey.String(*v.OptionGroupName)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDeleteTenantDatabaseInput(v *DeleteTenantDatabaseInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBInstanceIdentifier != nil {
		objectKey := object.Key("DBInstanceIdentifier")
		objectKey.String(*v.DBInstanceIdentifier)
	}

	if v.FinalDBSnapshotIdentifier != nil {
		objectKey := object.Key("FinalDBSnapshotIdentifier")
		objectKey.String(*v.FinalDBSnapshotIdentifier)
	}

	if v.SkipFinalSnapshot != nil {
		objectKey := object.Key("SkipFinalSnapshot")
		objectKey.Boolean(*v.SkipFinalSnapshot)
	}

	if v.TenantDBName != nil {
		objectKey := object.Key("TenantDBName")
		objectKey.String(*v.TenantDBName)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDeregisterDBProxyTargetsInput(v *DeregisterDBProxyTargetsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBClusterIdentifiers != nil {
		objectKey := object.Key("DBClusterIdentifiers")
		if err := awsAwsquery_serializeDocumentStringList(v.DBClusterIdentifiers, objectKey); err != nil {
			return err
		}
	}

	if v.DBInstanceIdentifiers != nil {
		objectKey := object.Key("DBInstanceIdentifiers")
		if err := awsAwsquery_serializeDocumentStringList(v.DBInstanceIdentifiers, objectKey); err != nil {
			return err
		}
	}

	if v.DBProxyName != nil {
		objectKey := object.Key("DBProxyName")
		objectKey.String(*v.DBProxyName)
	}

	if v.TargetGroupName != nil {
		objectKey := object.Key("TargetGroupName")
		objectKey.String(*v.TargetGroupName)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeAccountAttributesInput(v *DescribeAccountAttributesInput, value query.Value) error {
	object := value.Object()
	_ = object

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeBlueGreenDeploymentsInput(v *DescribeBlueGreenDeploymentsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.BlueGreenDeploymentIdentifier != nil {
		objectKey := object.Key("BlueGreenDeploymentIdentifier")
		objectKey.String(*v.BlueGreenDeploymentIdentifier)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeCertificatesInput(v *DescribeCertificatesInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.CertificateIdentifier != nil {
		objectKey := object.Key("CertificateIdentifier")
		objectKey.String(*v.CertificateIdentifier)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeDBClusterAutomatedBackupsInput(v *DescribeDBClusterAutomatedBackupsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBClusterIdentifier != nil {
		objectKey := object.Key("DBClusterIdentifier")
		objectKey.String(*v.DBClusterIdentifier)
	}

	if v.DbClusterResourceId != nil {
		objectKey := object.Key("DbClusterResourceId")
		objectKey.String(*v.DbClusterResourceId)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeDBClusterBacktracksInput(v *DescribeDBClusterBacktracksInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.BacktrackIdentifier != nil {
		objectKey := object.Key("BacktrackIdentifier")
		objectKey.String(*v.BacktrackIdentifier)
	}

	if v.DBClusterIdentifier != nil {
		objectKey := object.Key("DBClusterIdentifier")
		objectKey.String(*v.DBClusterIdentifier)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeDBClusterEndpointsInput(v *DescribeDBClusterEndpointsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBClusterEndpointIdentifier != nil {
		objectKey := object.Key("DBClusterEndpointIdentifier")
		objectKey.String(*v.DBClusterEndpointIdentifier)
	}

	if v.DBClusterIdentifier != nil {
		objectKey := object.Key("DBClusterIdentifier")
		objectKey.String(*v.DBClusterIdentifier)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeDBClusterParameterGroupsInput(v *DescribeDBClusterParameterGroupsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBClusterParameterGroupName != nil {
		objectKey := object.Key("DBClusterParameterGroupName")
		objectKey.String(*v.DBClusterParameterGroupName)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeDBClusterParametersInput(v *DescribeDBClusterParametersInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBClusterParameterGroupName != nil {
		objectKey := object.Key("DBClusterParameterGroupName")
		objectKey.String(*v.DBClusterParameterGroupName)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	if v.Source != nil {
		objectKey := object.Key("Source")
		objectKey.String(*v.Source)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeDBClustersInput(v *DescribeDBClustersInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBClusterIdentifier != nil {
		objectKey := object.Key("DBClusterIdentifier")
		objectKey.String(*v.DBClusterIdentifier)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.IncludeShared != nil {
		objectKey := object.Key("IncludeShared")
		objectKey.Boolean(*v.IncludeShared)
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeDBClusterSnapshotAttributesInput(v *DescribeDBClusterSnapshotAttributesInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBClusterSnapshotIdentifier != nil {
		objectKey := object.Key("DBClusterSnapshotIdentifier")
		objectKey.String(*v.DBClusterSnapshotIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeDBClusterSnapshotsInput(v *DescribeDBClusterSnapshotsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBClusterIdentifier != nil {
		objectKey := object.Key("DBClusterIdentifier")
		objectKey.String(*v.DBClusterIdentifier)
	}

	if v.DbClusterResourceId != nil {
		objectKey := object.Key("DbClusterResourceId")
		objectKey.String(*v.DbClusterResourceId)
	}

	if v.DBClusterSnapshotIdentifier != nil {
		objectKey := object.Key("DBClusterSnapshotIdentifier")
		objectKey.String(*v.DBClusterSnapshotIdentifier)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.IncludePublic != nil {
		objectKey := object.Key("IncludePublic")
		objectKey.Boolean(*v.IncludePublic)
	}

	if v.IncludeShared != nil {
		objectKey := object.Key("IncludeShared")
		objectKey.Boolean(*v.IncludeShared)
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	if v.SnapshotType != nil {
		objectKey := object.Key("SnapshotType")
		objectKey.String(*v.SnapshotType)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeDBEngineVersionsInput(v *DescribeDBEngineVersionsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBParameterGroupFamily != nil {
		objectKey := object.Key("DBParameterGroupFamily")
		objectKey.String(*v.DBParameterGroupFamily)
	}

	if v.DefaultOnly != nil {
		objectKey := object.Key("DefaultOnly")
		objectKey.Boolean(*v.DefaultOnly)
	}

	if v.Engine != nil {
		objectKey := object.Key("Engine")
		objectKey.String(*v.Engine)
	}

	if v.EngineVersion != nil {
		objectKey := object.Key("EngineVersion")
		objectKey.String(*v.EngineVersion)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.IncludeAll != nil {
		objectKey := object.Key("IncludeAll")
		objectKey.Boolean(*v.IncludeAll)
	}

	if v.ListSupportedCharacterSets != nil {
		objectKey := object.Key("ListSupportedCharacterSets")
		objectKey.Boolean(*v.ListSupportedCharacterSets)
	}

	if v.ListSupportedTimezones != nil {
		objectKey := object.Key("ListSupportedTimezones")
		objectKey.Boolean(*v.ListSupportedTimezones)
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeDBInstanceAutomatedBackupsInput(v *DescribeDBInstanceAutomatedBackupsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBInstanceAutomatedBackupsArn != nil {
		objectKey := object.Key("DBInstanceAutomatedBackupsArn")
		objectKey.String(*v.DBInstanceAutomatedBackupsArn)
	}

	if v.DBInstanceIdentifier != nil {
		objectKey := object.Key("DBInstanceIdentifier")
		objectKey.String(*v.DBInstanceIdentifier)
	}

	if v.DbiResourceId != nil {
		objectKey := object.Key("DbiResourceId")
		objectKey.String(*v.DbiResourceId)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeDBInstancesInput(v *DescribeDBInstancesInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBInstanceIdentifier != nil {
		objectKey := object.Key("DBInstanceIdentifier")
		objectKey.String(*v.DBInstanceIdentifier)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeDBLogFilesInput(v *DescribeDBLogFilesInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBInstanceIdentifier != nil {
		objectKey := object.Key("DBInstanceIdentifier")
		objectKey.String(*v.DBInstanceIdentifier)
	}

	if v.FileLastWritten != nil {
		objectKey := object.Key("FileLastWritten")
		objectKey.Long(*v.FileLastWritten)
	}

	if v.FilenameContains != nil {
		objectKey := object.Key("FilenameContains")
		objectKey.String(*v.FilenameContains)
	}

	if v.FileSize != nil {
		objectKey := object.Key("FileSize")
		objectKey.Long(*v.FileSize)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeDBMajorEngineVersionsInput(v *DescribeDBMajorEngineVersionsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.Engine != nil {
		objectKey := object.Key("Engine")
		objectKey.String(*v.Engine)
	}

	if v.MajorEngineVersion != nil {
		objectKey := object.Key("MajorEngineVersion")
		objectKey.String(*v.MajorEngineVersion)
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeDBParameterGroupsInput(v *DescribeDBParameterGroupsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBParameterGroupName != nil {
		objectKey := object.Key("DBParameterGroupName")
		objectKey.String(*v.DBParameterGroupName)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeDBParametersInput(v *DescribeDBParametersInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBParameterGroupName != nil {
		objectKey := object.Key("DBParameterGroupName")
		objectKey.String(*v.DBParameterGroupName)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	if v.Source != nil {
		objectKey := object.Key("Source")
		objectKey.String(*v.Source)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeDBProxiesInput(v *DescribeDBProxiesInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBProxyName != nil {
		objectKey := object.Key("DBProxyName")
		objectKey.String(*v.DBProxyName)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeDBProxyEndpointsInput(v *DescribeDBProxyEndpointsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBProxyEndpointName != nil {
		objectKey := object.Key("DBProxyEndpointName")
		objectKey.String(*v.DBProxyEndpointName)
	}

	if v.DBProxyName != nil {
		objectKey := object.Key("DBProxyName")
		objectKey.String(*v.DBProxyName)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeDBProxyTargetGroupsInput(v *DescribeDBProxyTargetGroupsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBProxyName != nil {
		objectKey := object.Key("DBProxyName")
		objectKey.String(*v.DBProxyName)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	if v.TargetGroupName != nil {
		objectKey := object.Key("TargetGroupName")
		objectKey.String(*v.TargetGroupName)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeDBProxyTargetsInput(v *DescribeDBProxyTargetsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBProxyName != nil {
		objectKey := object.Key("DBProxyName")
		objectKey.String(*v.DBProxyName)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	if v.TargetGroupName != nil {
		objectKey := object.Key("TargetGroupName")
		objectKey.String(*v.TargetGroupName)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeDBRecommendationsInput(v *DescribeDBRecommendationsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.LastUpdatedAfter != nil {
		objectKey := object.Key("LastUpdatedAfter")
		objectKey.String(smithytime.FormatDateTime(*v.LastUpdatedAfter))
	}

	if v.LastUpdatedBefore != nil {
		objectKey := object.Key("LastUpdatedBefore")
		objectKey.String(smithytime.FormatDateTime(*v.LastUpdatedBefore))
	}

	if v.Locale != nil {
		objectKey := object.Key("Locale")
		objectKey.String(*v.Locale)
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeDBSecurityGroupsInput(v *DescribeDBSecurityGroupsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBSecurityGroupName != nil {
		objectKey := object.Key("DBSecurityGroupName")
		objectKey.String(*v.DBSecurityGroupName)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeDBShardGroupsInput(v *DescribeDBShardGroupsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBShardGroupIdentifier != nil {
		objectKey := object.Key("DBShardGroupIdentifier")
		objectKey.String(*v.DBShardGroupIdentifier)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeDBSnapshotAttributesInput(v *DescribeDBSnapshotAttributesInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBSnapshotIdentifier != nil {
		objectKey := object.Key("DBSnapshotIdentifier")
		objectKey.String(*v.DBSnapshotIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeDBSnapshotsInput(v *DescribeDBSnapshotsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBInstanceIdentifier != nil {
		objectKey := object.Key("DBInstanceIdentifier")
		objectKey.String(*v.DBInstanceIdentifier)
	}

	if v.DbiResourceId != nil {
		objectKey := object.Key("DbiResourceId")
		objectKey.String(*v.DbiResourceId)
	}

	if v.DBSnapshotIdentifier != nil {
		objectKey := object.Key("DBSnapshotIdentifier")
		objectKey.String(*v.DBSnapshotIdentifier)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.IncludePublic != nil {
		objectKey := object.Key("IncludePublic")
		objectKey.Boolean(*v.IncludePublic)
	}

	if v.IncludeShared != nil {
		objectKey := object.Key("IncludeShared")
		objectKey.Boolean(*v.IncludeShared)
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	if v.SnapshotType != nil {
		objectKey := object.Key("SnapshotType")
		objectKey.String(*v.SnapshotType)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeDBSnapshotTenantDatabasesInput(v *DescribeDBSnapshotTenantDatabasesInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBInstanceIdentifier != nil {
		objectKey := object.Key("DBInstanceIdentifier")
		objectKey.String(*v.DBInstanceIdentifier)
	}

	if v.DbiResourceId != nil {
		objectKey := object.Key("DbiResourceId")
		objectKey.String(*v.DbiResourceId)
	}

	if v.DBSnapshotIdentifier != nil {
		objectKey := object.Key("DBSnapshotIdentifier")
		objectKey.String(*v.DBSnapshotIdentifier)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	if v.SnapshotType != nil {
		objectKey := object.Key("SnapshotType")
		objectKey.String(*v.SnapshotType)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeDBSubnetGroupsInput(v *DescribeDBSubnetGroupsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBSubnetGroupName != nil {
		objectKey := object.Key("DBSubnetGroupName")
		objectKey.String(*v.DBSubnetGroupName)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeEngineDefaultClusterParametersInput(v *DescribeEngineDefaultClusterParametersInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBParameterGroupFamily != nil {
		objectKey := object.Key("DBParameterGroupFamily")
		objectKey.String(*v.DBParameterGroupFamily)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeEngineDefaultParametersInput(v *DescribeEngineDefaultParametersInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBParameterGroupFamily != nil {
		objectKey := object.Key("DBParameterGroupFamily")
		objectKey.String(*v.DBParameterGroupFamily)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeEventCategoriesInput(v *DescribeEventCategoriesInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.SourceType != nil {
		objectKey := object.Key("SourceType")
		objectKey.String(*v.SourceType)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeEventsInput(v *DescribeEventsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.Duration != nil {
		objectKey := object.Key("Duration")
		objectKey.Integer(*v.Duration)
	}

	if v.EndTime != nil {
		objectKey := object.Key("EndTime")
		objectKey.String(smithytime.FormatDateTime(*v.EndTime))
	}

	if v.EventCategories != nil {
		objectKey := object.Key("EventCategories")
		if err := awsAwsquery_serializeDocumentEventCategoriesList(v.EventCategories, objectKey); err != nil {
			return err
		}
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	if v.SourceIdentifier != nil {
		objectKey := object.Key("SourceIdentifier")
		objectKey.String(*v.SourceIdentifier)
	}

	if len(v.SourceType) > 0 {
		objectKey := object.Key("SourceType")
		objectKey.String(string(v.SourceType))
	}

	if v.StartTime != nil {
		objectKey := object.Key("StartTime")
		objectKey.String(smithytime.FormatDateTime(*v.StartTime))
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeEventSubscriptionsInput(v *DescribeEventSubscriptionsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	if v.SubscriptionName != nil {
		objectKey := object.Key("SubscriptionName")
		objectKey.String(*v.SubscriptionName)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeExportTasksInput(v *DescribeExportTasksInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.ExportTaskIdentifier != nil {
		objectKey := object.Key("ExportTaskIdentifier")
		objectKey.String(*v.ExportTaskIdentifier)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	if v.SourceArn != nil {
		objectKey := object.Key("SourceArn")
		objectKey.String(*v.SourceArn)
	}

	if len(v.SourceType) > 0 {
		objectKey := object.Key("SourceType")
		objectKey.String(string(v.SourceType))
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeGlobalClustersInput(v *DescribeGlobalClustersInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.GlobalClusterIdentifier != nil {
		objectKey := object.Key("GlobalClusterIdentifier")
		objectKey.String(*v.GlobalClusterIdentifier)
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeIntegrationsInput(v *DescribeIntegrationsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.IntegrationIdentifier != nil {
		objectKey := object.Key("IntegrationIdentifier")
		objectKey.String(*v.IntegrationIdentifier)
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeOptionGroupOptionsInput(v *DescribeOptionGroupOptionsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.EngineName != nil {
		objectKey := object.Key("EngineName")
		objectKey.String(*v.EngineName)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.MajorEngineVersion != nil {
		objectKey := object.Key("MajorEngineVersion")
		objectKey.String(*v.MajorEngineVersion)
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeOptionGroupsInput(v *DescribeOptionGroupsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.EngineName != nil {
		objectKey := object.Key("EngineName")
		objectKey.String(*v.EngineName)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.MajorEngineVersion != nil {
		objectKey := object.Key("MajorEngineVersion")
		objectKey.String(*v.MajorEngineVersion)
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	if v.OptionGroupName != nil {
		objectKey := object.Key("OptionGroupName")
		objectKey.String(*v.OptionGroupName)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeOrderableDBInstanceOptionsInput(v *DescribeOrderableDBInstanceOptionsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.AvailabilityZoneGroup != nil {
		objectKey := object.Key("AvailabilityZoneGroup")
		objectKey.String(*v.AvailabilityZoneGroup)
	}

	if v.DBInstanceClass != nil {
		objectKey := object.Key("DBInstanceClass")
		objectKey.String(*v.DBInstanceClass)
	}

	if v.Engine != nil {
		objectKey := object.Key("Engine")
		objectKey.String(*v.Engine)
	}

	if v.EngineVersion != nil {
		objectKey := object.Key("EngineVersion")
		objectKey.String(*v.EngineVersion)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.LicenseModel != nil {
		objectKey := object.Key("LicenseModel")
		objectKey.String(*v.LicenseModel)
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	if v.Vpc != nil {
		objectKey := object.Key("Vpc")
		objectKey.Boolean(*v.Vpc)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribePendingMaintenanceActionsInput(v *DescribePendingMaintenanceActionsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	if v.ResourceIdentifier != nil {
		objectKey := object.Key("ResourceIdentifier")
		objectKey.String(*v.ResourceIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeReservedDBInstancesInput(v *DescribeReservedDBInstancesInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBInstanceClass != nil {
		objectKey := object.Key("DBInstanceClass")
		objectKey.String(*v.DBInstanceClass)
	}

	if v.Duration != nil {
		objectKey := object.Key("Duration")
		objectKey.String(*v.Duration)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.LeaseId != nil {
		objectKey := object.Key("LeaseId")
		objectKey.String(*v.LeaseId)
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	if v.MultiAZ != nil {
		objectKey := object.Key("MultiAZ")
		objectKey.Boolean(*v.MultiAZ)
	}

	if v.OfferingType != nil {
		objectKey := object.Key("OfferingType")
		objectKey.String(*v.OfferingType)
	}

	if v.ProductDescription != nil {
		objectKey := object.Key("ProductDescription")
		objectKey.String(*v.ProductDescription)
	}

	if v.ReservedDBInstanceId != nil {
		objectKey := object.Key("ReservedDBInstanceId")
		objectKey.String(*v.ReservedDBInstanceId)
	}

	if v.ReservedDBInstancesOfferingId != nil {
		objectKey := object.Key("ReservedDBInstancesOfferingId")
		objectKey.String(*v.ReservedDBInstancesOfferingId)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeReservedDBInstancesOfferingsInput(v *DescribeReservedDBInstancesOfferingsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBInstanceClass != nil {
		objectKey := object.Key("DBInstanceClass")
		objectKey.String(*v.DBInstanceClass)
	}

	if v.Duration != nil {
		objectKey := object.Key("Duration")
		objectKey.String(*v.Duration)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	if v.MultiAZ != nil {
		objectKey := object.Key("MultiAZ")
		objectKey.Boolean(*v.MultiAZ)
	}

	if v.OfferingType != nil {
		objectKey := object.Key("OfferingType")
		objectKey.String(*v.OfferingType)
	}

	if v.ProductDescription != nil {
		objectKey := object.Key("ProductDescription")
		objectKey.String(*v.ProductDescription)
	}

	if v.ReservedDBInstancesOfferingId != nil {
		objectKey := object.Key("ReservedDBInstancesOfferingId")
		objectKey.String(*v.ReservedDBInstancesOfferingId)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeServerlessV2PlatformVersionsInput(v *DescribeServerlessV2PlatformVersionsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DefaultOnly != nil {
		objectKey := object.Key("DefaultOnly")
		objectKey.Boolean(*v.DefaultOnly)
	}

	if v.Engine != nil {
		objectKey := object.Key("Engine")
		objectKey.String(*v.Engine)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.IncludeAll != nil {
		objectKey := object.Key("IncludeAll")
		objectKey.Boolean(*v.IncludeAll)
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	if v.ServerlessV2PlatformVersion != nil {
		objectKey := object.Key("ServerlessV2PlatformVersion")
		objectKey.String(*v.ServerlessV2PlatformVersion)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeSourceRegionsInput(v *DescribeSourceRegionsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	if v.RegionName != nil {
		objectKey := object.Key("RegionName")
		objectKey.String(*v.RegionName)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeTenantDatabasesInput(v *DescribeTenantDatabasesInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBInstanceIdentifier != nil {
		objectKey := object.Key("DBInstanceIdentifier")
		objectKey.String(*v.DBInstanceIdentifier)
	}

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		objectKey := object.Key("MaxRecords")
		objectKey.Integer(*v.MaxRecords)
	}

	if v.TenantDBName != nil {
		objectKey := object.Key("TenantDBName")
		objectKey.String(*v.TenantDBName)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeValidDBInstanceModificationsInput(v *DescribeValidDBInstanceModificationsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBInstanceIdentifier != nil {
		objectKey := object.Key("DBInstanceIdentifier")
		objectKey.String(*v.DBInstanceIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDisableHttpEndpointInput(v *DisableHttpEndpointInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.ResourceArn != nil {
		objectKey := object.Key("ResourceArn")
		objectKey.String(*v.ResourceArn)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDownloadDBLogFilePortionInput(v *DownloadDBLogFilePortionInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBInstanceIdentifier != nil {
		objectKey := object.Key("DBInstanceIdentifier")
		objectKey.String(*v.DBInstanceIdentifier)
	}

	if v.LogFileName != nil {
		objectKey := object.Key("LogFileName")
		objectKey.String(*v.LogFileName)
	}

	if v.Marker != nil {
		objectKey := object.Key("Marker")
		objectKey.String(*v.Marker)
	}

	if v.NumberOfLines != nil {
		objectKey := object.Key("NumberOfLines")
		objectKey.Integer(*v.NumberOfLines)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentEnableHttpEndpointInput(v *EnableHttpEndpointInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.ResourceArn != nil {
		objectKey := object.Key("ResourceArn")
		objectKey.String(*v.ResourceArn)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentFailoverDBClusterInput(v *FailoverDBClusterInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBClusterIdentifier != nil {
		objectKey := object.Key("DBClusterIdentifier")
		objectKey.String(*v.DBClusterIdentifier)
	}

	if v.TargetDBInstanceIdentifier != nil {
		objectKey := object.Key("TargetDBInstanceIdentifier")
		objectKey.String(*v.TargetDBInstanceIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentFailoverGlobalClusterInput(v *FailoverGlobalClusterInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.AllowDataLoss != nil {
		objectKey := object.Key("AllowDataLoss")
		objectKey.Boolean(*v.AllowDataLoss)
	}

	if v.GlobalClusterIdentifier != nil {
		objectKey := object.Key("GlobalClusterIdentifier")
		objectKey.String(*v.GlobalClusterIdentifier)
	}

	if v.Switchover != nil {
		objectKey := object.Key("Switchover")
		objectKey.Boolean(*v.Switchover)
	}

	if v.TargetDbClusterIdentifier != nil {
		objectKey := object.Key("TargetDbClusterIdentifier")
		objectKey.String(*v.TargetDbClusterIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentListTagsForResourceInput(v *ListTagsForResourceInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.Filters != nil {
		objectKey := object.Key("Filters")
		if err := awsAwsquery_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
			return err
		}
	}

	if v.ResourceName != nil {
		objectKey := object.Key("ResourceName")
		objectKey.String(*v.ResourceName)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentModifyActivityStreamInput(v *ModifyActivityStreamInput, value query.Value) error {
	object := value.Object()
	_ = object

	if len(v.AuditPolicyState) > 0 {
		objectKey := object.Key("AuditPolicyState")
		objectKey.String(string(v.AuditPolicyState))
	}

	if v.ResourceArn != nil {
		objectKey := object.Key("ResourceArn")
		objectKey.String(*v.ResourceArn)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentModifyCertificatesInput(v *ModifyCertificatesInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.CertificateIdentifier != nil {
		objectKey := object.Key("CertificateIdentifier")
		objectKey.String(*v.CertificateIdentifier)
	}

	if v.RemoveCustomerOverride != nil {
		objectKey := object.Key("RemoveCustomerOverride")
		objectKey.Boolean(*v.RemoveCustomerOverride)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentModifyCurrentDBClusterCapacityInput(v *ModifyCurrentDBClusterCapacityInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.Capacity != nil {
		objectKey := object.Key("Capacity")
		objectKey.Integer(*v.Capacity)
	}

	if v.DBClusterIdentifier != nil {
		objectKey := object.Key("DBClusterIdentifier")
		objectKey.String(*v.DBClusterIdentifier)
	}

	if v.SecondsBeforeTimeout != nil {
		objectKey := object.Key("SecondsBeforeTimeout")
		objectKey.Integer(*v.SecondsBeforeTimeout)
	}

	if v.TimeoutAction != nil {
		objectKey := object.Key("TimeoutAction")
		objectKey.String(*v.TimeoutAction)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentModifyCustomDBEngineVersionInput(v *ModifyCustomDBEngineVersionInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.Description != nil {
		objectKey := object.Key("Description")
		objectKey.String(*v.Description)
	}

	if v.Engine != nil {
		objectKey := object.Key("Engine")
		objectKey.String(*v.Engine)
	}

	if v.EngineVersion != nil {
		objectKey := object.Key("EngineVersion")
		objectKey.String(*v.EngineVersion)
	}

	if len(v.Status) > 0 {
		objectKey := object.Key("Status")
		objectKey.String(string(v.Status))
	}

	return nil
}

func awsAwsquery_serializeOpDocumentModifyDBClusterEndpointInput(v *ModifyDBClusterEndpointInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBClusterEndpointIdentifier != nil {
		objectKey := object.Key("DBClusterEndpointIdentifier")
		objectKey.String(*v.DBClusterEndpointIdentifier)
	}

	if v.EndpointType != nil {
		objectKey := object.Key("EndpointType")
		objectKey.String(*v.EndpointType)
	}

	if v.ExcludedMembers != nil {
		objectKey := object.Key("ExcludedMembers")
		if err := awsAwsquery_serializeDocumentStringList(v.ExcludedMembers, objectKey); err != nil {
			return err
		}
	}

	if v.StaticMembers != nil {
		objectKey := object.Key("StaticMembers")
		if err := awsAwsquery_serializeDocumentStringList(v.StaticMembers, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentModifyDBClusterInput(v *ModifyDBClusterInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.AllocatedStorage != nil {
		objectKey := object.Key("AllocatedStorage")
		objectKey.Integer(*v.AllocatedStorage)
	}

	if v.AllowEngineModeChange != nil {
		objectKey := object.Key("AllowEngineModeChange")
		objectKey.Boolean(*v.AllowEngineModeChange)
	}

	if v.AllowMajorVersionUpgrade != nil {
		objectKey := object.Key("AllowMajorVersionUpgrade")
		objectKey.Boolean(*v.AllowMajorVersionUpgrade)
	}

	if v.ApplyImmediately != nil {
		objectKey := object.Key("ApplyImmediately")
		objectKey.Boolean(*v.ApplyImmediately)
	}

	if v.AutoMinorVersionUpgrade != nil {
		objectKey := object.Key("AutoMinorVersionUpgrade")
		objectKey.Boolean(*v.AutoMinorVersionUpgrade)
	}

	if v.AwsBackupRecoveryPointArn != nil {
		objectKey := object.Key("AwsBackupRecoveryPointArn")
		objectKey.String(*v.AwsBackupRecoveryPointArn)
	}

	if v.BacktrackWindow != nil {
		objectKey := object.Key("BacktrackWindow")
		objectKey.Long(*v.BacktrackWindow)
	}

	if v.BackupRetentionPeriod != nil {
		objectKey := object.Key("BackupRetentionPeriod")
		objectKey.Integer(*v.BackupRetentionPeriod)
	}

	if v.CACertificateIdentifier != nil {
		objectKey := object.Key("CACertificateIdentifier")
		objectKey.String(*v.CACertificateIdentifier)
	}

	if v.CloudwatchLogsExportConfiguration != nil {
		objectKey := object.Key("CloudwatchLogsExportConfiguration")
		if err := awsAwsquery_serializeDocumentCloudwatchLogsExportConfiguration(v.CloudwatchLogsExportConfiguration, objectKey); err != nil {
			return err
		}
	}

	if v.CopyTagsToSnapshot != nil {
		objectKey := object.Key("CopyTagsToSnapshot")
		objectKey.Boolean(*v.CopyTagsToSnapshot)
	}

	if len(v.DatabaseInsightsMode) > 0 {
		objectKey := object.Key("DatabaseInsightsMode")
		objectKey.String(string(v.DatabaseInsightsMode))
	}

	if v.DBClusterIdentifier != nil {
		objectKey := object.Key("DBClusterIdentifier")
		objectKey.String(*v.DBClusterIdentifier)
	}

	if v.DBClusterInstanceClass != nil {
		objectKey := object.Key("DBClusterInstanceClass")
		objectKey.String(*v.DBClusterInstanceClass)
	}

	if v.DBClusterParameterGroupName != nil {
		objectKey := object.Key("DBClusterParameterGroupName")
		objectKey.String(*v.DBClusterParameterGroupName)
	}

	if v.DBInstanceParameterGroupName != nil {
		objectKey := object.Key("DBInstanceParameterGroupName")
		objectKey.String(*v.DBInstanceParameterGroupName)
	}

	if v.DeletionProtection != nil {
		objectKey := object.Key("DeletionProtection")
		objectKey.Boolean(*v.DeletionProtection)
	}

	if v.Domain != nil {
		objectKey := object.Key("Domain")
		objectKey.String(*v.Domain)
	}

	if v.DomainIAMRoleName != nil {
		objectKey := object.Key("DomainIAMRoleName")
		objectKey.String(*v.DomainIAMRoleName)
	}

	if v.EnableGlobalWriteForwarding != nil {
		objectKey := object.Key("EnableGlobalWriteForwarding")
		objectKey.Boolean(*v.EnableGlobalWriteForwarding)
	}

	if v.EnableHttpEndpoint != nil {
		objectKey := object.Key("EnableHttpEndpoint")
		objectKey.Boolean(*v.EnableHttpEndpoint)
	}

	if v.EnableIAMDatabaseAuthentication != nil {
		objectKey := object.Key("EnableIAMDatabaseAuthentication")
		objectKey.Boolean(*v.EnableIAMDatabaseAuthentication)
	}

	if v.EnableLimitlessDatabase != nil {
		objectKey := object.Key("EnableLimitlessDatabase")
		objectKey.Boolean(*v.EnableLimitlessDatabase)
	}

	if v.EnableLocalWriteForwarding != nil {
		objectKey := object.Key("EnableLocalWriteForwarding")
		objectKey.Boolean(*v.EnableLocalWriteForwarding)
	}

	if v.EnablePerformanceInsights != nil {
		objectKey := object.Key("EnablePerformanceInsights")
		objectKey.Boolean(*v.EnablePerformanceInsights)
	}

	if v.EngineMode != nil {
		objectKey := object.Key("EngineMode")
		objectKey.String(*v.EngineMode)
	}

	if v.EngineVersion != nil {
		objectKey := object.Key("EngineVersion")
		objectKey.String(*v.EngineVersion)
	}

	if v.Iops != nil {
		objectKey := object.Key("Iops")
		objectKey.Integer(*v.Iops)
	}

	if v.ManageMasterUserPassword != nil {
		objectKey := object.Key("ManageMasterUserPassword")
		objectKey.Boolean(*v.ManageMasterUserPassword)
	}

	if len(v.MasterUserAuthenticationType) > 0 {
		objectKey := object.Key("MasterUserAuthenticationType")
		objectKey.String(string(v.MasterUserAuthenticationType))
	}

	if v.MasterUserPassword != nil {
		objectKey := object.Key("MasterUserPassword")
		objectKey.String(*v.MasterUserPassword)
	}

	if v.MasterUserSecretKmsKeyId != nil {
		objectKey := object.Key("MasterUserSecretKmsKeyId")
		objectKey.String(*v.MasterUserSecretKmsKeyId)
	}

	if v.MonitoringInterval != nil {
		objectKey := object.Key("MonitoringInterval")
		objectKey.Integer(*v.MonitoringInterval)
	}

	if v.MonitoringRoleArn != nil {
		objectKey := object.Key("MonitoringRoleArn")
		objectKey.String(*v.MonitoringRoleArn)
	}

	if v.NetworkType != nil {
		objectKey := object.Key("NetworkType")
		objectKey.String(*v.NetworkType)
	}

	if v.NewDBClusterIdentifier != nil {
		objectKey := object.Key("NewDBClusterIdentifier")
		objectKey.String(*v.NewDBClusterIdentifier)
	}

	if v.OptionGroupName != nil {
		objectKey := object.Key("OptionGroupName")
		objectKey.String(*v.OptionGroupName)
	}

	if v.PerformanceInsightsKMSKeyId != nil {
		objectKey := object.Key("PerformanceInsightsKMSKeyId")
		objectKey.String(*v.PerformanceInsightsKMSKeyId)
	}

	if v.PerformanceInsightsRetentionPeriod != nil {
		objectKey := object.Key("PerformanceInsightsRetentionPeriod")
		objectKey.Integer(*v.PerformanceInsightsRetentionPeriod)
	}

	if v.Port != nil {
		objectKey := object.Key("Port")
		objectKey.Integer(*v.Port)
	}

	if v.PreferredBackupWindow != nil {
		objectKey := object.Key("PreferredBackupWindow")
		objectKey.String(*v.PreferredBackupWindow)
	}

	if v.PreferredMaintenanceWindow != nil {
		objectKey := object.Key("PreferredMaintenanceWindow")
		objectKey.String(*v.PreferredMaintenanceWindow)
	}

	if v.RotateMasterUserPassword != nil {
		objectKey := object.Key("RotateMasterUserPassword")
		objectKey.Boolean(*v.RotateMasterUserPassword)
	}

	if v.ScalingConfiguration != nil {
		objectKey := object.Key("ScalingConfiguration")
		if err := awsAwsquery_serializeDocumentScalingConfiguration(v.ScalingConfiguration, objectKey); err != nil {
			return err
		}
	}

	if v.ServerlessV2ScalingConfiguration != nil {
		objectKey := object.Key("ServerlessV2ScalingConfiguration")
		if err := awsAwsquery_serializeDocumentServerlessV2ScalingConfiguration(v.ServerlessV2ScalingConfiguration, objectKey); err != nil {
			return err
		}
	}

	if v.StorageType != nil {
		objectKey := object.Key("StorageType")
		objectKey.String(*v.StorageType)
	}

	if v.VpcSecurityGroupIds != nil {
		objectKey := object.Key("VpcSecurityGroupIds")
		if err := awsAwsquery_serializeDocumentVpcSecurityGroupIdList(v.VpcSecurityGroupIds, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentModifyDBClusterParameterGroupInput(v *ModifyDBClusterParameterGroupInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBClusterParameterGroupName != nil {
		objectKey := object.Key("DBClusterParameterGroupName")
		objectKey.String(*v.DBClusterParameterGroupName)
	}

	if v.Parameters != nil {
		objectKey := object.Key("Parameters")
		if err := awsAwsquery_serializeDocumentParametersList(v.Parameters, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentModifyDBClusterSnapshotAttributeInput(v *ModifyDBClusterSnapshotAttributeInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.AttributeName != nil {
		objectKey := object.Key("AttributeName")
		objectKey.String(*v.AttributeName)
	}

	if v.DBClusterSnapshotIdentifier != nil {
		objectKey := object.Key("DBClusterSnapshotIdentifier")
		objectKey.String(*v.DBClusterSnapshotIdentifier)
	}

	if v.ValuesToAdd != nil {
		objectKey := object.Key("ValuesToAdd")
		if err := awsAwsquery_serializeDocumentAttributeValueList(v.ValuesToAdd, objectKey); err != nil {
			return err
		}
	}

	if v.ValuesToRemove != nil {
		objectKey := object.Key("ValuesToRemove")
		if err := awsAwsquery_serializeDocumentAttributeValueList(v.ValuesToRemove, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentModifyDBInstanceInput(v *ModifyDBInstanceInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.AdditionalStorageVolumes != nil {
		objectKey := object.Key("AdditionalStorageVolumes")
		if err := awsAwsquery_serializeDocumentModifyAdditionalStorageVolumesList(v.AdditionalStorageVolumes, objectKey); err != nil {
			return err
		}
	}

	if v.AllocatedStorage != nil {
		objectKey := object.Key("AllocatedStorage")
		objectKey.Integer(*v.AllocatedStorage)
	}

	if v.AllowMajorVersionUpgrade != nil {
		objectKey := object.Key("AllowMajorVersionUpgrade")
		objectKey.Boolean(*v.AllowMajorVersionUpgrade)
	}

	if v.ApplyImmediately != nil {
		objectKey := object.Key("ApplyImmediately")
		objectKey.Boolean(*v.ApplyImmediately)
	}

	if len(v.AutomationMode) > 0 {
		objectKey := object.Key("AutomationMode")
		objectKey.String(string(v.AutomationMode))
	}

	if v.AutoMinorVersionUpgrade != nil {
		objectKey := object.Key("AutoMinorVersionUpgrade")
		objectKey.Boolean(*v.AutoMinorVersionUpgrade)
	}

	if v.AwsBackupRecoveryPointArn != nil {
		objectKey := object.Key("AwsBackupRecoveryPointArn")
		objectKey.String(*v.AwsBackupRecoveryPointArn)
	}

	if v.BackupRetentionPeriod != nil {
		objectKey := object.Key("BackupRetentionPeriod")
		objectKey.Integer(*v.BackupRetentionPeriod)
	}

	if v.CACertificateIdentifier != nil {
		objectKey := object.Key("CACertificateIdentifier")
		objectKey.String(*v.CACertificateIdentifier)
	}

	if v.CertificateRotationRestart != nil {
		objectKey := object.Key("CertificateRotationRestart")
		objectKey.Boolean(*v.CertificateRotationRestart)
	}

	if v.CloudwatchLogsExportConfiguration != nil {
		objectKey := object.Key("CloudwatchLogsExportConfiguration")
		if err := awsAwsquery_serializeDocumentCloudwatchLogsExportConfiguration(v.CloudwatchLogsExportConfiguration, objectKey); err != nil {
			return err
		}
	}

	if v.CopyTagsToSnapshot != nil {
		objectKey := object.Key("CopyTagsToSnapshot")
		objectKey.Boolean(*v.CopyTagsToSnapshot)
	}

	if len(v.DatabaseInsightsMode) > 0 {
		objectKey := object.Key("DatabaseInsightsMode")
		objectKey.String(string(v.DatabaseInsightsMode))
	}

	if v.DBInstanceClass != nil {
		objectKey := object.Key("DBInstanceClass")
		objectKey.String(*v.DBInstanceClass)
	}

	if v.DBInstanceIdentifier != nil {
		objectKey := object.Key("DBInstanceIdentifier")
		objectKey.String(*v.DBInstanceIdentifier)
	}

	if v.DBParameterGroupName != nil {
		objectKey := object.Key("DBParameterGroupName")
		objectKey.String(*v.DBParameterGroupName)
	}

	if v.DBPortNumber != nil {
		objectKey := object.Key("DBPortNumber")
		objectKey.Integer(*v.DBPortNumber)
	}

	if v.DBSecurityGroups != nil {
		objectKey := object.Key("DBSecurityGroups")
		if err := awsAwsquery_serializeDocumentDBSecurityGroupNameList(v.DBSecurityGroups, objectKey); err != nil {
			return err
		}
	}

	if v.DBSubnetGroupName != nil {
		objectKey := object.Key("DBSubnetGroupName")
		objectKey.String(*v.DBSubnetGroupName)
	}

	if v.DedicatedLogVolume != nil {
		objectKey := object.Key("DedicatedLogVolume")
		objectKey.Boolean(*v.DedicatedLogVolume)
	}

	if v.DeletionProtection != nil {
		objectKey := object.Key("DeletionProtection")
		objectKey.Boolean(*v.DeletionProtection)
	}

	if v.DisableDomain != nil {
		objectKey := object.Key("DisableDomain")
		objectKey.Boolean(*v.DisableDomain)
	}

	if v.Domain != nil {
		objectKey := object.Key("Domain")
		objectKey.String(*v.Domain)
	}

	if v.DomainAuthSecretArn != nil {
		objectKey := object.Key("DomainAuthSecretArn")
		objectKey.String(*v.DomainAuthSecretArn)
	}

	if v.DomainDnsIps != nil {
		objectKey := object.Key("DomainDnsIps")
		if err := awsAwsquery_serializeDocumentStringList(v.DomainDnsIps, objectKey); err != nil {
			return err
		}
	}

	if v.DomainFqdn != nil {
		objectKey := object.Key("DomainFqdn")
		objectKey.String(*v.DomainFqdn)
	}

	if v.DomainIAMRoleName != nil {
		objectKey := object.Key("DomainIAMRoleName")
		objectKey.String(*v.DomainIAMRoleName)
	}

	if v.DomainOu != nil {
		objectKey := object.Key("DomainOu")
		objectKey.String(*v.DomainOu)
	}

	if v.EnableCustomerOwnedIp != nil {
		objectKey := object.Key("EnableCustomerOwnedIp")
		objectKey.Boolean(*v.EnableCustomerOwnedIp)
	}

	if v.EnableIAMDatabaseAuthentication != nil {
		objectKey := object.Key("EnableIAMDatabaseAuthentication")
		objectKey.Boolean(*v.EnableIAMDatabaseAuthentication)
	}

	if v.EnablePerformanceInsights != nil {
		objectKey := object.Key("EnablePerformanceInsights")
		objectKey.Boolean(*v.EnablePerformanceInsights)
	}

	if v.Engine != nil {
		objectKey := object.Key("Engine")
		objectKey.String(*v.Engine)
	}

	if v.EngineVersion != nil {
		objectKey := object.Key("EngineVersion")
		objectKey.String(*v.EngineVersion)
	}

	if v.Iops != nil {
		objectKey := object.Key("Iops")
		objectKey.Integer(*v.Iops)
	}

	if v.LicenseModel != nil {
		objectKey := object.Key("LicenseModel")
		objectKey.String(*v.LicenseModel)
	}

	if v.ManageMasterUserPassword != nil {
		objectKey := object.Key("ManageMasterUserPassword")
		objectKey.Boolean(*v.ManageMasterUserPassword)
	}

	if len(v.MasterUserAuthenticationType) > 0 {
		objectKey := object.Key("MasterUserAuthenticationType")
		objectKey.String(string(v.MasterUserAuthenticationType))
	}

	if v.MasterUserPassword != nil {
		objectKey := object.Key("MasterUserPassword")
		objectKey.String(*v.MasterUserPassword)
	}

	if v.MasterUserSecretKmsKeyId != nil {
		objectKey := object.Key("MasterUserSecretKmsKeyId")
		objectKey.String(*v.MasterUserSecretKmsKeyId)
	}

	if v.MaxAllocatedStorage != nil {
		objectKey := object.Key("MaxAllocatedStorage")
		objectKey.Integer(*v.MaxAllocatedStorage)
	}

	if v.MonitoringInterval != nil {
		objectKey := object.Key("MonitoringInterval")
		objectKey.Integer(*v.MonitoringInterval)
	}

	if v.MonitoringRoleArn != nil {
		objectKey := object.Key("MonitoringRoleArn")
		objectKey.String(*v.MonitoringRoleArn)
	}

	if v.MultiAZ != nil {
		objectKey := object.Key("MultiAZ")
		objectKey.Boolean(*v.MultiAZ)
	}

	if v.MultiTenant != nil {
		objectKey := object.Key("MultiTenant")
		objectKey.Boolean(*v.MultiTenant)
	}

	if v.NetworkType != nil {
		objectKey := object.Key("NetworkType")
		objectKey.String(*v.NetworkType)
	}

	if v.NewDBInstanceIdentifier != nil {
		objectKey := object.Key("NewDBInstanceIdentifier")
		objectKey.String(*v.NewDBInstanceIdentifier)
	}

	if v.OptionGroupName != nil {
		objectKey := object.Key("OptionGroupName")
		objectKey.String(*v.OptionGroupName)
	}

	if v.PerformanceInsightsKMSKeyId != nil {
		objectKey := object.Key("PerformanceInsightsKMSKeyId")
		objectKey.String(*v.PerformanceInsightsKMSKeyId)
	}

	if v.PerformanceInsightsRetentionPeriod != nil {
		objectKey := object.Key("PerformanceInsightsRetentionPeriod")
		objectKey.Integer(*v.PerformanceInsightsRetentionPeriod)
	}

	if v.PreferredBackupWindow != nil {
		objectKey := object.Key("PreferredBackupWindow")
		objectKey.String(*v.PreferredBackupWindow)
	}

	if v.PreferredMaintenanceWindow != nil {
		objectKey := object.Key("PreferredMaintenanceWindow")
		objectKey.String(*v.PreferredMaintenanceWindow)
	}

	if v.ProcessorFeatures != nil {
		objectKey := object.Key("ProcessorFeatures")
		if err := awsAwsquery_serializeDocumentProcessorFeatureList(v.ProcessorFeatures, objectKey); err != nil {
			return err
		}
	}

	if v.PromotionTier != nil {
		objectKey := object.Key("PromotionTier")
		objectKey.Integer(*v.PromotionTier)
	}

	if v.PubliclyAccessible != nil {
		objectKey := object.Key("PubliclyAccessible")
		objectKey.Boolean(*v.PubliclyAccessible)
	}

	if len(v.ReplicaMode) > 0 {
		objectKey := object.Key("ReplicaMode")
		objectKey.String(string(v.ReplicaMode))
	}

	if v.ResumeFullAutomationModeMinutes != nil {
		objectKey := object.Key("ResumeFullAutomationModeMinutes")
		objectKey.Integer(*v.ResumeFullAutomationModeMinutes)
	}

	if v.RotateMasterUserPassword != nil {
		objectKey := object.Key("RotateMasterUserPassword")
		objectKey.Boolean(*v.RotateMasterUserPassword)
	}

	if v.StorageThroughput != nil {
		objectKey := object.Key("StorageThroughput")
		objectKey.Integer(*v.StorageThroughput)
	}

	if v.StorageType != nil {
		objectKey := object.Key("StorageType")
		objectKey.String(*v.StorageType)
	}

	if v.TagSpecifications != nil {
		objectKey := object.Key("TagSpecifications")
		if err := awsAwsquery_serializeDocumentTagSpecificationList(v.TagSpecifications, objectKey); err != nil {
			return err
		}
	}

	if v.TdeCredentialArn != nil {
		objectKey := object.Key("TdeCredentialArn")
		objectKey.String(*v.TdeCredentialArn)
	}

	if v.TdeCredentialPassword != nil {
		objectKey := object.Key("TdeCredentialPassword")
		objectKey.String(*v.TdeCredentialPassword)
	}

	if v.UseDefaultProcessorFeatures != nil {
		objectKey := object.Key("UseDefaultProcessorFeatures")
		objectKey.Boolean(*v.UseDefaultProcessorFeatures)
	}

	if v.VpcSecurityGroupIds != nil {
		objectKey := object.Key("VpcSecurityGroupIds")
		if err := awsAwsquery_serializeDocumentVpcSecurityGroupIdList(v.VpcSecurityGroupIds, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentModifyDBParameterGroupInput(v *ModifyDBParameterGroupInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBParameterGroupName != nil {
		objectKey := object.Key("DBParameterGroupName")
		objectKey.String(*v.DBParameterGroupName)
	}

	if v.Parameters != nil {
		objectKey := object.Key("Parameters")
		if err := awsAwsquery_serializeDocumentParametersList(v.Parameters, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentModifyDBProxyEndpointInput(v *ModifyDBProxyEndpointInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBProxyEndpointName != nil {
		objectKey := object.Key("DBProxyEndpointName")
		objectKey.String(*v.DBProxyEndpointName)
	}

	if v.NewDBProxyEndpointName != nil {
		objectKey := object.Key("NewDBProxyEndpointName")
		objectKey.String(*v.NewDBProxyEndpointName)
	}

	if v.VpcSecurityGroupIds != nil {
		objectKey := object.Key("VpcSecurityGroupIds")
		if err := awsAwsquery_serializeDocumentStringList(v.VpcSecurityGroupIds, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentModifyDBProxyInput(v *ModifyDBProxyInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.Auth != nil {
		objectKey := object.Key("Auth")
		if err := awsAwsquery_serializeDocumentUserAuthConfigList(v.Auth, objectKey); err != nil {
			return err
		}
	}

	if v.DBProxyName != nil {
		objectKey := object.Key("DBProxyName")
		objectKey.String(*v.DBProxyName)
	}

	if v.DebugLogging != nil {
		objectKey := object.Key("DebugLogging")
		objectKey.Boolean(*v.DebugLogging)
	}

	if len(v.DefaultAuthScheme) > 0 {
		objectKey := object.Key("DefaultAuthScheme")
		objectKey.String(string(v.DefaultAuthScheme))
	}

	if v.IdleClientTimeout != nil {
		objectKey := object.Key("IdleClientTimeout")
		objectKey.Integer(*v.IdleClientTimeout)
	}

	if v.NewDBProxyName != nil {
		objectKey := object.Key("NewDBProxyName")
		objectKey.String(*v.NewDBProxyName)
	}

	if v.RequireTLS != nil {
		objectKey := object.Key("RequireTLS")
		objectKey.Boolean(*v.RequireTLS)
	}

	if v.RoleArn != nil {
		objectKey := object.Key("RoleArn")
		objectKey.String(*v.RoleArn)
	}

	if v.SecurityGroups != nil {
		objectKey := object.Key("SecurityGroups")
		if err := awsAwsquery_serializeDocumentStringList(v.SecurityGroups, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentModifyDBProxyTargetGroupInput(v *ModifyDBProxyTargetGroupInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.ConnectionPoolConfig != nil {
		objectKey := object.Key("ConnectionPoolConfig")
		if err := awsAwsquery_serializeDocumentConnectionPoolConfiguration(v.ConnectionPoolConfig, objectKey); err != nil {
			return err
		}
	}

	if v.DBProxyName != nil {
		objectKey := object.Key("DBProxyName")
		objectKey.String(*v.DBProxyName)
	}

	if v.NewName != nil {
		objectKey := object.Key("NewName")
		objectKey.String(*v.NewName)
	}

	if v.TargetGroupName != nil {
		objectKey := object.Key("TargetGroupName")
		objectKey.String(*v.TargetGroupName)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentModifyDBRecommendationInput(v *ModifyDBRecommendationInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.Locale != nil {
		objectKey := object.Key("Locale")
		objectKey.String(*v.Locale)
	}

	if v.RecommendationId != nil {
		objectKey := object.Key("RecommendationId")
		objectKey.String(*v.RecommendationId)
	}

	if v.RecommendedActionUpdates != nil {
		objectKey := object.Key("RecommendedActionUpdates")
		if err := awsAwsquery_serializeDocumentRecommendedActionUpdateList(v.RecommendedActionUpdates, objectKey); err != nil {
			return err
		}
	}

	if v.Status != nil {
		objectKey := object.Key("Status")
		objectKey.String(*v.Status)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentModifyDBShardGroupInput(v *ModifyDBShardGroupInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.ComputeRedundancy != nil {
		objectKey := object.Key("ComputeRedundancy")
		objectKey.Integer(*v.ComputeRedundancy)
	}

	if v.DBShardGroupIdentifier != nil {
		objectKey := object.Key("DBShardGroupIdentifier")
		objectKey.String(*v.DBShardGroupIdentifier)
	}

	if v.MaxACU != nil {
		objectKey := object.Key("MaxACU")
		switch {
		case math.IsNaN(*v.MaxACU):
			objectKey.String("NaN")

		case math.IsInf(*v.MaxACU, 1):
			objectKey.String("Infinity")

		case math.IsInf(*v.MaxACU, -1):
			objectKey.String("-Infinity")

		default:
			objectKey.Double(*v.MaxACU)

		}
	}

	if v.MinACU != nil {
		objectKey := object.Key("MinACU")
		switch {
		case math.IsNaN(*v.MinACU):
			objectKey.String("NaN")

		case math.IsInf(*v.MinACU, 1):
			objectKey.String("Infinity")

		case math.IsInf(*v.MinACU, -1):
			objectKey.String("-Infinity")

		default:
			objectKey.Double(*v.MinACU)

		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentModifyDBSnapshotAttributeInput(v *ModifyDBSnapshotAttributeInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.AttributeName != nil {
		objectKey := object.Key("AttributeName")
		objectKey.String(*v.AttributeName)
	}

	if v.DBSnapshotIdentifier != nil {
		objectKey := object.Key("DBSnapshotIdentifier")
		objectKey.String(*v.DBSnapshotIdentifier)
	}

	if v.ValuesToAdd != nil {
		objectKey := object.Key("ValuesToAdd")
		if err := awsAwsquery_serializeDocumentAttributeValueList(v.ValuesToAdd, objectKey); err != nil {
			return err
		}
	}

	if v.ValuesToRemove != nil {
		objectKey := object.Key("ValuesToRemove")
		if err := awsAwsquery_serializeDocumentAttributeValueList(v.ValuesToRemove, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentModifyDBSnapshotInput(v *ModifyDBSnapshotInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBSnapshotIdentifier != nil {
		objectKey := object.Key("DBSnapshotIdentifier")
		objectKey.String(*v.DBSnapshotIdentifier)
	}

	if v.EngineVersion != nil {
		objectKey := object.Key("EngineVersion")
		objectKey.String(*v.EngineVersion)
	}

	if v.OptionGroupName != nil {
		objectKey := object.Key("OptionGroupName")
		objectKey.String(*v.OptionGroupName)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentModifyDBSubnetGroupInput(v *ModifyDBSubnetGroupInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBSubnetGroupDescription != nil {
		objectKey := object.Key("DBSubnetGroupDescription")
		objectKey.String(*v.DBSubnetGroupDescription)
	}

	if v.DBSubnetGroupName != nil {
		objectKey := object.Key("DBSubnetGroupName")
		objectKey.String(*v.DBSubnetGroupName)
	}

	if v.SubnetIds != nil {
		objectKey := object.Key("SubnetIds")
		if err := awsAwsquery_serializeDocumentSubnetIdentifierList(v.SubnetIds, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentModifyEventSubscriptionInput(v *ModifyEventSubscriptionInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.Enabled != nil {
		objectKey := object.Key("Enabled")
		objectKey.Boolean(*v.Enabled)
	}

	if v.EventCategories != nil {
		objectKey := object.Key("EventCategories")
		if err := awsAwsquery_serializeDocumentEventCategoriesList(v.EventCategories, objectKey); err != nil {
			return err
		}
	}

	if v.SnsTopicArn != nil {
		objectKey := object.Key("SnsTopicArn")
		objectKey.String(*v.SnsTopicArn)
	}

	if v.SourceType != nil {
		objectKey := object.Key("SourceType")
		objectKey.String(*v.SourceType)
	}

	if v.SubscriptionName != nil {
		objectKey := object.Key("SubscriptionName")
		objectKey.String(*v.SubscriptionName)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentModifyGlobalClusterInput(v *ModifyGlobalClusterInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.AllowMajorVersionUpgrade != nil {
		objectKey := object.Key("AllowMajorVersionUpgrade")
		objectKey.Boolean(*v.AllowMajorVersionUpgrade)
	}

	if v.DeletionProtection != nil {
		objectKey := object.Key("DeletionProtection")
		objectKey.Boolean(*v.DeletionProtection)
	}

	if v.EngineVersion != nil {
		objectKey := object.Key("EngineVersion")
		objectKey.String(*v.EngineVersion)
	}

	if v.GlobalClusterIdentifier != nil {
		objectKey := object.Key("GlobalClusterIdentifier")
		objectKey.String(*v.GlobalClusterIdentifier)
	}

	if v.NewGlobalClusterIdentifier != nil {
		objectKey := object.Key("NewGlobalClusterIdentifier")
		objectKey.String(*v.NewGlobalClusterIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentModifyIntegrationInput(v *ModifyIntegrationInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DataFilter != nil {
		objectKey := object.Key("DataFilter")
		objectKey.String(*v.DataFilter)
	}

	if v.Description != nil {
		objectKey := object.Key("Description")
		objectKey.String(*v.Description)
	}

	if v.IntegrationIdentifier != nil {
		objectKey := object.Key("IntegrationIdentifier")
		objectKey.String(*v.IntegrationIdentifier)
	}

	if v.IntegrationName != nil {
		objectKey := object.Key("IntegrationName")
		objectKey.String(*v.IntegrationName)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentModifyOptionGroupInput(v *ModifyOptionGroupInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.ApplyImmediately != nil {
		objectKey := object.Key("ApplyImmediately")
		objectKey.Boolean(*v.ApplyImmediately)
	}

	if v.OptionGroupName != nil {
		objectKey := object.Key("OptionGroupName")
		objectKey.String(*v.OptionGroupName)
	}

	if v.OptionsToInclude != nil {
		objectKey := object.Key("OptionsToInclude")
		if err := awsAwsquery_serializeDocumentOptionConfigurationList(v.OptionsToInclude, objectKey); err != nil {
			return err
		}
	}

	if v.OptionsToRemove != nil {
		objectKey := object.Key("OptionsToRemove")
		if err := awsAwsquery_serializeDocumentOptionNamesList(v.OptionsToRemove, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentModifyTenantDatabaseInput(v *ModifyTenantDatabaseInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBInstanceIdentifier != nil {
		objectKey := object.Key("DBInstanceIdentifier")
		objectKey.String(*v.DBInstanceIdentifier)
	}

	if v.ManageMasterUserPassword != nil {
		objectKey := object.Key("ManageMasterUserPassword")
		objectKey.Boolean(*v.ManageMasterUserPassword)
	}

	if v.MasterUserPassword != nil {
		objectKey := object.Key("MasterUserPassword")
		objectKey.String(*v.MasterUserPassword)
	}

	if v.MasterUserSecretKmsKeyId != nil {
		objectKey := object.Key("MasterUserSecretKmsKeyId")
		objectKey.String(*v.MasterUserSecretKmsKeyId)
	}

	if v.NewTenantDBName != nil {
		objectKey := object.Key("NewTenantDBName")
		objectKey.String(*v.NewTenantDBName)
	}

	if v.RotateMasterUserPassword != nil {
		objectKey := object.Key("RotateMasterUserPassword")
		objectKey.Boolean(*v.RotateMasterUserPassword)
	}

	if v.TenantDBName != nil {
		objectKey := object.Key("TenantDBName")
		objectKey.String(*v.TenantDBName)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentPromoteReadReplicaDBClusterInput(v *PromoteReadReplicaDBClusterInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBClusterIdentifier != nil {
		objectKey := object.Key("DBClusterIdentifier")
		objectKey.String(*v.DBClusterIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentPromoteReadReplicaInput(v *PromoteReadReplicaInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.BackupRetentionPeriod != nil {
		objectKey := object.Key("BackupRetentionPeriod")
		objectKey.Integer(*v.BackupRetentionPeriod)
	}

	if v.DBInstanceIdentifier != nil {
		objectKey := object.Key("DBInstanceIdentifier")
		objectKey.String(*v.DBInstanceIdentifier)
	}

	if v.PreferredBackupWindow != nil {
		objectKey := object.Key("PreferredBackupWindow")
		objectKey.String(*v.PreferredBackupWindow)
	}

	if v.TagSpecifications != nil {
		objectKey := object.Key("TagSpecifications")
		if err := awsAwsquery_serializeDocumentTagSpecificationList(v.TagSpecifications, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentPurchaseReservedDBInstancesOfferingInput(v *PurchaseReservedDBInstancesOfferingInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBInstanceCount != nil {
		objectKey := object.Key("DBInstanceCount")
		objectKey.Integer(*v.DBInstanceCount)
	}

	if v.ReservedDBInstanceId != nil {
		objectKey := object.Key("ReservedDBInstanceId")
		objectKey.String(*v.ReservedDBInstanceId)
	}

	if v.ReservedDBInstancesOfferingId != nil {
		objectKey := object.Key("ReservedDBInstancesOfferingId")
		objectKey.String(*v.ReservedDBInstancesOfferingId)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentRebootDBClusterInput(v *RebootDBClusterInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBClusterIdentifier != nil {
		objectKey := object.Key("DBClusterIdentifier")
		objectKey.String(*v.DBClusterIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentRebootDBInstanceInput(v *RebootDBInstanceInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBInstanceIdentifier != nil {
		objectKey := object.Key("DBInstanceIdentifier")
		objectKey.String(*v.DBInstanceIdentifier)
	}

	if v.ForceFailover != nil {
		objectKey := object.Key("ForceFailover")
		objectKey.Boolean(*v.ForceFailover)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentRebootDBShardGroupInput(v *RebootDBShardGroupInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBShardGroupIdentifier != nil {
		objectKey := object.Key("DBShardGroupIdentifier")
		objectKey.String(*v.DBShardGroupIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentRegisterDBProxyTargetsInput(v *RegisterDBProxyTargetsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBClusterIdentifiers != nil {
		objectKey := object.Key("DBClusterIdentifiers")
		if err := awsAwsquery_serializeDocumentStringList(v.DBClusterIdentifiers, objectKey); err != nil {
			return err
		}
	}

	if v.DBInstanceIdentifiers != nil {
		objectKey := object.Key("DBInstanceIdentifiers")
		if err := awsAwsquery_serializeDocumentStringList(v.DBInstanceIdentifiers, objectKey); err != nil {
			return err
		}
	}

	if v.DBProxyName != nil {
		objectKey := object.Key("DBProxyName")
		objectKey.String(*v.DBProxyName)
	}

	if v.TargetGroupName != nil {
		objectKey := object.Key("TargetGroupName")
		objectKey.String(*v.TargetGroupName)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentRemoveFromGlobalClusterInput(v *RemoveFromGlobalClusterInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DbClusterIdentifier != nil {
		objectKey := object.Key("DbClusterIdentifier")
		objectKey.String(*v.DbClusterIdentifier)
	}

	if v.GlobalClusterIdentifier != nil {
		objectKey := object.Key("GlobalClusterIdentifier")
		objectKey.String(*v.GlobalClusterIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentRemoveRoleFromDBClusterInput(v *RemoveRoleFromDBClusterInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBClusterIdentifier != nil {
		objectKey := object.Key("DBClusterIdentifier")
		objectKey.String(*v.DBClusterIdentifier)
	}

	if v.FeatureName != nil {
		objectKey := object.Key("FeatureName")
		objectKey.String(*v.FeatureName)
	}

	if v.RoleArn != nil {
		objectKey := object.Key("RoleArn")
		objectKey.String(*v.RoleArn)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentRemoveRoleFromDBInstanceInput(v *RemoveRoleFromDBInstanceInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBInstanceIdentifier != nil {
		objectKey := object.Key("DBInstanceIdentifier")
		objectKey.String(*v.DBInstanceIdentifier)
	}

	if v.FeatureName != nil {
		objectKey := object.Key("FeatureName")
		objectKey.String(*v.FeatureName)
	}

	if v.RoleArn != nil {
		objectKey := object.Key("RoleArn")
		objectKey.String(*v.RoleArn)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentRemoveSourceIdentifierFromSubscriptionInput(v *RemoveSourceIdentifierFromSubscriptionInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.SourceIdentifier != nil {
		objectKey := object.Key("SourceIdentifier")
		objectKey.String(*v.SourceIdentifier)
	}

	if v.SubscriptionName != nil {
		objectKey := object.Key("SubscriptionName")
		objectKey.String(*v.SubscriptionName)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentRemoveTagsFromResourceInput(v *RemoveTagsFromResourceInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.ResourceName != nil {
		objectKey := object.Key("ResourceName")
		objectKey.String(*v.ResourceName)
	}

	if v.TagKeys != nil {
		objectKey := object.Key("TagKeys")
		if err := awsAwsquery_serializeDocumentKeyList(v.TagKeys, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentResetDBClusterParameterGroupInput(v *ResetDBClusterParameterGroupInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBClusterParameterGroupName != nil {
		objectKey := object.Key("DBClusterParameterGroupName")
		objectKey.String(*v.DBClusterParameterGroupName)
	}

	if v.Parameters != nil {
		objectKey := object.Key("Parameters")
		if err := awsAwsquery_serializeDocumentParametersList(v.Parameters, objectKey); err != nil {
			return err
		}
	}

	if v.ResetAllParameters != nil {
		objectKey := object.Key("ResetAllParameters")
		objectKey.Boolean(*v.ResetAllParameters)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentResetDBParameterGroupInput(v *ResetDBParameterGroupInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBParameterGroupName != nil {
		objectKey := object.Key("DBParameterGroupName")
		objectKey.String(*v.DBParameterGroupName)
	}

	if v.Parameters != nil {
		objectKey := object.Key("Parameters")
		if err := awsAwsquery_serializeDocumentParametersList(v.Parameters, objectKey); err != nil {
			return err
		}
	}

	if v.ResetAllParameters != nil {
		objectKey := object.Key("ResetAllParameters")
		objectKey.Boolean(*v.ResetAllParameters)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentRestoreDBClusterFromS3Input(v *RestoreDBClusterFromS3Input, value query.Value) error {
	object := value.Object()
	_ = object

	if v.AvailabilityZones != nil {
		objectKey := object.Key("AvailabilityZones")
		if err := awsAwsquery_serializeDocumentAvailabilityZones(v.AvailabilityZones, objectKey); err != nil {
			return err
		}
	}

	if v.BacktrackWindow != nil {
		objectKey := object.Key("BacktrackWindow")
		objectKey.Long(*v.BacktrackWindow)
	}

	if v.BackupRetentionPeriod != nil {
		objectKey := object.Key("BackupRetentionPeriod")
		objectKey.Integer(*v.BackupRetentionPeriod)
	}

	if v.CharacterSetName != nil {
		objectKey := object.Key("CharacterSetName")
		objectKey.String(*v.CharacterSetName)
	}

	if v.CopyTagsToSnapshot != nil {
		objectKey := object.Key("CopyTagsToSnapshot")
		objectKey.Boolean(*v.CopyTagsToSnapshot)
	}

	if v.DatabaseName != nil {
		objectKey := object.Key("DatabaseName")
		objectKey.String(*v.DatabaseName)
	}

	if v.DBClusterIdentifier != nil {
		objectKey := object.Key("DBClusterIdentifier")
		objectKey.String(*v.DBClusterIdentifier)
	}

	if v.DBClusterParameterGroupName != nil {
		objectKey := object.Key("DBClusterParameterGroupName")
		objectKey.String(*v.DBClusterParameterGroupName)
	}

	if v.DBSubnetGroupName != nil {
		objectKey := object.Key("DBSubnetGroupName")
		objectKey.String(*v.DBSubnetGroupName)
	}

	if v.DeletionProtection != nil {
		objectKey := object.Key("DeletionProtection")
		objectKey.Boolean(*v.DeletionProtection)
	}

	if v.Domain != nil {
		objectKey := object.Key("Domain")
		objectKey.String(*v.Domain)
	}

	if v.DomainIAMRoleName != nil {
		objectKey := object.Key("DomainIAMRoleName")
		objectKey.String(*v.DomainIAMRoleName)
	}

	if v.EnableCloudwatchLogsExports != nil {
		objectKey := object.Key("EnableCloudwatchLogsExports")
		if err := awsAwsquery_serializeDocumentLogTypeList(v.EnableCloudwatchLogsExports, objectKey); err != nil {
			return err
		}
	}

	if v.EnableIAMDatabaseAuthentication != nil {
		objectKey := object.Key("EnableIAMDatabaseAuthentication")
		objectKey.Boolean(*v.EnableIAMDatabaseAuthentication)
	}

	if v.Engine != nil {
		objectKey := object.Key("Engine")
		objectKey.String(*v.Engine)
	}

	if v.EngineLifecycleSupport != nil {
		objectKey := object.Key("EngineLifecycleSupport")
		objectKey.String(*v.EngineLifecycleSupport)
	}

	if v.EngineVersion != nil {
		objectKey := object.Key("EngineVersion")
		objectKey.String(*v.EngineVersion)
	}

	if v.KmsKeyId != nil {
		objectKey := object.Key("KmsKeyId")
		objectKey.String(*v.KmsKeyId)
	}

	if v.ManageMasterUserPassword != nil {
		objectKey := object.Key("ManageMasterUserPassword")
		objectKey.Boolean(*v.ManageMasterUserPassword)
	}

	if v.MasterUsername != nil {
		objectKey := object.Key("MasterUsername")
		objectKey.String(*v.MasterUsername)
	}

	if v.MasterUserPassword != nil {
		objectKey := object.Key("MasterUserPassword")
		objectKey.String(*v.MasterUserPassword)
	}

	if v.MasterUserSecretKmsKeyId != nil {
		objectKey := object.Key("MasterUserSecretKmsKeyId")
		objectKey.String(*v.MasterUserSecretKmsKeyId)
	}

	if v.NetworkType != nil {
		objectKey := object.Key("NetworkType")
		objectKey.String(*v.NetworkType)
	}

	if v.OptionGroupName != nil {
		objectKey := object.Key("OptionGroupName")
		objectKey.String(*v.OptionGroupName)
	}

	if v.Port != nil {
		objectKey := object.Key("Port")
		objectKey.Integer(*v.Port)
	}

	if v.PreferredBackupWindow != nil {
		objectKey := object.Key("PreferredBackupWindow")
		objectKey.String(*v.PreferredBackupWindow)
	}

	if v.PreferredMaintenanceWindow != nil {
		objectKey := object.Key("PreferredMaintenanceWindow")
		objectKey.String(*v.PreferredMaintenanceWindow)
	}

	if v.S3BucketName != nil {
		objectKey := object.Key("S3BucketName")
		objectKey.String(*v.S3BucketName)
	}

	if v.S3IngestionRoleArn != nil {
		objectKey := object.Key("S3IngestionRoleArn")
		objectKey.String(*v.S3IngestionRoleArn)
	}

	if v.S3Prefix != nil {
		objectKey := object.Key("S3Prefix")
		objectKey.String(*v.S3Prefix)
	}

	if v.ServerlessV2ScalingConfiguration != nil {
		objectKey := object.Key("ServerlessV2ScalingConfiguration")
		if err := awsAwsquery_serializeDocumentServerlessV2ScalingConfiguration(v.ServerlessV2ScalingConfiguration, objectKey); err != nil {
			return err
		}
	}

	if v.SourceEngine != nil {
		objectKey := object.Key("SourceEngine")
		objectKey.String(*v.SourceEngine)
	}

	if v.SourceEngineVersion != nil {
		objectKey := object.Key("SourceEngineVersion")
		objectKey.String(*v.SourceEngineVersion)
	}

	if v.StorageEncrypted != nil {
		objectKey := object.Key("StorageEncrypted")
		objectKey.Boolean(*v.StorageEncrypted)
	}

	if v.StorageType != nil {
		objectKey := object.Key("StorageType")
		objectKey.String(*v.StorageType)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	if v.TagSpecifications != nil {
		objectKey := object.Key("TagSpecifications")
		if err := awsAwsquery_serializeDocumentTagSpecificationList(v.TagSpecifications, objectKey); err != nil {
			return err
		}
	}

	if v.VpcSecurityGroupIds != nil {
		objectKey := object.Key("VpcSecurityGroupIds")
		if err := awsAwsquery_serializeDocumentVpcSecurityGroupIdList(v.VpcSecurityGroupIds, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentRestoreDBClusterFromSnapshotInput(v *RestoreDBClusterFromSnapshotInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.AvailabilityZones != nil {
		objectKey := object.Key("AvailabilityZones")
		if err := awsAwsquery_serializeDocumentAvailabilityZones(v.AvailabilityZones, objectKey); err != nil {
			return err
		}
	}

	if v.BacktrackWindow != nil {
		objectKey := object.Key("BacktrackWindow")
		objectKey.Long(*v.BacktrackWindow)
	}

	if v.BackupRetentionPeriod != nil {
		objectKey := object.Key("BackupRetentionPeriod")
		objectKey.Integer(*v.BackupRetentionPeriod)
	}

	if v.CopyTagsToSnapshot != nil {
		objectKey := object.Key("CopyTagsToSnapshot")
		objectKey.Boolean(*v.CopyTagsToSnapshot)
	}

	if v.DatabaseName != nil {
		objectKey := object.Key("DatabaseName")
		objectKey.String(*v.DatabaseName)
	}

	if v.DBClusterIdentifier != nil {
		objectKey := object.Key("DBClusterIdentifier")
		objectKey.String(*v.DBClusterIdentifier)
	}

	if v.DBClusterInstanceClass != nil {
		objectKey := object.Key("DBClusterInstanceClass")
		objectKey.String(*v.DBClusterInstanceClass)
	}

	if v.DBClusterParameterGroupName != nil {
		objectKey := object.Key("DBClusterParameterGroupName")
		objectKey.String(*v.DBClusterParameterGroupName)
	}

	if v.DBSubnetGroupName != nil {
		objectKey := object.Key("DBSubnetGroupName")
		objectKey.String(*v.DBSubnetGroupName)
	}

	if v.DeletionProtection != nil {
		objectKey := object.Key("DeletionProtection")
		objectKey.Boolean(*v.DeletionProtection)
	}

	if v.Domain != nil {
		objectKey := object.Key("Domain")
		objectKey.String(*v.Domain)
	}

	if v.DomainIAMRoleName != nil {
		objectKey := object.Key("DomainIAMRoleName")
		objectKey.String(*v.DomainIAMRoleName)
	}

	if v.EnableCloudwatchLogsExports != nil {
		objectKey := object.Key("EnableCloudwatchLogsExports")
		if err := awsAwsquery_serializeDocumentLogTypeList(v.EnableCloudwatchLogsExports, objectKey); err != nil {
			return err
		}
	}

	if v.EnableIAMDatabaseAuthentication != nil {
		objectKey := object.Key("EnableIAMDatabaseAuthentication")
		objectKey.Boolean(*v.EnableIAMDatabaseAuthentication)
	}

	if v.EnableInternetAccessGateway != nil {
		objectKey := object.Key("EnableInternetAccessGateway")
		objectKey.Boolean(*v.EnableInternetAccessGateway)
	}

	if v.EnablePerformanceInsights != nil {
		objectKey := object.Key("EnablePerformanceInsights")
		objectKey.Boolean(*v.EnablePerformanceInsights)
	}

	if v.EnableVPCNetworking != nil {
		objectKey := object.Key("EnableVPCNetworking")
		objectKey.Boolean(*v.EnableVPCNetworking)
	}

	if v.Engine != nil {
		objectKey := object.Key("Engine")
		objectKey.String(*v.Engine)
	}

	if v.EngineLifecycleSupport != nil {
		objectKey := object.Key("EngineLifecycleSupport")
		objectKey.String(*v.EngineLifecycleSupport)
	}

	if v.EngineMode != nil {
		objectKey := object.Key("EngineMode")
		objectKey.String(*v.EngineMode)
	}

	if v.EngineVersion != nil {
		objectKey := object.Key("EngineVersion")
		objectKey.String(*v.EngineVersion)
	}

	if v.Iops != nil {
		objectKey := object.Key("Iops")
		objectKey.Integer(*v.Iops)
	}

	if v.KmsKeyId != nil {
		objectKey := object.Key("KmsKeyId")
		objectKey.String(*v.KmsKeyId)
	}

	if v.MonitoringInterval != nil {
		objectKey := object.Key("MonitoringInterval")
		objectKey.Integer(*v.MonitoringInterval)
	}

	if v.MonitoringRoleArn != nil {
		objectKey := object.Key("MonitoringRoleArn")
		objectKey.String(*v.MonitoringRoleArn)
	}

	if v.NetworkType != nil {
		objectKey := object.Key("NetworkType")
		objectKey.String(*v.NetworkType)
	}

	if v.OptionGroupName != nil {
		objectKey := object.Key("OptionGroupName")
		objectKey.String(*v.OptionGroupName)
	}

	if v.PerformanceInsightsKMSKeyId != nil {
		objectKey := object.Key("PerformanceInsightsKMSKeyId")
		objectKey.String(*v.PerformanceInsightsKMSKeyId)
	}

	if v.PerformanceInsightsRetentionPeriod != nil {
		objectKey := object.Key("PerformanceInsightsRetentionPeriod")
		objectKey.Integer(*v.PerformanceInsightsRetentionPeriod)
	}

	if v.Port != nil {
		objectKey := object.Key("Port")
		objectKey.Integer(*v.Port)
	}

	if v.PreferredBackupWindow != nil {
		objectKey := object.Key("PreferredBackupWindow")
		objectKey.String(*v.PreferredBackupWindow)
	}

	if v.PubliclyAccessible != nil {
		objectKey := object.Key("PubliclyAccessible")
		objectKey.Boolean(*v.PubliclyAccessible)
	}

	if v.RdsCustomClusterConfiguration != nil {
		objectKey := object.Key("RdsCustomClusterConfiguration")
		if err := awsAwsquery_serializeDocumentRdsCustomClusterConfiguration(v.RdsCustomClusterConfiguration, objectKey); err != nil {
			return err
		}
	}

	if v.ScalingConfiguration != nil {
		objectKey := object.Key("ScalingConfiguration")
		if err := awsAwsquery_serializeDocumentScalingConfiguration(v.ScalingConfiguration, objectKey); err != nil {
			return err
		}
	}

	if v.ServerlessV2ScalingConfiguration != nil {
		objectKey := object.Key("ServerlessV2ScalingConfiguration")
		if err := awsAwsquery_serializeDocumentServerlessV2ScalingConfiguration(v.ServerlessV2ScalingConfiguration, objectKey); err != nil {
			return err
		}
	}

	if v.SnapshotIdentifier != nil {
		objectKey := object.Key("SnapshotIdentifier")
		objectKey.String(*v.SnapshotIdentifier)
	}

	if v.StorageType != nil {
		objectKey := object.Key("StorageType")
		objectKey.String(*v.StorageType)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	if v.TagSpecifications != nil {
		objectKey := object.Key("TagSpecifications")
		if err := awsAwsquery_serializeDocumentTagSpecificationList(v.TagSpecifications, objectKey); err != nil {
			return err
		}
	}

	if v.VpcSecurityGroupIds != nil {
		objectKey := object.Key("VpcSecurityGroupIds")
		if err := awsAwsquery_serializeDocumentVpcSecurityGroupIdList(v.VpcSecurityGroupIds, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentRestoreDBClusterToPointInTimeInput(v *RestoreDBClusterToPointInTimeInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.BacktrackWindow != nil {
		objectKey := object.Key("BacktrackWindow")
		objectKey.Long(*v.BacktrackWindow)
	}

	if v.BackupRetentionPeriod != nil {
		objectKey := object.Key("BackupRetentionPeriod")
		objectKey.Integer(*v.BackupRetentionPeriod)
	}

	if v.CopyTagsToSnapshot != nil {
		objectKey := object.Key("CopyTagsToSnapshot")
		objectKey.Boolean(*v.CopyTagsToSnapshot)
	}

	if v.DBClusterIdentifier != nil {
		objectKey := object.Key("DBClusterIdentifier")
		objectKey.String(*v.DBClusterIdentifier)
	}

	if v.DBClusterInstanceClass != nil {
		objectKey := object.Key("DBClusterInstanceClass")
		objectKey.String(*v.DBClusterInstanceClass)
	}

	if v.DBClusterParameterGroupName != nil {
		objectKey := object.Key("DBClusterParameterGroupName")
		objectKey.String(*v.DBClusterParameterGroupName)
	}

	if v.DBSubnetGroupName != nil {
		objectKey := object.Key("DBSubnetGroupName")
		objectKey.String(*v.DBSubnetGroupName)
	}

	if v.DeletionProtection != nil {
		objectKey := object.Key("DeletionProtection")
		objectKey.Boolean(*v.DeletionProtection)
	}

	if v.Domain != nil {
		objectKey := object.Key("Domain")
		objectKey.String(*v.Domain)
	}

	if v.DomainIAMRoleName != nil {
		objectKey := object.Key("DomainIAMRoleName")
		objectKey.String(*v.DomainIAMRoleName)
	}

	if v.EnableCloudwatchLogsExports != nil {
		objectKey := object.Key("EnableCloudwatchLogsExports")
		if err := awsAwsquery_serializeDocumentLogTypeList(v.EnableCloudwatchLogsExports, objectKey); err != nil {
			return err
		}
	}

	if v.EnableIAMDatabaseAuthentication != nil {
		objectKey := object.Key("EnableIAMDatabaseAuthentication")
		objectKey.Boolean(*v.EnableIAMDatabaseAuthentication)
	}

	if v.EnableInternetAccessGateway != nil {
		objectKey := object.Key("EnableInternetAccessGateway")
		objectKey.Boolean(*v.EnableInternetAccessGateway)
	}

	if v.EnablePerformanceInsights != nil {
		objectKey := object.Key("EnablePerformanceInsights")
		objectKey.Boolean(*v.EnablePerformanceInsights)
	}

	if v.EnableVPCNetworking != nil {
		objectKey := object.Key("EnableVPCNetworking")
		objectKey.Boolean(*v.EnableVPCNetworking)
	}

	if v.EngineLifecycleSupport != nil {
		objectKey := object.Key("EngineLifecycleSupport")
		objectKey.String(*v.EngineLifecycleSupport)
	}

	if v.EngineMode != nil {
		objectKey := object.Key("EngineMode")
		objectKey.String(*v.EngineMode)
	}

	if v.Iops != nil {
		objectKey := object.Key("Iops")
		objectKey.Integer(*v.Iops)
	}

	if v.KmsKeyId != nil {
		objectKey := object.Key("KmsKeyId")
		objectKey.String(*v.KmsKeyId)
	}

	if v.MonitoringInterval != nil {
		objectKey := object.Key("MonitoringInterval")
		objectKey.Integer(*v.MonitoringInterval)
	}

	if v.MonitoringRoleArn != nil {
		objectKey := object.Key("MonitoringRoleArn")
		objectKey.String(*v.MonitoringRoleArn)
	}

	if v.NetworkType != nil {
		objectKey := object.Key("NetworkType")
		objectKey.String(*v.NetworkType)
	}

	if v.OptionGroupName != nil {
		objectKey := object.Key("OptionGroupName")
		objectKey.String(*v.OptionGroupName)
	}

	if v.PerformanceInsightsKMSKeyId != nil {
		objectKey := object.Key("PerformanceInsightsKMSKeyId")
		objectKey.String(*v.PerformanceInsightsKMSKeyId)
	}

	if v.PerformanceInsightsRetentionPeriod != nil {
		objectKey := object.Key("PerformanceInsightsRetentionPeriod")
		objectKey.Integer(*v.PerformanceInsightsRetentionPeriod)
	}

	if v.Port != nil {
		objectKey := object.Key("Port")
		objectKey.Integer(*v.Port)
	}

	if v.PreferredBackupWindow != nil {
		objectKey := object.Key("PreferredBackupWindow")
		objectKey.String(*v.PreferredBackupWindow)
	}

	if v.PubliclyAccessible != nil {
		objectKey := object.Key("PubliclyAccessible")
		objectKey.Boolean(*v.PubliclyAccessible)
	}

	if v.RdsCustomClusterConfiguration != nil {
		objectKey := object.Key("RdsCustomClusterConfiguration")
		if err := awsAwsquery_serializeDocumentRdsCustomClusterConfiguration(v.RdsCustomClusterConfiguration, objectKey); err != nil {
			return err
		}
	}

	if v.RestoreToTime != nil {
		objectKey := object.Key("RestoreToTime")
		objectKey.String(smithytime.FormatDateTime(*v.RestoreToTime))
	}

	if v.RestoreType != nil {
		objectKey := object.Key("RestoreType")
		objectKey.String(*v.RestoreType)
	}

	if v.ScalingConfiguration != nil {
		objectKey := object.Key("ScalingConfiguration")
		if err := awsAwsquery_serializeDocumentScalingConfiguration(v.ScalingConfiguration, objectKey); err != nil {
			return err
		}
	}

	if v.ServerlessV2ScalingConfiguration != nil {
		objectKey := object.Key("ServerlessV2ScalingConfiguration")
		if err := awsAwsquery_serializeDocumentServerlessV2ScalingConfiguration(v.ServerlessV2ScalingConfiguration, objectKey); err != nil {
			return err
		}
	}

	if v.SourceDBClusterIdentifier != nil {
		objectKey := object.Key("SourceDBClusterIdentifier")
		objectKey.String(*v.SourceDBClusterIdentifier)
	}

	if v.SourceDbClusterResourceId != nil {
		objectKey := object.Key("SourceDbClusterResourceId")
		objectKey.String(*v.SourceDbClusterResourceId)
	}

	if v.StorageType != nil {
		objectKey := object.Key("StorageType")
		objectKey.String(*v.StorageType)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	if v.TagSpecifications != nil {
		objectKey := object.Key("TagSpecifications")
		if err := awsAwsquery_serializeDocumentTagSpecificationList(v.TagSpecifications, objectKey); err != nil {
			return err
		}
	}

	if v.UseLatestRestorableTime != nil {
		objectKey := object.Key("UseLatestRestorableTime")
		objectKey.Boolean(*v.UseLatestRestorableTime)
	}

	if v.VpcSecurityGroupIds != nil {
		objectKey := object.Key("VpcSecurityGroupIds")
		if err := awsAwsquery_serializeDocumentVpcSecurityGroupIdList(v.VpcSecurityGroupIds, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentRestoreDBInstanceFromDBSnapshotInput(v *RestoreDBInstanceFromDBSnapshotInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.AdditionalStorageVolumes != nil {
		objectKey := object.Key("AdditionalStorageVolumes")
		if err := awsAwsquery_serializeDocumentAdditionalStorageVolumesList(v.AdditionalStorageVolumes, objectKey); err != nil {
			return err
		}
	}

	if v.AllocatedStorage != nil {
		objectKey := object.Key("AllocatedStorage")
		objectKey.Integer(*v.AllocatedStorage)
	}

	if v.AutoMinorVersionUpgrade != nil {
		objectKey := object.Key("AutoMinorVersionUpgrade")
		objectKey.Boolean(*v.AutoMinorVersionUpgrade)
	}

	if v.AvailabilityZone != nil {
		objectKey := object.Key("AvailabilityZone")
		objectKey.String(*v.AvailabilityZone)
	}

	if v.BackupRetentionPeriod != nil {
		objectKey := object.Key("BackupRetentionPeriod")
		objectKey.Integer(*v.BackupRetentionPeriod)
	}

	if v.BackupTarget != nil {
		objectKey := object.Key("BackupTarget")
		objectKey.String(*v.BackupTarget)
	}

	if v.CACertificateIdentifier != nil {
		objectKey := object.Key("CACertificateIdentifier")
		objectKey.String(*v.CACertificateIdentifier)
	}

	if v.CopyTagsToSnapshot != nil {
		objectKey := object.Key("CopyTagsToSnapshot")
		objectKey.Boolean(*v.CopyTagsToSnapshot)
	}

	if v.CustomIamInstanceProfile != nil {
		objectKey := object.Key("CustomIamInstanceProfile")
		objectKey.String(*v.CustomIamInstanceProfile)
	}

	if v.DBClusterSnapshotIdentifier != nil {
		objectKey := object.Key("DBClusterSnapshotIdentifier")
		objectKey.String(*v.DBClusterSnapshotIdentifier)
	}

	if v.DBInstanceClass != nil {
		objectKey := object.Key("DBInstanceClass")
		objectKey.String(*v.DBInstanceClass)
	}

	if v.DBInstanceIdentifier != nil {
		objectKey := object.Key("DBInstanceIdentifier")
		objectKey.String(*v.DBInstanceIdentifier)
	}

	if v.DBName != nil {
		objectKey := object.Key("DBName")
		objectKey.String(*v.DBName)
	}

	if v.DBParameterGroupName != nil {
		objectKey := object.Key("DBParameterGroupName")
		objectKey.String(*v.DBParameterGroupName)
	}

	if v.DBSnapshotIdentifier != nil {
		objectKey := object.Key("DBSnapshotIdentifier")
		objectKey.String(*v.DBSnapshotIdentifier)
	}

	if v.DBSubnetGroupName != nil {
		objectKey := object.Key("DBSubnetGroupName")
		objectKey.String(*v.DBSubnetGroupName)
	}

	if v.DedicatedLogVolume != nil {
		objectKey := object.Key("DedicatedLogVolume")
		objectKey.Boolean(*v.DedicatedLogVolume)
	}

	if v.DeletionProtection != nil {
		objectKey := object.Key("DeletionProtection")
		objectKey.Boolean(*v.DeletionProtection)
	}

	if v.Domain != nil {
		objectKey := object.Key("Domain")
		objectKey.String(*v.Domain)
	}

	if v.DomainAuthSecretArn != nil {
		objectKey := object.Key("DomainAuthSecretArn")
		objectKey.String(*v.DomainAuthSecretArn)
	}

	if v.DomainDnsIps != nil {
		objectKey := object.Key("DomainDnsIps")
		if err := awsAwsquery_serializeDocumentStringList(v.DomainDnsIps, objectKey); err != nil {
			return err
		}
	}

	if v.DomainFqdn != nil {
		objectKey := object.Key("DomainFqdn")
		objectKey.String(*v.DomainFqdn)
	}

	if v.DomainIAMRoleName != nil {
		objectKey := object.Key("DomainIAMRoleName")
		objectKey.String(*v.DomainIAMRoleName)
	}

	if v.DomainOu != nil {
		objectKey := object.Key("DomainOu")
		objectKey.String(*v.DomainOu)
	}

	if v.EnableCloudwatchLogsExports != nil {
		objectKey := object.Key("EnableCloudwatchLogsExports")
		if err := awsAwsquery_serializeDocumentLogTypeList(v.EnableCloudwatchLogsExports, objectKey); err != nil {
			return err
		}
	}

	if v.EnableCustomerOwnedIp != nil {
		objectKey := object.Key("EnableCustomerOwnedIp")
		objectKey.Boolean(*v.EnableCustomerOwnedIp)
	}

	if v.EnableIAMDatabaseAuthentication != nil {
		objectKey := object.Key("EnableIAMDatabaseAuthentication")
		objectKey.Boolean(*v.EnableIAMDatabaseAuthentication)
	}

	if v.Engine != nil {
		objectKey := object.Key("Engine")
		objectKey.String(*v.Engine)
	}

	if v.EngineLifecycleSupport != nil {
		objectKey := object.Key("EngineLifecycleSupport")
		objectKey.String(*v.EngineLifecycleSupport)
	}

	if v.Iops != nil {
		objectKey := object.Key("Iops")
		objectKey.Integer(*v.Iops)
	}

	if v.LicenseModel != nil {
		objectKey := object.Key("LicenseModel")
		objectKey.String(*v.LicenseModel)
	}

	if v.ManageMasterUserPassword != nil {
		objectKey := object.Key("ManageMasterUserPassword")
		objectKey.Boolean(*v.ManageMasterUserPassword)
	}

	if v.MasterUserSecretKmsKeyId != nil {
		objectKey := object.Key("MasterUserSecretKmsKeyId")
		objectKey.String(*v.MasterUserSecretKmsKeyId)
	}

	if v.MultiAZ != nil {
		objectKey := object.Key("MultiAZ")
		objectKey.Boolean(*v.MultiAZ)
	}

	if v.NetworkType != nil {
		objectKey := object.Key("NetworkType")
		objectKey.String(*v.NetworkType)
	}

	if v.OptionGroupName != nil {
		objectKey := object.Key("OptionGroupName")
		objectKey.String(*v.OptionGroupName)
	}

	if v.Port != nil {
		objectKey := object.Key("Port")
		objectKey.Integer(*v.Port)
	}

	if v.PreferredBackupWindow != nil {
		objectKey := object.Key("PreferredBackupWindow")
		objectKey.String(*v.PreferredBackupWindow)
	}

	if v.ProcessorFeatures != nil {
		objectKey := object.Key("ProcessorFeatures")
		if err := awsAwsquery_serializeDocumentProcessorFeatureList(v.ProcessorFeatures, objectKey); err != nil {
			return err
		}
	}

	if v.PubliclyAccessible != nil {
		objectKey := object.Key("PubliclyAccessible")
		objectKey.Boolean(*v.PubliclyAccessible)
	}

	if v.StorageThroughput != nil {
		objectKey := object.Key("StorageThroughput")
		objectKey.Integer(*v.StorageThroughput)
	}

	if v.StorageType != nil {
		objectKey := object.Key("StorageType")
		objectKey.String(*v.StorageType)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	if v.TagSpecifications != nil {
		objectKey := object.Key("TagSpecifications")
		if err := awsAwsquery_serializeDocumentTagSpecificationList(v.TagSpecifications, objectKey); err != nil {
			return err
		}
	}

	if v.TdeCredentialArn != nil {
		objectKey := object.Key("TdeCredentialArn")
		objectKey.String(*v.TdeCredentialArn)
	}

	if v.TdeCredentialPassword != nil {
		objectKey := object.Key("TdeCredentialPassword")
		objectKey.String(*v.TdeCredentialPassword)
	}

	if v.UseDefaultProcessorFeatures != nil {
		objectKey := object.Key("UseDefaultProcessorFeatures")
		objectKey.Boolean(*v.UseDefaultProcessorFeatures)
	}

	if v.VpcSecurityGroupIds != nil {
		objectKey := object.Key("VpcSecurityGroupIds")
		if err := awsAwsquery_serializeDocumentVpcSecurityGroupIdList(v.VpcSecurityGroupIds, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentRestoreDBInstanceFromS3Input(v *RestoreDBInstanceFromS3Input, value query.Value) error {
	object := value.Object()
	_ = object

	if v.AdditionalStorageVolumes != nil {
		objectKey := object.Key("AdditionalStorageVolumes")
		if err := awsAwsquery_serializeDocumentAdditionalStorageVolumesList(v.AdditionalStorageVolumes, objectKey); err != nil {
			return err
		}
	}

	if v.AllocatedStorage != nil {
		objectKey := object.Key("AllocatedStorage")
		objectKey.Integer(*v.AllocatedStorage)
	}

	if v.AutoMinorVersionUpgrade != nil {
		objectKey := object.Key("AutoMinorVersionUpgrade")
		objectKey.Boolean(*v.AutoMinorVersionUpgrade)
	}

	if v.AvailabilityZone != nil {
		objectKey := object.Key("AvailabilityZone")
		objectKey.String(*v.AvailabilityZone)
	}

	if v.BackupRetentionPeriod != nil {
		objectKey := object.Key("BackupRetentionPeriod")
		objectKey.Integer(*v.BackupRetentionPeriod)
	}

	if v.CACertificateIdentifier != nil {
		objectKey := object.Key("CACertificateIdentifier")
		objectKey.String(*v.CACertificateIdentifier)
	}

	if v.CopyTagsToSnapshot != nil {
		objectKey := object.Key("CopyTagsToSnapshot")
		objectKey.Boolean(*v.CopyTagsToSnapshot)
	}

	if len(v.DatabaseInsightsMode) > 0 {
		objectKey := object.Key("DatabaseInsightsMode")
		objectKey.String(string(v.DatabaseInsightsMode))
	}

	if v.DBInstanceClass != nil {
		objectKey := object.Key("DBInstanceClass")
		objectKey.String(*v.DBInstanceClass)
	}

	if v.DBInstanceIdentifier != nil {
		objectKey := object.Key("DBInstanceIdentifier")
		objectKey.String(*v.DBInstanceIdentifier)
	}

	if v.DBName != nil {
		objectKey := object.Key("DBName")
		objectKey.String(*v.DBName)
	}

	if v.DBParameterGroupName != nil {
		objectKey := object.Key("DBParameterGroupName")
		objectKey.String(*v.DBParameterGroupName)
	}

	if v.DBSecurityGroups != nil {
		objectKey := object.Key("DBSecurityGroups")
		if err := awsAwsquery_serializeDocumentDBSecurityGroupNameList(v.DBSecurityGroups, objectKey); err != nil {
			return err
		}
	}

	if v.DBSubnetGroupName != nil {
		objectKey := object.Key("DBSubnetGroupName")
		objectKey.String(*v.DBSubnetGroupName)
	}

	if v.DedicatedLogVolume != nil {
		objectKey := object.Key("DedicatedLogVolume")
		objectKey.Boolean(*v.DedicatedLogVolume)
	}

	if v.DeletionProtection != nil {
		objectKey := object.Key("DeletionProtection")
		objectKey.Boolean(*v.DeletionProtection)
	}

	if v.EnableCloudwatchLogsExports != nil {
		objectKey := object.Key("EnableCloudwatchLogsExports")
		if err := awsAwsquery_serializeDocumentLogTypeList(v.EnableCloudwatchLogsExports, objectKey); err != nil {
			return err
		}
	}

	if v.EnableIAMDatabaseAuthentication != nil {
		objectKey := object.Key("EnableIAMDatabaseAuthentication")
		objectKey.Boolean(*v.EnableIAMDatabaseAuthentication)
	}

	if v.EnablePerformanceInsights != nil {
		objectKey := object.Key("EnablePerformanceInsights")
		objectKey.Boolean(*v.EnablePerformanceInsights)
	}

	if v.Engine != nil {
		objectKey := object.Key("Engine")
		objectKey.String(*v.Engine)
	}

	if v.EngineLifecycleSupport != nil {
		objectKey := object.Key("EngineLifecycleSupport")
		objectKey.String(*v.EngineLifecycleSupport)
	}

	if v.EngineVersion != nil {
		objectKey := object.Key("EngineVersion")
		objectKey.String(*v.EngineVersion)
	}

	if v.Iops != nil {
		objectKey := object.Key("Iops")
		objectKey.Integer(*v.Iops)
	}

	if v.KmsKeyId != nil {
		objectKey := object.Key("KmsKeyId")
		objectKey.String(*v.KmsKeyId)
	}

	if v.LicenseModel != nil {
		objectKey := object.Key("LicenseModel")
		objectKey.String(*v.LicenseModel)
	}

	if v.ManageMasterUserPassword != nil {
		objectKey := object.Key("ManageMasterUserPassword")
		objectKey.Boolean(*v.ManageMasterUserPassword)
	}

	if v.MasterUsername != nil {
		objectKey := object.Key("MasterUsername")
		objectKey.String(*v.MasterUsername)
	}

	if v.MasterUserPassword != nil {
		objectKey := object.Key("MasterUserPassword")
		objectKey.String(*v.MasterUserPassword)
	}

	if v.MasterUserSecretKmsKeyId != nil {
		objectKey := object.Key("MasterUserSecretKmsKeyId")
		objectKey.String(*v.MasterUserSecretKmsKeyId)
	}

	if v.MaxAllocatedStorage != nil {
		objectKey := object.Key("MaxAllocatedStorage")
		objectKey.Integer(*v.MaxAllocatedStorage)
	}

	if v.MonitoringInterval != nil {
		objectKey := object.Key("MonitoringInterval")
		objectKey.Integer(*v.MonitoringInterval)
	}

	if v.MonitoringRoleArn != nil {
		objectKey := object.Key("MonitoringRoleArn")
		objectKey.String(*v.MonitoringRoleArn)
	}

	if v.MultiAZ != nil {
		objectKey := object.Key("MultiAZ")
		objectKey.Boolean(*v.MultiAZ)
	}

	if v.NetworkType != nil {
		objectKey := object.Key("NetworkType")
		objectKey.String(*v.NetworkType)
	}

	if v.OptionGroupName != nil {
		objectKey := object.Key("OptionGroupName")
		objectKey.String(*v.OptionGroupName)
	}

	if v.PerformanceInsightsKMSKeyId != nil {
		objectKey := object.Key("PerformanceInsightsKMSKeyId")
		objectKey.String(*v.PerformanceInsightsKMSKeyId)
	}

	if v.PerformanceInsightsRetentionPeriod != nil {
		objectKey := object.Key("PerformanceInsightsRetentionPeriod")
		objectKey.Integer(*v.PerformanceInsightsRetentionPeriod)
	}

	if v.Port != nil {
		objectKey := object.Key("Port")
		objectKey.Integer(*v.Port)
	}

	if v.PreferredBackupWindow != nil {
		objectKey := object.Key("PreferredBackupWindow")
		objectKey.String(*v.PreferredBackupWindow)
	}

	if v.PreferredMaintenanceWindow != nil {
		objectKey := object.Key("PreferredMaintenanceWindow")
		objectKey.String(*v.PreferredMaintenanceWindow)
	}

	if v.ProcessorFeatures != nil {
		objectKey := object.Key("ProcessorFeatures")
		if err := awsAwsquery_serializeDocumentProcessorFeatureList(v.ProcessorFeatures, objectKey); err != nil {
			return err
		}
	}

	if v.PubliclyAccessible != nil {
		objectKey := object.Key("PubliclyAccessible")
		objectKey.Boolean(*v.PubliclyAccessible)
	}

	if v.S3BucketName != nil {
		objectKey := object.Key("S3BucketName")
		objectKey.String(*v.S3BucketName)
	}

	if v.S3IngestionRoleArn != nil {
		objectKey := object.Key("S3IngestionRoleArn")
		objectKey.String(*v.S3IngestionRoleArn)
	}

	if v.S3Prefix != nil {
		objectKey := object.Key("S3Prefix")
		objectKey.String(*v.S3Prefix)
	}

	if v.SourceEngine != nil {
		objectKey := object.Key("SourceEngine")
		objectKey.String(*v.SourceEngine)
	}

	if v.SourceEngineVersion != nil {
		objectKey := object.Key("SourceEngineVersion")
		objectKey.String(*v.SourceEngineVersion)
	}

	if v.StorageEncrypted != nil {
		objectKey := object.Key("StorageEncrypted")
		objectKey.Boolean(*v.StorageEncrypted)
	}

	if v.StorageThroughput != nil {
		objectKey := object.Key("StorageThroughput")
		objectKey.Integer(*v.StorageThroughput)
	}

	if v.StorageType != nil {
		objectKey := object.Key("StorageType")
		objectKey.String(*v.StorageType)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	if v.TagSpecifications != nil {
		objectKey := object.Key("TagSpecifications")
		if err := awsAwsquery_serializeDocumentTagSpecificationList(v.TagSpecifications, objectKey); err != nil {
			return err
		}
	}

	if v.UseDefaultProcessorFeatures != nil {
		objectKey := object.Key("UseDefaultProcessorFeatures")
		objectKey.Boolean(*v.UseDefaultProcessorFeatures)
	}

	if v.VpcSecurityGroupIds != nil {
		objectKey := object.Key("VpcSecurityGroupIds")
		if err := awsAwsquery_serializeDocumentVpcSecurityGroupIdList(v.VpcSecurityGroupIds, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentRestoreDBInstanceToPointInTimeInput(v *RestoreDBInstanceToPointInTimeInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.AdditionalStorageVolumes != nil {
		objectKey := object.Key("AdditionalStorageVolumes")
		if err := awsAwsquery_serializeDocumentAdditionalStorageVolumesList(v.AdditionalStorageVolumes, objectKey); err != nil {
			return err
		}
	}

	if v.AllocatedStorage != nil {
		objectKey := object.Key("AllocatedStorage")
		objectKey.Integer(*v.AllocatedStorage)
	}

	if v.AutoMinorVersionUpgrade != nil {
		objectKey := object.Key("AutoMinorVersionUpgrade")
		objectKey.Boolean(*v.AutoMinorVersionUpgrade)
	}

	if v.AvailabilityZone != nil {
		objectKey := object.Key("AvailabilityZone")
		objectKey.String(*v.AvailabilityZone)
	}

	if v.BackupRetentionPeriod != nil {
		objectKey := object.Key("BackupRetentionPeriod")
		objectKey.Integer(*v.BackupRetentionPeriod)
	}

	if v.BackupTarget != nil {
		objectKey := object.Key("BackupTarget")
		objectKey.String(*v.BackupTarget)
	}

	if v.CACertificateIdentifier != nil {
		objectKey := object.Key("CACertificateIdentifier")
		objectKey.String(*v.CACertificateIdentifier)
	}

	if v.CopyTagsToSnapshot != nil {
		objectKey := object.Key("CopyTagsToSnapshot")
		objectKey.Boolean(*v.CopyTagsToSnapshot)
	}

	if v.CustomIamInstanceProfile != nil {
		objectKey := object.Key("CustomIamInstanceProfile")
		objectKey.String(*v.CustomIamInstanceProfile)
	}

	if v.DBInstanceClass != nil {
		objectKey := object.Key("DBInstanceClass")
		objectKey.String(*v.DBInstanceClass)
	}

	if v.DBName != nil {
		objectKey := object.Key("DBName")
		objectKey.String(*v.DBName)
	}

	if v.DBParameterGroupName != nil {
		objectKey := object.Key("DBParameterGroupName")
		objectKey.String(*v.DBParameterGroupName)
	}

	if v.DBSubnetGroupName != nil {
		objectKey := object.Key("DBSubnetGroupName")
		objectKey.String(*v.DBSubnetGroupName)
	}

	if v.DedicatedLogVolume != nil {
		objectKey := object.Key("DedicatedLogVolume")
		objectKey.Boolean(*v.DedicatedLogVolume)
	}

	if v.DeletionProtection != nil {
		objectKey := object.Key("DeletionProtection")
		objectKey.Boolean(*v.DeletionProtection)
	}

	if v.Domain != nil {
		objectKey := object.Key("Domain")
		objectKey.String(*v.Domain)
	}

	if v.DomainAuthSecretArn != nil {
		objectKey := object.Key("DomainAuthSecretArn")
		objectKey.String(*v.DomainAuthSecretArn)
	}

	if v.DomainDnsIps != nil {
		objectKey := object.Key("DomainDnsIps")
		if err := awsAwsquery_serializeDocumentStringList(v.DomainDnsIps, objectKey); err != nil {
			return err
		}
	}

	if v.DomainFqdn != nil {
		objectKey := object.Key("DomainFqdn")
		objectKey.String(*v.DomainFqdn)
	}

	if v.DomainIAMRoleName != nil {
		objectKey := object.Key("DomainIAMRoleName")
		objectKey.String(*v.DomainIAMRoleName)
	}

	if v.DomainOu != nil {
		objectKey := object.Key("DomainOu")
		objectKey.String(*v.DomainOu)
	}

	if v.EnableCloudwatchLogsExports != nil {
		objectKey := object.Key("EnableCloudwatchLogsExports")
		if err := awsAwsquery_serializeDocumentLogTypeList(v.EnableCloudwatchLogsExports, objectKey); err != nil {
			return err
		}
	}

	if v.EnableCustomerOwnedIp != nil {
		objectKey := object.Key("EnableCustomerOwnedIp")
		objectKey.Boolean(*v.EnableCustomerOwnedIp)
	}

	if v.EnableIAMDatabaseAuthentication != nil {
		objectKey := object.Key("EnableIAMDatabaseAuthentication")
		objectKey.Boolean(*v.EnableIAMDatabaseAuthentication)
	}

	if v.Engine != nil {
		objectKey := object.Key("Engine")
		objectKey.String(*v.Engine)
	}

	if v.EngineLifecycleSupport != nil {
		objectKey := object.Key("EngineLifecycleSupport")
		objectKey.String(*v.EngineLifecycleSupport)
	}

	if v.Iops != nil {
		objectKey := object.Key("Iops")
		objectKey.Integer(*v.Iops)
	}

	if v.LicenseModel != nil {
		objectKey := object.Key("LicenseModel")
		objectKey.String(*v.LicenseModel)
	}

	if v.ManageMasterUserPassword != nil {
		objectKey := object.Key("ManageMasterUserPassword")
		objectKey.Boolean(*v.ManageMasterUserPassword)
	}

	if v.MasterUserSecretKmsKeyId != nil {
		objectKey := object.Key("MasterUserSecretKmsKeyId")
		objectKey.String(*v.MasterUserSecretKmsKeyId)
	}

	if v.MaxAllocatedStorage != nil {
		objectKey := object.Key("MaxAllocatedStorage")
		objectKey.Integer(*v.MaxAllocatedStorage)
	}

	if v.MultiAZ != nil {
		objectKey := object.Key("MultiAZ")
		objectKey.Boolean(*v.MultiAZ)
	}

	if v.NetworkType != nil {
		objectKey := object.Key("NetworkType")
		objectKey.String(*v.NetworkType)
	}

	if v.OptionGroupName != nil {
		objectKey := object.Key("OptionGroupName")
		objectKey.String(*v.OptionGroupName)
	}

	if v.Port != nil {
		objectKey := object.Key("Port")
		objectKey.Integer(*v.Port)
	}

	if v.PreferredBackupWindow != nil {
		objectKey := object.Key("PreferredBackupWindow")
		objectKey.String(*v.PreferredBackupWindow)
	}

	if v.ProcessorFeatures != nil {
		objectKey := object.Key("ProcessorFeatures")
		if err := awsAwsquery_serializeDocumentProcessorFeatureList(v.ProcessorFeatures, objectKey); err != nil {
			return err
		}
	}

	if v.PubliclyAccessible != nil {
		objectKey := object.Key("PubliclyAccessible")
		objectKey.Boolean(*v.PubliclyAccessible)
	}

	if v.RestoreTime != nil {
		objectKey := object.Key("RestoreTime")
		objectKey.String(smithytime.FormatDateTime(*v.RestoreTime))
	}

	if v.SourceDBInstanceAutomatedBackupsArn != nil {
		objectKey := object.Key("SourceDBInstanceAutomatedBackupsArn")
		objectKey.String(*v.SourceDBInstanceAutomatedBackupsArn)
	}

	if v.SourceDBInstanceIdentifier != nil {
		objectKey := object.Key("SourceDBInstanceIdentifier")
		objectKey.String(*v.SourceDBInstanceIdentifier)
	}

	if v.SourceDbiResourceId != nil {
		objectKey := object.Key("SourceDbiResourceId")
		objectKey.String(*v.SourceDbiResourceId)
	}

	if v.StorageThroughput != nil {
		objectKey := object.Key("StorageThroughput")
		objectKey.Integer(*v.StorageThroughput)
	}

	if v.StorageType != nil {
		objectKey := object.Key("StorageType")
		objectKey.String(*v.StorageType)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	if v.TagSpecifications != nil {
		objectKey := object.Key("TagSpecifications")
		if err := awsAwsquery_serializeDocumentTagSpecificationList(v.TagSpecifications, objectKey); err != nil {
			return err
		}
	}

	if v.TargetDBInstanceIdentifier != nil {
		objectKey := object.Key("TargetDBInstanceIdentifier")
		objectKey.String(*v.TargetDBInstanceIdentifier)
	}

	if v.TdeCredentialArn != nil {
		objectKey := object.Key("TdeCredentialArn")
		objectKey.String(*v.TdeCredentialArn)
	}

	if v.TdeCredentialPassword != nil {
		objectKey := object.Key("TdeCredentialPassword")
		objectKey.String(*v.TdeCredentialPassword)
	}

	if v.UseDefaultProcessorFeatures != nil {
		objectKey := object.Key("UseDefaultProcessorFeatures")
		objectKey.Boolean(*v.UseDefaultProcessorFeatures)
	}

	if v.UseLatestRestorableTime != nil {
		objectKey := object.Key("UseLatestRestorableTime")
		objectKey.Boolean(*v.UseLatestRestorableTime)
	}

	if v.VpcSecurityGroupIds != nil {
		objectKey := object.Key("VpcSecurityGroupIds")
		if err := awsAwsquery_serializeDocumentVpcSecurityGroupIdList(v.VpcSecurityGroupIds, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentRevokeDBSecurityGroupIngressInput(v *RevokeDBSecurityGroupIngressInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.CIDRIP != nil {
		objectKey := object.Key("CIDRIP")
		objectKey.String(*v.CIDRIP)
	}

	if v.DBSecurityGroupName != nil {
		objectKey := object.Key("DBSecurityGroupName")
		objectKey.String(*v.DBSecurityGroupName)
	}

	if v.EC2SecurityGroupId != nil {
		objectKey := object.Key("EC2SecurityGroupId")
		objectKey.String(*v.EC2SecurityGroupId)
	}

	if v.EC2SecurityGroupName != nil {
		objectKey := object.Key("EC2SecurityGroupName")
		objectKey.String(*v.EC2SecurityGroupName)
	}

	if v.EC2SecurityGroupOwnerId != nil {
		objectKey := object.Key("EC2SecurityGroupOwnerId")
		objectKey.String(*v.EC2SecurityGroupOwnerId)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentStartActivityStreamInput(v *StartActivityStreamInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.ApplyImmediately != nil {
		objectKey := object.Key("ApplyImmediately")
		objectKey.Boolean(*v.ApplyImmediately)
	}

	if v.EngineNativeAuditFieldsIncluded != nil {
		objectKey := object.Key("EngineNativeAuditFieldsIncluded")
		objectKey.Boolean(*v.EngineNativeAuditFieldsIncluded)
	}

	if v.KmsKeyId != nil {
		objectKey := object.Key("KmsKeyId")
		objectKey.String(*v.KmsKeyId)
	}

	if len(v.Mode) > 0 {
		objectKey := object.Key("Mode")
		objectKey.String(string(v.Mode))
	}

	if v.ResourceArn != nil {
		objectKey := object.Key("ResourceArn")
		objectKey.String(*v.ResourceArn)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentStartDBClusterInput(v *StartDBClusterInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBClusterIdentifier != nil {
		objectKey := object.Key("DBClusterIdentifier")
		objectKey.String(*v.DBClusterIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentStartDBInstanceAutomatedBackupsReplicationInput(v *StartDBInstanceAutomatedBackupsReplicationInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.BackupRetentionPeriod != nil {
		objectKey := object.Key("BackupRetentionPeriod")
		objectKey.Integer(*v.BackupRetentionPeriod)
	}

	if v.KmsKeyId != nil {
		objectKey := object.Key("KmsKeyId")
		objectKey.String(*v.KmsKeyId)
	}

	if v.PreSignedUrl != nil {
		objectKey := object.Key("PreSignedUrl")
		objectKey.String(*v.PreSignedUrl)
	}

	if v.SourceDBInstanceArn != nil {
		objectKey := object.Key("SourceDBInstanceArn")
		objectKey.String(*v.SourceDBInstanceArn)
	}

	if v.Tags != nil {
		objectKey := object.Key("Tags")
		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentStartDBInstanceInput(v *StartDBInstanceInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBInstanceIdentifier != nil {
		objectKey := object.Key("DBInstanceIdentifier")
		objectKey.String(*v.DBInstanceIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentStartExportTaskInput(v *StartExportTaskInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.ExportOnly != nil {
		objectKey := object.Key("ExportOnly")
		if err := awsAwsquery_serializeDocumentStringList(v.ExportOnly, objectKey); err != nil {
			return err
		}
	}

	if v.ExportTaskIdentifier != nil {
		objectKey := object.Key("ExportTaskIdentifier")
		objectKey.String(*v.ExportTaskIdentifier)
	}

	if v.IamRoleArn != nil {
		objectKey := object.Key("IamRoleArn")
		objectKey.String(*v.IamRoleArn)
	}

	if v.KmsKeyId != nil {
		objectKey := object.Key("KmsKeyId")
		objectKey.String(*v.KmsKeyId)
	}

	if v.S3BucketName != nil {
		objectKey := object.Key("S3BucketName")
		objectKey.String(*v.S3BucketName)
	}

	if v.S3Prefix != nil {
		objectKey := object.Key("S3Prefix")
		objectKey.String(*v.S3Prefix)
	}

	if v.SourceArn != nil {
		objectKey := object.Key("SourceArn")
		objectKey.String(*v.SourceArn)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentStopActivityStreamInput(v *StopActivityStreamInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.ApplyImmediately != nil {
		objectKey := object.Key("ApplyImmediately")
		objectKey.Boolean(*v.ApplyImmediately)
	}

	if v.ResourceArn != nil {
		objectKey := object.Key("ResourceArn")
		objectKey.String(*v.ResourceArn)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentStopDBClusterInput(v *StopDBClusterInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBClusterIdentifier != nil {
		objectKey := object.Key("DBClusterIdentifier")
		objectKey.String(*v.DBClusterIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentStopDBInstanceAutomatedBackupsReplicationInput(v *StopDBInstanceAutomatedBackupsReplicationInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.SourceDBInstanceArn != nil {
		objectKey := object.Key("SourceDBInstanceArn")
		objectKey.String(*v.SourceDBInstanceArn)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentStopDBInstanceInput(v *StopDBInstanceInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBInstanceIdentifier != nil {
		objectKey := object.Key("DBInstanceIdentifier")
		objectKey.String(*v.DBInstanceIdentifier)
	}

	if v.DBSnapshotIdentifier != nil {
		objectKey := object.Key("DBSnapshotIdentifier")
		objectKey.String(*v.DBSnapshotIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentSwitchoverBlueGreenDeploymentInput(v *SwitchoverBlueGreenDeploymentInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.BlueGreenDeploymentIdentifier != nil {
		objectKey := object.Key("BlueGreenDeploymentIdentifier")
		objectKey.String(*v.BlueGreenDeploymentIdentifier)
	}

	if v.SwitchoverTimeout != nil {
		objectKey := object.Key("SwitchoverTimeout")
		objectKey.Integer(*v.SwitchoverTimeout)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentSwitchoverGlobalClusterInput(v *SwitchoverGlobalClusterInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.GlobalClusterIdentifier != nil {
		objectKey := object.Key("GlobalClusterIdentifier")
		objectKey.String(*v.GlobalClusterIdentifier)
	}

	if v.TargetDbClusterIdentifier != nil {
		objectKey := object.Key("TargetDbClusterIdentifier")
		objectKey.String(*v.TargetDbClusterIdentifier)
	}

	return nil
}

func awsAwsquery_serializeOpDocumentSwitchoverReadReplicaInput(v *SwitchoverReadReplicaInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.DBInstanceIdentifier != nil {
		objectKey := object.Key("DBInstanceIdentifier")
		objectKey.String(*v.DBInstanceIdentifier)
	}

	return nil
}