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

//go:build request_snapshot

package comprehend

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/comprehend/types"
	smithyendpoints "github.com/aws/smithy-go/endpoints"
	"github.com/aws/smithy-go/middleware"
	"github.com/aws/smithy-go/ptr"
	smithyhttp "github.com/aws/smithy-go/transport/http"
	"io"
	"io/fs"
	"net/url"
	"os"
	"slices"
	"strings"
	"testing"
	"time"
)

const serdeSSPrefix = "request_snapshot"

// errSerdeSnapshotOK is returned by the capture middleware to abort the request
// pipeline once the serialized request has been captured, so no network call is
// made. It is a control signal, not a failure.
var errSerdeSnapshotOK = errors.New("serde snapshot: request captured")

func serdeCreatePath(path string) (*os.File, error) {
	if err := os.MkdirAll(serdeSSPrefix, 0700); err != nil && !errors.Is(err, fs.ErrExist) {
		return nil, err
	}
	return os.Create(path)
}

func serdeSSPath(op string) string {
	return fmt.Sprintf("%s/%s.request.snap", serdeSSPrefix, op)
}

type captureSerdeRequestMiddleware struct {
	body     *bytes.Buffer
	method   *string
	rawPath  *string
	rawQuery *string
	header   *map[string][]string
}

func (*captureSerdeRequestMiddleware) ID() string { return "captureSerdeRequest" }

func (m *captureSerdeRequestMiddleware) HandleFinalize(
	ctx context.Context, input middleware.FinalizeInput, next middleware.FinalizeHandler,
) (
	middleware.FinalizeOutput, middleware.Metadata, error,
) {
	req, ok := input.Request.(*smithyhttp.Request)
	if !ok {
		return middleware.FinalizeOutput{}, middleware.Metadata{}, fmt.Errorf("unexpected transport type %T", input.Request)
	}

	built := req.Build(ctx)
	*m.method = built.Method
	*m.rawPath = built.URL.RawPath
	if *m.rawPath == "" {
		*m.rawPath = built.URL.Path
	}
	*m.rawQuery = built.URL.RawQuery
	*m.header = built.Header

	if built.Body != nil {
		if _, err := io.Copy(m.body, built.Body); err != nil {
			return middleware.FinalizeOutput{}, middleware.Metadata{}, err
		}
	}

	return middleware.FinalizeOutput{}, middleware.Metadata{}, errSerdeSnapshotOK
}

func serdeFormatRequest(method, rawPath, rawQuery string, header map[string][]string, body []byte) string {
	skipHeaders := map[string]bool{
		"Authorization":         true,
		"User-Agent":            true,
		"X-Amz-Date":            true,
		"X-Amz-Security-Token":  true,
		"Amz-Sdk-Invocation-Id": true,
		"Amz-Sdk-Request":       true,
	}

	var sb strings.Builder
	sb.WriteString(method)
	sb.WriteString(" ")
	sb.WriteString(rawPath)
	if rawQuery != "" {
		sb.WriteString("?")
		sb.WriteString(rawQuery)
	}
	sb.WriteString("\n\n")

	keys := make([]string, 0, len(header))
	for k := range header {
		if skipHeaders[k] {
			continue
		}
		keys = append(keys, k)
	}
	slices.Sort(keys)
	for _, k := range keys {
		for _, v := range header[k] {
			sb.WriteString(k)
			sb.WriteString(": ")
			sb.WriteString(v)
			sb.WriteString("\n")
		}
	}
	sb.WriteString("\n")
	if len(body) > 0 {
		sb.Write(body)
	}
	return sb.String()
}

func serdeUpdateSnapshot(method, rawPath, rawQuery string, header map[string][]string, body []byte, operation string) error {
	content := serdeFormatRequest(method, rawPath, rawQuery, header, body)
	// Leave the snapshot untouched if it's semantically equal to the new one.
	// Some protocols (rpcv2Cbor) serialize map/struct fields in a nondeterministic
	// byte order, so a blind rewrite would churn the file on every run.
	if existing, err := os.ReadFile(serdeSSPath(operation)); err == nil {
		prefix := serdeFormatRequest(method, rawPath, rawQuery, header, nil)
		if strings.HasPrefix(string(existing), prefix) &&
			serdeBodyEqual(body, []byte(string(existing)[len(prefix):])) {
			return nil
		}
	}
	f, err := serdeCreatePath(serdeSSPath(operation))
	if err != nil {
		return err
	}
	defer f.Close()
	if _, err := f.Write([]byte(content)); err != nil {
		return err
	}
	return nil
}

func serdeTestSnapshot(method, rawPath, rawQuery string, header map[string][]string, body []byte, operation string) error {
	f, err := os.Open(serdeSSPath(operation))
	if errors.Is(err, fs.ErrNotExist) {
		return nil
	}
	if err != nil {
		return err
	}
	defer f.Close()
	expected, err := io.ReadAll(f)
	if err != nil {
		return err
	}
	prefix := serdeFormatRequest(method, rawPath, rawQuery, header, nil)
	if !strings.HasPrefix(string(expected), prefix) ||
		!serdeBodyEqual(body, []byte(string(expected)[len(prefix):])) {
		content := serdeFormatRequest(method, rawPath, rawQuery, header, body)
		return fmt.Errorf("serde snapshot mismatch for %s:\nGOT:\n%s:\nEXPECTED:\n%s", operation, content, string(expected))
	}
	return nil
}

type serdeEndpointResolver struct{}

func (*serdeEndpointResolver) ResolveEndpoint(ctx context.Context, params EndpointParameters) (smithyendpoints.Endpoint, error) {
	return smithyendpoints.Endpoint{URI: url.URL{Scheme: "https", Host: "test.example.com"}}, nil
}

