serializers.go

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

package databasemigrationservice

import (
	"bytes"
	"context"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/databasemigrationservice/types"
	smithy "github.com/aws/smithy-go"
	"github.com/aws/smithy-go/encoding/httpbinding"
	smithyjson "github.com/aws/smithy-go/encoding/json"
	"github.com/aws/smithy-go/middleware"
	smithytime "github.com/aws/smithy-go/time"
	smithyhttp "github.com/aws/smithy-go/transport/http"
)

type awsAwsjson11_serializeOpAddTagsToResource struct {
}

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

func (m *awsAwsjson11_serializeOpAddTagsToResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*AddTagsToResourceInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.AddTagsToResource")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentAddTagsToResourceInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpApplyPendingMaintenanceAction struct {
}

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

func (m *awsAwsjson11_serializeOpApplyPendingMaintenanceAction) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*ApplyPendingMaintenanceActionInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.ApplyPendingMaintenanceAction")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentApplyPendingMaintenanceActionInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpCancelReplicationTaskAssessmentRun struct {
}

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

func (m *awsAwsjson11_serializeOpCancelReplicationTaskAssessmentRun) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*CancelReplicationTaskAssessmentRunInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.CancelReplicationTaskAssessmentRun")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentCancelReplicationTaskAssessmentRunInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpCreateEndpoint struct {
}

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

func (m *awsAwsjson11_serializeOpCreateEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*CreateEndpointInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.CreateEndpoint")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentCreateEndpointInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpCreateEventSubscription struct {
}

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

func (m *awsAwsjson11_serializeOpCreateEventSubscription) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*CreateEventSubscriptionInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.CreateEventSubscription")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentCreateEventSubscriptionInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpCreateReplicationInstance struct {
}

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

func (m *awsAwsjson11_serializeOpCreateReplicationInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*CreateReplicationInstanceInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.CreateReplicationInstance")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentCreateReplicationInstanceInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpCreateReplicationSubnetGroup struct {
}

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

func (m *awsAwsjson11_serializeOpCreateReplicationSubnetGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*CreateReplicationSubnetGroupInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.CreateReplicationSubnetGroup")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentCreateReplicationSubnetGroupInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpCreateReplicationTask struct {
}

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

func (m *awsAwsjson11_serializeOpCreateReplicationTask) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*CreateReplicationTaskInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.CreateReplicationTask")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentCreateReplicationTaskInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDeleteCertificate struct {
}

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

func (m *awsAwsjson11_serializeOpDeleteCertificate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DeleteCertificateInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DeleteCertificate")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDeleteCertificateInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDeleteConnection struct {
}

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

func (m *awsAwsjson11_serializeOpDeleteConnection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DeleteConnectionInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DeleteConnection")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDeleteConnectionInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDeleteEndpoint struct {
}

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

func (m *awsAwsjson11_serializeOpDeleteEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DeleteEndpointInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DeleteEndpoint")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDeleteEndpointInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDeleteEventSubscription struct {
}

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

func (m *awsAwsjson11_serializeOpDeleteEventSubscription) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DeleteEventSubscriptionInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DeleteEventSubscription")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDeleteEventSubscriptionInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDeleteReplicationInstance struct {
}

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

func (m *awsAwsjson11_serializeOpDeleteReplicationInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DeleteReplicationInstanceInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DeleteReplicationInstance")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDeleteReplicationInstanceInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDeleteReplicationSubnetGroup struct {
}

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

func (m *awsAwsjson11_serializeOpDeleteReplicationSubnetGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DeleteReplicationSubnetGroupInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DeleteReplicationSubnetGroup")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDeleteReplicationSubnetGroupInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDeleteReplicationTask struct {
}

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

func (m *awsAwsjson11_serializeOpDeleteReplicationTask) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DeleteReplicationTaskInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DeleteReplicationTask")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDeleteReplicationTaskInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDeleteReplicationTaskAssessmentRun struct {
}

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

func (m *awsAwsjson11_serializeOpDeleteReplicationTaskAssessmentRun) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DeleteReplicationTaskAssessmentRunInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DeleteReplicationTaskAssessmentRun")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDeleteReplicationTaskAssessmentRunInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDescribeAccountAttributes struct {
}

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

func (m *awsAwsjson11_serializeOpDescribeAccountAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DescribeAccountAttributesInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DescribeAccountAttributes")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDescribeAccountAttributesInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDescribeApplicableIndividualAssessments struct {
}

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

func (m *awsAwsjson11_serializeOpDescribeApplicableIndividualAssessments) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DescribeApplicableIndividualAssessmentsInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DescribeApplicableIndividualAssessments")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDescribeApplicableIndividualAssessmentsInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDescribeCertificates struct {
}

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

func (m *awsAwsjson11_serializeOpDescribeCertificates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DescribeCertificatesInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DescribeCertificates")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDescribeCertificatesInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDescribeConnections struct {
}

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

func (m *awsAwsjson11_serializeOpDescribeConnections) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DescribeConnectionsInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DescribeConnections")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDescribeConnectionsInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDescribeEndpoints struct {
}

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

func (m *awsAwsjson11_serializeOpDescribeEndpoints) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DescribeEndpointsInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DescribeEndpoints")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDescribeEndpointsInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDescribeEndpointSettings struct {
}

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

func (m *awsAwsjson11_serializeOpDescribeEndpointSettings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DescribeEndpointSettingsInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DescribeEndpointSettings")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDescribeEndpointSettingsInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDescribeEndpointTypes struct {
}

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

func (m *awsAwsjson11_serializeOpDescribeEndpointTypes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DescribeEndpointTypesInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DescribeEndpointTypes")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDescribeEndpointTypesInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDescribeEventCategories struct {
}

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

func (m *awsAwsjson11_serializeOpDescribeEventCategories) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DescribeEventCategoriesInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DescribeEventCategories")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDescribeEventCategoriesInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDescribeEvents struct {
}

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

func (m *awsAwsjson11_serializeOpDescribeEvents) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DescribeEventsInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DescribeEvents")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDescribeEventsInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDescribeEventSubscriptions struct {
}

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

func (m *awsAwsjson11_serializeOpDescribeEventSubscriptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DescribeEventSubscriptionsInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DescribeEventSubscriptions")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDescribeEventSubscriptionsInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDescribeOrderableReplicationInstances struct {
}

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

func (m *awsAwsjson11_serializeOpDescribeOrderableReplicationInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DescribeOrderableReplicationInstancesInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DescribeOrderableReplicationInstances")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDescribeOrderableReplicationInstancesInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDescribePendingMaintenanceActions struct {
}

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

func (m *awsAwsjson11_serializeOpDescribePendingMaintenanceActions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DescribePendingMaintenanceActionsInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DescribePendingMaintenanceActions")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDescribePendingMaintenanceActionsInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDescribeRefreshSchemasStatus struct {
}

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

func (m *awsAwsjson11_serializeOpDescribeRefreshSchemasStatus) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DescribeRefreshSchemasStatusInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DescribeRefreshSchemasStatus")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDescribeRefreshSchemasStatusInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDescribeReplicationInstances struct {
}

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

func (m *awsAwsjson11_serializeOpDescribeReplicationInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DescribeReplicationInstancesInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DescribeReplicationInstances")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDescribeReplicationInstancesInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDescribeReplicationInstanceTaskLogs struct {
}

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

func (m *awsAwsjson11_serializeOpDescribeReplicationInstanceTaskLogs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DescribeReplicationInstanceTaskLogsInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDescribeReplicationInstanceTaskLogsInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDescribeReplicationSubnetGroups struct {
}

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

func (m *awsAwsjson11_serializeOpDescribeReplicationSubnetGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DescribeReplicationSubnetGroupsInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DescribeReplicationSubnetGroups")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDescribeReplicationSubnetGroupsInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDescribeReplicationTaskAssessmentResults struct {
}

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

func (m *awsAwsjson11_serializeOpDescribeReplicationTaskAssessmentResults) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DescribeReplicationTaskAssessmentResultsInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDescribeReplicationTaskAssessmentResultsInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDescribeReplicationTaskAssessmentRuns struct {
}

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

func (m *awsAwsjson11_serializeOpDescribeReplicationTaskAssessmentRuns) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DescribeReplicationTaskAssessmentRunsInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDescribeReplicationTaskAssessmentRunsInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDescribeReplicationTaskIndividualAssessments struct {
}

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

func (m *awsAwsjson11_serializeOpDescribeReplicationTaskIndividualAssessments) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DescribeReplicationTaskIndividualAssessmentsInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDescribeReplicationTaskIndividualAssessmentsInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDescribeReplicationTasks struct {
}

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

func (m *awsAwsjson11_serializeOpDescribeReplicationTasks) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DescribeReplicationTasksInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DescribeReplicationTasks")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDescribeReplicationTasksInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDescribeSchemas struct {
}

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

func (m *awsAwsjson11_serializeOpDescribeSchemas) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DescribeSchemasInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DescribeSchemas")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDescribeSchemasInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDescribeTableStatistics struct {
}

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

func (m *awsAwsjson11_serializeOpDescribeTableStatistics) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*DescribeTableStatisticsInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.DescribeTableStatistics")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentDescribeTableStatisticsInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpImportCertificate struct {
}

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

func (m *awsAwsjson11_serializeOpImportCertificate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*ImportCertificateInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.ImportCertificate")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentImportCertificateInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpListTagsForResource struct {
}

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

func (m *awsAwsjson11_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*ListTagsForResourceInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.ListTagsForResource")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentListTagsForResourceInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpModifyEndpoint struct {
}

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

func (m *awsAwsjson11_serializeOpModifyEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*ModifyEndpointInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.ModifyEndpoint")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentModifyEndpointInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpModifyEventSubscription struct {
}

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

func (m *awsAwsjson11_serializeOpModifyEventSubscription) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*ModifyEventSubscriptionInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.ModifyEventSubscription")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentModifyEventSubscriptionInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpModifyReplicationInstance struct {
}

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

func (m *awsAwsjson11_serializeOpModifyReplicationInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*ModifyReplicationInstanceInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.ModifyReplicationInstance")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentModifyReplicationInstanceInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpModifyReplicationSubnetGroup struct {
}

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

func (m *awsAwsjson11_serializeOpModifyReplicationSubnetGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*ModifyReplicationSubnetGroupInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.ModifyReplicationSubnetGroup")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentModifyReplicationSubnetGroupInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpModifyReplicationTask struct {
}

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

func (m *awsAwsjson11_serializeOpModifyReplicationTask) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*ModifyReplicationTaskInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.ModifyReplicationTask")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentModifyReplicationTaskInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpMoveReplicationTask struct {
}

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

func (m *awsAwsjson11_serializeOpMoveReplicationTask) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*MoveReplicationTaskInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.MoveReplicationTask")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentMoveReplicationTaskInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpRebootReplicationInstance struct {
}

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

func (m *awsAwsjson11_serializeOpRebootReplicationInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*RebootReplicationInstanceInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.RebootReplicationInstance")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentRebootReplicationInstanceInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpRefreshSchemas struct {
}

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

func (m *awsAwsjson11_serializeOpRefreshSchemas) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*RefreshSchemasInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.RefreshSchemas")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentRefreshSchemasInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpReloadTables struct {
}

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

func (m *awsAwsjson11_serializeOpReloadTables) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*ReloadTablesInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.ReloadTables")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentReloadTablesInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpRemoveTagsFromResource struct {
}

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

func (m *awsAwsjson11_serializeOpRemoveTagsFromResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*RemoveTagsFromResourceInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.RemoveTagsFromResource")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentRemoveTagsFromResourceInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpStartReplicationTask struct {
}

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

func (m *awsAwsjson11_serializeOpStartReplicationTask) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*StartReplicationTaskInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.StartReplicationTask")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentStartReplicationTaskInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpStartReplicationTaskAssessment struct {
}

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

