xref: /dports/security/vault/vault-1.8.2/vendor/github.com/aws/aws-sdk-go-v2/service/kendra/serializers.go

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

package kendra

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

type awsAwsjson11_serializeOpBatchDeleteDocument struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpBatchPutDocument struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpCreateDataSource struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpCreateFaq struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpCreateIndex struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpCreateThesaurus struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDeleteDataSource struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDeleteFaq struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDeleteIndex struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDeleteThesaurus struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDescribeDataSource struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDescribeFaq struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDescribeIndex struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpDescribeThesaurus struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpListDataSources struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpListDataSourceSyncJobs struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpListFaqs struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpListIndices struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpListTagsForResource struct {
}

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

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpListThesauri struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpQuery struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpStartDataSourceSyncJob struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpStopDataSourceSyncJob struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpSubmitFeedback struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpTagResource struct {
}

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

func (m *awsAwsjson11_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)}
	}

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

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_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 awsAwsjson11_serializeOpUntagResource struct {
}

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

func (m *awsAwsjson11_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)}
	}

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

	jsonEncoder := smithyjson.NewEncoder()
	if err := awsAwsjson11_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)
}

type awsAwsjson11_serializeOpUpdateDataSource struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpUpdateIndex struct {
}

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

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

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

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

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

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

	return next.HandleSerialize(ctx, in)
}

type awsAwsjson11_serializeOpUpdateThesaurus struct {
}

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

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

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

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

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

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

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

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

	return nil
}

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

	return nil
}

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

	return nil
}

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

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

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

	return nil
}

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

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

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

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

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

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

	return nil
}

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

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

	return nil
}

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

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

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

	return nil
}

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

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

	return nil
}

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

	return nil
}

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

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

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

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

	return nil
}

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

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

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

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

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

	return nil
}

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

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

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

	if v.Blob != nil {
		ok := object.Key("Blob")
		ok.Base64EncodeBytes(v.Blob)
	}

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

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

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

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

	return nil
}

func awsAwsjson11_serializeDocumentDocumentAttribute(v *types.DocumentAttribute, 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")
		if err := awsAwsjson11_serializeDocumentDocumentAttributeValue(v.Value, ok); err != nil {
			return err
		}
	}

	return nil
}

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

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

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

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

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

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

func awsAwsjson11_serializeDocumentDocumentAttributeValue(v types.DocumentAttributeValue, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	switch uv := v.(type) {
	case *types.DocumentAttributeValueMemberDateValue:
		av := object.Key("DateValue")
		av.Double(smithytime.FormatEpochSeconds(uv.Value))

	case *types.DocumentAttributeValueMemberLongValue:
		av := object.Key("LongValue")
		av.Long(uv.Value)

	case *types.DocumentAttributeValueMemberStringListValue:
		av := object.Key("StringListValue")
		if err := awsAwsjson11_serializeDocumentDocumentAttributeStringListValue(uv.Value, av); err != nil {
			return err
		}

	case *types.DocumentAttributeValueMemberStringValue:
		av := object.Key("StringValue")
		av.String(uv.Value)

	default:
		return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)

	}
	return nil
}

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

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

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

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

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

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

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

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

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

	return nil
}

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

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

	return nil
}

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

	return nil
}

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

	return nil
}

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

	return nil
}

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

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

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

	return nil
}

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

	return nil
}

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

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

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

	return nil
}

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

	return nil
}

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

	return nil
}

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

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

	return nil
}

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

	return nil
}

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

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

	return nil
}

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

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

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

	return nil
}

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

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

func awsAwsjson11_serializeDocumentValueImportanceMap(v map[string]int32, value smithyjson.Value) error {
	object := value.Object()
	defer object.Close()

	for key := range v {
		om := object.Key(key)
		om.Integer(v[key])
	}
	return nil
}

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

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

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

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

	return nil
}

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

	return nil
}

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

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

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

	return nil
}

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

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

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

	return nil
}

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

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

	return nil
}

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

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

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

	return nil
}

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

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

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

	return nil
}

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

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

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

	return nil
}

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

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

	return nil
}

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

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

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

	return nil
}

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

	return nil
}

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

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

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

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

	return nil
}

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

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

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

	return nil
}

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

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

	return nil
}

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

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

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

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

	return nil
}

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

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

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

	return nil
}

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

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

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

	return nil
}

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

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

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

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

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

	return nil
}

func awsAwsjson11_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 := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
			return err
		}
	}

	return nil
}

func awsAwsjson11_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 := awsAwsjson11_serializeDocumentTagKeyList(v.TagKeys, ok); err != nil {
			return err
		}
	}

	return nil
}

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

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

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

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

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

	return nil
}

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

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

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

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

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

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

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

	return nil
}