func serdeNewClient() *Client {
	return New(Options{
		Region:             "us-east-1",
		EndpointResolverV2: &serdeEndpointResolver{},
	})
}
func serdeBodyEqual(got, expected []byte) bool {
	return bytes.Equal(got, expected)
}
func TestCheckRequestSnapshot_BatchDetectDominantLanguage(t *testing.T) {
	input := &BatchDetectDominantLanguageInput{
		TextList: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchDetectDominantLanguage(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchDetectDominantLanguage"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_BatchDetectEntities(t *testing.T) {
	input := &BatchDetectEntitiesInput{
		TextList: []string{
			"__Member__",
			"__Member__",
		},
		LanguageCode: types.LanguageCode("en"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchDetectEntities(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchDetectEntities"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_BatchDetectKeyPhrases(t *testing.T) {
	input := &BatchDetectKeyPhrasesInput{
		TextList: []string{
			"__Member__",
			"__Member__",
		},
		LanguageCode: types.LanguageCode("en"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchDetectKeyPhrases(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchDetectKeyPhrases"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_BatchDetectSentiment(t *testing.T) {
	input := &BatchDetectSentimentInput{
		TextList: []string{
			"__Member__",
			"__Member__",
		},
		LanguageCode: types.LanguageCode("en"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchDetectSentiment(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchDetectSentiment"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_BatchDetectSyntax(t *testing.T) {
	input := &BatchDetectSyntaxInput{
		TextList: []string{
			"__Member__",
			"__Member__",
		},
		LanguageCode: types.SyntaxLanguageCode("en"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchDetectSyntax(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchDetectSyntax"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_BatchDetectTargetedSentiment(t *testing.T) {
	input := &BatchDetectTargetedSentimentInput{
		TextList: []string{
			"__Member__",
			"__Member__",
		},
		LanguageCode: types.LanguageCode("en"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchDetectTargetedSentiment(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchDetectTargetedSentiment"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ClassifyDocument(t *testing.T) {
	input := &ClassifyDocumentInput{
		Text:        ptr.String("__Text__"),
		EndpointArn: ptr.String("__EndpointArn__"),
		Bytes:       []byte("blob"),
		DocumentReaderConfig: &types.DocumentReaderConfig{
			DocumentReadAction: types.DocumentReadAction("TEXTRACT_DETECT_DOCUMENT_TEXT"),
			DocumentReadMode:   types.DocumentReadMode("SERVICE_DEFAULT"),
			FeatureTypes: []types.DocumentReadFeatureTypes{
				types.DocumentReadFeatureTypes("TABLES"),
				types.DocumentReadFeatureTypes("TABLES"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ClassifyDocument(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ClassifyDocument"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ContainsPiiEntities(t *testing.T) {
	input := &ContainsPiiEntitiesInput{
		Text:         ptr.String("__Text__"),
		LanguageCode: types.LanguageCode("en"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ContainsPiiEntities(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ContainsPiiEntities"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateDataset(t *testing.T) {
	input := &CreateDatasetInput{
		FlywheelArn: ptr.String("__FlywheelArn__"),
		DatasetName: ptr.String("__DatasetName__"),
		DatasetType: types.DatasetType("TRAIN"),
		Description: ptr.String("__Description__"),
		InputDataConfig: &types.DatasetInputDataConfig{
			AugmentedManifests: []types.DatasetAugmentedManifestsListItem{
				{
					AttributeNames: []string{
						"__Member__",
						"__Member__",
					},
					S3Uri:                ptr.String("__S3Uri__"),
					AnnotationDataS3Uri:  ptr.String("__AnnotationDataS3Uri__"),
					SourceDocumentsS3Uri: ptr.String("__SourceDocumentsS3Uri__"),
					DocumentType:         types.AugmentedManifestsDocumentTypeFormat("PLAIN_TEXT_DOCUMENT"),
				},
				{
					AttributeNames: []string{
						"__Member__",
						"__Member__",
					},
					S3Uri:                ptr.String("__S3Uri__"),
					AnnotationDataS3Uri:  ptr.String("__AnnotationDataS3Uri__"),
					SourceDocumentsS3Uri: ptr.String("__SourceDocumentsS3Uri__"),
					DocumentType:         types.AugmentedManifestsDocumentTypeFormat("PLAIN_TEXT_DOCUMENT"),
				},
			},
			DataFormat: types.DatasetDataFormat("COMPREHEND_CSV"),
			DocumentClassifierInputDataConfig: &types.DatasetDocumentClassifierInputDataConfig{
				S3Uri:          ptr.String("__S3Uri__"),
				LabelDelimiter: ptr.String("__LabelDelimiter__"),
			},
			EntityRecognizerInputDataConfig: &types.DatasetEntityRecognizerInputDataConfig{
				Annotations: &types.DatasetEntityRecognizerAnnotations{
					S3Uri: ptr.String("__S3Uri__"),
				},
				Documents: &types.DatasetEntityRecognizerDocuments{
					S3Uri:       ptr.String("__S3Uri__"),
					InputFormat: types.InputFormat("ONE_DOC_PER_FILE"),
				},
				EntityList: &types.DatasetEntityRecognizerEntityList{
					S3Uri: ptr.String("__S3Uri__"),
				},
			},
		},
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateDataset(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateDataset"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateDocumentClassifier(t *testing.T) {
	input := &CreateDocumentClassifierInput{
		DocumentClassifierName: ptr.String("__DocumentClassifierName__"),
		VersionName:            ptr.String("__VersionName__"),
		DataAccessRoleArn:      ptr.String("__DataAccessRoleArn__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		InputDataConfig: &types.DocumentClassifierInputDataConfig{
			DataFormat:     types.DocumentClassifierDataFormat("COMPREHEND_CSV"),
			S3Uri:          ptr.String("__S3Uri__"),
			TestS3Uri:      ptr.String("__TestS3Uri__"),
			LabelDelimiter: ptr.String("__LabelDelimiter__"),
			AugmentedManifests: []types.AugmentedManifestsListItem{
				{
					S3Uri: ptr.String("__S3Uri__"),
					Split: types.Split("TRAIN"),
					AttributeNames: []string{
						"__Member__",
						"__Member__",
					},
					AnnotationDataS3Uri:  ptr.String("__AnnotationDataS3Uri__"),
					SourceDocumentsS3Uri: ptr.String("__SourceDocumentsS3Uri__"),
					DocumentType:         types.AugmentedManifestsDocumentTypeFormat("PLAIN_TEXT_DOCUMENT"),
				},
				{
					S3Uri: ptr.String("__S3Uri__"),
					Split: types.Split("TRAIN"),
					AttributeNames: []string{
						"__Member__",
						"__Member__",
					},
					AnnotationDataS3Uri:  ptr.String("__AnnotationDataS3Uri__"),
					SourceDocumentsS3Uri: ptr.String("__SourceDocumentsS3Uri__"),
					DocumentType:         types.AugmentedManifestsDocumentTypeFormat("PLAIN_TEXT_DOCUMENT"),
				},
			},
			DocumentType: types.DocumentClassifierDocumentTypeFormat("PLAIN_TEXT_DOCUMENT"),
			Documents: &types.DocumentClassifierDocuments{
				S3Uri:     ptr.String("__S3Uri__"),
				TestS3Uri: ptr.String("__TestS3Uri__"),
			},
			DocumentReaderConfig: &types.DocumentReaderConfig{
				DocumentReadAction: types.DocumentReadAction("TEXTRACT_DETECT_DOCUMENT_TEXT"),
				DocumentReadMode:   types.DocumentReadMode("SERVICE_DEFAULT"),
				FeatureTypes: []types.DocumentReadFeatureTypes{
					types.DocumentReadFeatureTypes("TABLES"),
					types.DocumentReadFeatureTypes("TABLES"),
				},
			},
		},
		OutputDataConfig: &types.DocumentClassifierOutputDataConfig{
			S3Uri:                 ptr.String("__S3Uri__"),
			KmsKeyId:              ptr.String("__KmsKeyId__"),
			FlywheelStatsS3Prefix: ptr.String("__FlywheelStatsS3Prefix__"),
		},
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		LanguageCode:       types.LanguageCode("en"),
		VolumeKmsKeyId:     ptr.String("__VolumeKmsKeyId__"),
		VpcConfig: &types.VpcConfig{
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
			Subnets: []string{
				"__Member__",
				"__Member__",
			},
		},
		Mode:          types.DocumentClassifierMode("MULTI_CLASS"),
		ModelKmsKeyId: ptr.String("__ModelKmsKeyId__"),
		ModelPolicy:   ptr.String("__ModelPolicy__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateDocumentClassifier(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateDocumentClassifier"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateEndpoint(t *testing.T) {
	input := &CreateEndpointInput{
		EndpointName:          ptr.String("__EndpointName__"),
		ModelArn:              ptr.String("__ModelArn__"),
		DesiredInferenceUnits: ptr.Int32(1),
		ClientRequestToken:    ptr.String("__ClientRequestToken__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		DataAccessRoleArn: ptr.String("__DataAccessRoleArn__"),
		FlywheelArn:       ptr.String("__FlywheelArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateEndpoint(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateEndpoint"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateEntityRecognizer(t *testing.T) {
	input := &CreateEntityRecognizerInput{
		RecognizerName:    ptr.String("__RecognizerName__"),
		VersionName:       ptr.String("__VersionName__"),
		DataAccessRoleArn: ptr.String("__DataAccessRoleArn__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		InputDataConfig: &types.EntityRecognizerInputDataConfig{
			DataFormat: types.EntityRecognizerDataFormat("COMPREHEND_CSV"),
			EntityTypes: []types.EntityTypesListItem{
				{
					Type: ptr.String("__Type__"),
				},
				{
					Type: ptr.String("__Type__"),
				},
			},
			Documents: &types.EntityRecognizerDocuments{
				S3Uri:       ptr.String("__S3Uri__"),
				TestS3Uri:   ptr.String("__TestS3Uri__"),
				InputFormat: types.InputFormat("ONE_DOC_PER_FILE"),
			},
			Annotations: &types.EntityRecognizerAnnotations{
				S3Uri:     ptr.String("__S3Uri__"),
				TestS3Uri: ptr.String("__TestS3Uri__"),
			},
			EntityList: &types.EntityRecognizerEntityList{
				S3Uri: ptr.String("__S3Uri__"),
			},
			AugmentedManifests: []types.AugmentedManifestsListItem{
				{
					S3Uri: ptr.String("__S3Uri__"),
					Split: types.Split("TRAIN"),
					AttributeNames: []string{
						"__Member__",
						"__Member__",
					},
					AnnotationDataS3Uri:  ptr.String("__AnnotationDataS3Uri__"),
					SourceDocumentsS3Uri: ptr.String("__SourceDocumentsS3Uri__"),
					DocumentType:         types.AugmentedManifestsDocumentTypeFormat("PLAIN_TEXT_DOCUMENT"),
				},
				{
					S3Uri: ptr.String("__S3Uri__"),
					Split: types.Split("TRAIN"),
					AttributeNames: []string{
						"__Member__",
						"__Member__",
					},
					AnnotationDataS3Uri:  ptr.String("__AnnotationDataS3Uri__"),
					SourceDocumentsS3Uri: ptr.String("__SourceDocumentsS3Uri__"),
					DocumentType:         types.AugmentedManifestsDocumentTypeFormat("PLAIN_TEXT_DOCUMENT"),
				},
			},
		},
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		LanguageCode:       types.LanguageCode("en"),
		VolumeKmsKeyId:     ptr.String("__VolumeKmsKeyId__"),
		VpcConfig: &types.VpcConfig{
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
			Subnets: []string{
				"__Member__",
				"__Member__",
			},
		},
		ModelKmsKeyId: ptr.String("__ModelKmsKeyId__"),
		ModelPolicy:   ptr.String("__ModelPolicy__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateEntityRecognizer(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateEntityRecognizer"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateFlywheel(t *testing.T) {
	input := &CreateFlywheelInput{
		FlywheelName:      ptr.String("__FlywheelName__"),
		ActiveModelArn:    ptr.String("__ActiveModelArn__"),
		DataAccessRoleArn: ptr.String("__DataAccessRoleArn__"),
		TaskConfig: &types.TaskConfig{
			LanguageCode: types.LanguageCode("en"),
			DocumentClassificationConfig: &types.DocumentClassificationConfig{
				Mode: types.DocumentClassifierMode("MULTI_CLASS"),
				Labels: []string{
					"__Member__",
					"__Member__",
				},
			},
			EntityRecognitionConfig: &types.EntityRecognitionConfig{
				EntityTypes: []types.EntityTypesListItem{
					{
						Type: ptr.String("__Type__"),
					},
					{
						Type: ptr.String("__Type__"),
					},
				},
			},
		},
		ModelType:     types.ModelType("DOCUMENT_CLASSIFIER"),
		DataLakeS3Uri: ptr.String("__DataLakeS3Uri__"),
		DataSecurityConfig: &types.DataSecurityConfig{
			ModelKmsKeyId:    ptr.String("__ModelKmsKeyId__"),
			VolumeKmsKeyId:   ptr.String("__VolumeKmsKeyId__"),
			DataLakeKmsKeyId: ptr.String("__DataLakeKmsKeyId__"),
			VpcConfig: &types.VpcConfig{
				SecurityGroupIds: []string{
					"__Member__",
					"__Member__",
				},
				Subnets: []string{
					"__Member__",
					"__Member__",
				},
			},
		},
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateFlywheel(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateFlywheel"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteDocumentClassifier(t *testing.T) {
	input := &DeleteDocumentClassifierInput{
		DocumentClassifierArn: ptr.String("__DocumentClassifierArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteDocumentClassifier(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteDocumentClassifier"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteEndpoint(t *testing.T) {
	input := &DeleteEndpointInput{
		EndpointArn: ptr.String("__EndpointArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteEndpoint(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteEndpoint"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteEntityRecognizer(t *testing.T) {
	input := &DeleteEntityRecognizerInput{
		EntityRecognizerArn: ptr.String("__EntityRecognizerArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteEntityRecognizer(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteEntityRecognizer"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteFlywheel(t *testing.T) {
	input := &DeleteFlywheelInput{
		FlywheelArn: ptr.String("__FlywheelArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteFlywheel(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteFlywheel"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteResourcePolicy(t *testing.T) {
	input := &DeleteResourcePolicyInput{
		ResourceArn:      ptr.String("__ResourceArn__"),
		PolicyRevisionId: ptr.String("__PolicyRevisionId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteResourcePolicy(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteResourcePolicy"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeDataset(t *testing.T) {
	input := &DescribeDatasetInput{
		DatasetArn: ptr.String("__DatasetArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeDataset(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeDataset"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeDocumentClassificationJob(t *testing.T) {
	input := &DescribeDocumentClassificationJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeDocumentClassificationJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeDocumentClassificationJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeDocumentClassifier(t *testing.T) {
	input := &DescribeDocumentClassifierInput{
		DocumentClassifierArn: ptr.String("__DocumentClassifierArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeDocumentClassifier(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeDocumentClassifier"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeDominantLanguageDetectionJob(t *testing.T) {
	input := &DescribeDominantLanguageDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeDominantLanguageDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeDominantLanguageDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeEndpoint(t *testing.T) {
	input := &DescribeEndpointInput{
		EndpointArn: ptr.String("__EndpointArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeEndpoint(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeEndpoint"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeEntitiesDetectionJob(t *testing.T) {
	input := &DescribeEntitiesDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeEntitiesDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeEntitiesDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeEntityRecognizer(t *testing.T) {
	input := &DescribeEntityRecognizerInput{
		EntityRecognizerArn: ptr.String("__EntityRecognizerArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeEntityRecognizer(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeEntityRecognizer"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeEventsDetectionJob(t *testing.T) {
	input := &DescribeEventsDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeEventsDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeEventsDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeFlywheel(t *testing.T) {
	input := &DescribeFlywheelInput{
		FlywheelArn: ptr.String("__FlywheelArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeFlywheel(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeFlywheel"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeFlywheelIteration(t *testing.T) {
	input := &DescribeFlywheelIterationInput{
		FlywheelArn:         ptr.String("__FlywheelArn__"),
		FlywheelIterationId: ptr.String("__FlywheelIterationId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeFlywheelIteration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeFlywheelIteration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeKeyPhrasesDetectionJob(t *testing.T) {
	input := &DescribeKeyPhrasesDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeKeyPhrasesDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeKeyPhrasesDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribePiiEntitiesDetectionJob(t *testing.T) {
	input := &DescribePiiEntitiesDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribePiiEntitiesDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribePiiEntitiesDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeResourcePolicy(t *testing.T) {
	input := &DescribeResourcePolicyInput{
		ResourceArn: ptr.String("__ResourceArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeResourcePolicy(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeResourcePolicy"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeSentimentDetectionJob(t *testing.T) {
	input := &DescribeSentimentDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeSentimentDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeSentimentDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeTargetedSentimentDetectionJob(t *testing.T) {
	input := &DescribeTargetedSentimentDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeTargetedSentimentDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeTargetedSentimentDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeTopicsDetectionJob(t *testing.T) {
	input := &DescribeTopicsDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeTopicsDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeTopicsDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DetectDominantLanguage(t *testing.T) {
	input := &DetectDominantLanguageInput{
		Text: ptr.String("__Text__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DetectDominantLanguage(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DetectDominantLanguage"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DetectEntities(t *testing.T) {
	input := &DetectEntitiesInput{
		Text:         ptr.String("__Text__"),
		LanguageCode: types.LanguageCode("en"),
		EndpointArn:  ptr.String("__EndpointArn__"),
		Bytes:        []byte("blob"),
		DocumentReaderConfig: &types.DocumentReaderConfig{
			DocumentReadAction: types.DocumentReadAction("TEXTRACT_DETECT_DOCUMENT_TEXT"),
			DocumentReadMode:   types.DocumentReadMode("SERVICE_DEFAULT"),
			FeatureTypes: []types.DocumentReadFeatureTypes{
				types.DocumentReadFeatureTypes("TABLES"),
				types.DocumentReadFeatureTypes("TABLES"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DetectEntities(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DetectEntities"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DetectKeyPhrases(t *testing.T) {
	input := &DetectKeyPhrasesInput{
		Text:         ptr.String("__Text__"),
		LanguageCode: types.LanguageCode("en"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DetectKeyPhrases(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DetectKeyPhrases"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DetectPiiEntities(t *testing.T) {
	input := &DetectPiiEntitiesInput{
		Text:         ptr.String("__Text__"),
		LanguageCode: types.LanguageCode("en"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DetectPiiEntities(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DetectPiiEntities"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DetectSentiment(t *testing.T) {
	input := &DetectSentimentInput{
		Text:         ptr.String("__Text__"),
		LanguageCode: types.LanguageCode("en"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DetectSentiment(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DetectSentiment"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DetectSyntax(t *testing.T) {
	input := &DetectSyntaxInput{
		Text:         ptr.String("__Text__"),
		LanguageCode: types.SyntaxLanguageCode("en"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DetectSyntax(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DetectSyntax"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DetectTargetedSentiment(t *testing.T) {
	input := &DetectTargetedSentimentInput{
		Text:         ptr.String("__Text__"),
		LanguageCode: types.LanguageCode("en"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DetectTargetedSentiment(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DetectTargetedSentiment"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DetectToxicContent(t *testing.T) {
	input := &DetectToxicContentInput{
		TextSegments: []types.TextSegment{
			{
				Text: ptr.String("__Text__"),
			},
			{
				Text: ptr.String("__Text__"),
			},
		},
		LanguageCode: types.LanguageCode("en"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DetectToxicContent(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DetectToxicContent"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ImportModel(t *testing.T) {
	input := &ImportModelInput{
		SourceModelArn:    ptr.String("__SourceModelArn__"),
		ModelName:         ptr.String("__ModelName__"),
		VersionName:       ptr.String("__VersionName__"),
		ModelKmsKeyId:     ptr.String("__ModelKmsKeyId__"),
		DataAccessRoleArn: ptr.String("__DataAccessRoleArn__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ImportModel(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ImportModel"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListDatasets(t *testing.T) {
	input := &ListDatasetsInput{
		FlywheelArn: ptr.String("__FlywheelArn__"),
		Filter: &types.DatasetFilter{
			Status:             types.DatasetStatus("CREATING"),
			DatasetType:        types.DatasetType("TRAIN"),
			CreationTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CreationTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListDatasets(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListDatasets"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListDocumentClassificationJobs(t *testing.T) {
	input := &ListDocumentClassificationJobsInput{
		Filter: &types.DocumentClassificationJobFilter{
			JobName:          ptr.String("__JobName__"),
			JobStatus:        types.JobStatus("SUBMITTED"),
			SubmitTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			SubmitTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListDocumentClassificationJobs(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListDocumentClassificationJobs"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListDocumentClassifiers(t *testing.T) {
	input := &ListDocumentClassifiersInput{
		Filter: &types.DocumentClassifierFilter{
			Status:                 types.ModelStatus("SUBMITTED"),
			DocumentClassifierName: ptr.String("__DocumentClassifierName__"),
			SubmitTimeBefore:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			SubmitTimeAfter:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListDocumentClassifiers(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListDocumentClassifiers"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListDocumentClassifierSummaries(t *testing.T) {
	input := &ListDocumentClassifierSummariesInput{
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListDocumentClassifierSummaries(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListDocumentClassifierSummaries"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListDominantLanguageDetectionJobs(t *testing.T) {
	input := &ListDominantLanguageDetectionJobsInput{
		Filter: &types.DominantLanguageDetectionJobFilter{
			JobName:          ptr.String("__JobName__"),
			JobStatus:        types.JobStatus("SUBMITTED"),
			SubmitTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			SubmitTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListDominantLanguageDetectionJobs(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListDominantLanguageDetectionJobs"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListEndpoints(t *testing.T) {
	input := &ListEndpointsInput{
		Filter: &types.EndpointFilter{
			ModelArn:           ptr.String("__ModelArn__"),
			Status:             types.EndpointStatus("CREATING"),
			CreationTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CreationTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListEndpoints(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListEndpoints"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListEntitiesDetectionJobs(t *testing.T) {
	input := &ListEntitiesDetectionJobsInput{
		Filter: &types.EntitiesDetectionJobFilter{
			JobName:          ptr.String("__JobName__"),
			JobStatus:        types.JobStatus("SUBMITTED"),
			SubmitTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			SubmitTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListEntitiesDetectionJobs(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListEntitiesDetectionJobs"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListEntityRecognizers(t *testing.T) {
	input := &ListEntityRecognizersInput{
		Filter: &types.EntityRecognizerFilter{
			Status:           types.ModelStatus("SUBMITTED"),
			RecognizerName:   ptr.String("__RecognizerName__"),
			SubmitTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			SubmitTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListEntityRecognizers(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListEntityRecognizers"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListEntityRecognizerSummaries(t *testing.T) {
	input := &ListEntityRecognizerSummariesInput{
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListEntityRecognizerSummaries(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListEntityRecognizerSummaries"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListEventsDetectionJobs(t *testing.T) {
	input := &ListEventsDetectionJobsInput{
		Filter: &types.EventsDetectionJobFilter{
			JobName:          ptr.String("__JobName__"),
			JobStatus:        types.JobStatus("SUBMITTED"),
			SubmitTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			SubmitTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListEventsDetectionJobs(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListEventsDetectionJobs"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListFlywheelIterationHistory(t *testing.T) {
	input := &ListFlywheelIterationHistoryInput{
		FlywheelArn: ptr.String("__FlywheelArn__"),
		Filter: &types.FlywheelIterationFilter{
			CreationTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CreationTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListFlywheelIterationHistory(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListFlywheelIterationHistory"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListFlywheels(t *testing.T) {
	input := &ListFlywheelsInput{
		Filter: &types.FlywheelFilter{
			Status:             types.FlywheelStatus("CREATING"),
			CreationTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CreationTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListFlywheels(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListFlywheels"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListKeyPhrasesDetectionJobs(t *testing.T) {
	input := &ListKeyPhrasesDetectionJobsInput{
		Filter: &types.KeyPhrasesDetectionJobFilter{
			JobName:          ptr.String("__JobName__"),
			JobStatus:        types.JobStatus("SUBMITTED"),
			SubmitTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			SubmitTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListKeyPhrasesDetectionJobs(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListKeyPhrasesDetectionJobs"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListPiiEntitiesDetectionJobs(t *testing.T) {
	input := &ListPiiEntitiesDetectionJobsInput{
		Filter: &types.PiiEntitiesDetectionJobFilter{
			JobName:          ptr.String("__JobName__"),
			JobStatus:        types.JobStatus("SUBMITTED"),
			SubmitTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			SubmitTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListPiiEntitiesDetectionJobs(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListPiiEntitiesDetectionJobs"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListSentimentDetectionJobs(t *testing.T) {
	input := &ListSentimentDetectionJobsInput{
		Filter: &types.SentimentDetectionJobFilter{
			JobName:          ptr.String("__JobName__"),
			JobStatus:        types.JobStatus("SUBMITTED"),
			SubmitTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			SubmitTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListSentimentDetectionJobs(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListSentimentDetectionJobs"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListTagsForResource(t *testing.T) {
	input := &ListTagsForResourceInput{
		ResourceArn: ptr.String("__ResourceArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListTagsForResource(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListTagsForResource"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListTargetedSentimentDetectionJobs(t *testing.T) {
	input := &ListTargetedSentimentDetectionJobsInput{
		Filter: &types.TargetedSentimentDetectionJobFilter{
			JobName:          ptr.String("__JobName__"),
			JobStatus:        types.JobStatus("SUBMITTED"),
			SubmitTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			SubmitTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListTargetedSentimentDetectionJobs(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListTargetedSentimentDetectionJobs"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListTopicsDetectionJobs(t *testing.T) {
	input := &ListTopicsDetectionJobsInput{
		Filter: &types.TopicsDetectionJobFilter{
			JobName:          ptr.String("__JobName__"),
			JobStatus:        types.JobStatus("SUBMITTED"),
			SubmitTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			SubmitTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListTopicsDetectionJobs(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListTopicsDetectionJobs"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutResourcePolicy(t *testing.T) {
	input := &PutResourcePolicyInput{
		ResourceArn:      ptr.String("__ResourceArn__"),
		ResourcePolicy:   ptr.String("__ResourcePolicy__"),
		PolicyRevisionId: ptr.String("__PolicyRevisionId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutResourcePolicy(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "PutResourcePolicy"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_StartDocumentClassificationJob(t *testing.T) {
	input := &StartDocumentClassificationJobInput{
		JobName:               ptr.String("__JobName__"),
		DocumentClassifierArn: ptr.String("__DocumentClassifierArn__"),
		InputDataConfig: &types.InputDataConfig{
			S3Uri:       ptr.String("__S3Uri__"),
			InputFormat: types.InputFormat("ONE_DOC_PER_FILE"),
			DocumentReaderConfig: &types.DocumentReaderConfig{
				DocumentReadAction: types.DocumentReadAction("TEXTRACT_DETECT_DOCUMENT_TEXT"),
				DocumentReadMode:   types.DocumentReadMode("SERVICE_DEFAULT"),
				FeatureTypes: []types.DocumentReadFeatureTypes{
					types.DocumentReadFeatureTypes("TABLES"),
					types.DocumentReadFeatureTypes("TABLES"),
				},
			},
		},
		OutputDataConfig: &types.OutputDataConfig{
			S3Uri:    ptr.String("__S3Uri__"),
			KmsKeyId: ptr.String("__KmsKeyId__"),
		},
		DataAccessRoleArn:  ptr.String("__DataAccessRoleArn__"),
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		VolumeKmsKeyId:     ptr.String("__VolumeKmsKeyId__"),
		VpcConfig: &types.VpcConfig{
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
			Subnets: []string{
				"__Member__",
				"__Member__",
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		FlywheelArn: ptr.String("__FlywheelArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartDocumentClassificationJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartDocumentClassificationJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_StartDominantLanguageDetectionJob(t *testing.T) {
	input := &StartDominantLanguageDetectionJobInput{
		InputDataConfig: &types.InputDataConfig{
			S3Uri:       ptr.String("__S3Uri__"),
			InputFormat: types.InputFormat("ONE_DOC_PER_FILE"),
			DocumentReaderConfig: &types.DocumentReaderConfig{
				DocumentReadAction: types.DocumentReadAction("TEXTRACT_DETECT_DOCUMENT_TEXT"),
				DocumentReadMode:   types.DocumentReadMode("SERVICE_DEFAULT"),
				FeatureTypes: []types.DocumentReadFeatureTypes{
					types.DocumentReadFeatureTypes("TABLES"),
					types.DocumentReadFeatureTypes("TABLES"),
				},
			},
		},
		OutputDataConfig: &types.OutputDataConfig{
			S3Uri:    ptr.String("__S3Uri__"),
			KmsKeyId: ptr.String("__KmsKeyId__"),
		},
		DataAccessRoleArn:  ptr.String("__DataAccessRoleArn__"),
		JobName:            ptr.String("__JobName__"),
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		VolumeKmsKeyId:     ptr.String("__VolumeKmsKeyId__"),
		VpcConfig: &types.VpcConfig{
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
			Subnets: []string{
				"__Member__",
				"__Member__",
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartDominantLanguageDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartDominantLanguageDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_StartEntitiesDetectionJob(t *testing.T) {
	input := &StartEntitiesDetectionJobInput{
		InputDataConfig: &types.InputDataConfig{
			S3Uri:       ptr.String("__S3Uri__"),
			InputFormat: types.InputFormat("ONE_DOC_PER_FILE"),
			DocumentReaderConfig: &types.DocumentReaderConfig{
				DocumentReadAction: types.DocumentReadAction("TEXTRACT_DETECT_DOCUMENT_TEXT"),
				DocumentReadMode:   types.DocumentReadMode("SERVICE_DEFAULT"),
				FeatureTypes: []types.DocumentReadFeatureTypes{
					types.DocumentReadFeatureTypes("TABLES"),
					types.DocumentReadFeatureTypes("TABLES"),
				},
			},
		},
		OutputDataConfig: &types.OutputDataConfig{
			S3Uri:    ptr.String("__S3Uri__"),
			KmsKeyId: ptr.String("__KmsKeyId__"),
		},
		DataAccessRoleArn:   ptr.String("__DataAccessRoleArn__"),
		JobName:             ptr.String("__JobName__"),
		EntityRecognizerArn: ptr.String("__EntityRecognizerArn__"),
		LanguageCode:        types.LanguageCode("en"),
		ClientRequestToken:  ptr.String("__ClientRequestToken__"),
		VolumeKmsKeyId:      ptr.String("__VolumeKmsKeyId__"),
		VpcConfig: &types.VpcConfig{
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
			Subnets: []string{
				"__Member__",
				"__Member__",
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		FlywheelArn: ptr.String("__FlywheelArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartEntitiesDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartEntitiesDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_StartEventsDetectionJob(t *testing.T) {
	input := &StartEventsDetectionJobInput{
		InputDataConfig: &types.InputDataConfig{
			S3Uri:       ptr.String("__S3Uri__"),
			InputFormat: types.InputFormat("ONE_DOC_PER_FILE"),
			DocumentReaderConfig: &types.DocumentReaderConfig{
				DocumentReadAction: types.DocumentReadAction("TEXTRACT_DETECT_DOCUMENT_TEXT"),
				DocumentReadMode:   types.DocumentReadMode("SERVICE_DEFAULT"),
				FeatureTypes: []types.DocumentReadFeatureTypes{
					types.DocumentReadFeatureTypes("TABLES"),
					types.DocumentReadFeatureTypes("TABLES"),
				},
			},
		},
		OutputDataConfig: &types.OutputDataConfig{
			S3Uri:    ptr.String("__S3Uri__"),
			KmsKeyId: ptr.String("__KmsKeyId__"),
		},
		DataAccessRoleArn:  ptr.String("__DataAccessRoleArn__"),
		JobName:            ptr.String("__JobName__"),
		LanguageCode:       types.LanguageCode("en"),
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		TargetEventTypes: []string{
			"__Member__",
			"__Member__",
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartEventsDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartEventsDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_StartFlywheelIteration(t *testing.T) {
	input := &StartFlywheelIterationInput{
		FlywheelArn:        ptr.String("__FlywheelArn__"),
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartFlywheelIteration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartFlywheelIteration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_StartKeyPhrasesDetectionJob(t *testing.T) {
	input := &StartKeyPhrasesDetectionJobInput{
		InputDataConfig: &types.InputDataConfig{
			S3Uri:       ptr.String("__S3Uri__"),
			InputFormat: types.InputFormat("ONE_DOC_PER_FILE"),
			DocumentReaderConfig: &types.DocumentReaderConfig{
				DocumentReadAction: types.DocumentReadAction("TEXTRACT_DETECT_DOCUMENT_TEXT"),
				DocumentReadMode:   types.DocumentReadMode("SERVICE_DEFAULT"),
				FeatureTypes: []types.DocumentReadFeatureTypes{
					types.DocumentReadFeatureTypes("TABLES"),
					types.DocumentReadFeatureTypes("TABLES"),
				},
			},
		},
		OutputDataConfig: &types.OutputDataConfig{
			S3Uri:    ptr.String("__S3Uri__"),
			KmsKeyId: ptr.String("__KmsKeyId__"),
		},
		DataAccessRoleArn:  ptr.String("__DataAccessRoleArn__"),
		JobName:            ptr.String("__JobName__"),
		LanguageCode:       types.LanguageCode("en"),
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		VolumeKmsKeyId:     ptr.String("__VolumeKmsKeyId__"),
		VpcConfig: &types.VpcConfig{
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
			Subnets: []string{
				"__Member__",
				"__Member__",
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartKeyPhrasesDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartKeyPhrasesDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_StartPiiEntitiesDetectionJob(t *testing.T) {
	input := &StartPiiEntitiesDetectionJobInput{
		InputDataConfig: &types.InputDataConfig{
			S3Uri:       ptr.String("__S3Uri__"),
			InputFormat: types.InputFormat("ONE_DOC_PER_FILE"),
			DocumentReaderConfig: &types.DocumentReaderConfig{
				DocumentReadAction: types.DocumentReadAction("TEXTRACT_DETECT_DOCUMENT_TEXT"),
				DocumentReadMode:   types.DocumentReadMode("SERVICE_DEFAULT"),
				FeatureTypes: []types.DocumentReadFeatureTypes{
					types.DocumentReadFeatureTypes("TABLES"),
					types.DocumentReadFeatureTypes("TABLES"),
				},
			},
		},
		OutputDataConfig: &types.OutputDataConfig{
			S3Uri:    ptr.String("__S3Uri__"),
			KmsKeyId: ptr.String("__KmsKeyId__"),
		},
		Mode: types.PiiEntitiesDetectionMode("ONLY_REDACTION"),
		RedactionConfig: &types.RedactionConfig{
			PiiEntityTypes: []types.PiiEntityType{
				types.PiiEntityType("BANK_ACCOUNT_NUMBER"),
				types.PiiEntityType("BANK_ACCOUNT_NUMBER"),
			},
			MaskMode:      types.PiiEntitiesDetectionMaskMode("MASK"),
			MaskCharacter: ptr.String("__MaskCharacter__"),
		},
		DataAccessRoleArn:  ptr.String("__DataAccessRoleArn__"),
		JobName:            ptr.String("__JobName__"),
		LanguageCode:       types.LanguageCode("en"),
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartPiiEntitiesDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartPiiEntitiesDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_StartSentimentDetectionJob(t *testing.T) {
	input := &StartSentimentDetectionJobInput{
		InputDataConfig: &types.InputDataConfig{
			S3Uri:       ptr.String("__S3Uri__"),
			InputFormat: types.InputFormat("ONE_DOC_PER_FILE"),
			DocumentReaderConfig: &types.DocumentReaderConfig{
				DocumentReadAction: types.DocumentReadAction("TEXTRACT_DETECT_DOCUMENT_TEXT"),
				DocumentReadMode:   types.DocumentReadMode("SERVICE_DEFAULT"),
				FeatureTypes: []types.DocumentReadFeatureTypes{
					types.DocumentReadFeatureTypes("TABLES"),
					types.DocumentReadFeatureTypes("TABLES"),
				},
			},
		},
		OutputDataConfig: &types.OutputDataConfig{
			S3Uri:    ptr.String("__S3Uri__"),
			KmsKeyId: ptr.String("__KmsKeyId__"),
		},
		DataAccessRoleArn:  ptr.String("__DataAccessRoleArn__"),
		JobName:            ptr.String("__JobName__"),
		LanguageCode:       types.LanguageCode("en"),
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		VolumeKmsKeyId:     ptr.String("__VolumeKmsKeyId__"),
		VpcConfig: &types.VpcConfig{
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
			Subnets: []string{
				"__Member__",
				"__Member__",
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartSentimentDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartSentimentDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_StartTargetedSentimentDetectionJob(t *testing.T) {
	input := &StartTargetedSentimentDetectionJobInput{
		InputDataConfig: &types.InputDataConfig{
			S3Uri:       ptr.String("__S3Uri__"),
			InputFormat: types.InputFormat("ONE_DOC_PER_FILE"),
			DocumentReaderConfig: &types.DocumentReaderConfig{
				DocumentReadAction: types.DocumentReadAction("TEXTRACT_DETECT_DOCUMENT_TEXT"),
				DocumentReadMode:   types.DocumentReadMode("SERVICE_DEFAULT"),
				FeatureTypes: []types.DocumentReadFeatureTypes{
					types.DocumentReadFeatureTypes("TABLES"),
					types.DocumentReadFeatureTypes("TABLES"),
				},
			},
		},
		OutputDataConfig: &types.OutputDataConfig{
			S3Uri:    ptr.String("__S3Uri__"),
			KmsKeyId: ptr.String("__KmsKeyId__"),
		},
		DataAccessRoleArn:  ptr.String("__DataAccessRoleArn__"),
		JobName:            ptr.String("__JobName__"),
		LanguageCode:       types.LanguageCode("en"),
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		VolumeKmsKeyId:     ptr.String("__VolumeKmsKeyId__"),
		VpcConfig: &types.VpcConfig{
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
			Subnets: []string{
				"__Member__",
				"__Member__",
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartTargetedSentimentDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartTargetedSentimentDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_StartTopicsDetectionJob(t *testing.T) {
	input := &StartTopicsDetectionJobInput{
		InputDataConfig: &types.InputDataConfig{
			S3Uri:       ptr.String("__S3Uri__"),
			InputFormat: types.InputFormat("ONE_DOC_PER_FILE"),
			DocumentReaderConfig: &types.DocumentReaderConfig{
				DocumentReadAction: types.DocumentReadAction("TEXTRACT_DETECT_DOCUMENT_TEXT"),
				DocumentReadMode:   types.DocumentReadMode("SERVICE_DEFAULT"),
				FeatureTypes: []types.DocumentReadFeatureTypes{
					types.DocumentReadFeatureTypes("TABLES"),
					types.DocumentReadFeatureTypes("TABLES"),
				},
			},
		},
		OutputDataConfig: &types.OutputDataConfig{
			S3Uri:    ptr.String("__S3Uri__"),
			KmsKeyId: ptr.String("__KmsKeyId__"),
		},
		DataAccessRoleArn:  ptr.String("__DataAccessRoleArn__"),
		JobName:            ptr.String("__JobName__"),
		NumberOfTopics:     ptr.Int32(1),
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		VolumeKmsKeyId:     ptr.String("__VolumeKmsKeyId__"),
		VpcConfig: &types.VpcConfig{
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
			Subnets: []string{
				"__Member__",
				"__Member__",
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartTopicsDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartTopicsDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_StopDominantLanguageDetectionJob(t *testing.T) {
	input := &StopDominantLanguageDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopDominantLanguageDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StopDominantLanguageDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_StopEntitiesDetectionJob(t *testing.T) {
	input := &StopEntitiesDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopEntitiesDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StopEntitiesDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_StopEventsDetectionJob(t *testing.T) {
	input := &StopEventsDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopEventsDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StopEventsDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_StopKeyPhrasesDetectionJob(t *testing.T) {
	input := &StopKeyPhrasesDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopKeyPhrasesDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StopKeyPhrasesDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_StopPiiEntitiesDetectionJob(t *testing.T) {
	input := &StopPiiEntitiesDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopPiiEntitiesDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StopPiiEntitiesDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_StopSentimentDetectionJob(t *testing.T) {
	input := &StopSentimentDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopSentimentDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StopSentimentDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_StopTargetedSentimentDetectionJob(t *testing.T) {
	input := &StopTargetedSentimentDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopTargetedSentimentDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StopTargetedSentimentDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_StopTrainingDocumentClassifier(t *testing.T) {
	input := &StopTrainingDocumentClassifierInput{
		DocumentClassifierArn: ptr.String("__DocumentClassifierArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopTrainingDocumentClassifier(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StopTrainingDocumentClassifier"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_StopTrainingEntityRecognizer(t *testing.T) {
	input := &StopTrainingEntityRecognizerInput{
		EntityRecognizerArn: ptr.String("__EntityRecognizerArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopTrainingEntityRecognizer(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StopTrainingEntityRecognizer"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_TagResource(t *testing.T) {
	input := &TagResourceInput{
		ResourceArn: ptr.String("__ResourceArn__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.TagResource(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "TagResource"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UntagResource(t *testing.T) {
	input := &UntagResourceInput{
		ResourceArn: ptr.String("__ResourceArn__"),
		TagKeys: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UntagResource(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UntagResource"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateEndpoint(t *testing.T) {
	input := &UpdateEndpointInput{
		EndpointArn:              ptr.String("__EndpointArn__"),
		DesiredModelArn:          ptr.String("__DesiredModelArn__"),
		DesiredInferenceUnits:    ptr.Int32(1),
		DesiredDataAccessRoleArn: ptr.String("__DesiredDataAccessRoleArn__"),
		FlywheelArn:              ptr.String("__FlywheelArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateEndpoint(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateEndpoint"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateFlywheel(t *testing.T) {
	input := &UpdateFlywheelInput{
		FlywheelArn:       ptr.String("__FlywheelArn__"),
		ActiveModelArn:    ptr.String("__ActiveModelArn__"),
		DataAccessRoleArn: ptr.String("__DataAccessRoleArn__"),
		DataSecurityConfig: &types.UpdateDataSecurityConfig{
			ModelKmsKeyId:  ptr.String("__ModelKmsKeyId__"),
			VolumeKmsKeyId: ptr.String("__VolumeKmsKeyId__"),
			VpcConfig: &types.VpcConfig{
				SecurityGroupIds: []string{
					"__Member__",
					"__Member__",
				},
				Subnets: []string{
					"__Member__",
					"__Member__",
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateFlywheel(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateFlywheel"); err != nil {
		t.Fatal(err)
	}
}
func TestUpdateRequestSnapshot_BatchDetectDominantLanguage(t *testing.T) {
	input := &BatchDetectDominantLanguageInput{
		TextList: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchDetectDominantLanguage(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchDetectDominantLanguage"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_BatchDetectEntities(t *testing.T) {
	input := &BatchDetectEntitiesInput{
		TextList: []string{
			"__Member__",
			"__Member__",
		},
		LanguageCode: types.LanguageCode("en"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchDetectEntities(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchDetectEntities"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_BatchDetectKeyPhrases(t *testing.T) {
	input := &BatchDetectKeyPhrasesInput{
		TextList: []string{
			"__Member__",
			"__Member__",
		},
		LanguageCode: types.LanguageCode("en"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchDetectKeyPhrases(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchDetectKeyPhrases"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_BatchDetectSentiment(t *testing.T) {
	input := &BatchDetectSentimentInput{
		TextList: []string{
			"__Member__",
			"__Member__",
		},
		LanguageCode: types.LanguageCode("en"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchDetectSentiment(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchDetectSentiment"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_BatchDetectSyntax(t *testing.T) {
	input := &BatchDetectSyntaxInput{
		TextList: []string{
			"__Member__",
			"__Member__",
		},
		LanguageCode: types.SyntaxLanguageCode("en"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchDetectSyntax(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchDetectSyntax"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_BatchDetectTargetedSentiment(t *testing.T) {
	input := &BatchDetectTargetedSentimentInput{
		TextList: []string{
			"__Member__",
			"__Member__",
		},
		LanguageCode: types.LanguageCode("en"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchDetectTargetedSentiment(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchDetectTargetedSentiment"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ClassifyDocument(t *testing.T) {
	input := &ClassifyDocumentInput{
		Text:        ptr.String("__Text__"),
		EndpointArn: ptr.String("__EndpointArn__"),
		Bytes:       []byte("blob"),
		DocumentReaderConfig: &types.DocumentReaderConfig{
			DocumentReadAction: types.DocumentReadAction("TEXTRACT_DETECT_DOCUMENT_TEXT"),
			DocumentReadMode:   types.DocumentReadMode("SERVICE_DEFAULT"),
			FeatureTypes: []types.DocumentReadFeatureTypes{
				types.DocumentReadFeatureTypes("TABLES"),
				types.DocumentReadFeatureTypes("TABLES"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ClassifyDocument(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ClassifyDocument"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ContainsPiiEntities(t *testing.T) {
	input := &ContainsPiiEntitiesInput{
		Text:         ptr.String("__Text__"),
		LanguageCode: types.LanguageCode("en"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ContainsPiiEntities(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ContainsPiiEntities"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateDataset(t *testing.T) {
	input := &CreateDatasetInput{
		FlywheelArn: ptr.String("__FlywheelArn__"),
		DatasetName: ptr.String("__DatasetName__"),
		DatasetType: types.DatasetType("TRAIN"),
		Description: ptr.String("__Description__"),
		InputDataConfig: &types.DatasetInputDataConfig{
			AugmentedManifests: []types.DatasetAugmentedManifestsListItem{
				{
					AttributeNames: []string{
						"__Member__",
						"__Member__",
					},
					S3Uri:                ptr.String("__S3Uri__"),
					AnnotationDataS3Uri:  ptr.String("__AnnotationDataS3Uri__"),
					SourceDocumentsS3Uri: ptr.String("__SourceDocumentsS3Uri__"),
					DocumentType:         types.AugmentedManifestsDocumentTypeFormat("PLAIN_TEXT_DOCUMENT"),
				},
				{
					AttributeNames: []string{
						"__Member__",
						"__Member__",
					},
					S3Uri:                ptr.String("__S3Uri__"),
					AnnotationDataS3Uri:  ptr.String("__AnnotationDataS3Uri__"),
					SourceDocumentsS3Uri: ptr.String("__SourceDocumentsS3Uri__"),
					DocumentType:         types.AugmentedManifestsDocumentTypeFormat("PLAIN_TEXT_DOCUMENT"),
				},
			},
			DataFormat: types.DatasetDataFormat("COMPREHEND_CSV"),
			DocumentClassifierInputDataConfig: &types.DatasetDocumentClassifierInputDataConfig{
				S3Uri:          ptr.String("__S3Uri__"),
				LabelDelimiter: ptr.String("__LabelDelimiter__"),
			},
			EntityRecognizerInputDataConfig: &types.DatasetEntityRecognizerInputDataConfig{
				Annotations: &types.DatasetEntityRecognizerAnnotations{
					S3Uri: ptr.String("__S3Uri__"),
				},
				Documents: &types.DatasetEntityRecognizerDocuments{
					S3Uri:       ptr.String("__S3Uri__"),
					InputFormat: types.InputFormat("ONE_DOC_PER_FILE"),
				},
				EntityList: &types.DatasetEntityRecognizerEntityList{
					S3Uri: ptr.String("__S3Uri__"),
				},
			},
		},
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateDataset(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateDataset"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateDocumentClassifier(t *testing.T) {
	input := &CreateDocumentClassifierInput{
		DocumentClassifierName: ptr.String("__DocumentClassifierName__"),
		VersionName:            ptr.String("__VersionName__"),
		DataAccessRoleArn:      ptr.String("__DataAccessRoleArn__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		InputDataConfig: &types.DocumentClassifierInputDataConfig{
			DataFormat:     types.DocumentClassifierDataFormat("COMPREHEND_CSV"),
			S3Uri:          ptr.String("__S3Uri__"),
			TestS3Uri:      ptr.String("__TestS3Uri__"),
			LabelDelimiter: ptr.String("__LabelDelimiter__"),
			AugmentedManifests: []types.AugmentedManifestsListItem{
				{
					S3Uri: ptr.String("__S3Uri__"),
					Split: types.Split("TRAIN"),
					AttributeNames: []string{
						"__Member__",
						"__Member__",
					},
					AnnotationDataS3Uri:  ptr.String("__AnnotationDataS3Uri__"),
					SourceDocumentsS3Uri: ptr.String("__SourceDocumentsS3Uri__"),
					DocumentType:         types.AugmentedManifestsDocumentTypeFormat("PLAIN_TEXT_DOCUMENT"),
				},
				{
					S3Uri: ptr.String("__S3Uri__"),
					Split: types.Split("TRAIN"),
					AttributeNames: []string{
						"__Member__",
						"__Member__",
					},
					AnnotationDataS3Uri:  ptr.String("__AnnotationDataS3Uri__"),
					SourceDocumentsS3Uri: ptr.String("__SourceDocumentsS3Uri__"),
					DocumentType:         types.AugmentedManifestsDocumentTypeFormat("PLAIN_TEXT_DOCUMENT"),
				},
			},
			DocumentType: types.DocumentClassifierDocumentTypeFormat("PLAIN_TEXT_DOCUMENT"),
			Documents: &types.DocumentClassifierDocuments{
				S3Uri:     ptr.String("__S3Uri__"),
				TestS3Uri: ptr.String("__TestS3Uri__"),
			},
			DocumentReaderConfig: &types.DocumentReaderConfig{
				DocumentReadAction: types.DocumentReadAction("TEXTRACT_DETECT_DOCUMENT_TEXT"),
				DocumentReadMode:   types.DocumentReadMode("SERVICE_DEFAULT"),
				FeatureTypes: []types.DocumentReadFeatureTypes{
					types.DocumentReadFeatureTypes("TABLES"),
					types.DocumentReadFeatureTypes("TABLES"),
				},
			},
		},
		OutputDataConfig: &types.DocumentClassifierOutputDataConfig{
			S3Uri:                 ptr.String("__S3Uri__"),
			KmsKeyId:              ptr.String("__KmsKeyId__"),
			FlywheelStatsS3Prefix: ptr.String("__FlywheelStatsS3Prefix__"),
		},
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		LanguageCode:       types.LanguageCode("en"),
		VolumeKmsKeyId:     ptr.String("__VolumeKmsKeyId__"),
		VpcConfig: &types.VpcConfig{
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
			Subnets: []string{
				"__Member__",
				"__Member__",
			},
		},
		Mode:          types.DocumentClassifierMode("MULTI_CLASS"),
		ModelKmsKeyId: ptr.String("__ModelKmsKeyId__"),
		ModelPolicy:   ptr.String("__ModelPolicy__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateDocumentClassifier(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateDocumentClassifier"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateEndpoint(t *testing.T) {
	input := &CreateEndpointInput{
		EndpointName:          ptr.String("__EndpointName__"),
		ModelArn:              ptr.String("__ModelArn__"),
		DesiredInferenceUnits: ptr.Int32(1),
		ClientRequestToken:    ptr.String("__ClientRequestToken__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		DataAccessRoleArn: ptr.String("__DataAccessRoleArn__"),
		FlywheelArn:       ptr.String("__FlywheelArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateEndpoint(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateEndpoint"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateEntityRecognizer(t *testing.T) {
	input := &CreateEntityRecognizerInput{
		RecognizerName:    ptr.String("__RecognizerName__"),
		VersionName:       ptr.String("__VersionName__"),
		DataAccessRoleArn: ptr.String("__DataAccessRoleArn__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		InputDataConfig: &types.EntityRecognizerInputDataConfig{
			DataFormat: types.EntityRecognizerDataFormat("COMPREHEND_CSV"),
			EntityTypes: []types.EntityTypesListItem{
				{
					Type: ptr.String("__Type__"),
				},
				{
					Type: ptr.String("__Type__"),
				},
			},
			Documents: &types.EntityRecognizerDocuments{
				S3Uri:       ptr.String("__S3Uri__"),
				TestS3Uri:   ptr.String("__TestS3Uri__"),
				InputFormat: types.InputFormat("ONE_DOC_PER_FILE"),
			},
			Annotations: &types.EntityRecognizerAnnotations{
				S3Uri:     ptr.String("__S3Uri__"),
				TestS3Uri: ptr.String("__TestS3Uri__"),
			},
			EntityList: &types.EntityRecognizerEntityList{
				S3Uri: ptr.String("__S3Uri__"),
			},
			AugmentedManifests: []types.AugmentedManifestsListItem{
				{
					S3Uri: ptr.String("__S3Uri__"),
					Split: types.Split("TRAIN"),
					AttributeNames: []string{
						"__Member__",
						"__Member__",
					},
					AnnotationDataS3Uri:  ptr.String("__AnnotationDataS3Uri__"),
					SourceDocumentsS3Uri: ptr.String("__SourceDocumentsS3Uri__"),
					DocumentType:         types.AugmentedManifestsDocumentTypeFormat("PLAIN_TEXT_DOCUMENT"),
				},
				{
					S3Uri: ptr.String("__S3Uri__"),
					Split: types.Split("TRAIN"),
					AttributeNames: []string{
						"__Member__",
						"__Member__",
					},
					AnnotationDataS3Uri:  ptr.String("__AnnotationDataS3Uri__"),
					SourceDocumentsS3Uri: ptr.String("__SourceDocumentsS3Uri__"),
					DocumentType:         types.AugmentedManifestsDocumentTypeFormat("PLAIN_TEXT_DOCUMENT"),
				},
			},
		},
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		LanguageCode:       types.LanguageCode("en"),
		VolumeKmsKeyId:     ptr.String("__VolumeKmsKeyId__"),
		VpcConfig: &types.VpcConfig{
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
			Subnets: []string{
				"__Member__",
				"__Member__",
			},
		},
		ModelKmsKeyId: ptr.String("__ModelKmsKeyId__"),
		ModelPolicy:   ptr.String("__ModelPolicy__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateEntityRecognizer(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateEntityRecognizer"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateFlywheel(t *testing.T) {
	input := &CreateFlywheelInput{
		FlywheelName:      ptr.String("__FlywheelName__"),
		ActiveModelArn:    ptr.String("__ActiveModelArn__"),
		DataAccessRoleArn: ptr.String("__DataAccessRoleArn__"),
		TaskConfig: &types.TaskConfig{
			LanguageCode: types.LanguageCode("en"),
			DocumentClassificationConfig: &types.DocumentClassificationConfig{
				Mode: types.DocumentClassifierMode("MULTI_CLASS"),
				Labels: []string{
					"__Member__",
					"__Member__",
				},
			},
			EntityRecognitionConfig: &types.EntityRecognitionConfig{
				EntityTypes: []types.EntityTypesListItem{
					{
						Type: ptr.String("__Type__"),
					},
					{
						Type: ptr.String("__Type__"),
					},
				},
			},
		},
		ModelType:     types.ModelType("DOCUMENT_CLASSIFIER"),
		DataLakeS3Uri: ptr.String("__DataLakeS3Uri__"),
		DataSecurityConfig: &types.DataSecurityConfig{
			ModelKmsKeyId:    ptr.String("__ModelKmsKeyId__"),
			VolumeKmsKeyId:   ptr.String("__VolumeKmsKeyId__"),
			DataLakeKmsKeyId: ptr.String("__DataLakeKmsKeyId__"),
			VpcConfig: &types.VpcConfig{
				SecurityGroupIds: []string{
					"__Member__",
					"__Member__",
				},
				Subnets: []string{
					"__Member__",
					"__Member__",
				},
			},
		},
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateFlywheel(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateFlywheel"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteDocumentClassifier(t *testing.T) {
	input := &DeleteDocumentClassifierInput{
		DocumentClassifierArn: ptr.String("__DocumentClassifierArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteDocumentClassifier(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteDocumentClassifier"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteEndpoint(t *testing.T) {
	input := &DeleteEndpointInput{
		EndpointArn: ptr.String("__EndpointArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteEndpoint(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteEndpoint"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteEntityRecognizer(t *testing.T) {
	input := &DeleteEntityRecognizerInput{
		EntityRecognizerArn: ptr.String("__EntityRecognizerArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteEntityRecognizer(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteEntityRecognizer"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteFlywheel(t *testing.T) {
	input := &DeleteFlywheelInput{
		FlywheelArn: ptr.String("__FlywheelArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteFlywheel(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteFlywheel"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteResourcePolicy(t *testing.T) {
	input := &DeleteResourcePolicyInput{
		ResourceArn:      ptr.String("__ResourceArn__"),
		PolicyRevisionId: ptr.String("__PolicyRevisionId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteResourcePolicy(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteResourcePolicy"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeDataset(t *testing.T) {
	input := &DescribeDatasetInput{
		DatasetArn: ptr.String("__DatasetArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeDataset(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeDataset"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeDocumentClassificationJob(t *testing.T) {
	input := &DescribeDocumentClassificationJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeDocumentClassificationJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeDocumentClassificationJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeDocumentClassifier(t *testing.T) {
	input := &DescribeDocumentClassifierInput{
		DocumentClassifierArn: ptr.String("__DocumentClassifierArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeDocumentClassifier(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeDocumentClassifier"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeDominantLanguageDetectionJob(t *testing.T) {
	input := &DescribeDominantLanguageDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeDominantLanguageDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeDominantLanguageDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeEndpoint(t *testing.T) {
	input := &DescribeEndpointInput{
		EndpointArn: ptr.String("__EndpointArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeEndpoint(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeEndpoint"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeEntitiesDetectionJob(t *testing.T) {
	input := &DescribeEntitiesDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeEntitiesDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeEntitiesDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeEntityRecognizer(t *testing.T) {
	input := &DescribeEntityRecognizerInput{
		EntityRecognizerArn: ptr.String("__EntityRecognizerArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeEntityRecognizer(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeEntityRecognizer"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeEventsDetectionJob(t *testing.T) {
	input := &DescribeEventsDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeEventsDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeEventsDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeFlywheel(t *testing.T) {
	input := &DescribeFlywheelInput{
		FlywheelArn: ptr.String("__FlywheelArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeFlywheel(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeFlywheel"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeFlywheelIteration(t *testing.T) {
	input := &DescribeFlywheelIterationInput{
		FlywheelArn:         ptr.String("__FlywheelArn__"),
		FlywheelIterationId: ptr.String("__FlywheelIterationId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeFlywheelIteration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeFlywheelIteration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeKeyPhrasesDetectionJob(t *testing.T) {
	input := &DescribeKeyPhrasesDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeKeyPhrasesDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeKeyPhrasesDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribePiiEntitiesDetectionJob(t *testing.T) {
	input := &DescribePiiEntitiesDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribePiiEntitiesDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribePiiEntitiesDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeResourcePolicy(t *testing.T) {
	input := &DescribeResourcePolicyInput{
		ResourceArn: ptr.String("__ResourceArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeResourcePolicy(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeResourcePolicy"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeSentimentDetectionJob(t *testing.T) {
	input := &DescribeSentimentDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeSentimentDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeSentimentDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeTargetedSentimentDetectionJob(t *testing.T) {
	input := &DescribeTargetedSentimentDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeTargetedSentimentDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeTargetedSentimentDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeTopicsDetectionJob(t *testing.T) {
	input := &DescribeTopicsDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeTopicsDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeTopicsDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DetectDominantLanguage(t *testing.T) {
	input := &DetectDominantLanguageInput{
		Text: ptr.String("__Text__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DetectDominantLanguage(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DetectDominantLanguage"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DetectEntities(t *testing.T) {
	input := &DetectEntitiesInput{
		Text:         ptr.String("__Text__"),
		LanguageCode: types.LanguageCode("en"),
		EndpointArn:  ptr.String("__EndpointArn__"),
		Bytes:        []byte("blob"),
		DocumentReaderConfig: &types.DocumentReaderConfig{
			DocumentReadAction: types.DocumentReadAction("TEXTRACT_DETECT_DOCUMENT_TEXT"),
			DocumentReadMode:   types.DocumentReadMode("SERVICE_DEFAULT"),
			FeatureTypes: []types.DocumentReadFeatureTypes{
				types.DocumentReadFeatureTypes("TABLES"),
				types.DocumentReadFeatureTypes("TABLES"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DetectEntities(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DetectEntities"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DetectKeyPhrases(t *testing.T) {
	input := &DetectKeyPhrasesInput{
		Text:         ptr.String("__Text__"),
		LanguageCode: types.LanguageCode("en"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DetectKeyPhrases(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DetectKeyPhrases"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DetectPiiEntities(t *testing.T) {
	input := &DetectPiiEntitiesInput{
		Text:         ptr.String("__Text__"),
		LanguageCode: types.LanguageCode("en"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DetectPiiEntities(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DetectPiiEntities"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DetectSentiment(t *testing.T) {
	input := &DetectSentimentInput{
		Text:         ptr.String("__Text__"),
		LanguageCode: types.LanguageCode("en"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DetectSentiment(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DetectSentiment"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DetectSyntax(t *testing.T) {
	input := &DetectSyntaxInput{
		Text:         ptr.String("__Text__"),
		LanguageCode: types.SyntaxLanguageCode("en"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DetectSyntax(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DetectSyntax"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DetectTargetedSentiment(t *testing.T) {
	input := &DetectTargetedSentimentInput{
		Text:         ptr.String("__Text__"),
		LanguageCode: types.LanguageCode("en"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DetectTargetedSentiment(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DetectTargetedSentiment"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DetectToxicContent(t *testing.T) {
	input := &DetectToxicContentInput{
		TextSegments: []types.TextSegment{
			{
				Text: ptr.String("__Text__"),
			},
			{
				Text: ptr.String("__Text__"),
			},
		},
		LanguageCode: types.LanguageCode("en"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DetectToxicContent(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DetectToxicContent"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ImportModel(t *testing.T) {
	input := &ImportModelInput{
		SourceModelArn:    ptr.String("__SourceModelArn__"),
		ModelName:         ptr.String("__ModelName__"),
		VersionName:       ptr.String("__VersionName__"),
		ModelKmsKeyId:     ptr.String("__ModelKmsKeyId__"),
		DataAccessRoleArn: ptr.String("__DataAccessRoleArn__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ImportModel(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ImportModel"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListDatasets(t *testing.T) {
	input := &ListDatasetsInput{
		FlywheelArn: ptr.String("__FlywheelArn__"),
		Filter: &types.DatasetFilter{
			Status:             types.DatasetStatus("CREATING"),
			DatasetType:        types.DatasetType("TRAIN"),
			CreationTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CreationTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListDatasets(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListDatasets"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListDocumentClassificationJobs(t *testing.T) {
	input := &ListDocumentClassificationJobsInput{
		Filter: &types.DocumentClassificationJobFilter{
			JobName:          ptr.String("__JobName__"),
			JobStatus:        types.JobStatus("SUBMITTED"),
			SubmitTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			SubmitTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListDocumentClassificationJobs(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListDocumentClassificationJobs"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListDocumentClassifiers(t *testing.T) {
	input := &ListDocumentClassifiersInput{
		Filter: &types.DocumentClassifierFilter{
			Status:                 types.ModelStatus("SUBMITTED"),
			DocumentClassifierName: ptr.String("__DocumentClassifierName__"),
			SubmitTimeBefore:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			SubmitTimeAfter:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListDocumentClassifiers(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListDocumentClassifiers"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListDocumentClassifierSummaries(t *testing.T) {
	input := &ListDocumentClassifierSummariesInput{
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListDocumentClassifierSummaries(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListDocumentClassifierSummaries"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListDominantLanguageDetectionJobs(t *testing.T) {
	input := &ListDominantLanguageDetectionJobsInput{
		Filter: &types.DominantLanguageDetectionJobFilter{
			JobName:          ptr.String("__JobName__"),
			JobStatus:        types.JobStatus("SUBMITTED"),
			SubmitTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			SubmitTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListDominantLanguageDetectionJobs(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListDominantLanguageDetectionJobs"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListEndpoints(t *testing.T) {
	input := &ListEndpointsInput{
		Filter: &types.EndpointFilter{
			ModelArn:           ptr.String("__ModelArn__"),
			Status:             types.EndpointStatus("CREATING"),
			CreationTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CreationTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListEndpoints(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListEndpoints"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListEntitiesDetectionJobs(t *testing.T) {
	input := &ListEntitiesDetectionJobsInput{
		Filter: &types.EntitiesDetectionJobFilter{
			JobName:          ptr.String("__JobName__"),
			JobStatus:        types.JobStatus("SUBMITTED"),
			SubmitTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			SubmitTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListEntitiesDetectionJobs(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListEntitiesDetectionJobs"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListEntityRecognizers(t *testing.T) {
	input := &ListEntityRecognizersInput{
		Filter: &types.EntityRecognizerFilter{
			Status:           types.ModelStatus("SUBMITTED"),
			RecognizerName:   ptr.String("__RecognizerName__"),
			SubmitTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			SubmitTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListEntityRecognizers(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListEntityRecognizers"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListEntityRecognizerSummaries(t *testing.T) {
	input := &ListEntityRecognizerSummariesInput{
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListEntityRecognizerSummaries(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListEntityRecognizerSummaries"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListEventsDetectionJobs(t *testing.T) {
	input := &ListEventsDetectionJobsInput{
		Filter: &types.EventsDetectionJobFilter{
			JobName:          ptr.String("__JobName__"),
			JobStatus:        types.JobStatus("SUBMITTED"),
			SubmitTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			SubmitTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListEventsDetectionJobs(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListEventsDetectionJobs"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListFlywheelIterationHistory(t *testing.T) {
	input := &ListFlywheelIterationHistoryInput{
		FlywheelArn: ptr.String("__FlywheelArn__"),
		Filter: &types.FlywheelIterationFilter{
			CreationTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CreationTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListFlywheelIterationHistory(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListFlywheelIterationHistory"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListFlywheels(t *testing.T) {
	input := &ListFlywheelsInput{
		Filter: &types.FlywheelFilter{
			Status:             types.FlywheelStatus("CREATING"),
			CreationTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CreationTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListFlywheels(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListFlywheels"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListKeyPhrasesDetectionJobs(t *testing.T) {
	input := &ListKeyPhrasesDetectionJobsInput{
		Filter: &types.KeyPhrasesDetectionJobFilter{
			JobName:          ptr.String("__JobName__"),
			JobStatus:        types.JobStatus("SUBMITTED"),
			SubmitTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			SubmitTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListKeyPhrasesDetectionJobs(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListKeyPhrasesDetectionJobs"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListPiiEntitiesDetectionJobs(t *testing.T) {
	input := &ListPiiEntitiesDetectionJobsInput{
		Filter: &types.PiiEntitiesDetectionJobFilter{
			JobName:          ptr.String("__JobName__"),
			JobStatus:        types.JobStatus("SUBMITTED"),
			SubmitTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			SubmitTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListPiiEntitiesDetectionJobs(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListPiiEntitiesDetectionJobs"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListSentimentDetectionJobs(t *testing.T) {
	input := &ListSentimentDetectionJobsInput{
		Filter: &types.SentimentDetectionJobFilter{
			JobName:          ptr.String("__JobName__"),
			JobStatus:        types.JobStatus("SUBMITTED"),
			SubmitTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			SubmitTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListSentimentDetectionJobs(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListSentimentDetectionJobs"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListTagsForResource(t *testing.T) {
	input := &ListTagsForResourceInput{
		ResourceArn: ptr.String("__ResourceArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListTagsForResource(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListTagsForResource"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListTargetedSentimentDetectionJobs(t *testing.T) {
	input := &ListTargetedSentimentDetectionJobsInput{
		Filter: &types.TargetedSentimentDetectionJobFilter{
			JobName:          ptr.String("__JobName__"),
			JobStatus:        types.JobStatus("SUBMITTED"),
			SubmitTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			SubmitTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListTargetedSentimentDetectionJobs(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListTargetedSentimentDetectionJobs"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListTopicsDetectionJobs(t *testing.T) {
	input := &ListTopicsDetectionJobsInput{
		Filter: &types.TopicsDetectionJobFilter{
			JobName:          ptr.String("__JobName__"),
			JobStatus:        types.JobStatus("SUBMITTED"),
			SubmitTimeBefore: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			SubmitTimeAfter:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListTopicsDetectionJobs(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListTopicsDetectionJobs"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutResourcePolicy(t *testing.T) {
	input := &PutResourcePolicyInput{
		ResourceArn:      ptr.String("__ResourceArn__"),
		ResourcePolicy:   ptr.String("__ResourcePolicy__"),
		PolicyRevisionId: ptr.String("__PolicyRevisionId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutResourcePolicy(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "PutResourcePolicy"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_StartDocumentClassificationJob(t *testing.T) {
	input := &StartDocumentClassificationJobInput{
		JobName:               ptr.String("__JobName__"),
		DocumentClassifierArn: ptr.String("__DocumentClassifierArn__"),
		InputDataConfig: &types.InputDataConfig{
			S3Uri:       ptr.String("__S3Uri__"),
			InputFormat: types.InputFormat("ONE_DOC_PER_FILE"),
			DocumentReaderConfig: &types.DocumentReaderConfig{
				DocumentReadAction: types.DocumentReadAction("TEXTRACT_DETECT_DOCUMENT_TEXT"),
				DocumentReadMode:   types.DocumentReadMode("SERVICE_DEFAULT"),
				FeatureTypes: []types.DocumentReadFeatureTypes{
					types.DocumentReadFeatureTypes("TABLES"),
					types.DocumentReadFeatureTypes("TABLES"),
				},
			},
		},
		OutputDataConfig: &types.OutputDataConfig{
			S3Uri:    ptr.String("__S3Uri__"),
			KmsKeyId: ptr.String("__KmsKeyId__"),
		},
		DataAccessRoleArn:  ptr.String("__DataAccessRoleArn__"),
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		VolumeKmsKeyId:     ptr.String("__VolumeKmsKeyId__"),
		VpcConfig: &types.VpcConfig{
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
			Subnets: []string{
				"__Member__",
				"__Member__",
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		FlywheelArn: ptr.String("__FlywheelArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartDocumentClassificationJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartDocumentClassificationJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_StartDominantLanguageDetectionJob(t *testing.T) {
	input := &StartDominantLanguageDetectionJobInput{
		InputDataConfig: &types.InputDataConfig{
			S3Uri:       ptr.String("__S3Uri__"),
			InputFormat: types.InputFormat("ONE_DOC_PER_FILE"),
			DocumentReaderConfig: &types.DocumentReaderConfig{
				DocumentReadAction: types.DocumentReadAction("TEXTRACT_DETECT_DOCUMENT_TEXT"),
				DocumentReadMode:   types.DocumentReadMode("SERVICE_DEFAULT"),
				FeatureTypes: []types.DocumentReadFeatureTypes{
					types.DocumentReadFeatureTypes("TABLES"),
					types.DocumentReadFeatureTypes("TABLES"),
				},
			},
		},
		OutputDataConfig: &types.OutputDataConfig{
			S3Uri:    ptr.String("__S3Uri__"),
			KmsKeyId: ptr.String("__KmsKeyId__"),
		},
		DataAccessRoleArn:  ptr.String("__DataAccessRoleArn__"),
		JobName:            ptr.String("__JobName__"),
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		VolumeKmsKeyId:     ptr.String("__VolumeKmsKeyId__"),
		VpcConfig: &types.VpcConfig{
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
			Subnets: []string{
				"__Member__",
				"__Member__",
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartDominantLanguageDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartDominantLanguageDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_StartEntitiesDetectionJob(t *testing.T) {
	input := &StartEntitiesDetectionJobInput{
		InputDataConfig: &types.InputDataConfig{
			S3Uri:       ptr.String("__S3Uri__"),
			InputFormat: types.InputFormat("ONE_DOC_PER_FILE"),
			DocumentReaderConfig: &types.DocumentReaderConfig{
				DocumentReadAction: types.DocumentReadAction("TEXTRACT_DETECT_DOCUMENT_TEXT"),
				DocumentReadMode:   types.DocumentReadMode("SERVICE_DEFAULT"),
				FeatureTypes: []types.DocumentReadFeatureTypes{
					types.DocumentReadFeatureTypes("TABLES"),
					types.DocumentReadFeatureTypes("TABLES"),
				},
			},
		},
		OutputDataConfig: &types.OutputDataConfig{
			S3Uri:    ptr.String("__S3Uri__"),
			KmsKeyId: ptr.String("__KmsKeyId__"),
		},
		DataAccessRoleArn:   ptr.String("__DataAccessRoleArn__"),
		JobName:             ptr.String("__JobName__"),
		EntityRecognizerArn: ptr.String("__EntityRecognizerArn__"),
		LanguageCode:        types.LanguageCode("en"),
		ClientRequestToken:  ptr.String("__ClientRequestToken__"),
		VolumeKmsKeyId:      ptr.String("__VolumeKmsKeyId__"),
		VpcConfig: &types.VpcConfig{
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
			Subnets: []string{
				"__Member__",
				"__Member__",
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		FlywheelArn: ptr.String("__FlywheelArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartEntitiesDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartEntitiesDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_StartEventsDetectionJob(t *testing.T) {
	input := &StartEventsDetectionJobInput{
		InputDataConfig: &types.InputDataConfig{
			S3Uri:       ptr.String("__S3Uri__"),
			InputFormat: types.InputFormat("ONE_DOC_PER_FILE"),
			DocumentReaderConfig: &types.DocumentReaderConfig{
				DocumentReadAction: types.DocumentReadAction("TEXTRACT_DETECT_DOCUMENT_TEXT"),
				DocumentReadMode:   types.DocumentReadMode("SERVICE_DEFAULT"),
				FeatureTypes: []types.DocumentReadFeatureTypes{
					types.DocumentReadFeatureTypes("TABLES"),
					types.DocumentReadFeatureTypes("TABLES"),
				},
			},
		},
		OutputDataConfig: &types.OutputDataConfig{
			S3Uri:    ptr.String("__S3Uri__"),
			KmsKeyId: ptr.String("__KmsKeyId__"),
		},
		DataAccessRoleArn:  ptr.String("__DataAccessRoleArn__"),
		JobName:            ptr.String("__JobName__"),
		LanguageCode:       types.LanguageCode("en"),
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		TargetEventTypes: []string{
			"__Member__",
			"__Member__",
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartEventsDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartEventsDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_StartFlywheelIteration(t *testing.T) {
	input := &StartFlywheelIterationInput{
		FlywheelArn:        ptr.String("__FlywheelArn__"),
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartFlywheelIteration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartFlywheelIteration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_StartKeyPhrasesDetectionJob(t *testing.T) {
	input := &StartKeyPhrasesDetectionJobInput{
		InputDataConfig: &types.InputDataConfig{
			S3Uri:       ptr.String("__S3Uri__"),
			InputFormat: types.InputFormat("ONE_DOC_PER_FILE"),
			DocumentReaderConfig: &types.DocumentReaderConfig{
				DocumentReadAction: types.DocumentReadAction("TEXTRACT_DETECT_DOCUMENT_TEXT"),
				DocumentReadMode:   types.DocumentReadMode("SERVICE_DEFAULT"),
				FeatureTypes: []types.DocumentReadFeatureTypes{
					types.DocumentReadFeatureTypes("TABLES"),
					types.DocumentReadFeatureTypes("TABLES"),
				},
			},
		},
		OutputDataConfig: &types.OutputDataConfig{
			S3Uri:    ptr.String("__S3Uri__"),
			KmsKeyId: ptr.String("__KmsKeyId__"),
		},
		DataAccessRoleArn:  ptr.String("__DataAccessRoleArn__"),
		JobName:            ptr.String("__JobName__"),
		LanguageCode:       types.LanguageCode("en"),
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		VolumeKmsKeyId:     ptr.String("__VolumeKmsKeyId__"),
		VpcConfig: &types.VpcConfig{
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
			Subnets: []string{
				"__Member__",
				"__Member__",
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartKeyPhrasesDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartKeyPhrasesDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_StartPiiEntitiesDetectionJob(t *testing.T) {
	input := &StartPiiEntitiesDetectionJobInput{
		InputDataConfig: &types.InputDataConfig{
			S3Uri:       ptr.String("__S3Uri__"),
			InputFormat: types.InputFormat("ONE_DOC_PER_FILE"),
			DocumentReaderConfig: &types.DocumentReaderConfig{
				DocumentReadAction: types.DocumentReadAction("TEXTRACT_DETECT_DOCUMENT_TEXT"),
				DocumentReadMode:   types.DocumentReadMode("SERVICE_DEFAULT"),
				FeatureTypes: []types.DocumentReadFeatureTypes{
					types.DocumentReadFeatureTypes("TABLES"),
					types.DocumentReadFeatureTypes("TABLES"),
				},
			},
		},
		OutputDataConfig: &types.OutputDataConfig{
			S3Uri:    ptr.String("__S3Uri__"),
			KmsKeyId: ptr.String("__KmsKeyId__"),
		},
		Mode: types.PiiEntitiesDetectionMode("ONLY_REDACTION"),
		RedactionConfig: &types.RedactionConfig{
			PiiEntityTypes: []types.PiiEntityType{
				types.PiiEntityType("BANK_ACCOUNT_NUMBER"),
				types.PiiEntityType("BANK_ACCOUNT_NUMBER"),
			},
			MaskMode:      types.PiiEntitiesDetectionMaskMode("MASK"),
			MaskCharacter: ptr.String("__MaskCharacter__"),
		},
		DataAccessRoleArn:  ptr.String("__DataAccessRoleArn__"),
		JobName:            ptr.String("__JobName__"),
		LanguageCode:       types.LanguageCode("en"),
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartPiiEntitiesDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartPiiEntitiesDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_StartSentimentDetectionJob(t *testing.T) {
	input := &StartSentimentDetectionJobInput{
		InputDataConfig: &types.InputDataConfig{
			S3Uri:       ptr.String("__S3Uri__"),
			InputFormat: types.InputFormat("ONE_DOC_PER_FILE"),
			DocumentReaderConfig: &types.DocumentReaderConfig{
				DocumentReadAction: types.DocumentReadAction("TEXTRACT_DETECT_DOCUMENT_TEXT"),
				DocumentReadMode:   types.DocumentReadMode("SERVICE_DEFAULT"),
				FeatureTypes: []types.DocumentReadFeatureTypes{
					types.DocumentReadFeatureTypes("TABLES"),
					types.DocumentReadFeatureTypes("TABLES"),
				},
			},
		},
		OutputDataConfig: &types.OutputDataConfig{
			S3Uri:    ptr.String("__S3Uri__"),
			KmsKeyId: ptr.String("__KmsKeyId__"),
		},
		DataAccessRoleArn:  ptr.String("__DataAccessRoleArn__"),
		JobName:            ptr.String("__JobName__"),
		LanguageCode:       types.LanguageCode("en"),
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		VolumeKmsKeyId:     ptr.String("__VolumeKmsKeyId__"),
		VpcConfig: &types.VpcConfig{
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
			Subnets: []string{
				"__Member__",
				"__Member__",
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartSentimentDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartSentimentDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_StartTargetedSentimentDetectionJob(t *testing.T) {
	input := &StartTargetedSentimentDetectionJobInput{
		InputDataConfig: &types.InputDataConfig{
			S3Uri:       ptr.String("__S3Uri__"),
			InputFormat: types.InputFormat("ONE_DOC_PER_FILE"),
			DocumentReaderConfig: &types.DocumentReaderConfig{
				DocumentReadAction: types.DocumentReadAction("TEXTRACT_DETECT_DOCUMENT_TEXT"),
				DocumentReadMode:   types.DocumentReadMode("SERVICE_DEFAULT"),
				FeatureTypes: []types.DocumentReadFeatureTypes{
					types.DocumentReadFeatureTypes("TABLES"),
					types.DocumentReadFeatureTypes("TABLES"),
				},
			},
		},
		OutputDataConfig: &types.OutputDataConfig{
			S3Uri:    ptr.String("__S3Uri__"),
			KmsKeyId: ptr.String("__KmsKeyId__"),
		},
		DataAccessRoleArn:  ptr.String("__DataAccessRoleArn__"),
		JobName:            ptr.String("__JobName__"),
		LanguageCode:       types.LanguageCode("en"),
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		VolumeKmsKeyId:     ptr.String("__VolumeKmsKeyId__"),
		VpcConfig: &types.VpcConfig{
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
			Subnets: []string{
				"__Member__",
				"__Member__",
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartTargetedSentimentDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartTargetedSentimentDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_StartTopicsDetectionJob(t *testing.T) {
	input := &StartTopicsDetectionJobInput{
		InputDataConfig: &types.InputDataConfig{
			S3Uri:       ptr.String("__S3Uri__"),
			InputFormat: types.InputFormat("ONE_DOC_PER_FILE"),
			DocumentReaderConfig: &types.DocumentReaderConfig{
				DocumentReadAction: types.DocumentReadAction("TEXTRACT_DETECT_DOCUMENT_TEXT"),
				DocumentReadMode:   types.DocumentReadMode("SERVICE_DEFAULT"),
				FeatureTypes: []types.DocumentReadFeatureTypes{
					types.DocumentReadFeatureTypes("TABLES"),
					types.DocumentReadFeatureTypes("TABLES"),
				},
			},
		},
		OutputDataConfig: &types.OutputDataConfig{
			S3Uri:    ptr.String("__S3Uri__"),
			KmsKeyId: ptr.String("__KmsKeyId__"),
		},
		DataAccessRoleArn:  ptr.String("__DataAccessRoleArn__"),
		JobName:            ptr.String("__JobName__"),
		NumberOfTopics:     ptr.Int32(1),
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		VolumeKmsKeyId:     ptr.String("__VolumeKmsKeyId__"),
		VpcConfig: &types.VpcConfig{
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
			Subnets: []string{
				"__Member__",
				"__Member__",
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartTopicsDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartTopicsDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_StopDominantLanguageDetectionJob(t *testing.T) {
	input := &StopDominantLanguageDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopDominantLanguageDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StopDominantLanguageDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_StopEntitiesDetectionJob(t *testing.T) {
	input := &StopEntitiesDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopEntitiesDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StopEntitiesDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_StopEventsDetectionJob(t *testing.T) {
	input := &StopEventsDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopEventsDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StopEventsDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_StopKeyPhrasesDetectionJob(t *testing.T) {
	input := &StopKeyPhrasesDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopKeyPhrasesDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StopKeyPhrasesDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_StopPiiEntitiesDetectionJob(t *testing.T) {
	input := &StopPiiEntitiesDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopPiiEntitiesDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StopPiiEntitiesDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_StopSentimentDetectionJob(t *testing.T) {
	input := &StopSentimentDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopSentimentDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StopSentimentDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_StopTargetedSentimentDetectionJob(t *testing.T) {
	input := &StopTargetedSentimentDetectionJobInput{
		JobId: ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopTargetedSentimentDetectionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StopTargetedSentimentDetectionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_StopTrainingDocumentClassifier(t *testing.T) {
	input := &StopTrainingDocumentClassifierInput{
		DocumentClassifierArn: ptr.String("__DocumentClassifierArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopTrainingDocumentClassifier(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StopTrainingDocumentClassifier"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_StopTrainingEntityRecognizer(t *testing.T) {
	input := &StopTrainingEntityRecognizerInput{
		EntityRecognizerArn: ptr.String("__EntityRecognizerArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopTrainingEntityRecognizer(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StopTrainingEntityRecognizer"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_TagResource(t *testing.T) {
	input := &TagResourceInput{
		ResourceArn: ptr.String("__ResourceArn__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.TagResource(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "TagResource"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UntagResource(t *testing.T) {
	input := &UntagResourceInput{
		ResourceArn: ptr.String("__ResourceArn__"),
		TagKeys: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UntagResource(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UntagResource"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateEndpoint(t *testing.T) {
	input := &UpdateEndpointInput{
		EndpointArn:              ptr.String("__EndpointArn__"),
		DesiredModelArn:          ptr.String("__DesiredModelArn__"),
		DesiredInferenceUnits:    ptr.Int32(1),
		DesiredDataAccessRoleArn: ptr.String("__DesiredDataAccessRoleArn__"),
		FlywheelArn:              ptr.String("__FlywheelArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateEndpoint(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateEndpoint"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateFlywheel(t *testing.T) {
	input := &UpdateFlywheelInput{
		FlywheelArn:       ptr.String("__FlywheelArn__"),
		ActiveModelArn:    ptr.String("__ActiveModelArn__"),
		DataAccessRoleArn: ptr.String("__DataAccessRoleArn__"),
		DataSecurityConfig: &types.UpdateDataSecurityConfig{
			ModelKmsKeyId:  ptr.String("__ModelKmsKeyId__"),
			VolumeKmsKeyId: ptr.String("__VolumeKmsKeyId__"),
			VpcConfig: &types.VpcConfig{
				SecurityGroupIds: []string{
					"__Member__",
					"__Member__",
				},
				Subnets: []string{
					"__Member__",
					"__Member__",
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateFlywheel(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateFlywheel"); err != nil {
		t.Fatal(err)
	}
}