func (m *awsAwsjson11_serializeOpStartReplicationTaskAssessment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*StartReplicationTaskAssessmentInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.StartReplicationTaskAssessment")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentStartReplicationTaskAssessmentInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpStartReplicationTaskAssessmentRun struct {
}

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

func (m *awsAwsjson11_serializeOpStartReplicationTaskAssessmentRun) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*StartReplicationTaskAssessmentRunInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.StartReplicationTaskAssessmentRun")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentStartReplicationTaskAssessmentRunInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpStopReplicationTask struct {
}

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

func (m *awsAwsjson11_serializeOpStopReplicationTask) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*StopReplicationTaskInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.StopReplicationTask")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentStopReplicationTaskInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpTestConnection struct {
}

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

func (m *awsAwsjson11_serializeOpTestConnection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
	request, ok := in.Request.(*smithyhttp.Request)
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
	}

	input, ok := in.Parameters.(*TestConnectionInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	request.Request.URL.Path = "/"
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonDMSv20160101.TestConnection")

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_serializeOpDocumentTestConnectionInput(input, jsonEncoder.Value); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}

	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	in.Request = request

	return next.HandleSerialize(ctx, in)
}
func awsAwsjson11_serializeDocumentArnList(v []string, value smithyjson.Value) error {
	array := value.Array()
	defer array.Close()

	for i := range v {
		av := array.Value()
		av.String(v[i])
	}
	return nil
}

func awsAwsjson11_serializeDocumentDmsTransferSettings(v *types.DmsTransferSettings, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.BucketName != nil {
		ok := object.Key("BucketName")
		ok.String(*v.BucketName)
	}

	if v.ServiceAccessRoleArn != nil {
		ok := object.Key("ServiceAccessRoleArn")
		ok.String(*v.ServiceAccessRoleArn)
	}

	return nil
}

func awsAwsjson11_serializeDocumentDocDbSettings(v *types.DocDbSettings, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.DatabaseName != nil {
		ok := object.Key("DatabaseName")
		ok.String(*v.DatabaseName)
	}

	if v.DocsToInvestigate != nil {
		ok := object.Key("DocsToInvestigate")
		ok.Integer(*v.DocsToInvestigate)
	}

	if v.ExtractDocId != nil {
		ok := object.Key("ExtractDocId")
		ok.Boolean(*v.ExtractDocId)
	}

	if v.KmsKeyId != nil {
		ok := object.Key("KmsKeyId")
		ok.String(*v.KmsKeyId)
	}

	if len(v.NestingLevel) > 0 {
		ok := object.Key("NestingLevel")
		ok.String(string(v.NestingLevel))
	}

	if v.Password != nil {
		ok := object.Key("Password")
		ok.String(*v.Password)
	}

	if v.Port != nil {
		ok := object.Key("Port")
		ok.Integer(*v.Port)
	}

	if v.SecretsManagerAccessRoleArn != nil {
		ok := object.Key("SecretsManagerAccessRoleArn")
		ok.String(*v.SecretsManagerAccessRoleArn)
	}

	if v.SecretsManagerSecretId != nil {
		ok := object.Key("SecretsManagerSecretId")
		ok.String(*v.SecretsManagerSecretId)
	}

	if v.ServerName != nil {
		ok := object.Key("ServerName")
		ok.String(*v.ServerName)
	}

	if v.Username != nil {
		ok := object.Key("Username")
		ok.String(*v.Username)
	}

	return nil
}

func awsAwsjson11_serializeDocumentDynamoDbSettings(v *types.DynamoDbSettings, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.ServiceAccessRoleArn != nil {
		ok := object.Key("ServiceAccessRoleArn")
		ok.String(*v.ServiceAccessRoleArn)
	}

	return nil
}

func awsAwsjson11_serializeDocumentElasticsearchSettings(v *types.ElasticsearchSettings, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.EndpointUri != nil {
		ok := object.Key("EndpointUri")
		ok.String(*v.EndpointUri)
	}

	if v.ErrorRetryDuration != nil {
		ok := object.Key("ErrorRetryDuration")
		ok.Integer(*v.ErrorRetryDuration)
	}

	if v.FullLoadErrorPercentage != nil {
		ok := object.Key("FullLoadErrorPercentage")
		ok.Integer(*v.FullLoadErrorPercentage)
	}

	if v.ServiceAccessRoleArn != nil {
		ok := object.Key("ServiceAccessRoleArn")
		ok.String(*v.ServiceAccessRoleArn)
	}

	return nil
}

func awsAwsjson11_serializeDocumentEventCategoriesList(v []string, value smithyjson.Value) error {
	array := value.Array()
	defer array.Close()

	for i := range v {
		av := array.Value()
		av.String(v[i])
	}
	return nil
}

func awsAwsjson11_serializeDocumentExcludeTestList(v []string, value smithyjson.Value) error {
	array := value.Array()
	defer array.Close()

	for i := range v {
		av := array.Value()
		av.String(v[i])
	}
	return nil
}

