serializers.go

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

package elasticbeanstalk

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

type awsAwsquery_serializeOpAbortEnvironmentUpdate struct {
}

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

func (m *awsAwsquery_serializeOpAbortEnvironmentUpdate) 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.(*AbortEnvironmentUpdateInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("AbortEnvironmentUpdate")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpApplyEnvironmentManagedAction struct {
}

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

func (m *awsAwsquery_serializeOpApplyEnvironmentManagedAction) 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.(*ApplyEnvironmentManagedActionInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ApplyEnvironmentManagedAction")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpAssociateEnvironmentOperationsRole struct {
}

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

func (m *awsAwsquery_serializeOpAssociateEnvironmentOperationsRole) 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.(*AssociateEnvironmentOperationsRoleInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("AssociateEnvironmentOperationsRole")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpCheckDNSAvailability struct {
}

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

func (m *awsAwsquery_serializeOpCheckDNSAvailability) 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.(*CheckDNSAvailabilityInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CheckDNSAvailability")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpComposeEnvironments struct {
}

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

func (m *awsAwsquery_serializeOpComposeEnvironments) 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.(*ComposeEnvironmentsInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ComposeEnvironments")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpCreateApplication struct {
}

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

func (m *awsAwsquery_serializeOpCreateApplication) 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.(*CreateApplicationInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CreateApplication")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpCreateApplicationVersion struct {
}

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

func (m *awsAwsquery_serializeOpCreateApplicationVersion) 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.(*CreateApplicationVersionInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CreateApplicationVersion")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpCreateConfigurationTemplate struct {
}

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

func (m *awsAwsquery_serializeOpCreateConfigurationTemplate) 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.(*CreateConfigurationTemplateInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CreateConfigurationTemplate")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpCreateEnvironment struct {
}

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

func (m *awsAwsquery_serializeOpCreateEnvironment) 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.(*CreateEnvironmentInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CreateEnvironment")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpCreatePlatformVersion struct {
}

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

func (m *awsAwsquery_serializeOpCreatePlatformVersion) 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.(*CreatePlatformVersionInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CreatePlatformVersion")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpCreateStorageLocation struct {
}

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

func (m *awsAwsquery_serializeOpCreateStorageLocation) 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.(*CreateStorageLocationInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("CreateStorageLocation")
	body.Key("Version").String("2010-12-01")

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpDeleteApplication struct {
}

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

func (m *awsAwsquery_serializeOpDeleteApplication) 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.(*DeleteApplicationInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeleteApplication")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpDeleteApplicationVersion struct {
}

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

func (m *awsAwsquery_serializeOpDeleteApplicationVersion) 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.(*DeleteApplicationVersionInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeleteApplicationVersion")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpDeleteConfigurationTemplate struct {
}

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

func (m *awsAwsquery_serializeOpDeleteConfigurationTemplate) 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.(*DeleteConfigurationTemplateInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeleteConfigurationTemplate")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpDeleteEnvironmentConfiguration struct {
}

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

func (m *awsAwsquery_serializeOpDeleteEnvironmentConfiguration) 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.(*DeleteEnvironmentConfigurationInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeleteEnvironmentConfiguration")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpDeletePlatformVersion struct {
}

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

func (m *awsAwsquery_serializeOpDeletePlatformVersion) 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.(*DeletePlatformVersionInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DeletePlatformVersion")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpDescribeAccountAttributes struct {
}

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

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

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

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeAccountAttributes")
	body.Key("Version").String("2010-12-01")

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpDescribeApplications struct {
}

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

func (m *awsAwsquery_serializeOpDescribeApplications) 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.(*DescribeApplicationsInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeApplications")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpDescribeApplicationVersions struct {
}

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

func (m *awsAwsquery_serializeOpDescribeApplicationVersions) 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.(*DescribeApplicationVersionsInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeApplicationVersions")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpDescribeConfigurationOptions struct {
}

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

func (m *awsAwsquery_serializeOpDescribeConfigurationOptions) 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.(*DescribeConfigurationOptionsInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeConfigurationOptions")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpDescribeConfigurationSettings struct {
}

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

func (m *awsAwsquery_serializeOpDescribeConfigurationSettings) 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.(*DescribeConfigurationSettingsInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeConfigurationSettings")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpDescribeEnvironmentHealth struct {
}

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

func (m *awsAwsquery_serializeOpDescribeEnvironmentHealth) 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.(*DescribeEnvironmentHealthInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeEnvironmentHealth")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpDescribeEnvironmentManagedActionHistory struct {
}

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

func (m *awsAwsquery_serializeOpDescribeEnvironmentManagedActionHistory) 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.(*DescribeEnvironmentManagedActionHistoryInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeEnvironmentManagedActionHistory")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpDescribeEnvironmentManagedActions struct {
}

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

func (m *awsAwsquery_serializeOpDescribeEnvironmentManagedActions) 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.(*DescribeEnvironmentManagedActionsInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeEnvironmentManagedActions")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpDescribeEnvironmentResources struct {
}

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

func (m *awsAwsquery_serializeOpDescribeEnvironmentResources) 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.(*DescribeEnvironmentResourcesInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeEnvironmentResources")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpDescribeEnvironments struct {
}

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

func (m *awsAwsquery_serializeOpDescribeEnvironments) 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.(*DescribeEnvironmentsInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeEnvironments")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpDescribeEvents struct {
}

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

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

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

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeEvents")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpDescribeInstancesHealth struct {
}

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

func (m *awsAwsquery_serializeOpDescribeInstancesHealth) 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.(*DescribeInstancesHealthInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribeInstancesHealth")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpDescribePlatformVersion struct {
}

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

func (m *awsAwsquery_serializeOpDescribePlatformVersion) 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.(*DescribePlatformVersionInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DescribePlatformVersion")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpDisassociateEnvironmentOperationsRole struct {
}

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

func (m *awsAwsquery_serializeOpDisassociateEnvironmentOperationsRole) 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.(*DisassociateEnvironmentOperationsRoleInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("DisassociateEnvironmentOperationsRole")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpListAvailableSolutionStacks struct {
}

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

func (m *awsAwsquery_serializeOpListAvailableSolutionStacks) 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.(*ListAvailableSolutionStacksInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ListAvailableSolutionStacks")
	body.Key("Version").String("2010-12-01")

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpListPlatformBranches struct {
}

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

func (m *awsAwsquery_serializeOpListPlatformBranches) 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.(*ListPlatformBranchesInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ListPlatformBranches")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpListPlatformVersions struct {
}

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

func (m *awsAwsquery_serializeOpListPlatformVersions) 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.(*ListPlatformVersionsInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ListPlatformVersions")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpListTagsForResource struct {
}

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

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

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

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ListTagsForResource")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpRebuildEnvironment struct {
}

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

func (m *awsAwsquery_serializeOpRebuildEnvironment) 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.(*RebuildEnvironmentInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("RebuildEnvironment")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpRequestEnvironmentInfo struct {
}

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

func (m *awsAwsquery_serializeOpRequestEnvironmentInfo) 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.(*RequestEnvironmentInfoInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("RequestEnvironmentInfo")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpRestartAppServer struct {
}

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

func (m *awsAwsquery_serializeOpRestartAppServer) 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.(*RestartAppServerInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("RestartAppServer")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpRetrieveEnvironmentInfo struct {
}

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

func (m *awsAwsquery_serializeOpRetrieveEnvironmentInfo) 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.(*RetrieveEnvironmentInfoInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("RetrieveEnvironmentInfo")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpSwapEnvironmentCNAMEs struct {
}

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

func (m *awsAwsquery_serializeOpSwapEnvironmentCNAMEs) 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.(*SwapEnvironmentCNAMEsInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("SwapEnvironmentCNAMEs")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpTerminateEnvironment struct {
}

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

func (m *awsAwsquery_serializeOpTerminateEnvironment) 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.(*TerminateEnvironmentInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("TerminateEnvironment")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpUpdateApplication struct {
}

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

func (m *awsAwsquery_serializeOpUpdateApplication) 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.(*UpdateApplicationInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("UpdateApplication")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpUpdateApplicationResourceLifecycle struct {
}

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

func (m *awsAwsquery_serializeOpUpdateApplicationResourceLifecycle) 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.(*UpdateApplicationResourceLifecycleInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("UpdateApplicationResourceLifecycle")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpUpdateApplicationVersion struct {
}

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

func (m *awsAwsquery_serializeOpUpdateApplicationVersion) 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.(*UpdateApplicationVersionInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("UpdateApplicationVersion")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpUpdateConfigurationTemplate struct {
}

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

func (m *awsAwsquery_serializeOpUpdateConfigurationTemplate) 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.(*UpdateConfigurationTemplateInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("UpdateConfigurationTemplate")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpUpdateEnvironment struct {
}

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

func (m *awsAwsquery_serializeOpUpdateEnvironment) 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.(*UpdateEnvironmentInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("UpdateEnvironment")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpUpdateTagsForResource struct {
}

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

func (m *awsAwsquery_serializeOpUpdateTagsForResource) 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.(*UpdateTagsForResourceInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("UpdateTagsForResource")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsquery_serializeOpValidateConfigurationSettings struct {
}

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

func (m *awsAwsquery_serializeOpValidateConfigurationSettings) 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.(*ValidateConfigurationSettingsInput)
	_ = input
	if !ok {
		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
	}

	operationPath := "/"
	if len(request.Request.URL.Path) == 0 {
		request.Request.URL.Path = operationPath
	} else {
		request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
		if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
			request.Request.URL.Path += "/"
		}
	}
	request.Request.Method = "POST"
	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
	if err != nil {
		return out, metadata, &smithy.SerializationError{Err: err}
	}
	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")

	bodyWriter := bytes.NewBuffer(nil)
	bodyEncoder := query.NewEncoder(bodyWriter)
	body := bodyEncoder.Object()
	body.Key("Action").String("ValidateConfigurationSettings")
	body.Key("Version").String("2010-12-01")

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

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

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

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

	return next.HandleSerialize(ctx, in)
}
func awsAwsquery_serializeDocumentApplicationNamesList(v []string, value query.Value) error {
	array := value.Array("member")

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

func awsAwsquery_serializeDocumentApplicationResourceLifecycleConfig(v *types.ApplicationResourceLifecycleConfig, value query.Value) error {
	object := value.Object()
	_ = object

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

	if v.VersionLifecycleConfig != nil {
		objectKey := object.Key("VersionLifecycleConfig")
		if err := awsAwsquery_serializeDocumentApplicationVersionLifecycleConfig(v.VersionLifecycleConfig, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeDocumentApplicationVersionLifecycleConfig(v *types.ApplicationVersionLifecycleConfig, value query.Value) error {
	object := value.Object()
	_ = object

	if v.MaxAgeRule != nil {
		objectKey := object.Key("MaxAgeRule")
		if err := awsAwsquery_serializeDocumentMaxAgeRule(v.MaxAgeRule, objectKey); err != nil {
			return err
		}
	}

	if v.MaxCountRule != nil {
		objectKey := object.Key("MaxCountRule")
		if err := awsAwsquery_serializeDocumentMaxCountRule(v.MaxCountRule, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeDocumentBuildConfiguration(v *types.BuildConfiguration, value query.Value) error {
	object := value.Object()
	_ = object

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

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

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

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

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

	return nil
}

func awsAwsquery_serializeDocumentConfigurationOptionSetting(v *types.ConfigurationOptionSetting, value query.Value) error {
	object := value.Object()
	_ = object

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

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

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

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

	return nil
}

func awsAwsquery_serializeDocumentConfigurationOptionSettingsList(v []types.ConfigurationOptionSetting, value query.Value) error {
	array := value.Array("member")

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

func awsAwsquery_serializeDocumentEnvironmentHealthAttributes(v []types.EnvironmentHealthAttribute, value query.Value) error {
	array := value.Array("member")

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

func awsAwsquery_serializeDocumentEnvironmentIdList(v []string, value query.Value) error {
	array := value.Array("member")

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

func awsAwsquery_serializeDocumentEnvironmentNamesList(v []string, value query.Value) error {
	array := value.Array("member")

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

func awsAwsquery_serializeDocumentEnvironmentTier(v *types.EnvironmentTier, value query.Value) error {
	object := value.Object()
	_ = object

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

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

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

	return nil
}

func awsAwsquery_serializeDocumentInstancesHealthAttributes(v []types.InstancesHealthAttribute, value query.Value) error {
	array := value.Array("member")

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

func awsAwsquery_serializeDocumentMaxAgeRule(v *types.MaxAgeRule, value query.Value) error {
	object := value.Object()
	_ = object

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

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

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

	return nil
}

func awsAwsquery_serializeDocumentMaxCountRule(v *types.MaxCountRule, value query.Value) error {
	object := value.Object()
	_ = object

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

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

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

	return nil
}

func awsAwsquery_serializeDocumentOptionSpecification(v *types.OptionSpecification, value query.Value) error {
	object := value.Object()
	_ = object

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

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

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

	return nil
}

func awsAwsquery_serializeDocumentOptionsSpecifierList(v []types.OptionSpecification, value query.Value) error {
	array := value.Array("member")

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

func awsAwsquery_serializeDocumentPlatformFilter(v *types.PlatformFilter, value query.Value) error {
	object := value.Object()
	_ = object

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

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

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

	return nil
}

func awsAwsquery_serializeDocumentPlatformFilters(v []types.PlatformFilter, value query.Value) error {
	array := value.Array("member")

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

func awsAwsquery_serializeDocumentPlatformFilterValueList(v []string, value query.Value) error {
	array := value.Array("member")

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

func awsAwsquery_serializeDocumentS3Location(v *types.S3Location, value query.Value) error {
	object := value.Object()
	_ = object

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

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

	return nil
}

func awsAwsquery_serializeDocumentSearchFilter(v *types.SearchFilter, value query.Value) error {
	object := value.Object()
	_ = object

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

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

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

	return nil
}

func awsAwsquery_serializeDocumentSearchFilters(v []types.SearchFilter, value query.Value) error {
	array := value.Array("member")

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

func awsAwsquery_serializeDocumentSearchFilterValues(v []string, value query.Value) error {
	array := value.Array("member")

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

func awsAwsquery_serializeDocumentSourceBuildInformation(v *types.SourceBuildInformation, value query.Value) error {
	object := value.Object()
	_ = object

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

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

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

	return nil
}

func awsAwsquery_serializeDocumentSourceConfiguration(v *types.SourceConfiguration, value query.Value) error {
	object := value.Object()
	_ = object

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

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

	return nil
}

func awsAwsquery_serializeDocumentTag(v *types.Tag, value query.Value) error {
	object := value.Object()
	_ = object

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

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

	return nil
}

func awsAwsquery_serializeDocumentTagKeyList(v []string, value query.Value) error {
	array := value.Array("member")

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

func awsAwsquery_serializeDocumentTagList(v []types.Tag, value query.Value) error {
	array := value.Array("member")

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

func awsAwsquery_serializeDocumentTags(v []types.Tag, value query.Value) error {
	array := value.Array("member")

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

func awsAwsquery_serializeDocumentVersionLabels(v []string, value query.Value) error {
	array := value.Array("member")

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

func awsAwsquery_serializeDocumentVersionLabelsList(v []string, value query.Value) error {
	array := value.Array("member")

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

func awsAwsquery_serializeOpDocumentAbortEnvironmentUpdateInput(v *AbortEnvironmentUpdateInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentApplyEnvironmentManagedActionInput(v *ApplyEnvironmentManagedActionInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentAssociateEnvironmentOperationsRoleInput(v *AssociateEnvironmentOperationsRoleInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentCheckDNSAvailabilityInput(v *CheckDNSAvailabilityInput, value query.Value) error {
	object := value.Object()
	_ = object

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

	return nil
}

func awsAwsquery_serializeOpDocumentComposeEnvironmentsInput(v *ComposeEnvironmentsInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

	if v.VersionLabels != nil {
		objectKey := object.Key("VersionLabels")
		if err := awsAwsquery_serializeDocumentVersionLabels(v.VersionLabels, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentCreateApplicationInput(v *CreateApplicationInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

	if v.ResourceLifecycleConfig != nil {
		objectKey := object.Key("ResourceLifecycleConfig")
		if err := awsAwsquery_serializeDocumentApplicationResourceLifecycleConfig(v.ResourceLifecycleConfig, objectKey); err != nil {
			return err
		}
	}

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

	return nil
}

func awsAwsquery_serializeOpDocumentCreateApplicationVersionInput(v *CreateApplicationVersionInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

	if v.BuildConfiguration != nil {
		objectKey := object.Key("BuildConfiguration")
		if err := awsAwsquery_serializeDocumentBuildConfiguration(v.BuildConfiguration, objectKey); err != nil {
			return err
		}
	}

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

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

	if v.SourceBuildInformation != nil {
		objectKey := object.Key("SourceBuildInformation")
		if err := awsAwsquery_serializeDocumentSourceBuildInformation(v.SourceBuildInformation, objectKey); err != nil {
			return err
		}
	}

	if v.SourceBundle != nil {
		objectKey := object.Key("SourceBundle")
		if err := awsAwsquery_serializeDocumentS3Location(v.SourceBundle, objectKey); err != nil {
			return err
		}
	}

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentCreateConfigurationTemplateInput(v *CreateConfigurationTemplateInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

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

	if v.OptionSettings != nil {
		objectKey := object.Key("OptionSettings")
		if err := awsAwsquery_serializeDocumentConfigurationOptionSettingsList(v.OptionSettings, objectKey); err != nil {
			return err
		}
	}

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

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

	if v.SourceConfiguration != nil {
		objectKey := object.Key("SourceConfiguration")
		if err := awsAwsquery_serializeDocumentSourceConfiguration(v.SourceConfiguration, objectKey); err != nil {
			return err
		}
	}

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentCreateEnvironmentInput(v *CreateEnvironmentInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

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

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

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

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

	if v.OptionSettings != nil {
		objectKey := object.Key("OptionSettings")
		if err := awsAwsquery_serializeDocumentConfigurationOptionSettingsList(v.OptionSettings, objectKey); err != nil {
			return err
		}
	}

	if v.OptionsToRemove != nil {
		objectKey := object.Key("OptionsToRemove")
		if err := awsAwsquery_serializeDocumentOptionsSpecifierList(v.OptionsToRemove, objectKey); err != nil {
			return err
		}
	}

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

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

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

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

	if v.Tier != nil {
		objectKey := object.Key("Tier")
		if err := awsAwsquery_serializeDocumentEnvironmentTier(v.Tier, objectKey); err != nil {
			return err
		}
	}

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

	return nil
}

func awsAwsquery_serializeOpDocumentCreatePlatformVersionInput(v *CreatePlatformVersionInput, value query.Value) error {
	object := value.Object()
	_ = object

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

	if v.OptionSettings != nil {
		objectKey := object.Key("OptionSettings")
		if err := awsAwsquery_serializeDocumentConfigurationOptionSettingsList(v.OptionSettings, objectKey); err != nil {
			return err
		}
	}

	if v.PlatformDefinitionBundle != nil {
		objectKey := object.Key("PlatformDefinitionBundle")
		if err := awsAwsquery_serializeDocumentS3Location(v.PlatformDefinitionBundle, objectKey); err != nil {
			return err
		}
	}

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

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentDeleteApplicationInput(v *DeleteApplicationInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentDeleteApplicationVersionInput(v *DeleteApplicationVersionInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentDeleteConfigurationTemplateInput(v *DeleteConfigurationTemplateInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentDeleteEnvironmentConfigurationInput(v *DeleteEnvironmentConfigurationInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentDeletePlatformVersionInput(v *DeletePlatformVersionInput, value query.Value) error {
	object := value.Object()
	_ = object

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

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeApplicationsInput(v *DescribeApplicationsInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.ApplicationNames != nil {
		objectKey := object.Key("ApplicationNames")
		if err := awsAwsquery_serializeDocumentApplicationNamesList(v.ApplicationNames, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeApplicationVersionsInput(v *DescribeApplicationVersionsInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

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

	if v.VersionLabels != nil {
		objectKey := object.Key("VersionLabels")
		if err := awsAwsquery_serializeDocumentVersionLabelsList(v.VersionLabels, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeConfigurationOptionsInput(v *DescribeConfigurationOptionsInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

	if v.Options != nil {
		objectKey := object.Key("Options")
		if err := awsAwsquery_serializeDocumentOptionsSpecifierList(v.Options, objectKey); err != nil {
			return err
		}
	}

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

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeConfigurationSettingsInput(v *DescribeConfigurationSettingsInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeEnvironmentHealthInput(v *DescribeEnvironmentHealthInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.AttributeNames != nil {
		objectKey := object.Key("AttributeNames")
		if err := awsAwsquery_serializeDocumentEnvironmentHealthAttributes(v.AttributeNames, objectKey); err != nil {
			return err
		}
	}

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeEnvironmentManagedActionHistoryInput(v *DescribeEnvironmentManagedActionHistoryInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeEnvironmentManagedActionsInput(v *DescribeEnvironmentManagedActionsInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeEnvironmentResourcesInput(v *DescribeEnvironmentResourcesInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeEnvironmentsInput(v *DescribeEnvironmentsInput, value query.Value) error {
	object := value.Object()
	_ = object

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

	if v.EnvironmentIds != nil {
		objectKey := object.Key("EnvironmentIds")
		if err := awsAwsquery_serializeDocumentEnvironmentIdList(v.EnvironmentIds, objectKey); err != nil {
			return err
		}
	}

	if v.EnvironmentNames != nil {
		objectKey := object.Key("EnvironmentNames")
		if err := awsAwsquery_serializeDocumentEnvironmentNamesList(v.EnvironmentNames, objectKey); err != nil {
			return err
		}
	}

	if v.IncludedDeletedBackTo != nil {
		objectKey := object.Key("IncludedDeletedBackTo")
		objectKey.String(smithytime.FormatDateTime(*v.IncludedDeletedBackTo))
	}

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

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

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeEventsInput(v *DescribeEventsInput, value query.Value) error {
	object := value.Object()
	_ = object

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

	if v.EndTime != nil {
		objectKey := object.Key("EndTime")
		objectKey.String(smithytime.FormatDateTime(*v.EndTime))
	}

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

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

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

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

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

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

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

	if v.StartTime != nil {
		objectKey := object.Key("StartTime")
		objectKey.String(smithytime.FormatDateTime(*v.StartTime))
	}

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentDescribeInstancesHealthInput(v *DescribeInstancesHealthInput, value query.Value) error {
	object := value.Object()
	_ = object

	if v.AttributeNames != nil {
		objectKey := object.Key("AttributeNames")
		if err := awsAwsquery_serializeDocumentInstancesHealthAttributes(v.AttributeNames, objectKey); err != nil {
			return err
		}
	}

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

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentDescribePlatformVersionInput(v *DescribePlatformVersionInput, value query.Value) error {
	object := value.Object()
	_ = object

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

	return nil
}

func awsAwsquery_serializeOpDocumentDisassociateEnvironmentOperationsRoleInput(v *DisassociateEnvironmentOperationsRoleInput, value query.Value) error {
	object := value.Object()
	_ = object

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

	return nil
}

func awsAwsquery_serializeOpDocumentListPlatformBranchesInput(v *ListPlatformBranchesInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentListPlatformVersionsInput(v *ListPlatformVersionsInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentListTagsForResourceInput(v *ListTagsForResourceInput, value query.Value) error {
	object := value.Object()
	_ = object

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

	return nil
}

func awsAwsquery_serializeOpDocumentRebuildEnvironmentInput(v *RebuildEnvironmentInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentRequestEnvironmentInfoInput(v *RequestEnvironmentInfoInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentRestartAppServerInput(v *RestartAppServerInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentRetrieveEnvironmentInfoInput(v *RetrieveEnvironmentInfoInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentSwapEnvironmentCNAMEsInput(v *SwapEnvironmentCNAMEsInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentTerminateEnvironmentInput(v *TerminateEnvironmentInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentUpdateApplicationInput(v *UpdateApplicationInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentUpdateApplicationResourceLifecycleInput(v *UpdateApplicationResourceLifecycleInput, value query.Value) error {
	object := value.Object()
	_ = object

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

	if v.ResourceLifecycleConfig != nil {
		objectKey := object.Key("ResourceLifecycleConfig")
		if err := awsAwsquery_serializeDocumentApplicationResourceLifecycleConfig(v.ResourceLifecycleConfig, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentUpdateApplicationVersionInput(v *UpdateApplicationVersionInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

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

	return nil
}

func awsAwsquery_serializeOpDocumentUpdateConfigurationTemplateInput(v *UpdateConfigurationTemplateInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

	if v.OptionSettings != nil {
		objectKey := object.Key("OptionSettings")
		if err := awsAwsquery_serializeDocumentConfigurationOptionSettingsList(v.OptionSettings, objectKey); err != nil {
			return err
		}
	}

	if v.OptionsToRemove != nil {
		objectKey := object.Key("OptionsToRemove")
		if err := awsAwsquery_serializeDocumentOptionsSpecifierList(v.OptionsToRemove, objectKey); err != nil {
			return err
		}
	}

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

	return nil
}

func awsAwsquery_serializeOpDocumentUpdateEnvironmentInput(v *UpdateEnvironmentInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

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

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

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

	if v.OptionSettings != nil {
		objectKey := object.Key("OptionSettings")
		if err := awsAwsquery_serializeDocumentConfigurationOptionSettingsList(v.OptionSettings, objectKey); err != nil {
			return err
		}
	}

	if v.OptionsToRemove != nil {
		objectKey := object.Key("OptionsToRemove")
		if err := awsAwsquery_serializeDocumentOptionsSpecifierList(v.OptionsToRemove, objectKey); err != nil {
			return err
		}
	}

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

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

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

	if v.Tier != nil {
		objectKey := object.Key("Tier")
		if err := awsAwsquery_serializeDocumentEnvironmentTier(v.Tier, objectKey); err != nil {
			return err
		}
	}

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

	return nil
}

func awsAwsquery_serializeOpDocumentUpdateTagsForResourceInput(v *UpdateTagsForResourceInput, value query.Value) error {
	object := value.Object()
	_ = object

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

	if v.TagsToAdd != nil {
		objectKey := object.Key("TagsToAdd")
		if err := awsAwsquery_serializeDocumentTagList(v.TagsToAdd, objectKey); err != nil {
			return err
		}
	}

	if v.TagsToRemove != nil {
		objectKey := object.Key("TagsToRemove")
		if err := awsAwsquery_serializeDocumentTagKeyList(v.TagsToRemove, objectKey); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsquery_serializeOpDocumentValidateConfigurationSettingsInput(v *ValidateConfigurationSettingsInput, value query.Value) error {
	object := value.Object()
	_ = object

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

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

	if v.OptionSettings != nil {
		objectKey := object.Key("OptionSettings")
		if err := awsAwsquery_serializeDocumentConfigurationOptionSettingsList(v.OptionSettings, objectKey); err != nil {
			return err
		}
	}

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

	return nil
}