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

package swf

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

type awsAwsjson10_serializeOpCountClosedWorkflowExecutions struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpCountOpenWorkflowExecutions struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpCountPendingActivityTasks struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpCountPendingDecisionTasks struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpDeprecateActivityType struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpDeprecateDomain struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpDeprecateWorkflowType struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpDescribeActivityType struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpDescribeDomain struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpDescribeWorkflowExecution struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpDescribeWorkflowType struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpGetWorkflowExecutionHistory struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpListActivityTypes struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpListClosedWorkflowExecutions struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpListDomains struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpListOpenWorkflowExecutions struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpListTagsForResource struct {
}

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

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpListWorkflowTypes struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpPollForActivityTask struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpPollForDecisionTask struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpRecordActivityTaskHeartbeat struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpRegisterActivityType struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpRegisterDomain struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpRegisterWorkflowType struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpRequestCancelWorkflowExecution struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpRespondActivityTaskCanceled struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpRespondActivityTaskCompleted struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpRespondActivityTaskFailed struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpRespondDecisionTaskCompleted struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpSignalWorkflowExecution struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpStartWorkflowExecution struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpTagResource struct {
}

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

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpTerminateWorkflowExecution struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpUndeprecateActivityType struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpUndeprecateDomain struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpUndeprecateWorkflowType struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson10_serializeOpUntagResource struct {
}

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

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}
func awsAwsjson10_serializeDocumentActivityType(v *types.ActivityType, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

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

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

	return nil
}

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

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

	return nil
}

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

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

	return nil
}

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

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

	return nil
}

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

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

	return nil
}

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

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

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

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

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

	if v.TagList != nil {
		ok := object.Key("tagList")
		if err := awsAwsjson10_serializeDocumentTagList(v.TagList, ok); err != nil {
			return err
		}
	}

	if v.TaskList != nil {
		ok := object.Key("taskList")
		if err := awsAwsjson10_serializeDocumentTaskList(v.TaskList, ok); err != nil {
			return err
		}
	}

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

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

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

	return nil
}

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

	if v.CancelTimerDecisionAttributes != nil {
		ok := object.Key("cancelTimerDecisionAttributes")
		if err := awsAwsjson10_serializeDocumentCancelTimerDecisionAttributes(v.CancelTimerDecisionAttributes, ok); err != nil {
			return err
		}
	}

	if v.CancelWorkflowExecutionDecisionAttributes != nil {
		ok := object.Key("cancelWorkflowExecutionDecisionAttributes")
		if err := awsAwsjson10_serializeDocumentCancelWorkflowExecutionDecisionAttributes(v.CancelWorkflowExecutionDecisionAttributes, ok); err != nil {
			return err
		}
	}

	if v.CompleteWorkflowExecutionDecisionAttributes != nil {
		ok := object.Key("completeWorkflowExecutionDecisionAttributes")
		if err := awsAwsjson10_serializeDocumentCompleteWorkflowExecutionDecisionAttributes(v.CompleteWorkflowExecutionDecisionAttributes, ok); err != nil {
			return err
		}
	}

	if v.ContinueAsNewWorkflowExecutionDecisionAttributes != nil {
		ok := object.Key("continueAsNewWorkflowExecutionDecisionAttributes")
		if err := awsAwsjson10_serializeDocumentContinueAsNewWorkflowExecutionDecisionAttributes(v.ContinueAsNewWorkflowExecutionDecisionAttributes, ok); err != nil {
			return err
		}
	}

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

	if v.FailWorkflowExecutionDecisionAttributes != nil {
		ok := object.Key("failWorkflowExecutionDecisionAttributes")
		if err := awsAwsjson10_serializeDocumentFailWorkflowExecutionDecisionAttributes(v.FailWorkflowExecutionDecisionAttributes, ok); err != nil {
			return err
		}
	}

	if v.RecordMarkerDecisionAttributes != nil {
		ok := object.Key("recordMarkerDecisionAttributes")
		if err := awsAwsjson10_serializeDocumentRecordMarkerDecisionAttributes(v.RecordMarkerDecisionAttributes, ok); err != nil {
			return err
		}
	}

	if v.RequestCancelActivityTaskDecisionAttributes != nil {
		ok := object.Key("requestCancelActivityTaskDecisionAttributes")
		if err := awsAwsjson10_serializeDocumentRequestCancelActivityTaskDecisionAttributes(v.RequestCancelActivityTaskDecisionAttributes, ok); err != nil {
			return err
		}
	}

	if v.RequestCancelExternalWorkflowExecutionDecisionAttributes != nil {
		ok := object.Key("requestCancelExternalWorkflowExecutionDecisionAttributes")
		if err := awsAwsjson10_serializeDocumentRequestCancelExternalWorkflowExecutionDecisionAttributes(v.RequestCancelExternalWorkflowExecutionDecisionAttributes, ok); err != nil {
			return err
		}
	}

	if v.ScheduleActivityTaskDecisionAttributes != nil {
		ok := object.Key("scheduleActivityTaskDecisionAttributes")
		if err := awsAwsjson10_serializeDocumentScheduleActivityTaskDecisionAttributes(v.ScheduleActivityTaskDecisionAttributes, ok); err != nil {
			return err
		}
	}

	if v.ScheduleLambdaFunctionDecisionAttributes != nil {
		ok := object.Key("scheduleLambdaFunctionDecisionAttributes")
		if err := awsAwsjson10_serializeDocumentScheduleLambdaFunctionDecisionAttributes(v.ScheduleLambdaFunctionDecisionAttributes, ok); err != nil {
			return err
		}
	}

	if v.SignalExternalWorkflowExecutionDecisionAttributes != nil {
		ok := object.Key("signalExternalWorkflowExecutionDecisionAttributes")
		if err := awsAwsjson10_serializeDocumentSignalExternalWorkflowExecutionDecisionAttributes(v.SignalExternalWorkflowExecutionDecisionAttributes, ok); err != nil {
			return err
		}
	}

	if v.StartChildWorkflowExecutionDecisionAttributes != nil {
		ok := object.Key("startChildWorkflowExecutionDecisionAttributes")
		if err := awsAwsjson10_serializeDocumentStartChildWorkflowExecutionDecisionAttributes(v.StartChildWorkflowExecutionDecisionAttributes, ok); err != nil {
			return err
		}
	}

	if v.StartTimerDecisionAttributes != nil {
		ok := object.Key("startTimerDecisionAttributes")
		if err := awsAwsjson10_serializeDocumentStartTimerDecisionAttributes(v.StartTimerDecisionAttributes, ok); err != nil {
			return err
		}
	}

	return nil
}

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

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

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

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

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

	return nil
}

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

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

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

	return nil
}

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

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

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

	return nil
}

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

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

	return nil
}

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

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

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

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

	return nil
}

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

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

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

	return nil
}

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

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

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

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

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

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

	if v.ActivityType != nil {
		ok := object.Key("activityType")
		if err := awsAwsjson10_serializeDocumentActivityType(v.ActivityType, ok); err != nil {
			return err
		}
	}

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

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

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

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

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

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

	if v.TaskList != nil {
		ok := object.Key("taskList")
		if err := awsAwsjson10_serializeDocumentTaskList(v.TaskList, ok); err != nil {
			return err
		}
	}

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

	return nil
}

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

	if v.TagList != nil {
		ok := object.Key("tagList")
		if err := awsAwsjson10_serializeDocumentTagList(v.TagList, ok); err != nil {
			return err
		}
	}

	if v.TaskList != nil {
		ok := object.Key("taskList")
		if err := awsAwsjson10_serializeDocumentTaskList(v.TaskList, ok); err != nil {
			return err
		}
	}

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

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

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

	if v.WorkflowType != nil {
		ok := object.Key("workflowType")
		if err := awsAwsjson10_serializeDocumentWorkflowType(v.WorkflowType, ok); err != nil {
			return err
		}
	}

	return nil
}

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

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

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

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

	return nil
}

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

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

	return nil
}

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

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

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

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

	return nil
}

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

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

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

	return nil
}

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

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

	return nil
}

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

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

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

	return nil
}

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

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

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

	return nil
}

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

	if v.CloseStatusFilter != nil {
		ok := object.Key("closeStatusFilter")
		if err := awsAwsjson10_serializeDocumentCloseStatusFilter(v.CloseStatusFilter, ok); err != nil {
			return err
		}
	}

	if v.CloseTimeFilter != nil {
		ok := object.Key("closeTimeFilter")
		if err := awsAwsjson10_serializeDocumentExecutionTimeFilter(v.CloseTimeFilter, ok); err != nil {
			return err
		}
	}

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

	if v.ExecutionFilter != nil {
		ok := object.Key("executionFilter")
		if err := awsAwsjson10_serializeDocumentWorkflowExecutionFilter(v.ExecutionFilter, ok); err != nil {
			return err
		}
	}

	if v.StartTimeFilter != nil {
		ok := object.Key("startTimeFilter")
		if err := awsAwsjson10_serializeDocumentExecutionTimeFilter(v.StartTimeFilter, ok); err != nil {
			return err
		}
	}

	if v.TagFilter != nil {
		ok := object.Key("tagFilter")
		if err := awsAwsjson10_serializeDocumentTagFilter(v.TagFilter, ok); err != nil {
			return err
		}
	}

	if v.TypeFilter != nil {
		ok := object.Key("typeFilter")
		if err := awsAwsjson10_serializeDocumentWorkflowTypeFilter(v.TypeFilter, ok); err != nil {
			return err
		}
	}

	return nil
}

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

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

	if v.ExecutionFilter != nil {
		ok := object.Key("executionFilter")
		if err := awsAwsjson10_serializeDocumentWorkflowExecutionFilter(v.ExecutionFilter, ok); err != nil {
			return err
		}
	}

	if v.StartTimeFilter != nil {
		ok := object.Key("startTimeFilter")
		if err := awsAwsjson10_serializeDocumentExecutionTimeFilter(v.StartTimeFilter, ok); err != nil {
			return err
		}
	}

	if v.TagFilter != nil {
		ok := object.Key("tagFilter")
		if err := awsAwsjson10_serializeDocumentTagFilter(v.TagFilter, ok); err != nil {
			return err
		}
	}

	if v.TypeFilter != nil {
		ok := object.Key("typeFilter")
		if err := awsAwsjson10_serializeDocumentWorkflowTypeFilter(v.TypeFilter, ok); err != nil {
			return err
		}
	}

	return nil
}

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

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

	if v.TaskList != nil {
		ok := object.Key("taskList")
		if err := awsAwsjson10_serializeDocumentTaskList(v.TaskList, ok); err != nil {
			return err
		}
	}

	return nil
}

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

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

	if v.TaskList != nil {
		ok := object.Key("taskList")
		if err := awsAwsjson10_serializeDocumentTaskList(v.TaskList, ok); err != nil {
			return err
		}
	}

	return nil
}

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

	if v.ActivityType != nil {
		ok := object.Key("activityType")
		if err := awsAwsjson10_serializeDocumentActivityType(v.ActivityType, ok); err != nil {
			return err
		}
	}

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

	return nil
}

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

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

	return nil
}

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

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

	if v.WorkflowType != nil {
		ok := object.Key("workflowType")
		if err := awsAwsjson10_serializeDocumentWorkflowType(v.WorkflowType, ok); err != nil {
			return err
		}
	}

	return nil
}

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

	if v.ActivityType != nil {
		ok := object.Key("activityType")
		if err := awsAwsjson10_serializeDocumentActivityType(v.ActivityType, ok); err != nil {
			return err
		}
	}

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

	return nil
}

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

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

	return nil
}

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

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

	if v.Execution != nil {
		ok := object.Key("execution")
		if err := awsAwsjson10_serializeDocumentWorkflowExecution(v.Execution, ok); err != nil {
			return err
		}
	}

	return nil
}

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

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

	if v.WorkflowType != nil {
		ok := object.Key("workflowType")
		if err := awsAwsjson10_serializeDocumentWorkflowType(v.WorkflowType, ok); err != nil {
			return err
		}
	}

	return nil
}

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

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

	if v.Execution != nil {
		ok := object.Key("execution")
		if err := awsAwsjson10_serializeDocumentWorkflowExecution(v.Execution, ok); err != nil {
			return err
		}
	}

	if v.MaximumPageSize != 0 {
		ok := object.Key("maximumPageSize")
		ok.Integer(v.MaximumPageSize)
	}

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

	if v.ReverseOrder {
		ok := object.Key("reverseOrder")
		ok.Boolean(v.ReverseOrder)
	}

	return nil
}

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

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

	if v.MaximumPageSize != 0 {
		ok := object.Key("maximumPageSize")
		ok.Integer(v.MaximumPageSize)
	}

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

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

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

	if v.ReverseOrder {
		ok := object.Key("reverseOrder")
		ok.Boolean(v.ReverseOrder)
	}

	return nil
}

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

	if v.CloseStatusFilter != nil {
		ok := object.Key("closeStatusFilter")
		if err := awsAwsjson10_serializeDocumentCloseStatusFilter(v.CloseStatusFilter, ok); err != nil {
			return err
		}
	}

	if v.CloseTimeFilter != nil {
		ok := object.Key("closeTimeFilter")
		if err := awsAwsjson10_serializeDocumentExecutionTimeFilter(v.CloseTimeFilter, ok); err != nil {
			return err
		}
	}

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

	if v.ExecutionFilter != nil {
		ok := object.Key("executionFilter")
		if err := awsAwsjson10_serializeDocumentWorkflowExecutionFilter(v.ExecutionFilter, ok); err != nil {
			return err
		}
	}

	if v.MaximumPageSize != 0 {
		ok := object.Key("maximumPageSize")
		ok.Integer(v.MaximumPageSize)
	}

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

	if v.ReverseOrder {
		ok := object.Key("reverseOrder")
		ok.Boolean(v.ReverseOrder)
	}

	if v.StartTimeFilter != nil {
		ok := object.Key("startTimeFilter")
		if err := awsAwsjson10_serializeDocumentExecutionTimeFilter(v.StartTimeFilter, ok); err != nil {
			return err
		}
	}

	if v.TagFilter != nil {
		ok := object.Key("tagFilter")
		if err := awsAwsjson10_serializeDocumentTagFilter(v.TagFilter, ok); err != nil {
			return err
		}
	}

	if v.TypeFilter != nil {
		ok := object.Key("typeFilter")
		if err := awsAwsjson10_serializeDocumentWorkflowTypeFilter(v.TypeFilter, ok); err != nil {
			return err
		}
	}

	return nil
}

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

	if v.MaximumPageSize != 0 {
		ok := object.Key("maximumPageSize")
		ok.Integer(v.MaximumPageSize)
	}

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

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

	if v.ReverseOrder {
		ok := object.Key("reverseOrder")
		ok.Boolean(v.ReverseOrder)
	}

	return nil
}

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

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

	if v.ExecutionFilter != nil {
		ok := object.Key("executionFilter")
		if err := awsAwsjson10_serializeDocumentWorkflowExecutionFilter(v.ExecutionFilter, ok); err != nil {
			return err
		}
	}

	if v.MaximumPageSize != 0 {
		ok := object.Key("maximumPageSize")
		ok.Integer(v.MaximumPageSize)
	}

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

	if v.ReverseOrder {
		ok := object.Key("reverseOrder")
		ok.Boolean(v.ReverseOrder)
	}

	if v.StartTimeFilter != nil {
		ok := object.Key("startTimeFilter")
		if err := awsAwsjson10_serializeDocumentExecutionTimeFilter(v.StartTimeFilter, ok); err != nil {
			return err
		}
	}

	if v.TagFilter != nil {
		ok := object.Key("tagFilter")
		if err := awsAwsjson10_serializeDocumentTagFilter(v.TagFilter, ok); err != nil {
			return err
		}
	}

	if v.TypeFilter != nil {
		ok := object.Key("typeFilter")
		if err := awsAwsjson10_serializeDocumentWorkflowTypeFilter(v.TypeFilter, ok); err != nil {
			return err
		}
	}

	return nil
}

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

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

	return nil
}

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

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

	if v.MaximumPageSize != 0 {
		ok := object.Key("maximumPageSize")
		ok.Integer(v.MaximumPageSize)
	}

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

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

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

	if v.ReverseOrder {
		ok := object.Key("reverseOrder")
		ok.Boolean(v.ReverseOrder)
	}

	return nil
}

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

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

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

	if v.TaskList != nil {
		ok := object.Key("taskList")
		if err := awsAwsjson10_serializeDocumentTaskList(v.TaskList, ok); err != nil {
			return err
		}
	}

	return nil
}

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

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

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

	if v.MaximumPageSize != 0 {
		ok := object.Key("maximumPageSize")
		ok.Integer(v.MaximumPageSize)
	}

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

	if v.ReverseOrder {
		ok := object.Key("reverseOrder")
		ok.Boolean(v.ReverseOrder)
	}

	if v.StartAtPreviousStartedEvent {
		ok := object.Key("startAtPreviousStartedEvent")
		ok.Boolean(v.StartAtPreviousStartedEvent)
	}

	if v.TaskList != nil {
		ok := object.Key("taskList")
		if err := awsAwsjson10_serializeDocumentTaskList(v.TaskList, ok); err != nil {
			return err
		}
	}

	return nil
}

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

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

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

	return nil
}

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

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

	if v.DefaultTaskList != nil {
		ok := object.Key("defaultTaskList")
		if err := awsAwsjson10_serializeDocumentTaskList(v.DefaultTaskList, ok); err != nil {
			return err
		}
	}

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

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

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

	return nil
}

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

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

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

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

	if v.DefaultTaskList != nil {
		ok := object.Key("defaultTaskList")
		if err := awsAwsjson10_serializeDocumentTaskList(v.DefaultTaskList, ok); err != nil {
			return err
		}
	}

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

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

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

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

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

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

	return nil
}

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

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

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

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

	return nil
}

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

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

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

	return nil
}

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

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

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

	return nil
}

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

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

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

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

	return nil
}

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

	if v.Decisions != nil {
		ok := object.Key("decisions")
		if err := awsAwsjson10_serializeDocumentDecisionList(v.Decisions, ok); err != nil {
			return err
		}
	}

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

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

	return nil
}

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

	if v.TagList != nil {
		ok := object.Key("tagList")
		if err := awsAwsjson10_serializeDocumentTagList(v.TagList, ok); err != nil {
			return err
		}
	}

	if v.TaskList != nil {
		ok := object.Key("taskList")
		if err := awsAwsjson10_serializeDocumentTaskList(v.TaskList, ok); err != nil {
			return err
		}
	}

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

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

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

	if v.WorkflowType != nil {
		ok := object.Key("workflowType")
		if err := awsAwsjson10_serializeDocumentWorkflowType(v.WorkflowType, ok); err != nil {
			return err
		}
	}

	return nil
}

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

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

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

	return nil
}

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

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

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

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

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

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

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

	return nil
}

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

	if v.ActivityType != nil {
		ok := object.Key("activityType")
		if err := awsAwsjson10_serializeDocumentActivityType(v.ActivityType, ok); err != nil {
			return err
		}
	}

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

	return nil
}

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

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

	return nil
}

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

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

	if v.WorkflowType != nil {
		ok := object.Key("workflowType")
		if err := awsAwsjson10_serializeDocumentWorkflowType(v.WorkflowType, ok); err != nil {
			return err
		}
	}

	return nil
}

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

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

	if v.TagKeys != nil {
		ok := object.Key("tagKeys")
		if err := awsAwsjson10_serializeDocumentResourceTagKeyList(v.TagKeys, ok); err != nil {
			return err
		}
	}

	return nil
}