func awsAwsjson11_serializeDocumentFilter(v *types.Filter, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.Name != nil {
		ok := object.Key("Name")
		ok.String(*v.Name)
	}

	if v.Values != nil {
		ok := object.Key("Values")
		if err := awsAwsjson11_serializeDocumentFilterValueList(v.Values, ok); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsjson11_serializeDocumentFilterList(v []types.Filter, value smithyjson.Value) error {
	array := value.Array()
	defer array.Close()

	for i := range v {
		av := array.Value()
		if err := awsAwsjson11_serializeDocumentFilter(&v[i], av); err != nil {
			return err
		}
	}
	return nil
}

func awsAwsjson11_serializeDocumentFilterValueList(v []string, value smithyjson.Value) error {
	array := value.Array()
	defer array.Close()

	for i := range v {
		av := array.Value()
		av.String(v[i])
	}
	return nil
}

func awsAwsjson11_serializeDocumentIBMDb2Settings(v *types.IBMDb2Settings, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.CurrentLsn != nil {
		ok := object.Key("CurrentLsn")
		ok.String(*v.CurrentLsn)
	}

	if v.DatabaseName != nil {
		ok := object.Key("DatabaseName")
		ok.String(*v.DatabaseName)
	}

	if v.MaxKBytesPerRead != nil {
		ok := object.Key("MaxKBytesPerRead")
		ok.Integer(*v.MaxKBytesPerRead)
	}

	if v.Password != nil {
		ok := object.Key("Password")
		ok.String(*v.Password)
	}

	if v.Port != nil {
		ok := object.Key("Port")
		ok.Integer(*v.Port)
	}

	if v.SecretsManagerAccessRoleArn != nil {
		ok := object.Key("SecretsManagerAccessRoleArn")
		ok.String(*v.SecretsManagerAccessRoleArn)
	}

	if v.SecretsManagerSecretId != nil {
		ok := object.Key("SecretsManagerSecretId")
		ok.String(*v.SecretsManagerSecretId)
	}

	if v.ServerName != nil {
		ok := object.Key("ServerName")
		ok.String(*v.ServerName)
	}

	if v.SetDataCaptureChanges != nil {
		ok := object.Key("SetDataCaptureChanges")
		ok.Boolean(*v.SetDataCaptureChanges)
	}

	if v.Username != nil {
		ok := object.Key("Username")
		ok.String(*v.Username)
	}

	return nil
}

func awsAwsjson11_serializeDocumentIncludeTestList(v []string, value smithyjson.Value) error {
	array := value.Array()
	defer array.Close()

	for i := range v {
		av := array.Value()
		av.String(v[i])
	}
	return nil
}

func awsAwsjson11_serializeDocumentIntegerList(v []int32, value smithyjson.Value) error {
	array := value.Array()
	defer array.Close()

	for i := range v {
		av := array.Value()
		av.Integer(v[i])
	}
	return nil
}

func awsAwsjson11_serializeDocumentKafkaSettings(v *types.KafkaSettings, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.Broker != nil {
		ok := object.Key("Broker")
		ok.String(*v.Broker)
	}

	if v.IncludeControlDetails != nil {
		ok := object.Key("IncludeControlDetails")
		ok.Boolean(*v.IncludeControlDetails)
	}

	if v.IncludeNullAndEmpty != nil {
		ok := object.Key("IncludeNullAndEmpty")
		ok.Boolean(*v.IncludeNullAndEmpty)
	}

	if v.IncludePartitionValue != nil {
		ok := object.Key("IncludePartitionValue")
		ok.Boolean(*v.IncludePartitionValue)
	}

	if v.IncludeTableAlterOperations != nil {
		ok := object.Key("IncludeTableAlterOperations")
		ok.Boolean(*v.IncludeTableAlterOperations)
	}

	if v.IncludeTransactionDetails != nil {
		ok := object.Key("IncludeTransactionDetails")
		ok.Boolean(*v.IncludeTransactionDetails)
	}

	if len(v.MessageFormat) > 0 {
		ok := object.Key("MessageFormat")
		ok.String(string(v.MessageFormat))
	}

	if v.MessageMaxBytes != nil {
		ok := object.Key("MessageMaxBytes")
		ok.Integer(*v.MessageMaxBytes)
	}

	if v.NoHexPrefix != nil {
		ok := object.Key("NoHexPrefix")
		ok.Boolean(*v.NoHexPrefix)
	}

	if v.PartitionIncludeSchemaTable != nil {
		ok := object.Key("PartitionIncludeSchemaTable")
		ok.Boolean(*v.PartitionIncludeSchemaTable)
	}

	if v.SaslPassword != nil {
		ok := object.Key("SaslPassword")
		ok.String(*v.SaslPassword)
	}

	if v.SaslUsername != nil {
		ok := object.Key("SaslUsername")
		ok.String(*v.SaslUsername)
	}

	if len(v.SecurityProtocol) > 0 {
		ok := object.Key("SecurityProtocol")
		ok.String(string(v.SecurityProtocol))
	}

	if v.SslCaCertificateArn != nil {
		ok := object.Key("SslCaCertificateArn")
		ok.String(*v.SslCaCertificateArn)
	}

	if v.SslClientCertificateArn != nil {
		ok := object.Key("SslClientCertificateArn")
		ok.String(*v.SslClientCertificateArn)
	}

	if v.SslClientKeyArn != nil {
		ok := object.Key("SslClientKeyArn")
		ok.String(*v.SslClientKeyArn)
	}

	if v.SslClientKeyPassword != nil {
		ok := object.Key("SslClientKeyPassword")
		ok.String(*v.SslClientKeyPassword)
	}

	if v.Topic != nil {
		ok := object.Key("Topic")
		ok.String(*v.Topic)
	}

	return nil
}

func awsAwsjson11_serializeDocumentKeyList(v []string, value smithyjson.Value) error {
	array := value.Array()
	defer array.Close()

	for i := range v {
		av := array.Value()
		av.String(v[i])
	}
	return nil
}

func awsAwsjson11_serializeDocumentKinesisSettings(v *types.KinesisSettings, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.IncludeControlDetails != nil {
		ok := object.Key("IncludeControlDetails")
		ok.Boolean(*v.IncludeControlDetails)
	}

	if v.IncludeNullAndEmpty != nil {
		ok := object.Key("IncludeNullAndEmpty")
		ok.Boolean(*v.IncludeNullAndEmpty)
	}

	if v.IncludePartitionValue != nil {
		ok := object.Key("IncludePartitionValue")
		ok.Boolean(*v.IncludePartitionValue)
	}

	if v.IncludeTableAlterOperations != nil {
		ok := object.Key("IncludeTableAlterOperations")
		ok.Boolean(*v.IncludeTableAlterOperations)
	}

	if v.IncludeTransactionDetails != nil {
		ok := object.Key("IncludeTransactionDetails")
		ok.Boolean(*v.IncludeTransactionDetails)
	}

	if len(v.MessageFormat) > 0 {
		ok := object.Key("MessageFormat")
		ok.String(string(v.MessageFormat))
	}

	if v.NoHexPrefix != nil {
		ok := object.Key("NoHexPrefix")
		ok.Boolean(*v.NoHexPrefix)
	}

	if v.PartitionIncludeSchemaTable != nil {
		ok := object.Key("PartitionIncludeSchemaTable")
		ok.Boolean(*v.PartitionIncludeSchemaTable)
	}

	if v.ServiceAccessRoleArn != nil {
		ok := object.Key("ServiceAccessRoleArn")
		ok.String(*v.ServiceAccessRoleArn)
	}

	if v.StreamArn != nil {
		ok := object.Key("StreamArn")
		ok.String(*v.StreamArn)
	}

	return nil
}

func awsAwsjson11_serializeDocumentMicrosoftSQLServerSettings(v *types.MicrosoftSQLServerSettings, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.BcpPacketSize != nil {
		ok := object.Key("BcpPacketSize")
		ok.Integer(*v.BcpPacketSize)
	}

	if v.ControlTablesFileGroup != nil {
		ok := object.Key("ControlTablesFileGroup")
		ok.String(*v.ControlTablesFileGroup)
	}

	if v.DatabaseName != nil {
		ok := object.Key("DatabaseName")
		ok.String(*v.DatabaseName)
	}

	if v.Password != nil {
		ok := object.Key("Password")
		ok.String(*v.Password)
	}

	if v.Port != nil {
		ok := object.Key("Port")
		ok.Integer(*v.Port)
	}

	if v.QuerySingleAlwaysOnNode != nil {
		ok := object.Key("QuerySingleAlwaysOnNode")
		ok.Boolean(*v.QuerySingleAlwaysOnNode)
	}

	if v.ReadBackupOnly != nil {
		ok := object.Key("ReadBackupOnly")
		ok.Boolean(*v.ReadBackupOnly)
	}

	if len(v.SafeguardPolicy) > 0 {
		ok := object.Key("SafeguardPolicy")
		ok.String(string(v.SafeguardPolicy))
	}

	if v.SecretsManagerAccessRoleArn != nil {
		ok := object.Key("SecretsManagerAccessRoleArn")
		ok.String(*v.SecretsManagerAccessRoleArn)
	}

	if v.SecretsManagerSecretId != nil {
		ok := object.Key("SecretsManagerSecretId")
		ok.String(*v.SecretsManagerSecretId)
	}

	if v.ServerName != nil {
		ok := object.Key("ServerName")
		ok.String(*v.ServerName)
	}

	if v.UseBcpFullLoad != nil {
		ok := object.Key("UseBcpFullLoad")
		ok.Boolean(*v.UseBcpFullLoad)
	}

	if v.Username != nil {
		ok := object.Key("Username")
		ok.String(*v.Username)
	}

	if v.UseThirdPartyBackupDevice != nil {
		ok := object.Key("UseThirdPartyBackupDevice")
		ok.Boolean(*v.UseThirdPartyBackupDevice)
	}

	return nil
}

func awsAwsjson11_serializeDocumentMongoDbSettings(v *types.MongoDbSettings, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if len(v.AuthMechanism) > 0 {
		ok := object.Key("AuthMechanism")
		ok.String(string(v.AuthMechanism))
	}

	if v.AuthSource != nil {
		ok := object.Key("AuthSource")
		ok.String(*v.AuthSource)
	}

	if len(v.AuthType) > 0 {
		ok := object.Key("AuthType")
		ok.String(string(v.AuthType))
	}

	if v.DatabaseName != nil {
		ok := object.Key("DatabaseName")
		ok.String(*v.DatabaseName)
	}

	if v.DocsToInvestigate != nil {
		ok := object.Key("DocsToInvestigate")
		ok.String(*v.DocsToInvestigate)
	}

	if v.ExtractDocId != nil {
		ok := object.Key("ExtractDocId")
		ok.String(*v.ExtractDocId)
	}

	if v.KmsKeyId != nil {
		ok := object.Key("KmsKeyId")
		ok.String(*v.KmsKeyId)
	}

	if len(v.NestingLevel) > 0 {
		ok := object.Key("NestingLevel")
		ok.String(string(v.NestingLevel))
	}

	if v.Password != nil {
		ok := object.Key("Password")
		ok.String(*v.Password)
	}

	if v.Port != nil {
		ok := object.Key("Port")
		ok.Integer(*v.Port)
	}

	if v.SecretsManagerAccessRoleArn != nil {
		ok := object.Key("SecretsManagerAccessRoleArn")
		ok.String(*v.SecretsManagerAccessRoleArn)
	}

	if v.SecretsManagerSecretId != nil {
		ok := object.Key("SecretsManagerSecretId")
		ok.String(*v.SecretsManagerSecretId)
	}

	if v.ServerName != nil {
		ok := object.Key("ServerName")
		ok.String(*v.ServerName)
	}

	if v.Username != nil {
		ok := object.Key("Username")
		ok.String(*v.Username)
	}

	return nil
}

func awsAwsjson11_serializeDocumentMySQLSettings(v *types.MySQLSettings, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.AfterConnectScript != nil {
		ok := object.Key("AfterConnectScript")
		ok.String(*v.AfterConnectScript)
	}

	if v.CleanSourceMetadataOnMismatch != nil {
		ok := object.Key("CleanSourceMetadataOnMismatch")
		ok.Boolean(*v.CleanSourceMetadataOnMismatch)
	}

	if v.DatabaseName != nil {
		ok := object.Key("DatabaseName")
		ok.String(*v.DatabaseName)
	}

	if v.EventsPollInterval != nil {
		ok := object.Key("EventsPollInterval")
		ok.Integer(*v.EventsPollInterval)
	}

	if v.MaxFileSize != nil {
		ok := object.Key("MaxFileSize")
		ok.Integer(*v.MaxFileSize)
	}

	if v.ParallelLoadThreads != nil {
		ok := object.Key("ParallelLoadThreads")
		ok.Integer(*v.ParallelLoadThreads)
	}

	if v.Password != nil {
		ok := object.Key("Password")
		ok.String(*v.Password)
	}

	if v.Port != nil {
		ok := object.Key("Port")
		ok.Integer(*v.Port)
	}

	if v.SecretsManagerAccessRoleArn != nil {
		ok := object.Key("SecretsManagerAccessRoleArn")
		ok.String(*v.SecretsManagerAccessRoleArn)
	}

	if v.SecretsManagerSecretId != nil {
		ok := object.Key("SecretsManagerSecretId")
		ok.String(*v.SecretsManagerSecretId)
	}

	if v.ServerName != nil {
		ok := object.Key("ServerName")
		ok.String(*v.ServerName)
	}

	if v.ServerTimezone != nil {
		ok := object.Key("ServerTimezone")
		ok.String(*v.ServerTimezone)
	}

	if len(v.TargetDbType) > 0 {
		ok := object.Key("TargetDbType")
		ok.String(string(v.TargetDbType))
	}

	if v.Username != nil {
		ok := object.Key("Username")
		ok.String(*v.Username)
	}

	return nil
}

func awsAwsjson11_serializeDocumentNeptuneSettings(v *types.NeptuneSettings, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.ErrorRetryDuration != nil {
		ok := object.Key("ErrorRetryDuration")
		ok.Integer(*v.ErrorRetryDuration)
	}

	if v.IamAuthEnabled != nil {
		ok := object.Key("IamAuthEnabled")
		ok.Boolean(*v.IamAuthEnabled)
	}

	if v.MaxFileSize != nil {
		ok := object.Key("MaxFileSize")
		ok.Integer(*v.MaxFileSize)
	}

	if v.MaxRetryCount != nil {
		ok := object.Key("MaxRetryCount")
		ok.Integer(*v.MaxRetryCount)
	}

	if v.S3BucketFolder != nil {
		ok := object.Key("S3BucketFolder")
		ok.String(*v.S3BucketFolder)
	}

	if v.S3BucketName != nil {
		ok := object.Key("S3BucketName")
		ok.String(*v.S3BucketName)
	}

	if v.ServiceAccessRoleArn != nil {
		ok := object.Key("ServiceAccessRoleArn")
		ok.String(*v.ServiceAccessRoleArn)
	}

	return nil
}

func awsAwsjson11_serializeDocumentOracleSettings(v *types.OracleSettings, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.AccessAlternateDirectly != nil {
		ok := object.Key("AccessAlternateDirectly")
		ok.Boolean(*v.AccessAlternateDirectly)
	}

	if v.AdditionalArchivedLogDestId != nil {
		ok := object.Key("AdditionalArchivedLogDestId")
		ok.Integer(*v.AdditionalArchivedLogDestId)
	}

	if v.AddSupplementalLogging != nil {
		ok := object.Key("AddSupplementalLogging")
		ok.Boolean(*v.AddSupplementalLogging)
	}

	if v.AllowSelectNestedTables != nil {
		ok := object.Key("AllowSelectNestedTables")
		ok.Boolean(*v.AllowSelectNestedTables)
	}

	if v.ArchivedLogDestId != nil {
		ok := object.Key("ArchivedLogDestId")
		ok.Integer(*v.ArchivedLogDestId)
	}

	if v.ArchivedLogsOnly != nil {
		ok := object.Key("ArchivedLogsOnly")
		ok.Boolean(*v.ArchivedLogsOnly)
	}

	if v.AsmPassword != nil {
		ok := object.Key("AsmPassword")
		ok.String(*v.AsmPassword)
	}

	if v.AsmServer != nil {
		ok := object.Key("AsmServer")
		ok.String(*v.AsmServer)
	}

	if v.AsmUser != nil {
		ok := object.Key("AsmUser")
		ok.String(*v.AsmUser)
	}

	if len(v.CharLengthSemantics) > 0 {
		ok := object.Key("CharLengthSemantics")
		ok.String(string(v.CharLengthSemantics))
	}

	if v.DatabaseName != nil {
		ok := object.Key("DatabaseName")
		ok.String(*v.DatabaseName)
	}

	if v.DirectPathNoLog != nil {
		ok := object.Key("DirectPathNoLog")
		ok.Boolean(*v.DirectPathNoLog)
	}

	if v.DirectPathParallelLoad != nil {
		ok := object.Key("DirectPathParallelLoad")
		ok.Boolean(*v.DirectPathParallelLoad)
	}

	if v.EnableHomogenousTablespace != nil {
		ok := object.Key("EnableHomogenousTablespace")
		ok.Boolean(*v.EnableHomogenousTablespace)
	}

	if v.ExtraArchivedLogDestIds != nil {
		ok := object.Key("ExtraArchivedLogDestIds")
		if err := awsAwsjson11_serializeDocumentIntegerList(v.ExtraArchivedLogDestIds, ok); err != nil {
			return err
		}
	}

	if v.FailTasksOnLobTruncation != nil {
		ok := object.Key("FailTasksOnLobTruncation")
		ok.Boolean(*v.FailTasksOnLobTruncation)
	}

	if v.NumberDatatypeScale != nil {
		ok := object.Key("NumberDatatypeScale")
		ok.Integer(*v.NumberDatatypeScale)
	}

	if v.OraclePathPrefix != nil {
		ok := object.Key("OraclePathPrefix")
		ok.String(*v.OraclePathPrefix)
	}

	if v.ParallelAsmReadThreads != nil {
		ok := object.Key("ParallelAsmReadThreads")
		ok.Integer(*v.ParallelAsmReadThreads)
	}

	if v.Password != nil {
		ok := object.Key("Password")
		ok.String(*v.Password)
	}

	if v.Port != nil {
		ok := object.Key("Port")
		ok.Integer(*v.Port)
	}

	if v.ReadAheadBlocks != nil {
		ok := object.Key("ReadAheadBlocks")
		ok.Integer(*v.ReadAheadBlocks)
	}

	if v.ReadTableSpaceName != nil {
		ok := object.Key("ReadTableSpaceName")
		ok.Boolean(*v.ReadTableSpaceName)
	}

	if v.ReplacePathPrefix != nil {
		ok := object.Key("ReplacePathPrefix")
		ok.Boolean(*v.ReplacePathPrefix)
	}

	if v.RetryInterval != nil {
		ok := object.Key("RetryInterval")
		ok.Integer(*v.RetryInterval)
	}

	if v.SecretsManagerAccessRoleArn != nil {
		ok := object.Key("SecretsManagerAccessRoleArn")
		ok.String(*v.SecretsManagerAccessRoleArn)
	}

	if v.SecretsManagerOracleAsmAccessRoleArn != nil {
		ok := object.Key("SecretsManagerOracleAsmAccessRoleArn")
		ok.String(*v.SecretsManagerOracleAsmAccessRoleArn)
	}

	if v.SecretsManagerOracleAsmSecretId != nil {
		ok := object.Key("SecretsManagerOracleAsmSecretId")
		ok.String(*v.SecretsManagerOracleAsmSecretId)
	}

	if v.SecretsManagerSecretId != nil {
		ok := object.Key("SecretsManagerSecretId")
		ok.String(*v.SecretsManagerSecretId)
	}

	if v.SecurityDbEncryption != nil {
		ok := object.Key("SecurityDbEncryption")
		ok.String(*v.SecurityDbEncryption)
	}

	if v.SecurityDbEncryptionName != nil {
		ok := object.Key("SecurityDbEncryptionName")
		ok.String(*v.SecurityDbEncryptionName)
	}

	if v.ServerName != nil {
		ok := object.Key("ServerName")
		ok.String(*v.ServerName)
	}

	if v.SpatialDataOptionToGeoJsonFunctionName != nil {
		ok := object.Key("SpatialDataOptionToGeoJsonFunctionName")
		ok.String(*v.SpatialDataOptionToGeoJsonFunctionName)
	}

	if v.StandbyDelayTime != nil {
		ok := object.Key("StandbyDelayTime")
		ok.Integer(*v.StandbyDelayTime)
	}

	if v.UseAlternateFolderForOnline != nil {
		ok := object.Key("UseAlternateFolderForOnline")
		ok.Boolean(*v.UseAlternateFolderForOnline)
	}

	if v.UseBFile != nil {
		ok := object.Key("UseBFile")
		ok.Boolean(*v.UseBFile)
	}

	if v.UseDirectPathFullLoad != nil {
		ok := object.Key("UseDirectPathFullLoad")
		ok.Boolean(*v.UseDirectPathFullLoad)
	}

	if v.UseLogminerReader != nil {
		ok := object.Key("UseLogminerReader")
		ok.Boolean(*v.UseLogminerReader)
	}

	if v.UsePathPrefix != nil {
		ok := object.Key("UsePathPrefix")
		ok.String(*v.UsePathPrefix)
	}

	if v.Username != nil {
		ok := object.Key("Username")
		ok.String(*v.Username)
	}

	return nil
}

func awsAwsjson11_serializeDocumentPostgreSQLSettings(v *types.PostgreSQLSettings, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.AfterConnectScript != nil {
		ok := object.Key("AfterConnectScript")
		ok.String(*v.AfterConnectScript)
	}

	if v.CaptureDdls != nil {
		ok := object.Key("CaptureDdls")
		ok.Boolean(*v.CaptureDdls)
	}

	if v.DatabaseName != nil {
		ok := object.Key("DatabaseName")
		ok.String(*v.DatabaseName)
	}

	if v.DdlArtifactsSchema != nil {
		ok := object.Key("DdlArtifactsSchema")
		ok.String(*v.DdlArtifactsSchema)
	}

	if v.ExecuteTimeout != nil {
		ok := object.Key("ExecuteTimeout")
		ok.Integer(*v.ExecuteTimeout)
	}

	if v.FailTasksOnLobTruncation != nil {
		ok := object.Key("FailTasksOnLobTruncation")
		ok.Boolean(*v.FailTasksOnLobTruncation)
	}

	if v.HeartbeatEnable != nil {
		ok := object.Key("HeartbeatEnable")
		ok.Boolean(*v.HeartbeatEnable)
	}

	if v.HeartbeatFrequency != nil {
		ok := object.Key("HeartbeatFrequency")
		ok.Integer(*v.HeartbeatFrequency)
	}

	if v.HeartbeatSchema != nil {
		ok := object.Key("HeartbeatSchema")
		ok.String(*v.HeartbeatSchema)
	}

	if v.MaxFileSize != nil {
		ok := object.Key("MaxFileSize")
		ok.Integer(*v.MaxFileSize)
	}

	if v.Password != nil {
		ok := object.Key("Password")
		ok.String(*v.Password)
	}

	if len(v.PluginName) > 0 {
		ok := object.Key("PluginName")
		ok.String(string(v.PluginName))
	}

	if v.Port != nil {
		ok := object.Key("Port")
		ok.Integer(*v.Port)
	}

	if v.SecretsManagerAccessRoleArn != nil {
		ok := object.Key("SecretsManagerAccessRoleArn")
		ok.String(*v.SecretsManagerAccessRoleArn)
	}

	if v.SecretsManagerSecretId != nil {
		ok := object.Key("SecretsManagerSecretId")
		ok.String(*v.SecretsManagerSecretId)
	}

	if v.ServerName != nil {
		ok := object.Key("ServerName")
		ok.String(*v.ServerName)
	}

	if v.SlotName != nil {
		ok := object.Key("SlotName")
		ok.String(*v.SlotName)
	}

	if v.Username != nil {
		ok := object.Key("Username")
		ok.String(*v.Username)
	}

	return nil
}

func awsAwsjson11_serializeDocumentRedisSettings(v *types.RedisSettings, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.AuthPassword != nil {
		ok := object.Key("AuthPassword")
		ok.String(*v.AuthPassword)
	}

	if len(v.AuthType) > 0 {
		ok := object.Key("AuthType")
		ok.String(string(v.AuthType))
	}

	if v.AuthUserName != nil {
		ok := object.Key("AuthUserName")
		ok.String(*v.AuthUserName)
	}

	{
		ok := object.Key("Port")
		ok.Integer(v.Port)
	}

	if v.ServerName != nil {
		ok := object.Key("ServerName")
		ok.String(*v.ServerName)
	}

	if v.SslCaCertificateArn != nil {
		ok := object.Key("SslCaCertificateArn")
		ok.String(*v.SslCaCertificateArn)
	}

	if len(v.SslSecurityProtocol) > 0 {
		ok := object.Key("SslSecurityProtocol")
		ok.String(string(v.SslSecurityProtocol))
	}

	return nil
}

func awsAwsjson11_serializeDocumentRedshiftSettings(v *types.RedshiftSettings, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.AcceptAnyDate != nil {
		ok := object.Key("AcceptAnyDate")
		ok.Boolean(*v.AcceptAnyDate)
	}

	if v.AfterConnectScript != nil {
		ok := object.Key("AfterConnectScript")
		ok.String(*v.AfterConnectScript)
	}

	if v.BucketFolder != nil {
		ok := object.Key("BucketFolder")
		ok.String(*v.BucketFolder)
	}

	if v.BucketName != nil {
		ok := object.Key("BucketName")
		ok.String(*v.BucketName)
	}

	if v.CaseSensitiveNames != nil {
		ok := object.Key("CaseSensitiveNames")
		ok.Boolean(*v.CaseSensitiveNames)
	}

	if v.CompUpdate != nil {
		ok := object.Key("CompUpdate")
		ok.Boolean(*v.CompUpdate)
	}

	if v.ConnectionTimeout != nil {
		ok := object.Key("ConnectionTimeout")
		ok.Integer(*v.ConnectionTimeout)
	}

	if v.DatabaseName != nil {
		ok := object.Key("DatabaseName")
		ok.String(*v.DatabaseName)
	}

	if v.DateFormat != nil {
		ok := object.Key("DateFormat")
		ok.String(*v.DateFormat)
	}

	if v.EmptyAsNull != nil {
		ok := object.Key("EmptyAsNull")
		ok.Boolean(*v.EmptyAsNull)
	}

	if len(v.EncryptionMode) > 0 {
		ok := object.Key("EncryptionMode")
		ok.String(string(v.EncryptionMode))
	}

	if v.ExplicitIds != nil {
		ok := object.Key("ExplicitIds")
		ok.Boolean(*v.ExplicitIds)
	}

	if v.FileTransferUploadStreams != nil {
		ok := object.Key("FileTransferUploadStreams")
		ok.Integer(*v.FileTransferUploadStreams)
	}

	if v.LoadTimeout != nil {
		ok := object.Key("LoadTimeout")
		ok.Integer(*v.LoadTimeout)
	}

	if v.MaxFileSize != nil {
		ok := object.Key("MaxFileSize")
		ok.Integer(*v.MaxFileSize)
	}

	if v.Password != nil {
		ok := object.Key("Password")
		ok.String(*v.Password)
	}

	if v.Port != nil {
		ok := object.Key("Port")
		ok.Integer(*v.Port)
	}

	if v.RemoveQuotes != nil {
		ok := object.Key("RemoveQuotes")
		ok.Boolean(*v.RemoveQuotes)
	}

	if v.ReplaceChars != nil {
		ok := object.Key("ReplaceChars")
		ok.String(*v.ReplaceChars)
	}

	if v.ReplaceInvalidChars != nil {
		ok := object.Key("ReplaceInvalidChars")
		ok.String(*v.ReplaceInvalidChars)
	}

	if v.SecretsManagerAccessRoleArn != nil {
		ok := object.Key("SecretsManagerAccessRoleArn")
		ok.String(*v.SecretsManagerAccessRoleArn)
	}

	if v.SecretsManagerSecretId != nil {
		ok := object.Key("SecretsManagerSecretId")
		ok.String(*v.SecretsManagerSecretId)
	}

	if v.ServerName != nil {
		ok := object.Key("ServerName")
		ok.String(*v.ServerName)
	}

	if v.ServerSideEncryptionKmsKeyId != nil {
		ok := object.Key("ServerSideEncryptionKmsKeyId")
		ok.String(*v.ServerSideEncryptionKmsKeyId)
	}

	if v.ServiceAccessRoleArn != nil {
		ok := object.Key("ServiceAccessRoleArn")
		ok.String(*v.ServiceAccessRoleArn)
	}

	if v.TimeFormat != nil {
		ok := object.Key("TimeFormat")
		ok.String(*v.TimeFormat)
	}

	if v.TrimBlanks != nil {
		ok := object.Key("TrimBlanks")
		ok.Boolean(*v.TrimBlanks)
	}

	if v.TruncateColumns != nil {
		ok := object.Key("TruncateColumns")
		ok.Boolean(*v.TruncateColumns)
	}

	if v.Username != nil {
		ok := object.Key("Username")
		ok.String(*v.Username)
	}

	if v.WriteBufferSize != nil {
		ok := object.Key("WriteBufferSize")
		ok.Integer(*v.WriteBufferSize)
	}

	return nil
}

func awsAwsjson11_serializeDocumentS3Settings(v *types.S3Settings, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.AddColumnName != nil {
		ok := object.Key("AddColumnName")
		ok.Boolean(*v.AddColumnName)
	}

	if v.BucketFolder != nil {
		ok := object.Key("BucketFolder")
		ok.String(*v.BucketFolder)
	}

	if v.BucketName != nil {
		ok := object.Key("BucketName")
		ok.String(*v.BucketName)
	}

	if len(v.CannedAclForObjects) > 0 {
		ok := object.Key("CannedAclForObjects")
		ok.String(string(v.CannedAclForObjects))
	}

	if v.CdcInsertsAndUpdates != nil {
		ok := object.Key("CdcInsertsAndUpdates")
		ok.Boolean(*v.CdcInsertsAndUpdates)
	}

	if v.CdcInsertsOnly != nil {
		ok := object.Key("CdcInsertsOnly")
		ok.Boolean(*v.CdcInsertsOnly)
	}

	if v.CdcMaxBatchInterval != nil {
		ok := object.Key("CdcMaxBatchInterval")
		ok.Integer(*v.CdcMaxBatchInterval)
	}

	if v.CdcMinFileSize != nil {
		ok := object.Key("CdcMinFileSize")
		ok.Integer(*v.CdcMinFileSize)
	}

	if v.CdcPath != nil {
		ok := object.Key("CdcPath")
		ok.String(*v.CdcPath)
	}

	if len(v.CompressionType) > 0 {
		ok := object.Key("CompressionType")
		ok.String(string(v.CompressionType))
	}

	if v.CsvDelimiter != nil {
		ok := object.Key("CsvDelimiter")
		ok.String(*v.CsvDelimiter)
	}

	if v.CsvNoSupValue != nil {
		ok := object.Key("CsvNoSupValue")
		ok.String(*v.CsvNoSupValue)
	}

	if v.CsvNullValue != nil {
		ok := object.Key("CsvNullValue")
		ok.String(*v.CsvNullValue)
	}

	if v.CsvRowDelimiter != nil {
		ok := object.Key("CsvRowDelimiter")
		ok.String(*v.CsvRowDelimiter)
	}

	if len(v.DataFormat) > 0 {
		ok := object.Key("DataFormat")
		ok.String(string(v.DataFormat))
	}

	if v.DataPageSize != nil {
		ok := object.Key("DataPageSize")
		ok.Integer(*v.DataPageSize)
	}

	if len(v.DatePartitionDelimiter) > 0 {
		ok := object.Key("DatePartitionDelimiter")
		ok.String(string(v.DatePartitionDelimiter))
	}

	if v.DatePartitionEnabled != nil {
		ok := object.Key("DatePartitionEnabled")
		ok.Boolean(*v.DatePartitionEnabled)
	}

	if len(v.DatePartitionSequence) > 0 {
		ok := object.Key("DatePartitionSequence")
		ok.String(string(v.DatePartitionSequence))
	}

	if v.DictPageSizeLimit != nil {
		ok := object.Key("DictPageSizeLimit")
		ok.Integer(*v.DictPageSizeLimit)
	}

	if v.EnableStatistics != nil {
		ok := object.Key("EnableStatistics")
		ok.Boolean(*v.EnableStatistics)
	}

	if len(v.EncodingType) > 0 {
		ok := object.Key("EncodingType")
		ok.String(string(v.EncodingType))
	}

	if len(v.EncryptionMode) > 0 {
		ok := object.Key("EncryptionMode")
		ok.String(string(v.EncryptionMode))
	}

	if v.ExternalTableDefinition != nil {
		ok := object.Key("ExternalTableDefinition")
		ok.String(*v.ExternalTableDefinition)
	}

	if v.IgnoreHeaderRows != nil {
		ok := object.Key("IgnoreHeaderRows")
		ok.Integer(*v.IgnoreHeaderRows)
	}

	if v.IncludeOpForFullLoad != nil {
		ok := object.Key("IncludeOpForFullLoad")
		ok.Boolean(*v.IncludeOpForFullLoad)
	}

	if v.MaxFileSize != nil {
		ok := object.Key("MaxFileSize")
		ok.Integer(*v.MaxFileSize)
	}

	if v.ParquetTimestampInMillisecond != nil {
		ok := object.Key("ParquetTimestampInMillisecond")
		ok.Boolean(*v.ParquetTimestampInMillisecond)
	}

	if len(v.ParquetVersion) > 0 {
		ok := object.Key("ParquetVersion")
		ok.String(string(v.ParquetVersion))
	}

	if v.PreserveTransactions != nil {
		ok := object.Key("PreserveTransactions")
		ok.Boolean(*v.PreserveTransactions)
	}

	if v.Rfc4180 != nil {
		ok := object.Key("Rfc4180")
		ok.Boolean(*v.Rfc4180)
	}

	if v.RowGroupLength != nil {
		ok := object.Key("RowGroupLength")
		ok.Integer(*v.RowGroupLength)
	}

	if v.ServerSideEncryptionKmsKeyId != nil {
		ok := object.Key("ServerSideEncryptionKmsKeyId")
		ok.String(*v.ServerSideEncryptionKmsKeyId)
	}

	if v.ServiceAccessRoleArn != nil {
		ok := object.Key("ServiceAccessRoleArn")
		ok.String(*v.ServiceAccessRoleArn)
	}

	if v.TimestampColumnName != nil {
		ok := object.Key("TimestampColumnName")
		ok.String(*v.TimestampColumnName)
	}

	if v.UseCsvNoSupValue != nil {
		ok := object.Key("UseCsvNoSupValue")
		ok.Boolean(*v.UseCsvNoSupValue)
	}

	return nil
}

func awsAwsjson11_serializeDocumentSourceIdsList(v []string, value smithyjson.Value) error {
	array := value.Array()
	defer array.Close()

	for i := range v {
		av := array.Value()
		av.String(v[i])
	}
	return nil
}

func awsAwsjson11_serializeDocumentSubnetIdentifierList(v []string, value smithyjson.Value) error {
	array := value.Array()
	defer array.Close()

	for i := range v {
		av := array.Value()
		av.String(v[i])
	}
	return nil
}

func awsAwsjson11_serializeDocumentSybaseSettings(v *types.SybaseSettings, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.DatabaseName != nil {
		ok := object.Key("DatabaseName")
		ok.String(*v.DatabaseName)
	}

	if v.Password != nil {
		ok := object.Key("Password")
		ok.String(*v.Password)
	}

	if v.Port != nil {
		ok := object.Key("Port")
		ok.Integer(*v.Port)
	}

	if v.SecretsManagerAccessRoleArn != nil {
		ok := object.Key("SecretsManagerAccessRoleArn")
		ok.String(*v.SecretsManagerAccessRoleArn)
	}

	if v.SecretsManagerSecretId != nil {
		ok := object.Key("SecretsManagerSecretId")
		ok.String(*v.SecretsManagerSecretId)
	}

	if v.ServerName != nil {
		ok := object.Key("ServerName")
		ok.String(*v.ServerName)
	}

	if v.Username != nil {
		ok := object.Key("Username")
		ok.String(*v.Username)
	}

	return nil
}

func awsAwsjson11_serializeDocumentTableListToReload(v []types.TableToReload, value smithyjson.Value) error {
	array := value.Array()
	defer array.Close()

	for i := range v {
		av := array.Value()
		if err := awsAwsjson11_serializeDocumentTableToReload(&v[i], av); err != nil {
			return err
		}
	}
	return nil
}

func awsAwsjson11_serializeDocumentTableToReload(v *types.TableToReload, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.SchemaName != nil {
		ok := object.Key("SchemaName")
		ok.String(*v.SchemaName)
	}

	if v.TableName != nil {
		ok := object.Key("TableName")
		ok.String(*v.TableName)
	}

	return nil
}

func awsAwsjson11_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.Key != nil {
		ok := object.Key("Key")
		ok.String(*v.Key)
	}

	if v.ResourceArn != nil {
		ok := object.Key("ResourceArn")
		ok.String(*v.ResourceArn)
	}

	if v.Value != nil {
		ok := object.Key("Value")
		ok.String(*v.Value)
	}

	return nil
}

func awsAwsjson11_serializeDocumentTagList(v []types.Tag, value smithyjson.Value) error {
	array := value.Array()
	defer array.Close()

	for i := range v {
		av := array.Value()
		if err := awsAwsjson11_serializeDocumentTag(&v[i], av); err != nil {
			return err
		}
	}
	return nil
}

func awsAwsjson11_serializeDocumentVpcSecurityGroupIdList(v []string, value smithyjson.Value) error {
	array := value.Array()
	defer array.Close()

	for i := range v {
		av := array.Value()
		av.String(v[i])
	}
	return nil
}

func awsAwsjson11_serializeOpDocumentAddTagsToResourceInput(v *AddTagsToResourceInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.ResourceArn != nil {
		ok := object.Key("ResourceArn")
		ok.String(*v.ResourceArn)
	}

	if v.Tags != nil {
		ok := object.Key("Tags")
		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentApplyPendingMaintenanceActionInput(v *ApplyPendingMaintenanceActionInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.ApplyAction != nil {
		ok := object.Key("ApplyAction")
		ok.String(*v.ApplyAction)
	}

	if v.OptInType != nil {
		ok := object.Key("OptInType")
		ok.String(*v.OptInType)
	}

	if v.ReplicationInstanceArn != nil {
		ok := object.Key("ReplicationInstanceArn")
		ok.String(*v.ReplicationInstanceArn)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentCancelReplicationTaskAssessmentRunInput(v *CancelReplicationTaskAssessmentRunInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.ReplicationTaskAssessmentRunArn != nil {
		ok := object.Key("ReplicationTaskAssessmentRunArn")
		ok.String(*v.ReplicationTaskAssessmentRunArn)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentCreateEndpointInput(v *CreateEndpointInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.CertificateArn != nil {
		ok := object.Key("CertificateArn")
		ok.String(*v.CertificateArn)
	}

	if v.DatabaseName != nil {
		ok := object.Key("DatabaseName")
		ok.String(*v.DatabaseName)
	}

	if v.DmsTransferSettings != nil {
		ok := object.Key("DmsTransferSettings")
		if err := awsAwsjson11_serializeDocumentDmsTransferSettings(v.DmsTransferSettings, ok); err != nil {
			return err
		}
	}

	if v.DocDbSettings != nil {
		ok := object.Key("DocDbSettings")
		if err := awsAwsjson11_serializeDocumentDocDbSettings(v.DocDbSettings, ok); err != nil {
			return err
		}
	}

	if v.DynamoDbSettings != nil {
		ok := object.Key("DynamoDbSettings")
		if err := awsAwsjson11_serializeDocumentDynamoDbSettings(v.DynamoDbSettings, ok); err != nil {
			return err
		}
	}

	if v.ElasticsearchSettings != nil {
		ok := object.Key("ElasticsearchSettings")
		if err := awsAwsjson11_serializeDocumentElasticsearchSettings(v.ElasticsearchSettings, ok); err != nil {
			return err
		}
	}

	if v.EndpointIdentifier != nil {
		ok := object.Key("EndpointIdentifier")
		ok.String(*v.EndpointIdentifier)
	}

	if len(v.EndpointType) > 0 {
		ok := object.Key("EndpointType")
		ok.String(string(v.EndpointType))
	}

	if v.EngineName != nil {
		ok := object.Key("EngineName")
		ok.String(*v.EngineName)
	}

	if v.ExternalTableDefinition != nil {
		ok := object.Key("ExternalTableDefinition")
		ok.String(*v.ExternalTableDefinition)
	}

	if v.ExtraConnectionAttributes != nil {
		ok := object.Key("ExtraConnectionAttributes")
		ok.String(*v.ExtraConnectionAttributes)
	}

	if v.IBMDb2Settings != nil {
		ok := object.Key("IBMDb2Settings")
		if err := awsAwsjson11_serializeDocumentIBMDb2Settings(v.IBMDb2Settings, ok); err != nil {
			return err
		}
	}

	if v.KafkaSettings != nil {
		ok := object.Key("KafkaSettings")
		if err := awsAwsjson11_serializeDocumentKafkaSettings(v.KafkaSettings, ok); err != nil {
			return err
		}
	}

	if v.KinesisSettings != nil {
		ok := object.Key("KinesisSettings")
		if err := awsAwsjson11_serializeDocumentKinesisSettings(v.KinesisSettings, ok); err != nil {
			return err
		}
	}

	if v.KmsKeyId != nil {
		ok := object.Key("KmsKeyId")
		ok.String(*v.KmsKeyId)
	}

	if v.MicrosoftSQLServerSettings != nil {
		ok := object.Key("MicrosoftSQLServerSettings")
		if err := awsAwsjson11_serializeDocumentMicrosoftSQLServerSettings(v.MicrosoftSQLServerSettings, ok); err != nil {
			return err
		}
	}

	if v.MongoDbSettings != nil {
		ok := object.Key("MongoDbSettings")
		if err := awsAwsjson11_serializeDocumentMongoDbSettings(v.MongoDbSettings, ok); err != nil {
			return err
		}
	}

	if v.MySQLSettings != nil {
		ok := object.Key("MySQLSettings")
		if err := awsAwsjson11_serializeDocumentMySQLSettings(v.MySQLSettings, ok); err != nil {
			return err
		}
	}

	if v.NeptuneSettings != nil {
		ok := object.Key("NeptuneSettings")
		if err := awsAwsjson11_serializeDocumentNeptuneSettings(v.NeptuneSettings, ok); err != nil {
			return err
		}
	}

	if v.OracleSettings != nil {
		ok := object.Key("OracleSettings")
		if err := awsAwsjson11_serializeDocumentOracleSettings(v.OracleSettings, ok); err != nil {
			return err
		}
	}

	if v.Password != nil {
		ok := object.Key("Password")
		ok.String(*v.Password)
	}

	if v.Port != nil {
		ok := object.Key("Port")
		ok.Integer(*v.Port)
	}

	if v.PostgreSQLSettings != nil {
		ok := object.Key("PostgreSQLSettings")
		if err := awsAwsjson11_serializeDocumentPostgreSQLSettings(v.PostgreSQLSettings, ok); err != nil {
			return err
		}
	}

	if v.RedisSettings != nil {
		ok := object.Key("RedisSettings")
		if err := awsAwsjson11_serializeDocumentRedisSettings(v.RedisSettings, ok); err != nil {
			return err
		}
	}

	if v.RedshiftSettings != nil {
		ok := object.Key("RedshiftSettings")
		if err := awsAwsjson11_serializeDocumentRedshiftSettings(v.RedshiftSettings, ok); err != nil {
			return err
		}
	}

	if v.ResourceIdentifier != nil {
		ok := object.Key("ResourceIdentifier")
		ok.String(*v.ResourceIdentifier)
	}

	if v.S3Settings != nil {
		ok := object.Key("S3Settings")
		if err := awsAwsjson11_serializeDocumentS3Settings(v.S3Settings, ok); err != nil {
			return err
		}
	}

	if v.ServerName != nil {
		ok := object.Key("ServerName")
		ok.String(*v.ServerName)
	}

	if v.ServiceAccessRoleArn != nil {
		ok := object.Key("ServiceAccessRoleArn")
		ok.String(*v.ServiceAccessRoleArn)
	}

	if len(v.SslMode) > 0 {
		ok := object.Key("SslMode")
		ok.String(string(v.SslMode))
	}

	if v.SybaseSettings != nil {
		ok := object.Key("SybaseSettings")
		if err := awsAwsjson11_serializeDocumentSybaseSettings(v.SybaseSettings, ok); err != nil {
			return err
		}
	}

	if v.Tags != nil {
		ok := object.Key("Tags")
		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
			return err
		}
	}

	if v.Username != nil {
		ok := object.Key("Username")
		ok.String(*v.Username)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentCreateEventSubscriptionInput(v *CreateEventSubscriptionInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.Enabled != nil {
		ok := object.Key("Enabled")
		ok.Boolean(*v.Enabled)
	}

	if v.EventCategories != nil {
		ok := object.Key("EventCategories")
		if err := awsAwsjson11_serializeDocumentEventCategoriesList(v.EventCategories, ok); err != nil {
			return err
		}
	}

	if v.SnsTopicArn != nil {
		ok := object.Key("SnsTopicArn")
		ok.String(*v.SnsTopicArn)
	}

	if v.SourceIds != nil {
		ok := object.Key("SourceIds")
		if err := awsAwsjson11_serializeDocumentSourceIdsList(v.SourceIds, ok); err != nil {
			return err
		}
	}

	if v.SourceType != nil {
		ok := object.Key("SourceType")
		ok.String(*v.SourceType)
	}

	if v.SubscriptionName != nil {
		ok := object.Key("SubscriptionName")
		ok.String(*v.SubscriptionName)
	}

	if v.Tags != nil {
		ok := object.Key("Tags")
		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentCreateReplicationInstanceInput(v *CreateReplicationInstanceInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.AllocatedStorage != nil {
		ok := object.Key("AllocatedStorage")
		ok.Integer(*v.AllocatedStorage)
	}

	if v.AutoMinorVersionUpgrade != nil {
		ok := object.Key("AutoMinorVersionUpgrade")
		ok.Boolean(*v.AutoMinorVersionUpgrade)
	}

	if v.AvailabilityZone != nil {
		ok := object.Key("AvailabilityZone")
		ok.String(*v.AvailabilityZone)
	}

	if v.DnsNameServers != nil {
		ok := object.Key("DnsNameServers")
		ok.String(*v.DnsNameServers)
	}

	if v.EngineVersion != nil {
		ok := object.Key("EngineVersion")
		ok.String(*v.EngineVersion)
	}

	if v.KmsKeyId != nil {
		ok := object.Key("KmsKeyId")
		ok.String(*v.KmsKeyId)
	}

	if v.MultiAZ != nil {
		ok := object.Key("MultiAZ")
		ok.Boolean(*v.MultiAZ)
	}

	if v.PreferredMaintenanceWindow != nil {
		ok := object.Key("PreferredMaintenanceWindow")
		ok.String(*v.PreferredMaintenanceWindow)
	}

	if v.PubliclyAccessible != nil {
		ok := object.Key("PubliclyAccessible")
		ok.Boolean(*v.PubliclyAccessible)
	}

	if v.ReplicationInstanceClass != nil {
		ok := object.Key("ReplicationInstanceClass")
		ok.String(*v.ReplicationInstanceClass)
	}

	if v.ReplicationInstanceIdentifier != nil {
		ok := object.Key("ReplicationInstanceIdentifier")
		ok.String(*v.ReplicationInstanceIdentifier)
	}

	if v.ReplicationSubnetGroupIdentifier != nil {
		ok := object.Key("ReplicationSubnetGroupIdentifier")
		ok.String(*v.ReplicationSubnetGroupIdentifier)
	}

	if v.ResourceIdentifier != nil {
		ok := object.Key("ResourceIdentifier")
		ok.String(*v.ResourceIdentifier)
	}

	if v.Tags != nil {
		ok := object.Key("Tags")
		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
			return err
		}
	}

	if v.VpcSecurityGroupIds != nil {
		ok := object.Key("VpcSecurityGroupIds")
		if err := awsAwsjson11_serializeDocumentVpcSecurityGroupIdList(v.VpcSecurityGroupIds, ok); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentCreateReplicationSubnetGroupInput(v *CreateReplicationSubnetGroupInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.ReplicationSubnetGroupDescription != nil {
		ok := object.Key("ReplicationSubnetGroupDescription")
		ok.String(*v.ReplicationSubnetGroupDescription)
	}

	if v.ReplicationSubnetGroupIdentifier != nil {
		ok := object.Key("ReplicationSubnetGroupIdentifier")
		ok.String(*v.ReplicationSubnetGroupIdentifier)
	}

	if v.SubnetIds != nil {
		ok := object.Key("SubnetIds")
		if err := awsAwsjson11_serializeDocumentSubnetIdentifierList(v.SubnetIds, ok); err != nil {
			return err
		}
	}

	if v.Tags != nil {
		ok := object.Key("Tags")
		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentCreateReplicationTaskInput(v *CreateReplicationTaskInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.CdcStartPosition != nil {
		ok := object.Key("CdcStartPosition")
		ok.String(*v.CdcStartPosition)
	}

	if v.CdcStartTime != nil {
		ok := object.Key("CdcStartTime")
		ok.Double(smithytime.FormatEpochSeconds(*v.CdcStartTime))
	}

	if v.CdcStopPosition != nil {
		ok := object.Key("CdcStopPosition")
		ok.String(*v.CdcStopPosition)
	}

	if len(v.MigrationType) > 0 {
		ok := object.Key("MigrationType")
		ok.String(string(v.MigrationType))
	}

	if v.ReplicationInstanceArn != nil {
		ok := object.Key("ReplicationInstanceArn")
		ok.String(*v.ReplicationInstanceArn)
	}

	if v.ReplicationTaskIdentifier != nil {
		ok := object.Key("ReplicationTaskIdentifier")
		ok.String(*v.ReplicationTaskIdentifier)
	}

	if v.ReplicationTaskSettings != nil {
		ok := object.Key("ReplicationTaskSettings")
		ok.String(*v.ReplicationTaskSettings)
	}

	if v.ResourceIdentifier != nil {
		ok := object.Key("ResourceIdentifier")
		ok.String(*v.ResourceIdentifier)
	}

	if v.SourceEndpointArn != nil {
		ok := object.Key("SourceEndpointArn")
		ok.String(*v.SourceEndpointArn)
	}

	if v.TableMappings != nil {
		ok := object.Key("TableMappings")
		ok.String(*v.TableMappings)
	}

	if v.Tags != nil {
		ok := object.Key("Tags")
		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
			return err
		}
	}

	if v.TargetEndpointArn != nil {
		ok := object.Key("TargetEndpointArn")
		ok.String(*v.TargetEndpointArn)
	}

	if v.TaskData != nil {
		ok := object.Key("TaskData")
		ok.String(*v.TaskData)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDeleteCertificateInput(v *DeleteCertificateInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.CertificateArn != nil {
		ok := object.Key("CertificateArn")
		ok.String(*v.CertificateArn)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDeleteConnectionInput(v *DeleteConnectionInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.EndpointArn != nil {
		ok := object.Key("EndpointArn")
		ok.String(*v.EndpointArn)
	}

	if v.ReplicationInstanceArn != nil {
		ok := object.Key("ReplicationInstanceArn")
		ok.String(*v.ReplicationInstanceArn)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDeleteEndpointInput(v *DeleteEndpointInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.EndpointArn != nil {
		ok := object.Key("EndpointArn")
		ok.String(*v.EndpointArn)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDeleteEventSubscriptionInput(v *DeleteEventSubscriptionInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.SubscriptionName != nil {
		ok := object.Key("SubscriptionName")
		ok.String(*v.SubscriptionName)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDeleteReplicationInstanceInput(v *DeleteReplicationInstanceInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.ReplicationInstanceArn != nil {
		ok := object.Key("ReplicationInstanceArn")
		ok.String(*v.ReplicationInstanceArn)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDeleteReplicationSubnetGroupInput(v *DeleteReplicationSubnetGroupInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.ReplicationSubnetGroupIdentifier != nil {
		ok := object.Key("ReplicationSubnetGroupIdentifier")
		ok.String(*v.ReplicationSubnetGroupIdentifier)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDeleteReplicationTaskAssessmentRunInput(v *DeleteReplicationTaskAssessmentRunInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.ReplicationTaskAssessmentRunArn != nil {
		ok := object.Key("ReplicationTaskAssessmentRunArn")
		ok.String(*v.ReplicationTaskAssessmentRunArn)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDeleteReplicationTaskInput(v *DeleteReplicationTaskInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.ReplicationTaskArn != nil {
		ok := object.Key("ReplicationTaskArn")
		ok.String(*v.ReplicationTaskArn)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDescribeAccountAttributesInput(v *DescribeAccountAttributesInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	return nil
}

func awsAwsjson11_serializeOpDocumentDescribeApplicableIndividualAssessmentsInput(v *DescribeApplicableIndividualAssessmentsInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.Marker != nil {
		ok := object.Key("Marker")
		ok.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		ok := object.Key("MaxRecords")
		ok.Integer(*v.MaxRecords)
	}

	if len(v.MigrationType) > 0 {
		ok := object.Key("MigrationType")
		ok.String(string(v.MigrationType))
	}

	if v.ReplicationInstanceArn != nil {
		ok := object.Key("ReplicationInstanceArn")
		ok.String(*v.ReplicationInstanceArn)
	}

	if v.ReplicationTaskArn != nil {
		ok := object.Key("ReplicationTaskArn")
		ok.String(*v.ReplicationTaskArn)
	}

	if v.SourceEngineName != nil {
		ok := object.Key("SourceEngineName")
		ok.String(*v.SourceEngineName)
	}

	if v.TargetEngineName != nil {
		ok := object.Key("TargetEngineName")
		ok.String(*v.TargetEngineName)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDescribeCertificatesInput(v *DescribeCertificatesInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.Filters != nil {
		ok := object.Key("Filters")
		if err := awsAwsjson11_serializeDocumentFilterList(v.Filters, ok); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		ok := object.Key("Marker")
		ok.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		ok := object.Key("MaxRecords")
		ok.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDescribeConnectionsInput(v *DescribeConnectionsInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.Filters != nil {
		ok := object.Key("Filters")
		if err := awsAwsjson11_serializeDocumentFilterList(v.Filters, ok); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		ok := object.Key("Marker")
		ok.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		ok := object.Key("MaxRecords")
		ok.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDescribeEndpointSettingsInput(v *DescribeEndpointSettingsInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.EngineName != nil {
		ok := object.Key("EngineName")
		ok.String(*v.EngineName)
	}

	if v.Marker != nil {
		ok := object.Key("Marker")
		ok.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		ok := object.Key("MaxRecords")
		ok.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDescribeEndpointsInput(v *DescribeEndpointsInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.Filters != nil {
		ok := object.Key("Filters")
		if err := awsAwsjson11_serializeDocumentFilterList(v.Filters, ok); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		ok := object.Key("Marker")
		ok.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		ok := object.Key("MaxRecords")
		ok.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDescribeEndpointTypesInput(v *DescribeEndpointTypesInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.Filters != nil {
		ok := object.Key("Filters")
		if err := awsAwsjson11_serializeDocumentFilterList(v.Filters, ok); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		ok := object.Key("Marker")
		ok.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		ok := object.Key("MaxRecords")
		ok.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDescribeEventCategoriesInput(v *DescribeEventCategoriesInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.Filters != nil {
		ok := object.Key("Filters")
		if err := awsAwsjson11_serializeDocumentFilterList(v.Filters, ok); err != nil {
			return err
		}
	}

	if v.SourceType != nil {
		ok := object.Key("SourceType")
		ok.String(*v.SourceType)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDescribeEventsInput(v *DescribeEventsInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.Duration != nil {
		ok := object.Key("Duration")
		ok.Integer(*v.Duration)
	}

	if v.EndTime != nil {
		ok := object.Key("EndTime")
		ok.Double(smithytime.FormatEpochSeconds(*v.EndTime))
	}

	if v.EventCategories != nil {
		ok := object.Key("EventCategories")
		if err := awsAwsjson11_serializeDocumentEventCategoriesList(v.EventCategories, ok); err != nil {
			return err
		}
	}

	if v.Filters != nil {
		ok := object.Key("Filters")
		if err := awsAwsjson11_serializeDocumentFilterList(v.Filters, ok); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		ok := object.Key("Marker")
		ok.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		ok := object.Key("MaxRecords")
		ok.Integer(*v.MaxRecords)
	}

	if v.SourceIdentifier != nil {
		ok := object.Key("SourceIdentifier")
		ok.String(*v.SourceIdentifier)
	}

	if len(v.SourceType) > 0 {
		ok := object.Key("SourceType")
		ok.String(string(v.SourceType))
	}

	if v.StartTime != nil {
		ok := object.Key("StartTime")
		ok.Double(smithytime.FormatEpochSeconds(*v.StartTime))
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDescribeEventSubscriptionsInput(v *DescribeEventSubscriptionsInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.Filters != nil {
		ok := object.Key("Filters")
		if err := awsAwsjson11_serializeDocumentFilterList(v.Filters, ok); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		ok := object.Key("Marker")
		ok.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		ok := object.Key("MaxRecords")
		ok.Integer(*v.MaxRecords)
	}

	if v.SubscriptionName != nil {
		ok := object.Key("SubscriptionName")
		ok.String(*v.SubscriptionName)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDescribeOrderableReplicationInstancesInput(v *DescribeOrderableReplicationInstancesInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.Marker != nil {
		ok := object.Key("Marker")
		ok.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		ok := object.Key("MaxRecords")
		ok.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDescribePendingMaintenanceActionsInput(v *DescribePendingMaintenanceActionsInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.Filters != nil {
		ok := object.Key("Filters")
		if err := awsAwsjson11_serializeDocumentFilterList(v.Filters, ok); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		ok := object.Key("Marker")
		ok.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		ok := object.Key("MaxRecords")
		ok.Integer(*v.MaxRecords)
	}

	if v.ReplicationInstanceArn != nil {
		ok := object.Key("ReplicationInstanceArn")
		ok.String(*v.ReplicationInstanceArn)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDescribeRefreshSchemasStatusInput(v *DescribeRefreshSchemasStatusInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.EndpointArn != nil {
		ok := object.Key("EndpointArn")
		ok.String(*v.EndpointArn)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDescribeReplicationInstancesInput(v *DescribeReplicationInstancesInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.Filters != nil {
		ok := object.Key("Filters")
		if err := awsAwsjson11_serializeDocumentFilterList(v.Filters, ok); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		ok := object.Key("Marker")
		ok.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		ok := object.Key("MaxRecords")
		ok.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDescribeReplicationInstanceTaskLogsInput(v *DescribeReplicationInstanceTaskLogsInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.Marker != nil {
		ok := object.Key("Marker")
		ok.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		ok := object.Key("MaxRecords")
		ok.Integer(*v.MaxRecords)
	}

	if v.ReplicationInstanceArn != nil {
		ok := object.Key("ReplicationInstanceArn")
		ok.String(*v.ReplicationInstanceArn)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDescribeReplicationSubnetGroupsInput(v *DescribeReplicationSubnetGroupsInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.Filters != nil {
		ok := object.Key("Filters")
		if err := awsAwsjson11_serializeDocumentFilterList(v.Filters, ok); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		ok := object.Key("Marker")
		ok.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		ok := object.Key("MaxRecords")
		ok.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDescribeReplicationTaskAssessmentResultsInput(v *DescribeReplicationTaskAssessmentResultsInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.Marker != nil {
		ok := object.Key("Marker")
		ok.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		ok := object.Key("MaxRecords")
		ok.Integer(*v.MaxRecords)
	}

	if v.ReplicationTaskArn != nil {
		ok := object.Key("ReplicationTaskArn")
		ok.String(*v.ReplicationTaskArn)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDescribeReplicationTaskAssessmentRunsInput(v *DescribeReplicationTaskAssessmentRunsInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.Filters != nil {
		ok := object.Key("Filters")
		if err := awsAwsjson11_serializeDocumentFilterList(v.Filters, ok); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		ok := object.Key("Marker")
		ok.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		ok := object.Key("MaxRecords")
		ok.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDescribeReplicationTaskIndividualAssessmentsInput(v *DescribeReplicationTaskIndividualAssessmentsInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.Filters != nil {
		ok := object.Key("Filters")
		if err := awsAwsjson11_serializeDocumentFilterList(v.Filters, ok); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		ok := object.Key("Marker")
		ok.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		ok := object.Key("MaxRecords")
		ok.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDescribeReplicationTasksInput(v *DescribeReplicationTasksInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.Filters != nil {
		ok := object.Key("Filters")
		if err := awsAwsjson11_serializeDocumentFilterList(v.Filters, ok); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		ok := object.Key("Marker")
		ok.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		ok := object.Key("MaxRecords")
		ok.Integer(*v.MaxRecords)
	}

	if v.WithoutSettings != nil {
		ok := object.Key("WithoutSettings")
		ok.Boolean(*v.WithoutSettings)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDescribeSchemasInput(v *DescribeSchemasInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.EndpointArn != nil {
		ok := object.Key("EndpointArn")
		ok.String(*v.EndpointArn)
	}

	if v.Marker != nil {
		ok := object.Key("Marker")
		ok.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		ok := object.Key("MaxRecords")
		ok.Integer(*v.MaxRecords)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentDescribeTableStatisticsInput(v *DescribeTableStatisticsInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.Filters != nil {
		ok := object.Key("Filters")
		if err := awsAwsjson11_serializeDocumentFilterList(v.Filters, ok); err != nil {
			return err
		}
	}

	if v.Marker != nil {
		ok := object.Key("Marker")
		ok.String(*v.Marker)
	}

	if v.MaxRecords != nil {
		ok := object.Key("MaxRecords")
		ok.Integer(*v.MaxRecords)
	}

	if v.ReplicationTaskArn != nil {
		ok := object.Key("ReplicationTaskArn")
		ok.String(*v.ReplicationTaskArn)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentImportCertificateInput(v *ImportCertificateInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.CertificateIdentifier != nil {
		ok := object.Key("CertificateIdentifier")
		ok.String(*v.CertificateIdentifier)
	}

	if v.CertificatePem != nil {
		ok := object.Key("CertificatePem")
		ok.String(*v.CertificatePem)
	}

	if v.CertificateWallet != nil {
		ok := object.Key("CertificateWallet")
		ok.Base64EncodeBytes(v.CertificateWallet)
	}

	if v.Tags != nil {
		ok := object.Key("Tags")
		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentListTagsForResourceInput(v *ListTagsForResourceInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.ResourceArn != nil {
		ok := object.Key("ResourceArn")
		ok.String(*v.ResourceArn)
	}

	if v.ResourceArnList != nil {
		ok := object.Key("ResourceArnList")
		if err := awsAwsjson11_serializeDocumentArnList(v.ResourceArnList, ok); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentModifyEndpointInput(v *ModifyEndpointInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.CertificateArn != nil {
		ok := object.Key("CertificateArn")
		ok.String(*v.CertificateArn)
	}

	if v.DatabaseName != nil {
		ok := object.Key("DatabaseName")
		ok.String(*v.DatabaseName)
	}

	if v.DmsTransferSettings != nil {
		ok := object.Key("DmsTransferSettings")
		if err := awsAwsjson11_serializeDocumentDmsTransferSettings(v.DmsTransferSettings, ok); err != nil {
			return err
		}
	}

	if v.DocDbSettings != nil {
		ok := object.Key("DocDbSettings")
		if err := awsAwsjson11_serializeDocumentDocDbSettings(v.DocDbSettings, ok); err != nil {
			return err
		}
	}

	if v.DynamoDbSettings != nil {
		ok := object.Key("DynamoDbSettings")
		if err := awsAwsjson11_serializeDocumentDynamoDbSettings(v.DynamoDbSettings, ok); err != nil {
			return err
		}
	}

	if v.ElasticsearchSettings != nil {
		ok := object.Key("ElasticsearchSettings")
		if err := awsAwsjson11_serializeDocumentElasticsearchSettings(v.ElasticsearchSettings, ok); err != nil {
			return err
		}
	}

	if v.EndpointArn != nil {
		ok := object.Key("EndpointArn")
		ok.String(*v.EndpointArn)
	}

	if v.EndpointIdentifier != nil {
		ok := object.Key("EndpointIdentifier")
		ok.String(*v.EndpointIdentifier)
	}

	if len(v.EndpointType) > 0 {
		ok := object.Key("EndpointType")
		ok.String(string(v.EndpointType))
	}

	if v.EngineName != nil {
		ok := object.Key("EngineName")
		ok.String(*v.EngineName)
	}

	if v.ExactSettings != nil {
		ok := object.Key("ExactSettings")
		ok.Boolean(*v.ExactSettings)
	}

	if v.ExternalTableDefinition != nil {
		ok := object.Key("ExternalTableDefinition")
		ok.String(*v.ExternalTableDefinition)
	}

	if v.ExtraConnectionAttributes != nil {
		ok := object.Key("ExtraConnectionAttributes")
		ok.String(*v.ExtraConnectionAttributes)
	}

	if v.IBMDb2Settings != nil {
		ok := object.Key("IBMDb2Settings")
		if err := awsAwsjson11_serializeDocumentIBMDb2Settings(v.IBMDb2Settings, ok); err != nil {
			return err
		}
	}

	if v.KafkaSettings != nil {
		ok := object.Key("KafkaSettings")
		if err := awsAwsjson11_serializeDocumentKafkaSettings(v.KafkaSettings, ok); err != nil {
			return err
		}
	}

	if v.KinesisSettings != nil {
		ok := object.Key("KinesisSettings")
		if err := awsAwsjson11_serializeDocumentKinesisSettings(v.KinesisSettings, ok); err != nil {
			return err
		}
	}

	if v.MicrosoftSQLServerSettings != nil {
		ok := object.Key("MicrosoftSQLServerSettings")
		if err := awsAwsjson11_serializeDocumentMicrosoftSQLServerSettings(v.MicrosoftSQLServerSettings, ok); err != nil {
			return err
		}
	}

	if v.MongoDbSettings != nil {
		ok := object.Key("MongoDbSettings")
		if err := awsAwsjson11_serializeDocumentMongoDbSettings(v.MongoDbSettings, ok); err != nil {
			return err
		}
	}

	if v.MySQLSettings != nil {
		ok := object.Key("MySQLSettings")
		if err := awsAwsjson11_serializeDocumentMySQLSettings(v.MySQLSettings, ok); err != nil {
			return err
		}
	}

	if v.NeptuneSettings != nil {
		ok := object.Key("NeptuneSettings")
		if err := awsAwsjson11_serializeDocumentNeptuneSettings(v.NeptuneSettings, ok); err != nil {
			return err
		}
	}

	if v.OracleSettings != nil {
		ok := object.Key("OracleSettings")
		if err := awsAwsjson11_serializeDocumentOracleSettings(v.OracleSettings, ok); err != nil {
			return err
		}
	}

	if v.Password != nil {
		ok := object.Key("Password")
		ok.String(*v.Password)
	}

	if v.Port != nil {
		ok := object.Key("Port")
		ok.Integer(*v.Port)
	}

	if v.PostgreSQLSettings != nil {
		ok := object.Key("PostgreSQLSettings")
		if err := awsAwsjson11_serializeDocumentPostgreSQLSettings(v.PostgreSQLSettings, ok); err != nil {
			return err
		}
	}

	if v.RedisSettings != nil {
		ok := object.Key("RedisSettings")
		if err := awsAwsjson11_serializeDocumentRedisSettings(v.RedisSettings, ok); err != nil {
			return err
		}
	}

	if v.RedshiftSettings != nil {
		ok := object.Key("RedshiftSettings")
		if err := awsAwsjson11_serializeDocumentRedshiftSettings(v.RedshiftSettings, ok); err != nil {
			return err
		}
	}

	if v.S3Settings != nil {
		ok := object.Key("S3Settings")
		if err := awsAwsjson11_serializeDocumentS3Settings(v.S3Settings, ok); err != nil {
			return err
		}
	}

	if v.ServerName != nil {
		ok := object.Key("ServerName")
		ok.String(*v.ServerName)
	}

	if v.ServiceAccessRoleArn != nil {
		ok := object.Key("ServiceAccessRoleArn")
		ok.String(*v.ServiceAccessRoleArn)
	}

	if len(v.SslMode) > 0 {
		ok := object.Key("SslMode")
		ok.String(string(v.SslMode))
	}

	if v.SybaseSettings != nil {
		ok := object.Key("SybaseSettings")
		if err := awsAwsjson11_serializeDocumentSybaseSettings(v.SybaseSettings, ok); err != nil {
			return err
		}
	}

	if v.Username != nil {
		ok := object.Key("Username")
		ok.String(*v.Username)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentModifyEventSubscriptionInput(v *ModifyEventSubscriptionInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.Enabled != nil {
		ok := object.Key("Enabled")
		ok.Boolean(*v.Enabled)
	}

	if v.EventCategories != nil {
		ok := object.Key("EventCategories")
		if err := awsAwsjson11_serializeDocumentEventCategoriesList(v.EventCategories, ok); err != nil {
			return err
		}
	}

	if v.SnsTopicArn != nil {
		ok := object.Key("SnsTopicArn")
		ok.String(*v.SnsTopicArn)
	}

	if v.SourceType != nil {
		ok := object.Key("SourceType")
		ok.String(*v.SourceType)
	}

	if v.SubscriptionName != nil {
		ok := object.Key("SubscriptionName")
		ok.String(*v.SubscriptionName)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentModifyReplicationInstanceInput(v *ModifyReplicationInstanceInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.AllocatedStorage != nil {
		ok := object.Key("AllocatedStorage")
		ok.Integer(*v.AllocatedStorage)
	}

	if v.AllowMajorVersionUpgrade {
		ok := object.Key("AllowMajorVersionUpgrade")
		ok.Boolean(v.AllowMajorVersionUpgrade)
	}

	if v.ApplyImmediately {
		ok := object.Key("ApplyImmediately")
		ok.Boolean(v.ApplyImmediately)
	}

	if v.AutoMinorVersionUpgrade != nil {
		ok := object.Key("AutoMinorVersionUpgrade")
		ok.Boolean(*v.AutoMinorVersionUpgrade)
	}

	if v.EngineVersion != nil {
		ok := object.Key("EngineVersion")
		ok.String(*v.EngineVersion)
	}

	if v.MultiAZ != nil {
		ok := object.Key("MultiAZ")
		ok.Boolean(*v.MultiAZ)
	}

	if v.PreferredMaintenanceWindow != nil {
		ok := object.Key("PreferredMaintenanceWindow")
		ok.String(*v.PreferredMaintenanceWindow)
	}

	if v.ReplicationInstanceArn != nil {
		ok := object.Key("ReplicationInstanceArn")
		ok.String(*v.ReplicationInstanceArn)
	}

	if v.ReplicationInstanceClass != nil {
		ok := object.Key("ReplicationInstanceClass")
		ok.String(*v.ReplicationInstanceClass)
	}

	if v.ReplicationInstanceIdentifier != nil {
		ok := object.Key("ReplicationInstanceIdentifier")
		ok.String(*v.ReplicationInstanceIdentifier)
	}

	if v.VpcSecurityGroupIds != nil {
		ok := object.Key("VpcSecurityGroupIds")
		if err := awsAwsjson11_serializeDocumentVpcSecurityGroupIdList(v.VpcSecurityGroupIds, ok); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentModifyReplicationSubnetGroupInput(v *ModifyReplicationSubnetGroupInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.ReplicationSubnetGroupDescription != nil {
		ok := object.Key("ReplicationSubnetGroupDescription")
		ok.String(*v.ReplicationSubnetGroupDescription)
	}

	if v.ReplicationSubnetGroupIdentifier != nil {
		ok := object.Key("ReplicationSubnetGroupIdentifier")
		ok.String(*v.ReplicationSubnetGroupIdentifier)
	}

	if v.SubnetIds != nil {
		ok := object.Key("SubnetIds")
		if err := awsAwsjson11_serializeDocumentSubnetIdentifierList(v.SubnetIds, ok); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentModifyReplicationTaskInput(v *ModifyReplicationTaskInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.CdcStartPosition != nil {
		ok := object.Key("CdcStartPosition")
		ok.String(*v.CdcStartPosition)
	}

	if v.CdcStartTime != nil {
		ok := object.Key("CdcStartTime")
		ok.Double(smithytime.FormatEpochSeconds(*v.CdcStartTime))
	}

	if v.CdcStopPosition != nil {
		ok := object.Key("CdcStopPosition")
		ok.String(*v.CdcStopPosition)
	}

	if len(v.MigrationType) > 0 {
		ok := object.Key("MigrationType")
		ok.String(string(v.MigrationType))
	}

	if v.ReplicationTaskArn != nil {
		ok := object.Key("ReplicationTaskArn")
		ok.String(*v.ReplicationTaskArn)
	}

	if v.ReplicationTaskIdentifier != nil {
		ok := object.Key("ReplicationTaskIdentifier")
		ok.String(*v.ReplicationTaskIdentifier)
	}

	if v.ReplicationTaskSettings != nil {
		ok := object.Key("ReplicationTaskSettings")
		ok.String(*v.ReplicationTaskSettings)
	}

	if v.TableMappings != nil {
		ok := object.Key("TableMappings")
		ok.String(*v.TableMappings)
	}

	if v.TaskData != nil {
		ok := object.Key("TaskData")
		ok.String(*v.TaskData)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentMoveReplicationTaskInput(v *MoveReplicationTaskInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.ReplicationTaskArn != nil {
		ok := object.Key("ReplicationTaskArn")
		ok.String(*v.ReplicationTaskArn)
	}

	if v.TargetReplicationInstanceArn != nil {
		ok := object.Key("TargetReplicationInstanceArn")
		ok.String(*v.TargetReplicationInstanceArn)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentRebootReplicationInstanceInput(v *RebootReplicationInstanceInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.ForceFailover != nil {
		ok := object.Key("ForceFailover")
		ok.Boolean(*v.ForceFailover)
	}

	if v.ForcePlannedFailover != nil {
		ok := object.Key("ForcePlannedFailover")
		ok.Boolean(*v.ForcePlannedFailover)
	}

	if v.ReplicationInstanceArn != nil {
		ok := object.Key("ReplicationInstanceArn")
		ok.String(*v.ReplicationInstanceArn)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentRefreshSchemasInput(v *RefreshSchemasInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.EndpointArn != nil {
		ok := object.Key("EndpointArn")
		ok.String(*v.EndpointArn)
	}

	if v.ReplicationInstanceArn != nil {
		ok := object.Key("ReplicationInstanceArn")
		ok.String(*v.ReplicationInstanceArn)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentReloadTablesInput(v *ReloadTablesInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if len(v.ReloadOption) > 0 {
		ok := object.Key("ReloadOption")
		ok.String(string(v.ReloadOption))
	}

	if v.ReplicationTaskArn != nil {
		ok := object.Key("ReplicationTaskArn")
		ok.String(*v.ReplicationTaskArn)
	}

	if v.TablesToReload != nil {
		ok := object.Key("TablesToReload")
		if err := awsAwsjson11_serializeDocumentTableListToReload(v.TablesToReload, ok); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentRemoveTagsFromResourceInput(v *RemoveTagsFromResourceInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.ResourceArn != nil {
		ok := object.Key("ResourceArn")
		ok.String(*v.ResourceArn)
	}

	if v.TagKeys != nil {
		ok := object.Key("TagKeys")
		if err := awsAwsjson11_serializeDocumentKeyList(v.TagKeys, ok); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentStartReplicationTaskAssessmentInput(v *StartReplicationTaskAssessmentInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.ReplicationTaskArn != nil {
		ok := object.Key("ReplicationTaskArn")
		ok.String(*v.ReplicationTaskArn)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentStartReplicationTaskAssessmentRunInput(v *StartReplicationTaskAssessmentRunInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.AssessmentRunName != nil {
		ok := object.Key("AssessmentRunName")
		ok.String(*v.AssessmentRunName)
	}

	if v.Exclude != nil {
		ok := object.Key("Exclude")
		if err := awsAwsjson11_serializeDocumentExcludeTestList(v.Exclude, ok); err != nil {
			return err
		}
	}

	if v.IncludeOnly != nil {
		ok := object.Key("IncludeOnly")
		if err := awsAwsjson11_serializeDocumentIncludeTestList(v.IncludeOnly, ok); err != nil {
			return err
		}
	}

	if v.ReplicationTaskArn != nil {
		ok := object.Key("ReplicationTaskArn")
		ok.String(*v.ReplicationTaskArn)
	}

	if v.ResultEncryptionMode != nil {
		ok := object.Key("ResultEncryptionMode")
		ok.String(*v.ResultEncryptionMode)
	}

	if v.ResultKmsKeyArn != nil {
		ok := object.Key("ResultKmsKeyArn")
		ok.String(*v.ResultKmsKeyArn)
	}

	if v.ResultLocationBucket != nil {
		ok := object.Key("ResultLocationBucket")
		ok.String(*v.ResultLocationBucket)
	}

	if v.ResultLocationFolder != nil {
		ok := object.Key("ResultLocationFolder")
		ok.String(*v.ResultLocationFolder)
	}

	if v.ServiceAccessRoleArn != nil {
		ok := object.Key("ServiceAccessRoleArn")
		ok.String(*v.ServiceAccessRoleArn)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentStartReplicationTaskInput(v *StartReplicationTaskInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.CdcStartPosition != nil {
		ok := object.Key("CdcStartPosition")
		ok.String(*v.CdcStartPosition)
	}

	if v.CdcStartTime != nil {
		ok := object.Key("CdcStartTime")
		ok.Double(smithytime.FormatEpochSeconds(*v.CdcStartTime))
	}

	if v.CdcStopPosition != nil {
		ok := object.Key("CdcStopPosition")
		ok.String(*v.CdcStopPosition)
	}

	if v.ReplicationTaskArn != nil {
		ok := object.Key("ReplicationTaskArn")
		ok.String(*v.ReplicationTaskArn)
	}

	if len(v.StartReplicationTaskType) > 0 {
		ok := object.Key("StartReplicationTaskType")
		ok.String(string(v.StartReplicationTaskType))
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentStopReplicationTaskInput(v *StopReplicationTaskInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.ReplicationTaskArn != nil {
		ok := object.Key("ReplicationTaskArn")
		ok.String(*v.ReplicationTaskArn)
	}

	return nil
}

func awsAwsjson11_serializeOpDocumentTestConnectionInput(v *TestConnectionInput, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	if v.EndpointArn != nil {
		ok := object.Key("EndpointArn")
		ok.String(*v.EndpointArn)
	}

	if v.ReplicationInstanceArn != nil {
		ok := object.Key("ReplicationInstanceArn")
		ok.String(*v.ReplicationInstanceArn)
	}

	return nil
}