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

//go:build request_snapshot

package dynamodb

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/dynamodb/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_BatchExecuteStatement(t *testing.T) {
	input := &BatchExecuteStatementInput{
		Statements: []types.BatchStatementRequest{
			{
				Statement: ptr.String("__Statement__"),
				Parameters: []types.AttributeValue{
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
				},
				ConsistentRead:                      ptr.Bool(true),
				ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
			},
			{
				Statement: ptr.String("__Statement__"),
				Parameters: []types.AttributeValue{
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
				},
				ConsistentRead:                      ptr.Bool(true),
				ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
			},
		},
		ReturnConsumedCapacity: types.ReturnConsumedCapacity("INDEXES"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchExecuteStatement(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(), "BatchExecuteStatement"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_BatchGetItem(t *testing.T) {
	input := &BatchGetItemInput{
		RequestItems: map[string]types.KeysAndAttributes{
			"key0": {
				Keys: []map[string]types.AttributeValue{
					{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
				},
				AttributesToGet: []string{
					"__Member__",
					"__Member__",
				},
				ConsistentRead:       ptr.Bool(true),
				ProjectionExpression: ptr.String("__ProjectionExpression__"),
				ExpressionAttributeNames: map[string]string{
					"key0": "__Value__",
				},
			},
		},
		ReturnConsumedCapacity: types.ReturnConsumedCapacity("INDEXES"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchGetItem(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(), "BatchGetItem"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_BatchWriteItem(t *testing.T) {
	input := &BatchWriteItemInput{
		RequestItems: map[string][]types.WriteRequest{
			"key0": {
				{
					PutRequest: &types.PutRequest{
						Item: map[string]types.AttributeValue{
							"key0": &types.AttributeValueMemberS{
								Value: "__AttributeValueMemberS__",
							},
						},
					},
					DeleteRequest: &types.DeleteRequest{
						Key: map[string]types.AttributeValue{
							"key0": &types.AttributeValueMemberS{
								Value: "__AttributeValueMemberS__",
							},
						},
					},
				},
				{
					PutRequest: &types.PutRequest{
						Item: map[string]types.AttributeValue{
							"key0": &types.AttributeValueMemberS{
								Value: "__AttributeValueMemberS__",
							},
						},
					},
					DeleteRequest: &types.DeleteRequest{
						Key: map[string]types.AttributeValue{
							"key0": &types.AttributeValueMemberS{
								Value: "__AttributeValueMemberS__",
							},
						},
					},
				},
			},
		},
		ReturnConsumedCapacity:      types.ReturnConsumedCapacity("INDEXES"),
		ReturnItemCollectionMetrics: types.ReturnItemCollectionMetrics("SIZE"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchWriteItem(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(), "BatchWriteItem"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateBackup(t *testing.T) {
	input := &CreateBackupInput{
		TableName:  ptr.String("__TableName__"),
		BackupName: ptr.String("__BackupName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateBackup(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(), "CreateBackup"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateGlobalTable(t *testing.T) {
	input := &CreateGlobalTableInput{
		GlobalTableName: ptr.String("__GlobalTableName__"),
		ReplicationGroup: []types.Replica{
			{
				RegionName: ptr.String("__RegionName__"),
			},
			{
				RegionName: ptr.String("__RegionName__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateGlobalTable(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(), "CreateGlobalTable"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateTable(t *testing.T) {
	input := &CreateTableInput{
		AttributeDefinitions: []types.AttributeDefinition{
			{
				AttributeName: ptr.String("__AttributeName__"),
				AttributeType: types.ScalarAttributeType("S"),
			},
			{
				AttributeName: ptr.String("__AttributeName__"),
				AttributeType: types.ScalarAttributeType("S"),
			},
		},
		TableName: ptr.String("__TableName__"),
		KeySchema: []types.KeySchemaElement{
			{
				AttributeName: ptr.String("__AttributeName__"),
				KeyType:       types.KeyType("HASH"),
			},
			{
				AttributeName: ptr.String("__AttributeName__"),
				KeyType:       types.KeyType("HASH"),
			},
		},
		LocalSecondaryIndexes: []types.LocalSecondaryIndex{
			{
				IndexName: ptr.String("__IndexName__"),
				KeySchema: []types.KeySchemaElement{
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
				},
				Projection: &types.Projection{
					ProjectionType: types.ProjectionType("ALL"),
					NonKeyAttributes: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
			{
				IndexName: ptr.String("__IndexName__"),
				KeySchema: []types.KeySchemaElement{
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
				},
				Projection: &types.Projection{
					ProjectionType: types.ProjectionType("ALL"),
					NonKeyAttributes: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
		},
		GlobalSecondaryIndexes: []types.GlobalSecondaryIndex{
			{
				IndexName: ptr.String("__IndexName__"),
				KeySchema: []types.KeySchemaElement{
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
				},
				Projection: &types.Projection{
					ProjectionType: types.ProjectionType("ALL"),
					NonKeyAttributes: []string{
						"__Member__",
						"__Member__",
					},
				},
				ProvisionedThroughput: &types.ProvisionedThroughput{
					ReadCapacityUnits:  ptr.Int64(1),
					WriteCapacityUnits: ptr.Int64(1),
				},
				OnDemandThroughput: &types.OnDemandThroughput{
					MaxReadRequestUnits:  ptr.Int64(1),
					MaxWriteRequestUnits: ptr.Int64(1),
				},
				WarmThroughput: &types.WarmThroughput{
					ReadUnitsPerSecond:  ptr.Int64(1),
					WriteUnitsPerSecond: ptr.Int64(1),
				},
			},
			{
				IndexName: ptr.String("__IndexName__"),
				KeySchema: []types.KeySchemaElement{
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
				},
				Projection: &types.Projection{
					ProjectionType: types.ProjectionType("ALL"),
					NonKeyAttributes: []string{
						"__Member__",
						"__Member__",
					},
				},
				ProvisionedThroughput: &types.ProvisionedThroughput{
					ReadCapacityUnits:  ptr.Int64(1),
					WriteCapacityUnits: ptr.Int64(1),
				},
				OnDemandThroughput: &types.OnDemandThroughput{
					MaxReadRequestUnits:  ptr.Int64(1),
					MaxWriteRequestUnits: ptr.Int64(1),
				},
				WarmThroughput: &types.WarmThroughput{
					ReadUnitsPerSecond:  ptr.Int64(1),
					WriteUnitsPerSecond: ptr.Int64(1),
				},
			},
		},
		BillingMode: types.BillingMode("PROVISIONED"),
		ProvisionedThroughput: &types.ProvisionedThroughput{
			ReadCapacityUnits:  ptr.Int64(1),
			WriteCapacityUnits: ptr.Int64(1),
		},
		StreamSpecification: &types.StreamSpecification{
			StreamEnabled:  ptr.Bool(true),
			StreamViewType: types.StreamViewType("NEW_IMAGE"),
		},
		SSESpecification: &types.SSESpecification{
			Enabled:        ptr.Bool(true),
			SSEType:        types.SSEType("AES256"),
			KMSMasterKeyId: ptr.String("__KMSMasterKeyId__"),
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		TableClass:                types.TableClass("STANDARD"),
		DeletionProtectionEnabled: ptr.Bool(true),
		WarmThroughput: &types.WarmThroughput{
			ReadUnitsPerSecond:  ptr.Int64(1),
			WriteUnitsPerSecond: ptr.Int64(1),
		},
		ResourcePolicy: ptr.String("__ResourcePolicy__"),
		OnDemandThroughput: &types.OnDemandThroughput{
			MaxReadRequestUnits:  ptr.Int64(1),
			MaxWriteRequestUnits: ptr.Int64(1),
		},
		GlobalTableSourceArn:               ptr.String("__GlobalTableSourceArn__"),
		GlobalTableSettingsReplicationMode: types.GlobalTableSettingsReplicationMode("ENABLED"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateTable(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(), "CreateTable"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteBackup(t *testing.T) {
	input := &DeleteBackupInput{
		BackupArn: ptr.String("__BackupArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBackup(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(), "DeleteBackup"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteItem(t *testing.T) {
	input := &DeleteItemInput{
		TableName: ptr.String("__TableName__"),
		Key: map[string]types.AttributeValue{
			"key0": &types.AttributeValueMemberS{
				Value: "__AttributeValueMemberS__",
			},
		},
		Expected: map[string]types.ExpectedAttributeValue{
			"key0": {
				Value: &types.AttributeValueMemberS{
					Value: "__AttributeValueMemberS__",
				},
				Exists:             ptr.Bool(true),
				ComparisonOperator: types.ComparisonOperator("EQ"),
				AttributeValueList: []types.AttributeValue{
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
				},
			},
		},
		ConditionalOperator:         types.ConditionalOperator("AND"),
		ReturnValues:                types.ReturnValue("NONE"),
		ReturnConsumedCapacity:      types.ReturnConsumedCapacity("INDEXES"),
		ReturnItemCollectionMetrics: types.ReturnItemCollectionMetrics("SIZE"),
		ConditionExpression:         ptr.String("__ConditionExpression__"),
		ExpressionAttributeNames: map[string]string{
			"key0": "__Value__",
		},
		ExpressionAttributeValues: map[string]types.AttributeValue{
			"key0": &types.AttributeValueMemberS{
				Value: "__AttributeValueMemberS__",
			},
		},
		ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteItem(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(), "DeleteItem"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteResourcePolicy(t *testing.T) {
	input := &DeleteResourcePolicyInput{
		ResourceArn:        ptr.String("__ResourceArn__"),
		ExpectedRevisionId: ptr.String("__ExpectedRevisionId__"),
	}
	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_DeleteTable(t *testing.T) {
	input := &DeleteTableInput{
		TableName: ptr.String("__TableName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteTable(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(), "DeleteTable"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeBackup(t *testing.T) {
	input := &DescribeBackupInput{
		BackupArn: ptr.String("__BackupArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeBackup(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(), "DescribeBackup"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeContinuousBackups(t *testing.T) {
	input := &DescribeContinuousBackupsInput{
		TableName: ptr.String("__TableName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeContinuousBackups(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(), "DescribeContinuousBackups"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeContributorInsights(t *testing.T) {
	input := &DescribeContributorInsightsInput{
		TableName: ptr.String("__TableName__"),
		IndexName: ptr.String("__IndexName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeContributorInsights(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(), "DescribeContributorInsights"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeEndpoints(t *testing.T) {
	input := &DescribeEndpointsInput{}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeEndpoints(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(), "DescribeEndpoints"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeExport(t *testing.T) {
	input := &DescribeExportInput{
		ExportArn: ptr.String("__ExportArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeExport(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(), "DescribeExport"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeGlobalTable(t *testing.T) {
	input := &DescribeGlobalTableInput{
		GlobalTableName: ptr.String("__GlobalTableName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeGlobalTable(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(), "DescribeGlobalTable"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeGlobalTableSettings(t *testing.T) {
	input := &DescribeGlobalTableSettingsInput{
		GlobalTableName: ptr.String("__GlobalTableName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeGlobalTableSettings(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(), "DescribeGlobalTableSettings"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeImport(t *testing.T) {
	input := &DescribeImportInput{
		ImportArn: ptr.String("__ImportArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeImport(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(), "DescribeImport"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeKinesisStreamingDestination(t *testing.T) {
	input := &DescribeKinesisStreamingDestinationInput{
		TableName: ptr.String("__TableName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeKinesisStreamingDestination(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(), "DescribeKinesisStreamingDestination"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeLimits(t *testing.T) {
	input := &DescribeLimitsInput{}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeLimits(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(), "DescribeLimits"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeTable(t *testing.T) {
	input := &DescribeTableInput{
		TableName: ptr.String("__TableName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeTable(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(), "DescribeTable"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeTableReplicaAutoScaling(t *testing.T) {
	input := &DescribeTableReplicaAutoScalingInput{
		TableName: ptr.String("__TableName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeTableReplicaAutoScaling(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(), "DescribeTableReplicaAutoScaling"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeTimeToLive(t *testing.T) {
	input := &DescribeTimeToLiveInput{
		TableName: ptr.String("__TableName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeTimeToLive(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(), "DescribeTimeToLive"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DisableKinesisStreamingDestination(t *testing.T) {
	input := &DisableKinesisStreamingDestinationInput{
		TableName: ptr.String("__TableName__"),
		StreamArn: ptr.String("__StreamArn__"),
		EnableKinesisStreamingConfiguration: &types.EnableKinesisStreamingConfiguration{
			ApproximateCreationDateTimePrecision: types.ApproximateCreationDateTimePrecision("MILLISECOND"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DisableKinesisStreamingDestination(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(), "DisableKinesisStreamingDestination"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_EnableKinesisStreamingDestination(t *testing.T) {
	input := &EnableKinesisStreamingDestinationInput{
		TableName: ptr.String("__TableName__"),
		StreamArn: ptr.String("__StreamArn__"),
		EnableKinesisStreamingConfiguration: &types.EnableKinesisStreamingConfiguration{
			ApproximateCreationDateTimePrecision: types.ApproximateCreationDateTimePrecision("MILLISECOND"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.EnableKinesisStreamingDestination(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(), "EnableKinesisStreamingDestination"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ExecuteStatement(t *testing.T) {
	input := &ExecuteStatementInput{
		Statement: ptr.String("__Statement__"),
		Parameters: []types.AttributeValue{
			&types.AttributeValueMemberS{
				Value: "__AttributeValueMemberS__",
			},
			&types.AttributeValueMemberS{
				Value: "__AttributeValueMemberS__",
			},
		},
		ConsistentRead:                      ptr.Bool(true),
		NextToken:                           ptr.String("__NextToken__"),
		ReturnConsumedCapacity:              types.ReturnConsumedCapacity("INDEXES"),
		Limit:                               ptr.Int32(1),
		ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ExecuteStatement(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(), "ExecuteStatement"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ExecuteTransaction(t *testing.T) {
	input := &ExecuteTransactionInput{
		TransactStatements: []types.ParameterizedStatement{
			{
				Statement: ptr.String("__Statement__"),
				Parameters: []types.AttributeValue{
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
				},
				ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
			},
			{
				Statement: ptr.String("__Statement__"),
				Parameters: []types.AttributeValue{
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
				},
				ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
			},
		},
		ClientRequestToken:     ptr.String("__ClientRequestToken__"),
		ReturnConsumedCapacity: types.ReturnConsumedCapacity("INDEXES"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ExecuteTransaction(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(), "ExecuteTransaction"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ExportTableToPointInTime(t *testing.T) {
	input := &ExportTableToPointInTimeInput{
		TableArn:       ptr.String("__TableArn__"),
		ExportTime:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ClientToken:    ptr.String("__ClientToken__"),
		S3Bucket:       ptr.String("__S3Bucket__"),
		S3BucketOwner:  ptr.String("__S3BucketOwner__"),
		S3Prefix:       ptr.String("__S3Prefix__"),
		S3SseAlgorithm: types.S3SseAlgorithm("AES256"),
		S3SseKmsKeyId:  ptr.String("__S3SseKmsKeyId__"),
		ExportFormat:   types.ExportFormat("DYNAMODB_JSON"),
		ExportType:     types.ExportType("FULL_EXPORT"),
		IncrementalExportSpecification: &types.IncrementalExportSpecification{
			ExportFromTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			ExportToTime:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			ExportViewType: types.ExportViewType("NEW_IMAGE"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ExportTableToPointInTime(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(), "ExportTableToPointInTime"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetItem(t *testing.T) {
	input := &GetItemInput{
		TableName: ptr.String("__TableName__"),
		Key: map[string]types.AttributeValue{
			"key0": &types.AttributeValueMemberS{
				Value: "__AttributeValueMemberS__",
			},
		},
		AttributesToGet: []string{
			"__Member__",
			"__Member__",
		},
		ConsistentRead:         ptr.Bool(true),
		ReturnConsumedCapacity: types.ReturnConsumedCapacity("INDEXES"),
		ProjectionExpression:   ptr.String("__ProjectionExpression__"),
		ExpressionAttributeNames: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetItem(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(), "GetItem"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetResourcePolicy(t *testing.T) {
	input := &GetResourcePolicyInput{
		ResourceArn: ptr.String("__ResourceArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetResourcePolicy(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(), "GetResourcePolicy"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ImportTable(t *testing.T) {
	input := &ImportTableInput{
		ClientToken: ptr.String("__ClientToken__"),
		S3BucketSource: &types.S3BucketSource{
			S3BucketOwner: ptr.String("__S3BucketOwner__"),
			S3Bucket:      ptr.String("__S3Bucket__"),
			S3KeyPrefix:   ptr.String("__S3KeyPrefix__"),
		},
		InputFormat: types.InputFormat("DYNAMODB_JSON"),
		InputFormatOptions: &types.InputFormatOptions{
			Csv: &types.CsvOptions{
				Delimiter: ptr.String("__Delimiter__"),
				HeaderList: []string{
					"__Member__",
					"__Member__",
				},
			},
		},
		InputCompressionType: types.InputCompressionType("GZIP"),
		TableCreationParameters: &types.TableCreationParameters{
			TableName: ptr.String("__TableName__"),
			AttributeDefinitions: []types.AttributeDefinition{
				{
					AttributeName: ptr.String("__AttributeName__"),
					AttributeType: types.ScalarAttributeType("S"),
				},
				{
					AttributeName: ptr.String("__AttributeName__"),
					AttributeType: types.ScalarAttributeType("S"),
				},
			},
			KeySchema: []types.KeySchemaElement{
				{
					AttributeName: ptr.String("__AttributeName__"),
					KeyType:       types.KeyType("HASH"),
				},
				{
					AttributeName: ptr.String("__AttributeName__"),
					KeyType:       types.KeyType("HASH"),
				},
			},
			BillingMode: types.BillingMode("PROVISIONED"),
			ProvisionedThroughput: &types.ProvisionedThroughput{
				ReadCapacityUnits:  ptr.Int64(1),
				WriteCapacityUnits: ptr.Int64(1),
			},
			OnDemandThroughput: &types.OnDemandThroughput{
				MaxReadRequestUnits:  ptr.Int64(1),
				MaxWriteRequestUnits: ptr.Int64(1),
			},
			SSESpecification: &types.SSESpecification{
				Enabled:        ptr.Bool(true),
				SSEType:        types.SSEType("AES256"),
				KMSMasterKeyId: ptr.String("__KMSMasterKeyId__"),
			},
			GlobalSecondaryIndexes: []types.GlobalSecondaryIndex{
				{
					IndexName: ptr.String("__IndexName__"),
					KeySchema: []types.KeySchemaElement{
						{
							AttributeName: ptr.String("__AttributeName__"),
							KeyType:       types.KeyType("HASH"),
						},
						{
							AttributeName: ptr.String("__AttributeName__"),
							KeyType:       types.KeyType("HASH"),
						},
					},
					Projection: &types.Projection{
						ProjectionType: types.ProjectionType("ALL"),
						NonKeyAttributes: []string{
							"__Member__",
							"__Member__",
						},
					},
					ProvisionedThroughput: &types.ProvisionedThroughput{
						ReadCapacityUnits:  ptr.Int64(1),
						WriteCapacityUnits: ptr.Int64(1),
					},
					OnDemandThroughput: &types.OnDemandThroughput{
						MaxReadRequestUnits:  ptr.Int64(1),
						MaxWriteRequestUnits: ptr.Int64(1),
					},
					WarmThroughput: &types.WarmThroughput{
						ReadUnitsPerSecond:  ptr.Int64(1),
						WriteUnitsPerSecond: ptr.Int64(1),
					},
				},
				{
					IndexName: ptr.String("__IndexName__"),
					KeySchema: []types.KeySchemaElement{
						{
							AttributeName: ptr.String("__AttributeName__"),
							KeyType:       types.KeyType("HASH"),
						},
						{
							AttributeName: ptr.String("__AttributeName__"),
							KeyType:       types.KeyType("HASH"),
						},
					},
					Projection: &types.Projection{
						ProjectionType: types.ProjectionType("ALL"),
						NonKeyAttributes: []string{
							"__Member__",
							"__Member__",
						},
					},
					ProvisionedThroughput: &types.ProvisionedThroughput{
						ReadCapacityUnits:  ptr.Int64(1),
						WriteCapacityUnits: ptr.Int64(1),
					},
					OnDemandThroughput: &types.OnDemandThroughput{
						MaxReadRequestUnits:  ptr.Int64(1),
						MaxWriteRequestUnits: ptr.Int64(1),
					},
					WarmThroughput: &types.WarmThroughput{
						ReadUnitsPerSecond:  ptr.Int64(1),
						WriteUnitsPerSecond: ptr.Int64(1),
					},
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ImportTable(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(), "ImportTable"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListBackups(t *testing.T) {
	input := &ListBackupsInput{
		TableName:               ptr.String("__TableName__"),
		Limit:                   ptr.Int32(1),
		TimeRangeLowerBound:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		TimeRangeUpperBound:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ExclusiveStartBackupArn: ptr.String("__ExclusiveStartBackupArn__"),
		BackupType:              types.BackupTypeFilter("USER"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBackups(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(), "ListBackups"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListContributorInsights(t *testing.T) {
	input := &ListContributorInsightsInput{
		TableName:  ptr.String("__TableName__"),
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: 1,
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListContributorInsights(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(), "ListContributorInsights"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListExports(t *testing.T) {
	input := &ListExportsInput{
		TableArn:   ptr.String("__TableArn__"),
		MaxResults: ptr.Int32(1),
		NextToken:  ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListExports(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(), "ListExports"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListGlobalTables(t *testing.T) {
	input := &ListGlobalTablesInput{
		ExclusiveStartGlobalTableName: ptr.String("__ExclusiveStartGlobalTableName__"),
		Limit:                         ptr.Int32(1),
		RegionName:                    ptr.String("__RegionName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListGlobalTables(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(), "ListGlobalTables"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListImports(t *testing.T) {
	input := &ListImportsInput{
		TableArn:  ptr.String("__TableArn__"),
		PageSize:  ptr.Int32(1),
		NextToken: ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListImports(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(), "ListImports"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListTables(t *testing.T) {
	input := &ListTablesInput{
		ExclusiveStartTableName: ptr.String("__ExclusiveStartTableName__"),
		Limit:                   ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListTables(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(), "ListTables"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListTagsOfResource(t *testing.T) {
	input := &ListTagsOfResourceInput{
		ResourceArn: ptr.String("__ResourceArn__"),
		NextToken:   ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListTagsOfResource(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(), "ListTagsOfResource"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutItem(t *testing.T) {
	input := &PutItemInput{
		TableName: ptr.String("__TableName__"),
		Item: map[string]types.AttributeValue{
			"key0": &types.AttributeValueMemberS{
				Value: "__AttributeValueMemberS__",
			},
		},
		Expected: map[string]types.ExpectedAttributeValue{
			"key0": {
				Value: &types.AttributeValueMemberS{
					Value: "__AttributeValueMemberS__",
				},
				Exists:             ptr.Bool(true),
				ComparisonOperator: types.ComparisonOperator("EQ"),
				AttributeValueList: []types.AttributeValue{
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
				},
			},
		},
		ReturnValues:                types.ReturnValue("NONE"),
		ReturnConsumedCapacity:      types.ReturnConsumedCapacity("INDEXES"),
		ReturnItemCollectionMetrics: types.ReturnItemCollectionMetrics("SIZE"),
		ConditionalOperator:         types.ConditionalOperator("AND"),
		ConditionExpression:         ptr.String("__ConditionExpression__"),
		ExpressionAttributeNames: map[string]string{
			"key0": "__Value__",
		},
		ExpressionAttributeValues: map[string]types.AttributeValue{
			"key0": &types.AttributeValueMemberS{
				Value: "__AttributeValueMemberS__",
			},
		},
		ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutItem(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(), "PutItem"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutResourcePolicy(t *testing.T) {
	input := &PutResourcePolicyInput{
		ResourceArn:                     ptr.String("__ResourceArn__"),
		Policy:                          ptr.String("__Policy__"),
		ExpectedRevisionId:              ptr.String("__ExpectedRevisionId__"),
		ConfirmRemoveSelfResourceAccess: true,
	}
	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_Query(t *testing.T) {
	input := &QueryInput{
		TableName: ptr.String("__TableName__"),
		IndexName: ptr.String("__IndexName__"),
		Select:    types.Select("ALL_ATTRIBUTES"),
		AttributesToGet: []string{
			"__Member__",
			"__Member__",
		},
		Limit:          ptr.Int32(1),
		ConsistentRead: ptr.Bool(true),
		KeyConditions: map[string]types.Condition{
			"key0": {
				AttributeValueList: []types.AttributeValue{
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
				},
				ComparisonOperator: types.ComparisonOperator("EQ"),
			},
		},
		QueryFilter: map[string]types.Condition{
			"key0": {
				AttributeValueList: []types.AttributeValue{
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
				},
				ComparisonOperator: types.ComparisonOperator("EQ"),
			},
		},
		ConditionalOperator: types.ConditionalOperator("AND"),
		ScanIndexForward:    ptr.Bool(true),
		ExclusiveStartKey: map[string]types.AttributeValue{
			"key0": &types.AttributeValueMemberS{
				Value: "__AttributeValueMemberS__",
			},
		},
		ReturnConsumedCapacity: types.ReturnConsumedCapacity("INDEXES"),
		ProjectionExpression:   ptr.String("__ProjectionExpression__"),
		FilterExpression:       ptr.String("__FilterExpression__"),
		KeyConditionExpression: ptr.String("__KeyConditionExpression__"),
		ExpressionAttributeNames: map[string]string{
			"key0": "__Value__",
		},
		ExpressionAttributeValues: map[string]types.AttributeValue{
			"key0": &types.AttributeValueMemberS{
				Value: "__AttributeValueMemberS__",
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.Query(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(), "Query"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_RestoreTableFromBackup(t *testing.T) {
	input := &RestoreTableFromBackupInput{
		TargetTableName:     ptr.String("__TargetTableName__"),
		BackupArn:           ptr.String("__BackupArn__"),
		BillingModeOverride: types.BillingMode("PROVISIONED"),
		GlobalSecondaryIndexOverride: []types.GlobalSecondaryIndex{
			{
				IndexName: ptr.String("__IndexName__"),
				KeySchema: []types.KeySchemaElement{
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
				},
				Projection: &types.Projection{
					ProjectionType: types.ProjectionType("ALL"),
					NonKeyAttributes: []string{
						"__Member__",
						"__Member__",
					},
				},
				ProvisionedThroughput: &types.ProvisionedThroughput{
					ReadCapacityUnits:  ptr.Int64(1),
					WriteCapacityUnits: ptr.Int64(1),
				},
				OnDemandThroughput: &types.OnDemandThroughput{
					MaxReadRequestUnits:  ptr.Int64(1),
					MaxWriteRequestUnits: ptr.Int64(1),
				},
				WarmThroughput: &types.WarmThroughput{
					ReadUnitsPerSecond:  ptr.Int64(1),
					WriteUnitsPerSecond: ptr.Int64(1),
				},
			},
			{
				IndexName: ptr.String("__IndexName__"),
				KeySchema: []types.KeySchemaElement{
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
				},
				Projection: &types.Projection{
					ProjectionType: types.ProjectionType("ALL"),
					NonKeyAttributes: []string{
						"__Member__",
						"__Member__",
					},
				},
				ProvisionedThroughput: &types.ProvisionedThroughput{
					ReadCapacityUnits:  ptr.Int64(1),
					WriteCapacityUnits: ptr.Int64(1),
				},
				OnDemandThroughput: &types.OnDemandThroughput{
					MaxReadRequestUnits:  ptr.Int64(1),
					MaxWriteRequestUnits: ptr.Int64(1),
				},
				WarmThroughput: &types.WarmThroughput{
					ReadUnitsPerSecond:  ptr.Int64(1),
					WriteUnitsPerSecond: ptr.Int64(1),
				},
			},
		},
		LocalSecondaryIndexOverride: []types.LocalSecondaryIndex{
			{
				IndexName: ptr.String("__IndexName__"),
				KeySchema: []types.KeySchemaElement{
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
				},
				Projection: &types.Projection{
					ProjectionType: types.ProjectionType("ALL"),
					NonKeyAttributes: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
			{
				IndexName: ptr.String("__IndexName__"),
				KeySchema: []types.KeySchemaElement{
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
				},
				Projection: &types.Projection{
					ProjectionType: types.ProjectionType("ALL"),
					NonKeyAttributes: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
		},
		ProvisionedThroughputOverride: &types.ProvisionedThroughput{
			ReadCapacityUnits:  ptr.Int64(1),
			WriteCapacityUnits: ptr.Int64(1),
		},
		OnDemandThroughputOverride: &types.OnDemandThroughput{
			MaxReadRequestUnits:  ptr.Int64(1),
			MaxWriteRequestUnits: ptr.Int64(1),
		},
		SSESpecificationOverride: &types.SSESpecification{
			Enabled:        ptr.Bool(true),
			SSEType:        types.SSEType("AES256"),
			KMSMasterKeyId: ptr.String("__KMSMasterKeyId__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.RestoreTableFromBackup(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(), "RestoreTableFromBackup"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_RestoreTableToPointInTime(t *testing.T) {
	input := &RestoreTableToPointInTimeInput{
		SourceTableArn:          ptr.String("__SourceTableArn__"),
		SourceTableName:         ptr.String("__SourceTableName__"),
		TargetTableName:         ptr.String("__TargetTableName__"),
		UseLatestRestorableTime: ptr.Bool(true),
		RestoreDateTime:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		BillingModeOverride:     types.BillingMode("PROVISIONED"),
		GlobalSecondaryIndexOverride: []types.GlobalSecondaryIndex{
			{
				IndexName: ptr.String("__IndexName__"),
				KeySchema: []types.KeySchemaElement{
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
				},
				Projection: &types.Projection{
					ProjectionType: types.ProjectionType("ALL"),
					NonKeyAttributes: []string{
						"__Member__",
						"__Member__",
					},
				},
				ProvisionedThroughput: &types.ProvisionedThroughput{
					ReadCapacityUnits:  ptr.Int64(1),
					WriteCapacityUnits: ptr.Int64(1),
				},
				OnDemandThroughput: &types.OnDemandThroughput{
					MaxReadRequestUnits:  ptr.Int64(1),
					MaxWriteRequestUnits: ptr.Int64(1),
				},
				WarmThroughput: &types.WarmThroughput{
					ReadUnitsPerSecond:  ptr.Int64(1),
					WriteUnitsPerSecond: ptr.Int64(1),
				},
			},
			{
				IndexName: ptr.String("__IndexName__"),
				KeySchema: []types.KeySchemaElement{
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
				},
				Projection: &types.Projection{
					ProjectionType: types.ProjectionType("ALL"),
					NonKeyAttributes: []string{
						"__Member__",
						"__Member__",
					},
				},
				ProvisionedThroughput: &types.ProvisionedThroughput{
					ReadCapacityUnits:  ptr.Int64(1),
					WriteCapacityUnits: ptr.Int64(1),
				},
				OnDemandThroughput: &types.OnDemandThroughput{
					MaxReadRequestUnits:  ptr.Int64(1),
					MaxWriteRequestUnits: ptr.Int64(1),
				},
				WarmThroughput: &types.WarmThroughput{
					ReadUnitsPerSecond:  ptr.Int64(1),
					WriteUnitsPerSecond: ptr.Int64(1),
				},
			},
		},
		LocalSecondaryIndexOverride: []types.LocalSecondaryIndex{
			{
				IndexName: ptr.String("__IndexName__"),
				KeySchema: []types.KeySchemaElement{
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
				},
				Projection: &types.Projection{
					ProjectionType: types.ProjectionType("ALL"),
					NonKeyAttributes: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
			{
				IndexName: ptr.String("__IndexName__"),
				KeySchema: []types.KeySchemaElement{
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
				},
				Projection: &types.Projection{
					ProjectionType: types.ProjectionType("ALL"),
					NonKeyAttributes: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
		},
		ProvisionedThroughputOverride: &types.ProvisionedThroughput{
			ReadCapacityUnits:  ptr.Int64(1),
			WriteCapacityUnits: ptr.Int64(1),
		},
		OnDemandThroughputOverride: &types.OnDemandThroughput{
			MaxReadRequestUnits:  ptr.Int64(1),
			MaxWriteRequestUnits: ptr.Int64(1),
		},
		SSESpecificationOverride: &types.SSESpecification{
			Enabled:        ptr.Bool(true),
			SSEType:        types.SSEType("AES256"),
			KMSMasterKeyId: ptr.String("__KMSMasterKeyId__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.RestoreTableToPointInTime(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(), "RestoreTableToPointInTime"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_Scan(t *testing.T) {
	input := &ScanInput{
		TableName: ptr.String("__TableName__"),
		IndexName: ptr.String("__IndexName__"),
		AttributesToGet: []string{
			"__Member__",
			"__Member__",
		},
		Limit:  ptr.Int32(1),
		Select: types.Select("ALL_ATTRIBUTES"),
		ScanFilter: map[string]types.Condition{
			"key0": {
				AttributeValueList: []types.AttributeValue{
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
				},
				ComparisonOperator: types.ComparisonOperator("EQ"),
			},
		},
		ConditionalOperator: types.ConditionalOperator("AND"),
		ExclusiveStartKey: map[string]types.AttributeValue{
			"key0": &types.AttributeValueMemberS{
				Value: "__AttributeValueMemberS__",
			},
		},
		ReturnConsumedCapacity: types.ReturnConsumedCapacity("INDEXES"),
		TotalSegments:          ptr.Int32(1),
		Segment:                ptr.Int32(1),
		ProjectionExpression:   ptr.String("__ProjectionExpression__"),
		FilterExpression:       ptr.String("__FilterExpression__"),
		ExpressionAttributeNames: map[string]string{
			"key0": "__Value__",
		},
		ExpressionAttributeValues: map[string]types.AttributeValue{
			"key0": &types.AttributeValueMemberS{
				Value: "__AttributeValueMemberS__",
			},
		},
		ConsistentRead: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.Scan(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(), "Scan"); 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_TransactGetItems(t *testing.T) {
	input := &TransactGetItemsInput{
		TransactItems: []types.TransactGetItem{
			{
				Get: &types.Get{
					Key: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					TableName:            ptr.String("__TableName__"),
					ProjectionExpression: ptr.String("__ProjectionExpression__"),
					ExpressionAttributeNames: map[string]string{
						"key0": "__Value__",
					},
				},
			},
			{
				Get: &types.Get{
					Key: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					TableName:            ptr.String("__TableName__"),
					ProjectionExpression: ptr.String("__ProjectionExpression__"),
					ExpressionAttributeNames: map[string]string{
						"key0": "__Value__",
					},
				},
			},
		},
		ReturnConsumedCapacity: types.ReturnConsumedCapacity("INDEXES"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.TransactGetItems(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(), "TransactGetItems"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_TransactWriteItems(t *testing.T) {
	input := &TransactWriteItemsInput{
		TransactItems: []types.TransactWriteItem{
			{
				ConditionCheck: &types.ConditionCheck{
					Key: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					TableName:           ptr.String("__TableName__"),
					ConditionExpression: ptr.String("__ConditionExpression__"),
					ExpressionAttributeNames: map[string]string{
						"key0": "__Value__",
					},
					ExpressionAttributeValues: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
				},
				Put: &types.Put{
					Item: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					TableName:           ptr.String("__TableName__"),
					ConditionExpression: ptr.String("__ConditionExpression__"),
					ExpressionAttributeNames: map[string]string{
						"key0": "__Value__",
					},
					ExpressionAttributeValues: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
				},
				Delete: &types.Delete{
					Key: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					TableName:           ptr.String("__TableName__"),
					ConditionExpression: ptr.String("__ConditionExpression__"),
					ExpressionAttributeNames: map[string]string{
						"key0": "__Value__",
					},
					ExpressionAttributeValues: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
				},
				Update: &types.Update{
					Key: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					UpdateExpression:    ptr.String("__UpdateExpression__"),
					TableName:           ptr.String("__TableName__"),
					ConditionExpression: ptr.String("__ConditionExpression__"),
					ExpressionAttributeNames: map[string]string{
						"key0": "__Value__",
					},
					ExpressionAttributeValues: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
				},
			},
			{
				ConditionCheck: &types.ConditionCheck{
					Key: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					TableName:           ptr.String("__TableName__"),
					ConditionExpression: ptr.String("__ConditionExpression__"),
					ExpressionAttributeNames: map[string]string{
						"key0": "__Value__",
					},
					ExpressionAttributeValues: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
				},
				Put: &types.Put{
					Item: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					TableName:           ptr.String("__TableName__"),
					ConditionExpression: ptr.String("__ConditionExpression__"),
					ExpressionAttributeNames: map[string]string{
						"key0": "__Value__",
					},
					ExpressionAttributeValues: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
				},
				Delete: &types.Delete{
					Key: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					TableName:           ptr.String("__TableName__"),
					ConditionExpression: ptr.String("__ConditionExpression__"),
					ExpressionAttributeNames: map[string]string{
						"key0": "__Value__",
					},
					ExpressionAttributeValues: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
				},
				Update: &types.Update{
					Key: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					UpdateExpression:    ptr.String("__UpdateExpression__"),
					TableName:           ptr.String("__TableName__"),
					ConditionExpression: ptr.String("__ConditionExpression__"),
					ExpressionAttributeNames: map[string]string{
						"key0": "__Value__",
					},
					ExpressionAttributeValues: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
				},
			},
		},
		ReturnConsumedCapacity:      types.ReturnConsumedCapacity("INDEXES"),
		ReturnItemCollectionMetrics: types.ReturnItemCollectionMetrics("SIZE"),
		ClientRequestToken:          ptr.String("__ClientRequestToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.TransactWriteItems(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(), "TransactWriteItems"); 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_UpdateContinuousBackups(t *testing.T) {
	input := &UpdateContinuousBackupsInput{
		TableName: ptr.String("__TableName__"),
		PointInTimeRecoverySpecification: &types.PointInTimeRecoverySpecification{
			PointInTimeRecoveryEnabled: ptr.Bool(true),
			RecoveryPeriodInDays:       ptr.Int32(1),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateContinuousBackups(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(), "UpdateContinuousBackups"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateContributorInsights(t *testing.T) {
	input := &UpdateContributorInsightsInput{
		TableName:                 ptr.String("__TableName__"),
		IndexName:                 ptr.String("__IndexName__"),
		ContributorInsightsAction: types.ContributorInsightsAction("ENABLE"),
		ContributorInsightsMode:   types.ContributorInsightsMode("ACCESSED_AND_THROTTLED_KEYS"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateContributorInsights(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(), "UpdateContributorInsights"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateGlobalTable(t *testing.T) {
	input := &UpdateGlobalTableInput{
		GlobalTableName: ptr.String("__GlobalTableName__"),
		ReplicaUpdates: []types.ReplicaUpdate{
			{
				Create: &types.CreateReplicaAction{
					RegionName: ptr.String("__RegionName__"),
				},
				Delete: &types.DeleteReplicaAction{
					RegionName: ptr.String("__RegionName__"),
				},
			},
			{
				Create: &types.CreateReplicaAction{
					RegionName: ptr.String("__RegionName__"),
				},
				Delete: &types.DeleteReplicaAction{
					RegionName: ptr.String("__RegionName__"),
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateGlobalTable(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(), "UpdateGlobalTable"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateGlobalTableSettings(t *testing.T) {
	input := &UpdateGlobalTableSettingsInput{
		GlobalTableName:                          ptr.String("__GlobalTableName__"),
		GlobalTableBillingMode:                   types.BillingMode("PROVISIONED"),
		GlobalTableProvisionedWriteCapacityUnits: ptr.Int64(1),
		GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate: &types.AutoScalingSettingsUpdate{
			MinimumUnits:        ptr.Int64(1),
			MaximumUnits:        ptr.Int64(1),
			AutoScalingDisabled: ptr.Bool(true),
			AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
			ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
				PolicyName: ptr.String("__PolicyName__"),
				TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
					DisableScaleIn:   ptr.Bool(true),
					ScaleInCooldown:  ptr.Int32(1),
					ScaleOutCooldown: ptr.Int32(1),
					TargetValue:      ptr.Float64(1.0),
				},
			},
		},
		GlobalTableGlobalSecondaryIndexSettingsUpdate: []types.GlobalTableGlobalSecondaryIndexSettingsUpdate{
			{
				IndexName:                     ptr.String("__IndexName__"),
				ProvisionedWriteCapacityUnits: ptr.Int64(1),
				ProvisionedWriteCapacityAutoScalingSettingsUpdate: &types.AutoScalingSettingsUpdate{
					MinimumUnits:        ptr.Int64(1),
					MaximumUnits:        ptr.Int64(1),
					AutoScalingDisabled: ptr.Bool(true),
					AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
					ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
						PolicyName: ptr.String("__PolicyName__"),
						TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
							DisableScaleIn:   ptr.Bool(true),
							ScaleInCooldown:  ptr.Int32(1),
							ScaleOutCooldown: ptr.Int32(1),
							TargetValue:      ptr.Float64(1.0),
						},
					},
				},
			},
			{
				IndexName:                     ptr.String("__IndexName__"),
				ProvisionedWriteCapacityUnits: ptr.Int64(1),
				ProvisionedWriteCapacityAutoScalingSettingsUpdate: &types.AutoScalingSettingsUpdate{
					MinimumUnits:        ptr.Int64(1),
					MaximumUnits:        ptr.Int64(1),
					AutoScalingDisabled: ptr.Bool(true),
					AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
					ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
						PolicyName: ptr.String("__PolicyName__"),
						TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
							DisableScaleIn:   ptr.Bool(true),
							ScaleInCooldown:  ptr.Int32(1),
							ScaleOutCooldown: ptr.Int32(1),
							TargetValue:      ptr.Float64(1.0),
						},
					},
				},
			},
		},
		ReplicaSettingsUpdate: []types.ReplicaSettingsUpdate{
			{
				RegionName:                          ptr.String("__RegionName__"),
				ReplicaProvisionedReadCapacityUnits: ptr.Int64(1),
				ReplicaProvisionedReadCapacityAutoScalingSettingsUpdate: &types.AutoScalingSettingsUpdate{
					MinimumUnits:        ptr.Int64(1),
					MaximumUnits:        ptr.Int64(1),
					AutoScalingDisabled: ptr.Bool(true),
					AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
					ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
						PolicyName: ptr.String("__PolicyName__"),
						TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
							DisableScaleIn:   ptr.Bool(true),
							ScaleInCooldown:  ptr.Int32(1),
							ScaleOutCooldown: ptr.Int32(1),
							TargetValue:      ptr.Float64(1.0),
						},
					},
				},
				ReplicaGlobalSecondaryIndexSettingsUpdate: []types.ReplicaGlobalSecondaryIndexSettingsUpdate{
					{
						IndexName:                    ptr.String("__IndexName__"),
						ProvisionedReadCapacityUnits: ptr.Int64(1),
						ProvisionedReadCapacityAutoScalingSettingsUpdate: &types.AutoScalingSettingsUpdate{
							MinimumUnits:        ptr.Int64(1),
							MaximumUnits:        ptr.Int64(1),
							AutoScalingDisabled: ptr.Bool(true),
							AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
							ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
								PolicyName: ptr.String("__PolicyName__"),
								TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
									DisableScaleIn:   ptr.Bool(true),
									ScaleInCooldown:  ptr.Int32(1),
									ScaleOutCooldown: ptr.Int32(1),
									TargetValue:      ptr.Float64(1.0),
								},
							},
						},
					},
					{
						IndexName:                    ptr.String("__IndexName__"),
						ProvisionedReadCapacityUnits: ptr.Int64(1),
						ProvisionedReadCapacityAutoScalingSettingsUpdate: &types.AutoScalingSettingsUpdate{
							MinimumUnits:        ptr.Int64(1),
							MaximumUnits:        ptr.Int64(1),
							AutoScalingDisabled: ptr.Bool(true),
							AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
							ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
								PolicyName: ptr.String("__PolicyName__"),
								TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
									DisableScaleIn:   ptr.Bool(true),
									ScaleInCooldown:  ptr.Int32(1),
									ScaleOutCooldown: ptr.Int32(1),
									TargetValue:      ptr.Float64(1.0),
								},
							},
						},
					},
				},
				ReplicaTableClass: types.TableClass("STANDARD"),
			},
			{
				RegionName:                          ptr.String("__RegionName__"),
				ReplicaProvisionedReadCapacityUnits: ptr.Int64(1),
				ReplicaProvisionedReadCapacityAutoScalingSettingsUpdate: &types.AutoScalingSettingsUpdate{
					MinimumUnits:        ptr.Int64(1),
					MaximumUnits:        ptr.Int64(1),
					AutoScalingDisabled: ptr.Bool(true),
					AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
					ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
						PolicyName: ptr.String("__PolicyName__"),
						TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
							DisableScaleIn:   ptr.Bool(true),
							ScaleInCooldown:  ptr.Int32(1),
							ScaleOutCooldown: ptr.Int32(1),
							TargetValue:      ptr.Float64(1.0),
						},
					},
				},
				ReplicaGlobalSecondaryIndexSettingsUpdate: []types.ReplicaGlobalSecondaryIndexSettingsUpdate{
					{
						IndexName:                    ptr.String("__IndexName__"),
						ProvisionedReadCapacityUnits: ptr.Int64(1),
						ProvisionedReadCapacityAutoScalingSettingsUpdate: &types.AutoScalingSettingsUpdate{
							MinimumUnits:        ptr.Int64(1),
							MaximumUnits:        ptr.Int64(1),
							AutoScalingDisabled: ptr.Bool(true),
							AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
							ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
								PolicyName: ptr.String("__PolicyName__"),
								TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
									DisableScaleIn:   ptr.Bool(true),
									ScaleInCooldown:  ptr.Int32(1),
									ScaleOutCooldown: ptr.Int32(1),
									TargetValue:      ptr.Float64(1.0),
								},
							},
						},
					},
					{
						IndexName:                    ptr.String("__IndexName__"),
						ProvisionedReadCapacityUnits: ptr.Int64(1),
						ProvisionedReadCapacityAutoScalingSettingsUpdate: &types.AutoScalingSettingsUpdate{
							MinimumUnits:        ptr.Int64(1),
							MaximumUnits:        ptr.Int64(1),
							AutoScalingDisabled: ptr.Bool(true),
							AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
							ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
								PolicyName: ptr.String("__PolicyName__"),
								TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
									DisableScaleIn:   ptr.Bool(true),
									ScaleInCooldown:  ptr.Int32(1),
									ScaleOutCooldown: ptr.Int32(1),
									TargetValue:      ptr.Float64(1.0),
								},
							},
						},
					},
				},
				ReplicaTableClass: types.TableClass("STANDARD"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateGlobalTableSettings(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(), "UpdateGlobalTableSettings"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateItem(t *testing.T) {
	input := &UpdateItemInput{
		TableName: ptr.String("__TableName__"),
		Key: map[string]types.AttributeValue{
			"key0": &types.AttributeValueMemberS{
				Value: "__AttributeValueMemberS__",
			},
		},
		AttributeUpdates: map[string]types.AttributeValueUpdate{
			"key0": {
				Value: &types.AttributeValueMemberS{
					Value: "__AttributeValueMemberS__",
				},
				Action: types.AttributeAction("ADD"),
			},
		},
		Expected: map[string]types.ExpectedAttributeValue{
			"key0": {
				Value: &types.AttributeValueMemberS{
					Value: "__AttributeValueMemberS__",
				},
				Exists:             ptr.Bool(true),
				ComparisonOperator: types.ComparisonOperator("EQ"),
				AttributeValueList: []types.AttributeValue{
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
				},
			},
		},
		ConditionalOperator:         types.ConditionalOperator("AND"),
		ReturnValues:                types.ReturnValue("NONE"),
		ReturnConsumedCapacity:      types.ReturnConsumedCapacity("INDEXES"),
		ReturnItemCollectionMetrics: types.ReturnItemCollectionMetrics("SIZE"),
		UpdateExpression:            ptr.String("__UpdateExpression__"),
		ConditionExpression:         ptr.String("__ConditionExpression__"),
		ExpressionAttributeNames: map[string]string{
			"key0": "__Value__",
		},
		ExpressionAttributeValues: map[string]types.AttributeValue{
			"key0": &types.AttributeValueMemberS{
				Value: "__AttributeValueMemberS__",
			},
		},
		ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateItem(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(), "UpdateItem"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateKinesisStreamingDestination(t *testing.T) {
	input := &UpdateKinesisStreamingDestinationInput{
		TableName: ptr.String("__TableName__"),
		StreamArn: ptr.String("__StreamArn__"),
		UpdateKinesisStreamingConfiguration: &types.UpdateKinesisStreamingConfiguration{
			ApproximateCreationDateTimePrecision: types.ApproximateCreationDateTimePrecision("MILLISECOND"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateKinesisStreamingDestination(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(), "UpdateKinesisStreamingDestination"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateTable(t *testing.T) {
	input := &UpdateTableInput{
		AttributeDefinitions: []types.AttributeDefinition{
			{
				AttributeName: ptr.String("__AttributeName__"),
				AttributeType: types.ScalarAttributeType("S"),
			},
			{
				AttributeName: ptr.String("__AttributeName__"),
				AttributeType: types.ScalarAttributeType("S"),
			},
		},
		TableName:   ptr.String("__TableName__"),
		BillingMode: types.BillingMode("PROVISIONED"),
		ProvisionedThroughput: &types.ProvisionedThroughput{
			ReadCapacityUnits:  ptr.Int64(1),
			WriteCapacityUnits: ptr.Int64(1),
		},
		GlobalSecondaryIndexUpdates: []types.GlobalSecondaryIndexUpdate{
			{
				Update: &types.UpdateGlobalSecondaryIndexAction{
					IndexName: ptr.String("__IndexName__"),
					ProvisionedThroughput: &types.ProvisionedThroughput{
						ReadCapacityUnits:  ptr.Int64(1),
						WriteCapacityUnits: ptr.Int64(1),
					},
					OnDemandThroughput: &types.OnDemandThroughput{
						MaxReadRequestUnits:  ptr.Int64(1),
						MaxWriteRequestUnits: ptr.Int64(1),
					},
					WarmThroughput: &types.WarmThroughput{
						ReadUnitsPerSecond:  ptr.Int64(1),
						WriteUnitsPerSecond: ptr.Int64(1),
					},
				},
				Create: &types.CreateGlobalSecondaryIndexAction{
					IndexName: ptr.String("__IndexName__"),
					KeySchema: []types.KeySchemaElement{
						{
							AttributeName: ptr.String("__AttributeName__"),
							KeyType:       types.KeyType("HASH"),
						},
						{
							AttributeName: ptr.String("__AttributeName__"),
							KeyType:       types.KeyType("HASH"),
						},
					},
					Projection: &types.Projection{
						ProjectionType: types.ProjectionType("ALL"),
						NonKeyAttributes: []string{
							"__Member__",
							"__Member__",
						},
					},
					ProvisionedThroughput: &types.ProvisionedThroughput{
						ReadCapacityUnits:  ptr.Int64(1),
						WriteCapacityUnits: ptr.Int64(1),
					},
					OnDemandThroughput: &types.OnDemandThroughput{
						MaxReadRequestUnits:  ptr.Int64(1),
						MaxWriteRequestUnits: ptr.Int64(1),
					},
					WarmThroughput: &types.WarmThroughput{
						ReadUnitsPerSecond:  ptr.Int64(1),
						WriteUnitsPerSecond: ptr.Int64(1),
					},
				},
				Delete: &types.DeleteGlobalSecondaryIndexAction{
					IndexName: ptr.String("__IndexName__"),
				},
			},
			{
				Update: &types.UpdateGlobalSecondaryIndexAction{
					IndexName: ptr.String("__IndexName__"),
					ProvisionedThroughput: &types.ProvisionedThroughput{
						ReadCapacityUnits:  ptr.Int64(1),
						WriteCapacityUnits: ptr.Int64(1),
					},
					OnDemandThroughput: &types.OnDemandThroughput{
						MaxReadRequestUnits:  ptr.Int64(1),
						MaxWriteRequestUnits: ptr.Int64(1),
					},
					WarmThroughput: &types.WarmThroughput{
						ReadUnitsPerSecond:  ptr.Int64(1),
						WriteUnitsPerSecond: ptr.Int64(1),
					},
				},
				Create: &types.CreateGlobalSecondaryIndexAction{
					IndexName: ptr.String("__IndexName__"),
					KeySchema: []types.KeySchemaElement{
						{
							AttributeName: ptr.String("__AttributeName__"),
							KeyType:       types.KeyType("HASH"),
						},
						{
							AttributeName: ptr.String("__AttributeName__"),
							KeyType:       types.KeyType("HASH"),
						},
					},
					Projection: &types.Projection{
						ProjectionType: types.ProjectionType("ALL"),
						NonKeyAttributes: []string{
							"__Member__",
							"__Member__",
						},
					},
					ProvisionedThroughput: &types.ProvisionedThroughput{
						ReadCapacityUnits:  ptr.Int64(1),
						WriteCapacityUnits: ptr.Int64(1),
					},
					OnDemandThroughput: &types.OnDemandThroughput{
						MaxReadRequestUnits:  ptr.Int64(1),
						MaxWriteRequestUnits: ptr.Int64(1),
					},
					WarmThroughput: &types.WarmThroughput{
						ReadUnitsPerSecond:  ptr.Int64(1),
						WriteUnitsPerSecond: ptr.Int64(1),
					},
				},
				Delete: &types.DeleteGlobalSecondaryIndexAction{
					IndexName: ptr.String("__IndexName__"),
				},
			},
		},
		StreamSpecification: &types.StreamSpecification{
			StreamEnabled:  ptr.Bool(true),
			StreamViewType: types.StreamViewType("NEW_IMAGE"),
		},
		SSESpecification: &types.SSESpecification{
			Enabled:        ptr.Bool(true),
			SSEType:        types.SSEType("AES256"),
			KMSMasterKeyId: ptr.String("__KMSMasterKeyId__"),
		},
		ReplicaUpdates: []types.ReplicationGroupUpdate{
			{
				Create: &types.CreateReplicationGroupMemberAction{
					RegionName:     ptr.String("__RegionName__"),
					KMSMasterKeyId: ptr.String("__KMSMasterKeyId__"),
					ProvisionedThroughputOverride: &types.ProvisionedThroughputOverride{
						ReadCapacityUnits: ptr.Int64(1),
					},
					OnDemandThroughputOverride: &types.OnDemandThroughputOverride{
						MaxReadRequestUnits: ptr.Int64(1),
					},
					GlobalSecondaryIndexes: []types.ReplicaGlobalSecondaryIndex{
						{
							IndexName: ptr.String("__IndexName__"),
							ProvisionedThroughputOverride: &types.ProvisionedThroughputOverride{
								ReadCapacityUnits: ptr.Int64(1),
							},
							OnDemandThroughputOverride: &types.OnDemandThroughputOverride{
								MaxReadRequestUnits: ptr.Int64(1),
							},
						},
						{
							IndexName: ptr.String("__IndexName__"),
							ProvisionedThroughputOverride: &types.ProvisionedThroughputOverride{
								ReadCapacityUnits: ptr.Int64(1),
							},
							OnDemandThroughputOverride: &types.OnDemandThroughputOverride{
								MaxReadRequestUnits: ptr.Int64(1),
							},
						},
					},
					TableClassOverride: types.TableClass("STANDARD"),
				},
				Update: &types.UpdateReplicationGroupMemberAction{
					RegionName:     ptr.String("__RegionName__"),
					KMSMasterKeyId: ptr.String("__KMSMasterKeyId__"),
					ProvisionedThroughputOverride: &types.ProvisionedThroughputOverride{
						ReadCapacityUnits: ptr.Int64(1),
					},
					OnDemandThroughputOverride: &types.OnDemandThroughputOverride{
						MaxReadRequestUnits: ptr.Int64(1),
					},
					GlobalSecondaryIndexes: []types.ReplicaGlobalSecondaryIndex{
						{
							IndexName: ptr.String("__IndexName__"),
							ProvisionedThroughputOverride: &types.ProvisionedThroughputOverride{
								ReadCapacityUnits: ptr.Int64(1),
							},
							OnDemandThroughputOverride: &types.OnDemandThroughputOverride{
								MaxReadRequestUnits: ptr.Int64(1),
							},
						},
						{
							IndexName: ptr.String("__IndexName__"),
							ProvisionedThroughputOverride: &types.ProvisionedThroughputOverride{
								ReadCapacityUnits: ptr.Int64(1),
							},
							OnDemandThroughputOverride: &types.OnDemandThroughputOverride{
								MaxReadRequestUnits: ptr.Int64(1),
							},
						},
					},
					TableClassOverride: types.TableClass("STANDARD"),
				},
				Delete: &types.DeleteReplicationGroupMemberAction{
					RegionName: ptr.String("__RegionName__"),
				},
			},
			{
				Create: &types.CreateReplicationGroupMemberAction{
					RegionName:     ptr.String("__RegionName__"),
					KMSMasterKeyId: ptr.String("__KMSMasterKeyId__"),
					ProvisionedThroughputOverride: &types.ProvisionedThroughputOverride{
						ReadCapacityUnits: ptr.Int64(1),
					},
					OnDemandThroughputOverride: &types.OnDemandThroughputOverride{
						MaxReadRequestUnits: ptr.Int64(1),
					},
					GlobalSecondaryIndexes: []types.ReplicaGlobalSecondaryIndex{
						{
							IndexName: ptr.String("__IndexName__"),
							ProvisionedThroughputOverride: &types.ProvisionedThroughputOverride{
								ReadCapacityUnits: ptr.Int64(1),
							},
							OnDemandThroughputOverride: &types.OnDemandThroughputOverride{
								MaxReadRequestUnits: ptr.Int64(1),
							},
						},
						{
							IndexName: ptr.String("__IndexName__"),
							ProvisionedThroughputOverride: &types.ProvisionedThroughputOverride{
								ReadCapacityUnits: ptr.Int64(1),
							},
							OnDemandThroughputOverride: &types.OnDemandThroughputOverride{
								MaxReadRequestUnits: ptr.Int64(1),
							},
						},
					},
					TableClassOverride: types.TableClass("STANDARD"),
				},
				Update: &types.UpdateReplicationGroupMemberAction{
					RegionName:     ptr.String("__RegionName__"),
					KMSMasterKeyId: ptr.String("__KMSMasterKeyId__"),
					ProvisionedThroughputOverride: &types.ProvisionedThroughputOverride{
						ReadCapacityUnits: ptr.Int64(1),
					},
					OnDemandThroughputOverride: &types.OnDemandThroughputOverride{
						MaxReadRequestUnits: ptr.Int64(1),
					},
					GlobalSecondaryIndexes: []types.ReplicaGlobalSecondaryIndex{
						{
							IndexName: ptr.String("__IndexName__"),
							ProvisionedThroughputOverride: &types.ProvisionedThroughputOverride{
								ReadCapacityUnits: ptr.Int64(1),
							},
							OnDemandThroughputOverride: &types.OnDemandThroughputOverride{
								MaxReadRequestUnits: ptr.Int64(1),
							},
						},
						{
							IndexName: ptr.String("__IndexName__"),
							ProvisionedThroughputOverride: &types.ProvisionedThroughputOverride{
								ReadCapacityUnits: ptr.Int64(1),
							},
							OnDemandThroughputOverride: &types.OnDemandThroughputOverride{
								MaxReadRequestUnits: ptr.Int64(1),
							},
						},
					},
					TableClassOverride: types.TableClass("STANDARD"),
				},
				Delete: &types.DeleteReplicationGroupMemberAction{
					RegionName: ptr.String("__RegionName__"),
				},
			},
		},
		TableClass:                types.TableClass("STANDARD"),
		DeletionProtectionEnabled: ptr.Bool(true),
		MultiRegionConsistency:    types.MultiRegionConsistency("EVENTUAL"),
		GlobalTableWitnessUpdates: []types.GlobalTableWitnessGroupUpdate{
			{
				Create: &types.CreateGlobalTableWitnessGroupMemberAction{
					RegionName: ptr.String("__RegionName__"),
				},
				Delete: &types.DeleteGlobalTableWitnessGroupMemberAction{
					RegionName: ptr.String("__RegionName__"),
				},
			},
			{
				Create: &types.CreateGlobalTableWitnessGroupMemberAction{
					RegionName: ptr.String("__RegionName__"),
				},
				Delete: &types.DeleteGlobalTableWitnessGroupMemberAction{
					RegionName: ptr.String("__RegionName__"),
				},
			},
		},
		OnDemandThroughput: &types.OnDemandThroughput{
			MaxReadRequestUnits:  ptr.Int64(1),
			MaxWriteRequestUnits: ptr.Int64(1),
		},
		WarmThroughput: &types.WarmThroughput{
			ReadUnitsPerSecond:  ptr.Int64(1),
			WriteUnitsPerSecond: ptr.Int64(1),
		},
		GlobalTableSettingsReplicationMode: types.GlobalTableSettingsReplicationMode("ENABLED"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateTable(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(), "UpdateTable"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateTableReplicaAutoScaling(t *testing.T) {
	input := &UpdateTableReplicaAutoScalingInput{
		GlobalSecondaryIndexUpdates: []types.GlobalSecondaryIndexAutoScalingUpdate{
			{
				IndexName: ptr.String("__IndexName__"),
				ProvisionedWriteCapacityAutoScalingUpdate: &types.AutoScalingSettingsUpdate{
					MinimumUnits:        ptr.Int64(1),
					MaximumUnits:        ptr.Int64(1),
					AutoScalingDisabled: ptr.Bool(true),
					AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
					ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
						PolicyName: ptr.String("__PolicyName__"),
						TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
							DisableScaleIn:   ptr.Bool(true),
							ScaleInCooldown:  ptr.Int32(1),
							ScaleOutCooldown: ptr.Int32(1),
							TargetValue:      ptr.Float64(1.0),
						},
					},
				},
			},
			{
				IndexName: ptr.String("__IndexName__"),
				ProvisionedWriteCapacityAutoScalingUpdate: &types.AutoScalingSettingsUpdate{
					MinimumUnits:        ptr.Int64(1),
					MaximumUnits:        ptr.Int64(1),
					AutoScalingDisabled: ptr.Bool(true),
					AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
					ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
						PolicyName: ptr.String("__PolicyName__"),
						TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
							DisableScaleIn:   ptr.Bool(true),
							ScaleInCooldown:  ptr.Int32(1),
							ScaleOutCooldown: ptr.Int32(1),
							TargetValue:      ptr.Float64(1.0),
						},
					},
				},
			},
		},
		TableName: ptr.String("__TableName__"),
		ProvisionedWriteCapacityAutoScalingUpdate: &types.AutoScalingSettingsUpdate{
			MinimumUnits:        ptr.Int64(1),
			MaximumUnits:        ptr.Int64(1),
			AutoScalingDisabled: ptr.Bool(true),
			AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
			ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
				PolicyName: ptr.String("__PolicyName__"),
				TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
					DisableScaleIn:   ptr.Bool(true),
					ScaleInCooldown:  ptr.Int32(1),
					ScaleOutCooldown: ptr.Int32(1),
					TargetValue:      ptr.Float64(1.0),
				},
			},
		},
		ReplicaUpdates: []types.ReplicaAutoScalingUpdate{
			{
				RegionName: ptr.String("__RegionName__"),
				ReplicaGlobalSecondaryIndexUpdates: []types.ReplicaGlobalSecondaryIndexAutoScalingUpdate{
					{
						IndexName: ptr.String("__IndexName__"),
						ProvisionedReadCapacityAutoScalingUpdate: &types.AutoScalingSettingsUpdate{
							MinimumUnits:        ptr.Int64(1),
							MaximumUnits:        ptr.Int64(1),
							AutoScalingDisabled: ptr.Bool(true),
							AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
							ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
								PolicyName: ptr.String("__PolicyName__"),
								TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
									DisableScaleIn:   ptr.Bool(true),
									ScaleInCooldown:  ptr.Int32(1),
									ScaleOutCooldown: ptr.Int32(1),
									TargetValue:      ptr.Float64(1.0),
								},
							},
						},
					},
					{
						IndexName: ptr.String("__IndexName__"),
						ProvisionedReadCapacityAutoScalingUpdate: &types.AutoScalingSettingsUpdate{
							MinimumUnits:        ptr.Int64(1),
							MaximumUnits:        ptr.Int64(1),
							AutoScalingDisabled: ptr.Bool(true),
							AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
							ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
								PolicyName: ptr.String("__PolicyName__"),
								TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
									DisableScaleIn:   ptr.Bool(true),
									ScaleInCooldown:  ptr.Int32(1),
									ScaleOutCooldown: ptr.Int32(1),
									TargetValue:      ptr.Float64(1.0),
								},
							},
						},
					},
				},
				ReplicaProvisionedReadCapacityAutoScalingUpdate: &types.AutoScalingSettingsUpdate{
					MinimumUnits:        ptr.Int64(1),
					MaximumUnits:        ptr.Int64(1),
					AutoScalingDisabled: ptr.Bool(true),
					AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
					ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
						PolicyName: ptr.String("__PolicyName__"),
						TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
							DisableScaleIn:   ptr.Bool(true),
							ScaleInCooldown:  ptr.Int32(1),
							ScaleOutCooldown: ptr.Int32(1),
							TargetValue:      ptr.Float64(1.0),
						},
					},
				},
			},
			{
				RegionName: ptr.String("__RegionName__"),
				ReplicaGlobalSecondaryIndexUpdates: []types.ReplicaGlobalSecondaryIndexAutoScalingUpdate{
					{
						IndexName: ptr.String("__IndexName__"),
						ProvisionedReadCapacityAutoScalingUpdate: &types.AutoScalingSettingsUpdate{
							MinimumUnits:        ptr.Int64(1),
							MaximumUnits:        ptr.Int64(1),
							AutoScalingDisabled: ptr.Bool(true),
							AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
							ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
								PolicyName: ptr.String("__PolicyName__"),
								TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
									DisableScaleIn:   ptr.Bool(true),
									ScaleInCooldown:  ptr.Int32(1),
									ScaleOutCooldown: ptr.Int32(1),
									TargetValue:      ptr.Float64(1.0),
								},
							},
						},
					},
					{
						IndexName: ptr.String("__IndexName__"),
						ProvisionedReadCapacityAutoScalingUpdate: &types.AutoScalingSettingsUpdate{
							MinimumUnits:        ptr.Int64(1),
							MaximumUnits:        ptr.Int64(1),
							AutoScalingDisabled: ptr.Bool(true),
							AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
							ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
								PolicyName: ptr.String("__PolicyName__"),
								TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
									DisableScaleIn:   ptr.Bool(true),
									ScaleInCooldown:  ptr.Int32(1),
									ScaleOutCooldown: ptr.Int32(1),
									TargetValue:      ptr.Float64(1.0),
								},
							},
						},
					},
				},
				ReplicaProvisionedReadCapacityAutoScalingUpdate: &types.AutoScalingSettingsUpdate{
					MinimumUnits:        ptr.Int64(1),
					MaximumUnits:        ptr.Int64(1),
					AutoScalingDisabled: ptr.Bool(true),
					AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
					ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
						PolicyName: ptr.String("__PolicyName__"),
						TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
							DisableScaleIn:   ptr.Bool(true),
							ScaleInCooldown:  ptr.Int32(1),
							ScaleOutCooldown: ptr.Int32(1),
							TargetValue:      ptr.Float64(1.0),
						},
					},
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateTableReplicaAutoScaling(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(), "UpdateTableReplicaAutoScaling"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateTimeToLive(t *testing.T) {
	input := &UpdateTimeToLiveInput{
		TableName: ptr.String("__TableName__"),
		TimeToLiveSpecification: &types.TimeToLiveSpecification{
			Enabled:       ptr.Bool(true),
			AttributeName: ptr.String("__AttributeName__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateTimeToLive(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(), "UpdateTimeToLive"); err != nil {
		t.Fatal(err)
	}
}
func TestUpdateRequestSnapshot_BatchExecuteStatement(t *testing.T) {
	input := &BatchExecuteStatementInput{
		Statements: []types.BatchStatementRequest{
			{
				Statement: ptr.String("__Statement__"),
				Parameters: []types.AttributeValue{
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
				},
				ConsistentRead:                      ptr.Bool(true),
				ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
			},
			{
				Statement: ptr.String("__Statement__"),
				Parameters: []types.AttributeValue{
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
				},
				ConsistentRead:                      ptr.Bool(true),
				ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
			},
		},
		ReturnConsumedCapacity: types.ReturnConsumedCapacity("INDEXES"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchExecuteStatement(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(), "BatchExecuteStatement"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_BatchGetItem(t *testing.T) {
	input := &BatchGetItemInput{
		RequestItems: map[string]types.KeysAndAttributes{
			"key0": {
				Keys: []map[string]types.AttributeValue{
					{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
				},
				AttributesToGet: []string{
					"__Member__",
					"__Member__",
				},
				ConsistentRead:       ptr.Bool(true),
				ProjectionExpression: ptr.String("__ProjectionExpression__"),
				ExpressionAttributeNames: map[string]string{
					"key0": "__Value__",
				},
			},
		},
		ReturnConsumedCapacity: types.ReturnConsumedCapacity("INDEXES"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchGetItem(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(), "BatchGetItem"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_BatchWriteItem(t *testing.T) {
	input := &BatchWriteItemInput{
		RequestItems: map[string][]types.WriteRequest{
			"key0": {
				{
					PutRequest: &types.PutRequest{
						Item: map[string]types.AttributeValue{
							"key0": &types.AttributeValueMemberS{
								Value: "__AttributeValueMemberS__",
							},
						},
					},
					DeleteRequest: &types.DeleteRequest{
						Key: map[string]types.AttributeValue{
							"key0": &types.AttributeValueMemberS{
								Value: "__AttributeValueMemberS__",
							},
						},
					},
				},
				{
					PutRequest: &types.PutRequest{
						Item: map[string]types.AttributeValue{
							"key0": &types.AttributeValueMemberS{
								Value: "__AttributeValueMemberS__",
							},
						},
					},
					DeleteRequest: &types.DeleteRequest{
						Key: map[string]types.AttributeValue{
							"key0": &types.AttributeValueMemberS{
								Value: "__AttributeValueMemberS__",
							},
						},
					},
				},
			},
		},
		ReturnConsumedCapacity:      types.ReturnConsumedCapacity("INDEXES"),
		ReturnItemCollectionMetrics: types.ReturnItemCollectionMetrics("SIZE"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchWriteItem(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(), "BatchWriteItem"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateBackup(t *testing.T) {
	input := &CreateBackupInput{
		TableName:  ptr.String("__TableName__"),
		BackupName: ptr.String("__BackupName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateBackup(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(), "CreateBackup"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateGlobalTable(t *testing.T) {
	input := &CreateGlobalTableInput{
		GlobalTableName: ptr.String("__GlobalTableName__"),
		ReplicationGroup: []types.Replica{
			{
				RegionName: ptr.String("__RegionName__"),
			},
			{
				RegionName: ptr.String("__RegionName__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateGlobalTable(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(), "CreateGlobalTable"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateTable(t *testing.T) {
	input := &CreateTableInput{
		AttributeDefinitions: []types.AttributeDefinition{
			{
				AttributeName: ptr.String("__AttributeName__"),
				AttributeType: types.ScalarAttributeType("S"),
			},
			{
				AttributeName: ptr.String("__AttributeName__"),
				AttributeType: types.ScalarAttributeType("S"),
			},
		},
		TableName: ptr.String("__TableName__"),
		KeySchema: []types.KeySchemaElement{
			{
				AttributeName: ptr.String("__AttributeName__"),
				KeyType:       types.KeyType("HASH"),
			},
			{
				AttributeName: ptr.String("__AttributeName__"),
				KeyType:       types.KeyType("HASH"),
			},
		},
		LocalSecondaryIndexes: []types.LocalSecondaryIndex{
			{
				IndexName: ptr.String("__IndexName__"),
				KeySchema: []types.KeySchemaElement{
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
				},
				Projection: &types.Projection{
					ProjectionType: types.ProjectionType("ALL"),
					NonKeyAttributes: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
			{
				IndexName: ptr.String("__IndexName__"),
				KeySchema: []types.KeySchemaElement{
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
				},
				Projection: &types.Projection{
					ProjectionType: types.ProjectionType("ALL"),
					NonKeyAttributes: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
		},
		GlobalSecondaryIndexes: []types.GlobalSecondaryIndex{
			{
				IndexName: ptr.String("__IndexName__"),
				KeySchema: []types.KeySchemaElement{
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
				},
				Projection: &types.Projection{
					ProjectionType: types.ProjectionType("ALL"),
					NonKeyAttributes: []string{
						"__Member__",
						"__Member__",
					},
				},
				ProvisionedThroughput: &types.ProvisionedThroughput{
					ReadCapacityUnits:  ptr.Int64(1),
					WriteCapacityUnits: ptr.Int64(1),
				},
				OnDemandThroughput: &types.OnDemandThroughput{
					MaxReadRequestUnits:  ptr.Int64(1),
					MaxWriteRequestUnits: ptr.Int64(1),
				},
				WarmThroughput: &types.WarmThroughput{
					ReadUnitsPerSecond:  ptr.Int64(1),
					WriteUnitsPerSecond: ptr.Int64(1),
				},
			},
			{
				IndexName: ptr.String("__IndexName__"),
				KeySchema: []types.KeySchemaElement{
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
				},
				Projection: &types.Projection{
					ProjectionType: types.ProjectionType("ALL"),
					NonKeyAttributes: []string{
						"__Member__",
						"__Member__",
					},
				},
				ProvisionedThroughput: &types.ProvisionedThroughput{
					ReadCapacityUnits:  ptr.Int64(1),
					WriteCapacityUnits: ptr.Int64(1),
				},
				OnDemandThroughput: &types.OnDemandThroughput{
					MaxReadRequestUnits:  ptr.Int64(1),
					MaxWriteRequestUnits: ptr.Int64(1),
				},
				WarmThroughput: &types.WarmThroughput{
					ReadUnitsPerSecond:  ptr.Int64(1),
					WriteUnitsPerSecond: ptr.Int64(1),
				},
			},
		},
		BillingMode: types.BillingMode("PROVISIONED"),
		ProvisionedThroughput: &types.ProvisionedThroughput{
			ReadCapacityUnits:  ptr.Int64(1),
			WriteCapacityUnits: ptr.Int64(1),
		},
		StreamSpecification: &types.StreamSpecification{
			StreamEnabled:  ptr.Bool(true),
			StreamViewType: types.StreamViewType("NEW_IMAGE"),
		},
		SSESpecification: &types.SSESpecification{
			Enabled:        ptr.Bool(true),
			SSEType:        types.SSEType("AES256"),
			KMSMasterKeyId: ptr.String("__KMSMasterKeyId__"),
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		TableClass:                types.TableClass("STANDARD"),
		DeletionProtectionEnabled: ptr.Bool(true),
		WarmThroughput: &types.WarmThroughput{
			ReadUnitsPerSecond:  ptr.Int64(1),
			WriteUnitsPerSecond: ptr.Int64(1),
		},
		ResourcePolicy: ptr.String("__ResourcePolicy__"),
		OnDemandThroughput: &types.OnDemandThroughput{
			MaxReadRequestUnits:  ptr.Int64(1),
			MaxWriteRequestUnits: ptr.Int64(1),
		},
		GlobalTableSourceArn:               ptr.String("__GlobalTableSourceArn__"),
		GlobalTableSettingsReplicationMode: types.GlobalTableSettingsReplicationMode("ENABLED"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateTable(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(), "CreateTable"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteBackup(t *testing.T) {
	input := &DeleteBackupInput{
		BackupArn: ptr.String("__BackupArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBackup(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(), "DeleteBackup"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteItem(t *testing.T) {
	input := &DeleteItemInput{
		TableName: ptr.String("__TableName__"),
		Key: map[string]types.AttributeValue{
			"key0": &types.AttributeValueMemberS{
				Value: "__AttributeValueMemberS__",
			},
		},
		Expected: map[string]types.ExpectedAttributeValue{
			"key0": {
				Value: &types.AttributeValueMemberS{
					Value: "__AttributeValueMemberS__",
				},
				Exists:             ptr.Bool(true),
				ComparisonOperator: types.ComparisonOperator("EQ"),
				AttributeValueList: []types.AttributeValue{
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
				},
			},
		},
		ConditionalOperator:         types.ConditionalOperator("AND"),
		ReturnValues:                types.ReturnValue("NONE"),
		ReturnConsumedCapacity:      types.ReturnConsumedCapacity("INDEXES"),
		ReturnItemCollectionMetrics: types.ReturnItemCollectionMetrics("SIZE"),
		ConditionExpression:         ptr.String("__ConditionExpression__"),
		ExpressionAttributeNames: map[string]string{
			"key0": "__Value__",
		},
		ExpressionAttributeValues: map[string]types.AttributeValue{
			"key0": &types.AttributeValueMemberS{
				Value: "__AttributeValueMemberS__",
			},
		},
		ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteItem(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(), "DeleteItem"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteResourcePolicy(t *testing.T) {
	input := &DeleteResourcePolicyInput{
		ResourceArn:        ptr.String("__ResourceArn__"),
		ExpectedRevisionId: ptr.String("__ExpectedRevisionId__"),
	}
	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_DeleteTable(t *testing.T) {
	input := &DeleteTableInput{
		TableName: ptr.String("__TableName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteTable(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(), "DeleteTable"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeBackup(t *testing.T) {
	input := &DescribeBackupInput{
		BackupArn: ptr.String("__BackupArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeBackup(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(), "DescribeBackup"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeContinuousBackups(t *testing.T) {
	input := &DescribeContinuousBackupsInput{
		TableName: ptr.String("__TableName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeContinuousBackups(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(), "DescribeContinuousBackups"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeContributorInsights(t *testing.T) {
	input := &DescribeContributorInsightsInput{
		TableName: ptr.String("__TableName__"),
		IndexName: ptr.String("__IndexName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeContributorInsights(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(), "DescribeContributorInsights"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeEndpoints(t *testing.T) {
	input := &DescribeEndpointsInput{}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeEndpoints(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(), "DescribeEndpoints"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeExport(t *testing.T) {
	input := &DescribeExportInput{
		ExportArn: ptr.String("__ExportArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeExport(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(), "DescribeExport"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeGlobalTable(t *testing.T) {
	input := &DescribeGlobalTableInput{
		GlobalTableName: ptr.String("__GlobalTableName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeGlobalTable(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(), "DescribeGlobalTable"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeGlobalTableSettings(t *testing.T) {
	input := &DescribeGlobalTableSettingsInput{
		GlobalTableName: ptr.String("__GlobalTableName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeGlobalTableSettings(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(), "DescribeGlobalTableSettings"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeImport(t *testing.T) {
	input := &DescribeImportInput{
		ImportArn: ptr.String("__ImportArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeImport(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(), "DescribeImport"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeKinesisStreamingDestination(t *testing.T) {
	input := &DescribeKinesisStreamingDestinationInput{
		TableName: ptr.String("__TableName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeKinesisStreamingDestination(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(), "DescribeKinesisStreamingDestination"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeLimits(t *testing.T) {
	input := &DescribeLimitsInput{}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeLimits(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(), "DescribeLimits"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeTable(t *testing.T) {
	input := &DescribeTableInput{
		TableName: ptr.String("__TableName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeTable(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(), "DescribeTable"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeTableReplicaAutoScaling(t *testing.T) {
	input := &DescribeTableReplicaAutoScalingInput{
		TableName: ptr.String("__TableName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeTableReplicaAutoScaling(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(), "DescribeTableReplicaAutoScaling"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeTimeToLive(t *testing.T) {
	input := &DescribeTimeToLiveInput{
		TableName: ptr.String("__TableName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeTimeToLive(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(), "DescribeTimeToLive"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DisableKinesisStreamingDestination(t *testing.T) {
	input := &DisableKinesisStreamingDestinationInput{
		TableName: ptr.String("__TableName__"),
		StreamArn: ptr.String("__StreamArn__"),
		EnableKinesisStreamingConfiguration: &types.EnableKinesisStreamingConfiguration{
			ApproximateCreationDateTimePrecision: types.ApproximateCreationDateTimePrecision("MILLISECOND"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DisableKinesisStreamingDestination(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(), "DisableKinesisStreamingDestination"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_EnableKinesisStreamingDestination(t *testing.T) {
	input := &EnableKinesisStreamingDestinationInput{
		TableName: ptr.String("__TableName__"),
		StreamArn: ptr.String("__StreamArn__"),
		EnableKinesisStreamingConfiguration: &types.EnableKinesisStreamingConfiguration{
			ApproximateCreationDateTimePrecision: types.ApproximateCreationDateTimePrecision("MILLISECOND"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.EnableKinesisStreamingDestination(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(), "EnableKinesisStreamingDestination"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ExecuteStatement(t *testing.T) {
	input := &ExecuteStatementInput{
		Statement: ptr.String("__Statement__"),
		Parameters: []types.AttributeValue{
			&types.AttributeValueMemberS{
				Value: "__AttributeValueMemberS__",
			},
			&types.AttributeValueMemberS{
				Value: "__AttributeValueMemberS__",
			},
		},
		ConsistentRead:                      ptr.Bool(true),
		NextToken:                           ptr.String("__NextToken__"),
		ReturnConsumedCapacity:              types.ReturnConsumedCapacity("INDEXES"),
		Limit:                               ptr.Int32(1),
		ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ExecuteStatement(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(), "ExecuteStatement"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ExecuteTransaction(t *testing.T) {
	input := &ExecuteTransactionInput{
		TransactStatements: []types.ParameterizedStatement{
			{
				Statement: ptr.String("__Statement__"),
				Parameters: []types.AttributeValue{
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
				},
				ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
			},
			{
				Statement: ptr.String("__Statement__"),
				Parameters: []types.AttributeValue{
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
				},
				ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
			},
		},
		ClientRequestToken:     ptr.String("__ClientRequestToken__"),
		ReturnConsumedCapacity: types.ReturnConsumedCapacity("INDEXES"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ExecuteTransaction(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(), "ExecuteTransaction"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ExportTableToPointInTime(t *testing.T) {
	input := &ExportTableToPointInTimeInput{
		TableArn:       ptr.String("__TableArn__"),
		ExportTime:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ClientToken:    ptr.String("__ClientToken__"),
		S3Bucket:       ptr.String("__S3Bucket__"),
		S3BucketOwner:  ptr.String("__S3BucketOwner__"),
		S3Prefix:       ptr.String("__S3Prefix__"),
		S3SseAlgorithm: types.S3SseAlgorithm("AES256"),
		S3SseKmsKeyId:  ptr.String("__S3SseKmsKeyId__"),
		ExportFormat:   types.ExportFormat("DYNAMODB_JSON"),
		ExportType:     types.ExportType("FULL_EXPORT"),
		IncrementalExportSpecification: &types.IncrementalExportSpecification{
			ExportFromTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			ExportToTime:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			ExportViewType: types.ExportViewType("NEW_IMAGE"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ExportTableToPointInTime(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(), "ExportTableToPointInTime"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetItem(t *testing.T) {
	input := &GetItemInput{
		TableName: ptr.String("__TableName__"),
		Key: map[string]types.AttributeValue{
			"key0": &types.AttributeValueMemberS{
				Value: "__AttributeValueMemberS__",
			},
		},
		AttributesToGet: []string{
			"__Member__",
			"__Member__",
		},
		ConsistentRead:         ptr.Bool(true),
		ReturnConsumedCapacity: types.ReturnConsumedCapacity("INDEXES"),
		ProjectionExpression:   ptr.String("__ProjectionExpression__"),
		ExpressionAttributeNames: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetItem(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(), "GetItem"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetResourcePolicy(t *testing.T) {
	input := &GetResourcePolicyInput{
		ResourceArn: ptr.String("__ResourceArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetResourcePolicy(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(), "GetResourcePolicy"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ImportTable(t *testing.T) {
	input := &ImportTableInput{
		ClientToken: ptr.String("__ClientToken__"),
		S3BucketSource: &types.S3BucketSource{
			S3BucketOwner: ptr.String("__S3BucketOwner__"),
			S3Bucket:      ptr.String("__S3Bucket__"),
			S3KeyPrefix:   ptr.String("__S3KeyPrefix__"),
		},
		InputFormat: types.InputFormat("DYNAMODB_JSON"),
		InputFormatOptions: &types.InputFormatOptions{
			Csv: &types.CsvOptions{
				Delimiter: ptr.String("__Delimiter__"),
				HeaderList: []string{
					"__Member__",
					"__Member__",
				},
			},
		},
		InputCompressionType: types.InputCompressionType("GZIP"),
		TableCreationParameters: &types.TableCreationParameters{
			TableName: ptr.String("__TableName__"),
			AttributeDefinitions: []types.AttributeDefinition{
				{
					AttributeName: ptr.String("__AttributeName__"),
					AttributeType: types.ScalarAttributeType("S"),
				},
				{
					AttributeName: ptr.String("__AttributeName__"),
					AttributeType: types.ScalarAttributeType("S"),
				},
			},
			KeySchema: []types.KeySchemaElement{
				{
					AttributeName: ptr.String("__AttributeName__"),
					KeyType:       types.KeyType("HASH"),
				},
				{
					AttributeName: ptr.String("__AttributeName__"),
					KeyType:       types.KeyType("HASH"),
				},
			},
			BillingMode: types.BillingMode("PROVISIONED"),
			ProvisionedThroughput: &types.ProvisionedThroughput{
				ReadCapacityUnits:  ptr.Int64(1),
				WriteCapacityUnits: ptr.Int64(1),
			},
			OnDemandThroughput: &types.OnDemandThroughput{
				MaxReadRequestUnits:  ptr.Int64(1),
				MaxWriteRequestUnits: ptr.Int64(1),
			},
			SSESpecification: &types.SSESpecification{
				Enabled:        ptr.Bool(true),
				SSEType:        types.SSEType("AES256"),
				KMSMasterKeyId: ptr.String("__KMSMasterKeyId__"),
			},
			GlobalSecondaryIndexes: []types.GlobalSecondaryIndex{
				{
					IndexName: ptr.String("__IndexName__"),
					KeySchema: []types.KeySchemaElement{
						{
							AttributeName: ptr.String("__AttributeName__"),
							KeyType:       types.KeyType("HASH"),
						},
						{
							AttributeName: ptr.String("__AttributeName__"),
							KeyType:       types.KeyType("HASH"),
						},
					},
					Projection: &types.Projection{
						ProjectionType: types.ProjectionType("ALL"),
						NonKeyAttributes: []string{
							"__Member__",
							"__Member__",
						},
					},
					ProvisionedThroughput: &types.ProvisionedThroughput{
						ReadCapacityUnits:  ptr.Int64(1),
						WriteCapacityUnits: ptr.Int64(1),
					},
					OnDemandThroughput: &types.OnDemandThroughput{
						MaxReadRequestUnits:  ptr.Int64(1),
						MaxWriteRequestUnits: ptr.Int64(1),
					},
					WarmThroughput: &types.WarmThroughput{
						ReadUnitsPerSecond:  ptr.Int64(1),
						WriteUnitsPerSecond: ptr.Int64(1),
					},
				},
				{
					IndexName: ptr.String("__IndexName__"),
					KeySchema: []types.KeySchemaElement{
						{
							AttributeName: ptr.String("__AttributeName__"),
							KeyType:       types.KeyType("HASH"),
						},
						{
							AttributeName: ptr.String("__AttributeName__"),
							KeyType:       types.KeyType("HASH"),
						},
					},
					Projection: &types.Projection{
						ProjectionType: types.ProjectionType("ALL"),
						NonKeyAttributes: []string{
							"__Member__",
							"__Member__",
						},
					},
					ProvisionedThroughput: &types.ProvisionedThroughput{
						ReadCapacityUnits:  ptr.Int64(1),
						WriteCapacityUnits: ptr.Int64(1),
					},
					OnDemandThroughput: &types.OnDemandThroughput{
						MaxReadRequestUnits:  ptr.Int64(1),
						MaxWriteRequestUnits: ptr.Int64(1),
					},
					WarmThroughput: &types.WarmThroughput{
						ReadUnitsPerSecond:  ptr.Int64(1),
						WriteUnitsPerSecond: ptr.Int64(1),
					},
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ImportTable(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(), "ImportTable"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListBackups(t *testing.T) {
	input := &ListBackupsInput{
		TableName:               ptr.String("__TableName__"),
		Limit:                   ptr.Int32(1),
		TimeRangeLowerBound:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		TimeRangeUpperBound:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ExclusiveStartBackupArn: ptr.String("__ExclusiveStartBackupArn__"),
		BackupType:              types.BackupTypeFilter("USER"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBackups(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(), "ListBackups"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListContributorInsights(t *testing.T) {
	input := &ListContributorInsightsInput{
		TableName:  ptr.String("__TableName__"),
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: 1,
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListContributorInsights(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(), "ListContributorInsights"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListExports(t *testing.T) {
	input := &ListExportsInput{
		TableArn:   ptr.String("__TableArn__"),
		MaxResults: ptr.Int32(1),
		NextToken:  ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListExports(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(), "ListExports"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListGlobalTables(t *testing.T) {
	input := &ListGlobalTablesInput{
		ExclusiveStartGlobalTableName: ptr.String("__ExclusiveStartGlobalTableName__"),
		Limit:                         ptr.Int32(1),
		RegionName:                    ptr.String("__RegionName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListGlobalTables(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(), "ListGlobalTables"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListImports(t *testing.T) {
	input := &ListImportsInput{
		TableArn:  ptr.String("__TableArn__"),
		PageSize:  ptr.Int32(1),
		NextToken: ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListImports(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(), "ListImports"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListTables(t *testing.T) {
	input := &ListTablesInput{
		ExclusiveStartTableName: ptr.String("__ExclusiveStartTableName__"),
		Limit:                   ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListTables(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(), "ListTables"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListTagsOfResource(t *testing.T) {
	input := &ListTagsOfResourceInput{
		ResourceArn: ptr.String("__ResourceArn__"),
		NextToken:   ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListTagsOfResource(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(), "ListTagsOfResource"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutItem(t *testing.T) {
	input := &PutItemInput{
		TableName: ptr.String("__TableName__"),
		Item: map[string]types.AttributeValue{
			"key0": &types.AttributeValueMemberS{
				Value: "__AttributeValueMemberS__",
			},
		},
		Expected: map[string]types.ExpectedAttributeValue{
			"key0": {
				Value: &types.AttributeValueMemberS{
					Value: "__AttributeValueMemberS__",
				},
				Exists:             ptr.Bool(true),
				ComparisonOperator: types.ComparisonOperator("EQ"),
				AttributeValueList: []types.AttributeValue{
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
				},
			},
		},
		ReturnValues:                types.ReturnValue("NONE"),
		ReturnConsumedCapacity:      types.ReturnConsumedCapacity("INDEXES"),
		ReturnItemCollectionMetrics: types.ReturnItemCollectionMetrics("SIZE"),
		ConditionalOperator:         types.ConditionalOperator("AND"),
		ConditionExpression:         ptr.String("__ConditionExpression__"),
		ExpressionAttributeNames: map[string]string{
			"key0": "__Value__",
		},
		ExpressionAttributeValues: map[string]types.AttributeValue{
			"key0": &types.AttributeValueMemberS{
				Value: "__AttributeValueMemberS__",
			},
		},
		ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutItem(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(), "PutItem"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutResourcePolicy(t *testing.T) {
	input := &PutResourcePolicyInput{
		ResourceArn:                     ptr.String("__ResourceArn__"),
		Policy:                          ptr.String("__Policy__"),
		ExpectedRevisionId:              ptr.String("__ExpectedRevisionId__"),
		ConfirmRemoveSelfResourceAccess: true,
	}
	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_Query(t *testing.T) {
	input := &QueryInput{
		TableName: ptr.String("__TableName__"),
		IndexName: ptr.String("__IndexName__"),
		Select:    types.Select("ALL_ATTRIBUTES"),
		AttributesToGet: []string{
			"__Member__",
			"__Member__",
		},
		Limit:          ptr.Int32(1),
		ConsistentRead: ptr.Bool(true),
		KeyConditions: map[string]types.Condition{
			"key0": {
				AttributeValueList: []types.AttributeValue{
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
				},
				ComparisonOperator: types.ComparisonOperator("EQ"),
			},
		},
		QueryFilter: map[string]types.Condition{
			"key0": {
				AttributeValueList: []types.AttributeValue{
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
				},
				ComparisonOperator: types.ComparisonOperator("EQ"),
			},
		},
		ConditionalOperator: types.ConditionalOperator("AND"),
		ScanIndexForward:    ptr.Bool(true),
		ExclusiveStartKey: map[string]types.AttributeValue{
			"key0": &types.AttributeValueMemberS{
				Value: "__AttributeValueMemberS__",
			},
		},
		ReturnConsumedCapacity: types.ReturnConsumedCapacity("INDEXES"),
		ProjectionExpression:   ptr.String("__ProjectionExpression__"),
		FilterExpression:       ptr.String("__FilterExpression__"),
		KeyConditionExpression: ptr.String("__KeyConditionExpression__"),
		ExpressionAttributeNames: map[string]string{
			"key0": "__Value__",
		},
		ExpressionAttributeValues: map[string]types.AttributeValue{
			"key0": &types.AttributeValueMemberS{
				Value: "__AttributeValueMemberS__",
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.Query(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(), "Query"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_RestoreTableFromBackup(t *testing.T) {
	input := &RestoreTableFromBackupInput{
		TargetTableName:     ptr.String("__TargetTableName__"),
		BackupArn:           ptr.String("__BackupArn__"),
		BillingModeOverride: types.BillingMode("PROVISIONED"),
		GlobalSecondaryIndexOverride: []types.GlobalSecondaryIndex{
			{
				IndexName: ptr.String("__IndexName__"),
				KeySchema: []types.KeySchemaElement{
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
				},
				Projection: &types.Projection{
					ProjectionType: types.ProjectionType("ALL"),
					NonKeyAttributes: []string{
						"__Member__",
						"__Member__",
					},
				},
				ProvisionedThroughput: &types.ProvisionedThroughput{
					ReadCapacityUnits:  ptr.Int64(1),
					WriteCapacityUnits: ptr.Int64(1),
				},
				OnDemandThroughput: &types.OnDemandThroughput{
					MaxReadRequestUnits:  ptr.Int64(1),
					MaxWriteRequestUnits: ptr.Int64(1),
				},
				WarmThroughput: &types.WarmThroughput{
					ReadUnitsPerSecond:  ptr.Int64(1),
					WriteUnitsPerSecond: ptr.Int64(1),
				},
			},
			{
				IndexName: ptr.String("__IndexName__"),
				KeySchema: []types.KeySchemaElement{
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
				},
				Projection: &types.Projection{
					ProjectionType: types.ProjectionType("ALL"),
					NonKeyAttributes: []string{
						"__Member__",
						"__Member__",
					},
				},
				ProvisionedThroughput: &types.ProvisionedThroughput{
					ReadCapacityUnits:  ptr.Int64(1),
					WriteCapacityUnits: ptr.Int64(1),
				},
				OnDemandThroughput: &types.OnDemandThroughput{
					MaxReadRequestUnits:  ptr.Int64(1),
					MaxWriteRequestUnits: ptr.Int64(1),
				},
				WarmThroughput: &types.WarmThroughput{
					ReadUnitsPerSecond:  ptr.Int64(1),
					WriteUnitsPerSecond: ptr.Int64(1),
				},
			},
		},
		LocalSecondaryIndexOverride: []types.LocalSecondaryIndex{
			{
				IndexName: ptr.String("__IndexName__"),
				KeySchema: []types.KeySchemaElement{
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
				},
				Projection: &types.Projection{
					ProjectionType: types.ProjectionType("ALL"),
					NonKeyAttributes: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
			{
				IndexName: ptr.String("__IndexName__"),
				KeySchema: []types.KeySchemaElement{
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
				},
				Projection: &types.Projection{
					ProjectionType: types.ProjectionType("ALL"),
					NonKeyAttributes: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
		},
		ProvisionedThroughputOverride: &types.ProvisionedThroughput{
			ReadCapacityUnits:  ptr.Int64(1),
			WriteCapacityUnits: ptr.Int64(1),
		},
		OnDemandThroughputOverride: &types.OnDemandThroughput{
			MaxReadRequestUnits:  ptr.Int64(1),
			MaxWriteRequestUnits: ptr.Int64(1),
		},
		SSESpecificationOverride: &types.SSESpecification{
			Enabled:        ptr.Bool(true),
			SSEType:        types.SSEType("AES256"),
			KMSMasterKeyId: ptr.String("__KMSMasterKeyId__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.RestoreTableFromBackup(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(), "RestoreTableFromBackup"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_RestoreTableToPointInTime(t *testing.T) {
	input := &RestoreTableToPointInTimeInput{
		SourceTableArn:          ptr.String("__SourceTableArn__"),
		SourceTableName:         ptr.String("__SourceTableName__"),
		TargetTableName:         ptr.String("__TargetTableName__"),
		UseLatestRestorableTime: ptr.Bool(true),
		RestoreDateTime:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		BillingModeOverride:     types.BillingMode("PROVISIONED"),
		GlobalSecondaryIndexOverride: []types.GlobalSecondaryIndex{
			{
				IndexName: ptr.String("__IndexName__"),
				KeySchema: []types.KeySchemaElement{
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
				},
				Projection: &types.Projection{
					ProjectionType: types.ProjectionType("ALL"),
					NonKeyAttributes: []string{
						"__Member__",
						"__Member__",
					},
				},
				ProvisionedThroughput: &types.ProvisionedThroughput{
					ReadCapacityUnits:  ptr.Int64(1),
					WriteCapacityUnits: ptr.Int64(1),
				},
				OnDemandThroughput: &types.OnDemandThroughput{
					MaxReadRequestUnits:  ptr.Int64(1),
					MaxWriteRequestUnits: ptr.Int64(1),
				},
				WarmThroughput: &types.WarmThroughput{
					ReadUnitsPerSecond:  ptr.Int64(1),
					WriteUnitsPerSecond: ptr.Int64(1),
				},
			},
			{
				IndexName: ptr.String("__IndexName__"),
				KeySchema: []types.KeySchemaElement{
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
				},
				Projection: &types.Projection{
					ProjectionType: types.ProjectionType("ALL"),
					NonKeyAttributes: []string{
						"__Member__",
						"__Member__",
					},
				},
				ProvisionedThroughput: &types.ProvisionedThroughput{
					ReadCapacityUnits:  ptr.Int64(1),
					WriteCapacityUnits: ptr.Int64(1),
				},
				OnDemandThroughput: &types.OnDemandThroughput{
					MaxReadRequestUnits:  ptr.Int64(1),
					MaxWriteRequestUnits: ptr.Int64(1),
				},
				WarmThroughput: &types.WarmThroughput{
					ReadUnitsPerSecond:  ptr.Int64(1),
					WriteUnitsPerSecond: ptr.Int64(1),
				},
			},
		},
		LocalSecondaryIndexOverride: []types.LocalSecondaryIndex{
			{
				IndexName: ptr.String("__IndexName__"),
				KeySchema: []types.KeySchemaElement{
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
				},
				Projection: &types.Projection{
					ProjectionType: types.ProjectionType("ALL"),
					NonKeyAttributes: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
			{
				IndexName: ptr.String("__IndexName__"),
				KeySchema: []types.KeySchemaElement{
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
					{
						AttributeName: ptr.String("__AttributeName__"),
						KeyType:       types.KeyType("HASH"),
					},
				},
				Projection: &types.Projection{
					ProjectionType: types.ProjectionType("ALL"),
					NonKeyAttributes: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
		},
		ProvisionedThroughputOverride: &types.ProvisionedThroughput{
			ReadCapacityUnits:  ptr.Int64(1),
			WriteCapacityUnits: ptr.Int64(1),
		},
		OnDemandThroughputOverride: &types.OnDemandThroughput{
			MaxReadRequestUnits:  ptr.Int64(1),
			MaxWriteRequestUnits: ptr.Int64(1),
		},
		SSESpecificationOverride: &types.SSESpecification{
			Enabled:        ptr.Bool(true),
			SSEType:        types.SSEType("AES256"),
			KMSMasterKeyId: ptr.String("__KMSMasterKeyId__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.RestoreTableToPointInTime(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(), "RestoreTableToPointInTime"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_Scan(t *testing.T) {
	input := &ScanInput{
		TableName: ptr.String("__TableName__"),
		IndexName: ptr.String("__IndexName__"),
		AttributesToGet: []string{
			"__Member__",
			"__Member__",
		},
		Limit:  ptr.Int32(1),
		Select: types.Select("ALL_ATTRIBUTES"),
		ScanFilter: map[string]types.Condition{
			"key0": {
				AttributeValueList: []types.AttributeValue{
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
				},
				ComparisonOperator: types.ComparisonOperator("EQ"),
			},
		},
		ConditionalOperator: types.ConditionalOperator("AND"),
		ExclusiveStartKey: map[string]types.AttributeValue{
			"key0": &types.AttributeValueMemberS{
				Value: "__AttributeValueMemberS__",
			},
		},
		ReturnConsumedCapacity: types.ReturnConsumedCapacity("INDEXES"),
		TotalSegments:          ptr.Int32(1),
		Segment:                ptr.Int32(1),
		ProjectionExpression:   ptr.String("__ProjectionExpression__"),
		FilterExpression:       ptr.String("__FilterExpression__"),
		ExpressionAttributeNames: map[string]string{
			"key0": "__Value__",
		},
		ExpressionAttributeValues: map[string]types.AttributeValue{
			"key0": &types.AttributeValueMemberS{
				Value: "__AttributeValueMemberS__",
			},
		},
		ConsistentRead: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.Scan(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(), "Scan"); 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_TransactGetItems(t *testing.T) {
	input := &TransactGetItemsInput{
		TransactItems: []types.TransactGetItem{
			{
				Get: &types.Get{
					Key: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					TableName:            ptr.String("__TableName__"),
					ProjectionExpression: ptr.String("__ProjectionExpression__"),
					ExpressionAttributeNames: map[string]string{
						"key0": "__Value__",
					},
				},
			},
			{
				Get: &types.Get{
					Key: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					TableName:            ptr.String("__TableName__"),
					ProjectionExpression: ptr.String("__ProjectionExpression__"),
					ExpressionAttributeNames: map[string]string{
						"key0": "__Value__",
					},
				},
			},
		},
		ReturnConsumedCapacity: types.ReturnConsumedCapacity("INDEXES"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.TransactGetItems(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(), "TransactGetItems"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_TransactWriteItems(t *testing.T) {
	input := &TransactWriteItemsInput{
		TransactItems: []types.TransactWriteItem{
			{
				ConditionCheck: &types.ConditionCheck{
					Key: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					TableName:           ptr.String("__TableName__"),
					ConditionExpression: ptr.String("__ConditionExpression__"),
					ExpressionAttributeNames: map[string]string{
						"key0": "__Value__",
					},
					ExpressionAttributeValues: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
				},
				Put: &types.Put{
					Item: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					TableName:           ptr.String("__TableName__"),
					ConditionExpression: ptr.String("__ConditionExpression__"),
					ExpressionAttributeNames: map[string]string{
						"key0": "__Value__",
					},
					ExpressionAttributeValues: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
				},
				Delete: &types.Delete{
					Key: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					TableName:           ptr.String("__TableName__"),
					ConditionExpression: ptr.String("__ConditionExpression__"),
					ExpressionAttributeNames: map[string]string{
						"key0": "__Value__",
					},
					ExpressionAttributeValues: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
				},
				Update: &types.Update{
					Key: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					UpdateExpression:    ptr.String("__UpdateExpression__"),
					TableName:           ptr.String("__TableName__"),
					ConditionExpression: ptr.String("__ConditionExpression__"),
					ExpressionAttributeNames: map[string]string{
						"key0": "__Value__",
					},
					ExpressionAttributeValues: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
				},
			},
			{
				ConditionCheck: &types.ConditionCheck{
					Key: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					TableName:           ptr.String("__TableName__"),
					ConditionExpression: ptr.String("__ConditionExpression__"),
					ExpressionAttributeNames: map[string]string{
						"key0": "__Value__",
					},
					ExpressionAttributeValues: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
				},
				Put: &types.Put{
					Item: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					TableName:           ptr.String("__TableName__"),
					ConditionExpression: ptr.String("__ConditionExpression__"),
					ExpressionAttributeNames: map[string]string{
						"key0": "__Value__",
					},
					ExpressionAttributeValues: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
				},
				Delete: &types.Delete{
					Key: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					TableName:           ptr.String("__TableName__"),
					ConditionExpression: ptr.String("__ConditionExpression__"),
					ExpressionAttributeNames: map[string]string{
						"key0": "__Value__",
					},
					ExpressionAttributeValues: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
				},
				Update: &types.Update{
					Key: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					UpdateExpression:    ptr.String("__UpdateExpression__"),
					TableName:           ptr.String("__TableName__"),
					ConditionExpression: ptr.String("__ConditionExpression__"),
					ExpressionAttributeNames: map[string]string{
						"key0": "__Value__",
					},
					ExpressionAttributeValues: map[string]types.AttributeValue{
						"key0": &types.AttributeValueMemberS{
							Value: "__AttributeValueMemberS__",
						},
					},
					ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
				},
			},
		},
		ReturnConsumedCapacity:      types.ReturnConsumedCapacity("INDEXES"),
		ReturnItemCollectionMetrics: types.ReturnItemCollectionMetrics("SIZE"),
		ClientRequestToken:          ptr.String("__ClientRequestToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.TransactWriteItems(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(), "TransactWriteItems"); 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_UpdateContinuousBackups(t *testing.T) {
	input := &UpdateContinuousBackupsInput{
		TableName: ptr.String("__TableName__"),
		PointInTimeRecoverySpecification: &types.PointInTimeRecoverySpecification{
			PointInTimeRecoveryEnabled: ptr.Bool(true),
			RecoveryPeriodInDays:       ptr.Int32(1),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateContinuousBackups(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(), "UpdateContinuousBackups"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateContributorInsights(t *testing.T) {
	input := &UpdateContributorInsightsInput{
		TableName:                 ptr.String("__TableName__"),
		IndexName:                 ptr.String("__IndexName__"),
		ContributorInsightsAction: types.ContributorInsightsAction("ENABLE"),
		ContributorInsightsMode:   types.ContributorInsightsMode("ACCESSED_AND_THROTTLED_KEYS"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateContributorInsights(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(), "UpdateContributorInsights"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateGlobalTable(t *testing.T) {
	input := &UpdateGlobalTableInput{
		GlobalTableName: ptr.String("__GlobalTableName__"),
		ReplicaUpdates: []types.ReplicaUpdate{
			{
				Create: &types.CreateReplicaAction{
					RegionName: ptr.String("__RegionName__"),
				},
				Delete: &types.DeleteReplicaAction{
					RegionName: ptr.String("__RegionName__"),
				},
			},
			{
				Create: &types.CreateReplicaAction{
					RegionName: ptr.String("__RegionName__"),
				},
				Delete: &types.DeleteReplicaAction{
					RegionName: ptr.String("__RegionName__"),
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateGlobalTable(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(), "UpdateGlobalTable"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateGlobalTableSettings(t *testing.T) {
	input := &UpdateGlobalTableSettingsInput{
		GlobalTableName:                          ptr.String("__GlobalTableName__"),
		GlobalTableBillingMode:                   types.BillingMode("PROVISIONED"),
		GlobalTableProvisionedWriteCapacityUnits: ptr.Int64(1),
		GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate: &types.AutoScalingSettingsUpdate{
			MinimumUnits:        ptr.Int64(1),
			MaximumUnits:        ptr.Int64(1),
			AutoScalingDisabled: ptr.Bool(true),
			AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
			ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
				PolicyName: ptr.String("__PolicyName__"),
				TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
					DisableScaleIn:   ptr.Bool(true),
					ScaleInCooldown:  ptr.Int32(1),
					ScaleOutCooldown: ptr.Int32(1),
					TargetValue:      ptr.Float64(1.0),
				},
			},
		},
		GlobalTableGlobalSecondaryIndexSettingsUpdate: []types.GlobalTableGlobalSecondaryIndexSettingsUpdate{
			{
				IndexName:                     ptr.String("__IndexName__"),
				ProvisionedWriteCapacityUnits: ptr.Int64(1),
				ProvisionedWriteCapacityAutoScalingSettingsUpdate: &types.AutoScalingSettingsUpdate{
					MinimumUnits:        ptr.Int64(1),
					MaximumUnits:        ptr.Int64(1),
					AutoScalingDisabled: ptr.Bool(true),
					AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
					ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
						PolicyName: ptr.String("__PolicyName__"),
						TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
							DisableScaleIn:   ptr.Bool(true),
							ScaleInCooldown:  ptr.Int32(1),
							ScaleOutCooldown: ptr.Int32(1),
							TargetValue:      ptr.Float64(1.0),
						},
					},
				},
			},
			{
				IndexName:                     ptr.String("__IndexName__"),
				ProvisionedWriteCapacityUnits: ptr.Int64(1),
				ProvisionedWriteCapacityAutoScalingSettingsUpdate: &types.AutoScalingSettingsUpdate{
					MinimumUnits:        ptr.Int64(1),
					MaximumUnits:        ptr.Int64(1),
					AutoScalingDisabled: ptr.Bool(true),
					AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
					ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
						PolicyName: ptr.String("__PolicyName__"),
						TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
							DisableScaleIn:   ptr.Bool(true),
							ScaleInCooldown:  ptr.Int32(1),
							ScaleOutCooldown: ptr.Int32(1),
							TargetValue:      ptr.Float64(1.0),
						},
					},
				},
			},
		},
		ReplicaSettingsUpdate: []types.ReplicaSettingsUpdate{
			{
				RegionName:                          ptr.String("__RegionName__"),
				ReplicaProvisionedReadCapacityUnits: ptr.Int64(1),
				ReplicaProvisionedReadCapacityAutoScalingSettingsUpdate: &types.AutoScalingSettingsUpdate{
					MinimumUnits:        ptr.Int64(1),
					MaximumUnits:        ptr.Int64(1),
					AutoScalingDisabled: ptr.Bool(true),
					AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
					ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
						PolicyName: ptr.String("__PolicyName__"),
						TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
							DisableScaleIn:   ptr.Bool(true),
							ScaleInCooldown:  ptr.Int32(1),
							ScaleOutCooldown: ptr.Int32(1),
							TargetValue:      ptr.Float64(1.0),
						},
					},
				},
				ReplicaGlobalSecondaryIndexSettingsUpdate: []types.ReplicaGlobalSecondaryIndexSettingsUpdate{
					{
						IndexName:                    ptr.String("__IndexName__"),
						ProvisionedReadCapacityUnits: ptr.Int64(1),
						ProvisionedReadCapacityAutoScalingSettingsUpdate: &types.AutoScalingSettingsUpdate{
							MinimumUnits:        ptr.Int64(1),
							MaximumUnits:        ptr.Int64(1),
							AutoScalingDisabled: ptr.Bool(true),
							AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
							ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
								PolicyName: ptr.String("__PolicyName__"),
								TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
									DisableScaleIn:   ptr.Bool(true),
									ScaleInCooldown:  ptr.Int32(1),
									ScaleOutCooldown: ptr.Int32(1),
									TargetValue:      ptr.Float64(1.0),
								},
							},
						},
					},
					{
						IndexName:                    ptr.String("__IndexName__"),
						ProvisionedReadCapacityUnits: ptr.Int64(1),
						ProvisionedReadCapacityAutoScalingSettingsUpdate: &types.AutoScalingSettingsUpdate{
							MinimumUnits:        ptr.Int64(1),
							MaximumUnits:        ptr.Int64(1),
							AutoScalingDisabled: ptr.Bool(true),
							AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
							ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
								PolicyName: ptr.String("__PolicyName__"),
								TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
									DisableScaleIn:   ptr.Bool(true),
									ScaleInCooldown:  ptr.Int32(1),
									ScaleOutCooldown: ptr.Int32(1),
									TargetValue:      ptr.Float64(1.0),
								},
							},
						},
					},
				},
				ReplicaTableClass: types.TableClass("STANDARD"),
			},
			{
				RegionName:                          ptr.String("__RegionName__"),
				ReplicaProvisionedReadCapacityUnits: ptr.Int64(1),
				ReplicaProvisionedReadCapacityAutoScalingSettingsUpdate: &types.AutoScalingSettingsUpdate{
					MinimumUnits:        ptr.Int64(1),
					MaximumUnits:        ptr.Int64(1),
					AutoScalingDisabled: ptr.Bool(true),
					AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
					ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
						PolicyName: ptr.String("__PolicyName__"),
						TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
							DisableScaleIn:   ptr.Bool(true),
							ScaleInCooldown:  ptr.Int32(1),
							ScaleOutCooldown: ptr.Int32(1),
							TargetValue:      ptr.Float64(1.0),
						},
					},
				},
				ReplicaGlobalSecondaryIndexSettingsUpdate: []types.ReplicaGlobalSecondaryIndexSettingsUpdate{
					{
						IndexName:                    ptr.String("__IndexName__"),
						ProvisionedReadCapacityUnits: ptr.Int64(1),
						ProvisionedReadCapacityAutoScalingSettingsUpdate: &types.AutoScalingSettingsUpdate{
							MinimumUnits:        ptr.Int64(1),
							MaximumUnits:        ptr.Int64(1),
							AutoScalingDisabled: ptr.Bool(true),
							AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
							ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
								PolicyName: ptr.String("__PolicyName__"),
								TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
									DisableScaleIn:   ptr.Bool(true),
									ScaleInCooldown:  ptr.Int32(1),
									ScaleOutCooldown: ptr.Int32(1),
									TargetValue:      ptr.Float64(1.0),
								},
							},
						},
					},
					{
						IndexName:                    ptr.String("__IndexName__"),
						ProvisionedReadCapacityUnits: ptr.Int64(1),
						ProvisionedReadCapacityAutoScalingSettingsUpdate: &types.AutoScalingSettingsUpdate{
							MinimumUnits:        ptr.Int64(1),
							MaximumUnits:        ptr.Int64(1),
							AutoScalingDisabled: ptr.Bool(true),
							AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
							ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
								PolicyName: ptr.String("__PolicyName__"),
								TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
									DisableScaleIn:   ptr.Bool(true),
									ScaleInCooldown:  ptr.Int32(1),
									ScaleOutCooldown: ptr.Int32(1),
									TargetValue:      ptr.Float64(1.0),
								},
							},
						},
					},
				},
				ReplicaTableClass: types.TableClass("STANDARD"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateGlobalTableSettings(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(), "UpdateGlobalTableSettings"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateItem(t *testing.T) {
	input := &UpdateItemInput{
		TableName: ptr.String("__TableName__"),
		Key: map[string]types.AttributeValue{
			"key0": &types.AttributeValueMemberS{
				Value: "__AttributeValueMemberS__",
			},
		},
		AttributeUpdates: map[string]types.AttributeValueUpdate{
			"key0": {
				Value: &types.AttributeValueMemberS{
					Value: "__AttributeValueMemberS__",
				},
				Action: types.AttributeAction("ADD"),
			},
		},
		Expected: map[string]types.ExpectedAttributeValue{
			"key0": {
				Value: &types.AttributeValueMemberS{
					Value: "__AttributeValueMemberS__",
				},
				Exists:             ptr.Bool(true),
				ComparisonOperator: types.ComparisonOperator("EQ"),
				AttributeValueList: []types.AttributeValue{
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
					&types.AttributeValueMemberS{
						Value: "__AttributeValueMemberS__",
					},
				},
			},
		},
		ConditionalOperator:         types.ConditionalOperator("AND"),
		ReturnValues:                types.ReturnValue("NONE"),
		ReturnConsumedCapacity:      types.ReturnConsumedCapacity("INDEXES"),
		ReturnItemCollectionMetrics: types.ReturnItemCollectionMetrics("SIZE"),
		UpdateExpression:            ptr.String("__UpdateExpression__"),
		ConditionExpression:         ptr.String("__ConditionExpression__"),
		ExpressionAttributeNames: map[string]string{
			"key0": "__Value__",
		},
		ExpressionAttributeValues: map[string]types.AttributeValue{
			"key0": &types.AttributeValueMemberS{
				Value: "__AttributeValueMemberS__",
			},
		},
		ReturnValuesOnConditionCheckFailure: types.ReturnValuesOnConditionCheckFailure("ALL_OLD"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateItem(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(), "UpdateItem"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateKinesisStreamingDestination(t *testing.T) {
	input := &UpdateKinesisStreamingDestinationInput{
		TableName: ptr.String("__TableName__"),
		StreamArn: ptr.String("__StreamArn__"),
		UpdateKinesisStreamingConfiguration: &types.UpdateKinesisStreamingConfiguration{
			ApproximateCreationDateTimePrecision: types.ApproximateCreationDateTimePrecision("MILLISECOND"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateKinesisStreamingDestination(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(), "UpdateKinesisStreamingDestination"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateTable(t *testing.T) {
	input := &UpdateTableInput{
		AttributeDefinitions: []types.AttributeDefinition{
			{
				AttributeName: ptr.String("__AttributeName__"),
				AttributeType: types.ScalarAttributeType("S"),
			},
			{
				AttributeName: ptr.String("__AttributeName__"),
				AttributeType: types.ScalarAttributeType("S"),
			},
		},
		TableName:   ptr.String("__TableName__"),
		BillingMode: types.BillingMode("PROVISIONED"),
		ProvisionedThroughput: &types.ProvisionedThroughput{
			ReadCapacityUnits:  ptr.Int64(1),
			WriteCapacityUnits: ptr.Int64(1),
		},
		GlobalSecondaryIndexUpdates: []types.GlobalSecondaryIndexUpdate{
			{
				Update: &types.UpdateGlobalSecondaryIndexAction{
					IndexName: ptr.String("__IndexName__"),
					ProvisionedThroughput: &types.ProvisionedThroughput{
						ReadCapacityUnits:  ptr.Int64(1),
						WriteCapacityUnits: ptr.Int64(1),
					},
					OnDemandThroughput: &types.OnDemandThroughput{
						MaxReadRequestUnits:  ptr.Int64(1),
						MaxWriteRequestUnits: ptr.Int64(1),
					},
					WarmThroughput: &types.WarmThroughput{
						ReadUnitsPerSecond:  ptr.Int64(1),
						WriteUnitsPerSecond: ptr.Int64(1),
					},
				},
				Create: &types.CreateGlobalSecondaryIndexAction{
					IndexName: ptr.String("__IndexName__"),
					KeySchema: []types.KeySchemaElement{
						{
							AttributeName: ptr.String("__AttributeName__"),
							KeyType:       types.KeyType("HASH"),
						},
						{
							AttributeName: ptr.String("__AttributeName__"),
							KeyType:       types.KeyType("HASH"),
						},
					},
					Projection: &types.Projection{
						ProjectionType: types.ProjectionType("ALL"),
						NonKeyAttributes: []string{
							"__Member__",
							"__Member__",
						},
					},
					ProvisionedThroughput: &types.ProvisionedThroughput{
						ReadCapacityUnits:  ptr.Int64(1),
						WriteCapacityUnits: ptr.Int64(1),
					},
					OnDemandThroughput: &types.OnDemandThroughput{
						MaxReadRequestUnits:  ptr.Int64(1),
						MaxWriteRequestUnits: ptr.Int64(1),
					},
					WarmThroughput: &types.WarmThroughput{
						ReadUnitsPerSecond:  ptr.Int64(1),
						WriteUnitsPerSecond: ptr.Int64(1),
					},
				},
				Delete: &types.DeleteGlobalSecondaryIndexAction{
					IndexName: ptr.String("__IndexName__"),
				},
			},
			{
				Update: &types.UpdateGlobalSecondaryIndexAction{
					IndexName: ptr.String("__IndexName__"),
					ProvisionedThroughput: &types.ProvisionedThroughput{
						ReadCapacityUnits:  ptr.Int64(1),
						WriteCapacityUnits: ptr.Int64(1),
					},
					OnDemandThroughput: &types.OnDemandThroughput{
						MaxReadRequestUnits:  ptr.Int64(1),
						MaxWriteRequestUnits: ptr.Int64(1),
					},
					WarmThroughput: &types.WarmThroughput{
						ReadUnitsPerSecond:  ptr.Int64(1),
						WriteUnitsPerSecond: ptr.Int64(1),
					},
				},
				Create: &types.CreateGlobalSecondaryIndexAction{
					IndexName: ptr.String("__IndexName__"),
					KeySchema: []types.KeySchemaElement{
						{
							AttributeName: ptr.String("__AttributeName__"),
							KeyType:       types.KeyType("HASH"),
						},
						{
							AttributeName: ptr.String("__AttributeName__"),
							KeyType:       types.KeyType("HASH"),
						},
					},
					Projection: &types.Projection{
						ProjectionType: types.ProjectionType("ALL"),
						NonKeyAttributes: []string{
							"__Member__",
							"__Member__",
						},
					},
					ProvisionedThroughput: &types.ProvisionedThroughput{
						ReadCapacityUnits:  ptr.Int64(1),
						WriteCapacityUnits: ptr.Int64(1),
					},
					OnDemandThroughput: &types.OnDemandThroughput{
						MaxReadRequestUnits:  ptr.Int64(1),
						MaxWriteRequestUnits: ptr.Int64(1),
					},
					WarmThroughput: &types.WarmThroughput{
						ReadUnitsPerSecond:  ptr.Int64(1),
						WriteUnitsPerSecond: ptr.Int64(1),
					},
				},
				Delete: &types.DeleteGlobalSecondaryIndexAction{
					IndexName: ptr.String("__IndexName__"),
				},
			},
		},
		StreamSpecification: &types.StreamSpecification{
			StreamEnabled:  ptr.Bool(true),
			StreamViewType: types.StreamViewType("NEW_IMAGE"),
		},
		SSESpecification: &types.SSESpecification{
			Enabled:        ptr.Bool(true),
			SSEType:        types.SSEType("AES256"),
			KMSMasterKeyId: ptr.String("__KMSMasterKeyId__"),
		},
		ReplicaUpdates: []types.ReplicationGroupUpdate{
			{
				Create: &types.CreateReplicationGroupMemberAction{
					RegionName:     ptr.String("__RegionName__"),
					KMSMasterKeyId: ptr.String("__KMSMasterKeyId__"),
					ProvisionedThroughputOverride: &types.ProvisionedThroughputOverride{
						ReadCapacityUnits: ptr.Int64(1),
					},
					OnDemandThroughputOverride: &types.OnDemandThroughputOverride{
						MaxReadRequestUnits: ptr.Int64(1),
					},
					GlobalSecondaryIndexes: []types.ReplicaGlobalSecondaryIndex{
						{
							IndexName: ptr.String("__IndexName__"),
							ProvisionedThroughputOverride: &types.ProvisionedThroughputOverride{
								ReadCapacityUnits: ptr.Int64(1),
							},
							OnDemandThroughputOverride: &types.OnDemandThroughputOverride{
								MaxReadRequestUnits: ptr.Int64(1),
							},
						},
						{
							IndexName: ptr.String("__IndexName__"),
							ProvisionedThroughputOverride: &types.ProvisionedThroughputOverride{
								ReadCapacityUnits: ptr.Int64(1),
							},
							OnDemandThroughputOverride: &types.OnDemandThroughputOverride{
								MaxReadRequestUnits: ptr.Int64(1),
							},
						},
					},
					TableClassOverride: types.TableClass("STANDARD"),
				},
				Update: &types.UpdateReplicationGroupMemberAction{
					RegionName:     ptr.String("__RegionName__"),
					KMSMasterKeyId: ptr.String("__KMSMasterKeyId__"),
					ProvisionedThroughputOverride: &types.ProvisionedThroughputOverride{
						ReadCapacityUnits: ptr.Int64(1),
					},
					OnDemandThroughputOverride: &types.OnDemandThroughputOverride{
						MaxReadRequestUnits: ptr.Int64(1),
					},
					GlobalSecondaryIndexes: []types.ReplicaGlobalSecondaryIndex{
						{
							IndexName: ptr.String("__IndexName__"),
							ProvisionedThroughputOverride: &types.ProvisionedThroughputOverride{
								ReadCapacityUnits: ptr.Int64(1),
							},
							OnDemandThroughputOverride: &types.OnDemandThroughputOverride{
								MaxReadRequestUnits: ptr.Int64(1),
							},
						},
						{
							IndexName: ptr.String("__IndexName__"),
							ProvisionedThroughputOverride: &types.ProvisionedThroughputOverride{
								ReadCapacityUnits: ptr.Int64(1),
							},
							OnDemandThroughputOverride: &types.OnDemandThroughputOverride{
								MaxReadRequestUnits: ptr.Int64(1),
							},
						},
					},
					TableClassOverride: types.TableClass("STANDARD"),
				},
				Delete: &types.DeleteReplicationGroupMemberAction{
					RegionName: ptr.String("__RegionName__"),
				},
			},
			{
				Create: &types.CreateReplicationGroupMemberAction{
					RegionName:     ptr.String("__RegionName__"),
					KMSMasterKeyId: ptr.String("__KMSMasterKeyId__"),
					ProvisionedThroughputOverride: &types.ProvisionedThroughputOverride{
						ReadCapacityUnits: ptr.Int64(1),
					},
					OnDemandThroughputOverride: &types.OnDemandThroughputOverride{
						MaxReadRequestUnits: ptr.Int64(1),
					},
					GlobalSecondaryIndexes: []types.ReplicaGlobalSecondaryIndex{
						{
							IndexName: ptr.String("__IndexName__"),
							ProvisionedThroughputOverride: &types.ProvisionedThroughputOverride{
								ReadCapacityUnits: ptr.Int64(1),
							},
							OnDemandThroughputOverride: &types.OnDemandThroughputOverride{
								MaxReadRequestUnits: ptr.Int64(1),
							},
						},
						{
							IndexName: ptr.String("__IndexName__"),
							ProvisionedThroughputOverride: &types.ProvisionedThroughputOverride{
								ReadCapacityUnits: ptr.Int64(1),
							},
							OnDemandThroughputOverride: &types.OnDemandThroughputOverride{
								MaxReadRequestUnits: ptr.Int64(1),
							},
						},
					},
					TableClassOverride: types.TableClass("STANDARD"),
				},
				Update: &types.UpdateReplicationGroupMemberAction{
					RegionName:     ptr.String("__RegionName__"),
					KMSMasterKeyId: ptr.String("__KMSMasterKeyId__"),
					ProvisionedThroughputOverride: &types.ProvisionedThroughputOverride{
						ReadCapacityUnits: ptr.Int64(1),
					},
					OnDemandThroughputOverride: &types.OnDemandThroughputOverride{
						MaxReadRequestUnits: ptr.Int64(1),
					},
					GlobalSecondaryIndexes: []types.ReplicaGlobalSecondaryIndex{
						{
							IndexName: ptr.String("__IndexName__"),
							ProvisionedThroughputOverride: &types.ProvisionedThroughputOverride{
								ReadCapacityUnits: ptr.Int64(1),
							},
							OnDemandThroughputOverride: &types.OnDemandThroughputOverride{
								MaxReadRequestUnits: ptr.Int64(1),
							},
						},
						{
							IndexName: ptr.String("__IndexName__"),
							ProvisionedThroughputOverride: &types.ProvisionedThroughputOverride{
								ReadCapacityUnits: ptr.Int64(1),
							},
							OnDemandThroughputOverride: &types.OnDemandThroughputOverride{
								MaxReadRequestUnits: ptr.Int64(1),
							},
						},
					},
					TableClassOverride: types.TableClass("STANDARD"),
				},
				Delete: &types.DeleteReplicationGroupMemberAction{
					RegionName: ptr.String("__RegionName__"),
				},
			},
		},
		TableClass:                types.TableClass("STANDARD"),
		DeletionProtectionEnabled: ptr.Bool(true),
		MultiRegionConsistency:    types.MultiRegionConsistency("EVENTUAL"),
		GlobalTableWitnessUpdates: []types.GlobalTableWitnessGroupUpdate{
			{
				Create: &types.CreateGlobalTableWitnessGroupMemberAction{
					RegionName: ptr.String("__RegionName__"),
				},
				Delete: &types.DeleteGlobalTableWitnessGroupMemberAction{
					RegionName: ptr.String("__RegionName__"),
				},
			},
			{
				Create: &types.CreateGlobalTableWitnessGroupMemberAction{
					RegionName: ptr.String("__RegionName__"),
				},
				Delete: &types.DeleteGlobalTableWitnessGroupMemberAction{
					RegionName: ptr.String("__RegionName__"),
				},
			},
		},
		OnDemandThroughput: &types.OnDemandThroughput{
			MaxReadRequestUnits:  ptr.Int64(1),
			MaxWriteRequestUnits: ptr.Int64(1),
		},
		WarmThroughput: &types.WarmThroughput{
			ReadUnitsPerSecond:  ptr.Int64(1),
			WriteUnitsPerSecond: ptr.Int64(1),
		},
		GlobalTableSettingsReplicationMode: types.GlobalTableSettingsReplicationMode("ENABLED"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateTable(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(), "UpdateTable"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateTableReplicaAutoScaling(t *testing.T) {
	input := &UpdateTableReplicaAutoScalingInput{
		GlobalSecondaryIndexUpdates: []types.GlobalSecondaryIndexAutoScalingUpdate{
			{
				IndexName: ptr.String("__IndexName__"),
				ProvisionedWriteCapacityAutoScalingUpdate: &types.AutoScalingSettingsUpdate{
					MinimumUnits:        ptr.Int64(1),
					MaximumUnits:        ptr.Int64(1),
					AutoScalingDisabled: ptr.Bool(true),
					AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
					ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
						PolicyName: ptr.String("__PolicyName__"),
						TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
							DisableScaleIn:   ptr.Bool(true),
							ScaleInCooldown:  ptr.Int32(1),
							ScaleOutCooldown: ptr.Int32(1),
							TargetValue:      ptr.Float64(1.0),
						},
					},
				},
			},
			{
				IndexName: ptr.String("__IndexName__"),
				ProvisionedWriteCapacityAutoScalingUpdate: &types.AutoScalingSettingsUpdate{
					MinimumUnits:        ptr.Int64(1),
					MaximumUnits:        ptr.Int64(1),
					AutoScalingDisabled: ptr.Bool(true),
					AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
					ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
						PolicyName: ptr.String("__PolicyName__"),
						TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
							DisableScaleIn:   ptr.Bool(true),
							ScaleInCooldown:  ptr.Int32(1),
							ScaleOutCooldown: ptr.Int32(1),
							TargetValue:      ptr.Float64(1.0),
						},
					},
				},
			},
		},
		TableName: ptr.String("__TableName__"),
		ProvisionedWriteCapacityAutoScalingUpdate: &types.AutoScalingSettingsUpdate{
			MinimumUnits:        ptr.Int64(1),
			MaximumUnits:        ptr.Int64(1),
			AutoScalingDisabled: ptr.Bool(true),
			AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
			ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
				PolicyName: ptr.String("__PolicyName__"),
				TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
					DisableScaleIn:   ptr.Bool(true),
					ScaleInCooldown:  ptr.Int32(1),
					ScaleOutCooldown: ptr.Int32(1),
					TargetValue:      ptr.Float64(1.0),
				},
			},
		},
		ReplicaUpdates: []types.ReplicaAutoScalingUpdate{
			{
				RegionName: ptr.String("__RegionName__"),
				ReplicaGlobalSecondaryIndexUpdates: []types.ReplicaGlobalSecondaryIndexAutoScalingUpdate{
					{
						IndexName: ptr.String("__IndexName__"),
						ProvisionedReadCapacityAutoScalingUpdate: &types.AutoScalingSettingsUpdate{
							MinimumUnits:        ptr.Int64(1),
							MaximumUnits:        ptr.Int64(1),
							AutoScalingDisabled: ptr.Bool(true),
							AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
							ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
								PolicyName: ptr.String("__PolicyName__"),
								TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
									DisableScaleIn:   ptr.Bool(true),
									ScaleInCooldown:  ptr.Int32(1),
									ScaleOutCooldown: ptr.Int32(1),
									TargetValue:      ptr.Float64(1.0),
								},
							},
						},
					},
					{
						IndexName: ptr.String("__IndexName__"),
						ProvisionedReadCapacityAutoScalingUpdate: &types.AutoScalingSettingsUpdate{
							MinimumUnits:        ptr.Int64(1),
							MaximumUnits:        ptr.Int64(1),
							AutoScalingDisabled: ptr.Bool(true),
							AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
							ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
								PolicyName: ptr.String("__PolicyName__"),
								TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
									DisableScaleIn:   ptr.Bool(true),
									ScaleInCooldown:  ptr.Int32(1),
									ScaleOutCooldown: ptr.Int32(1),
									TargetValue:      ptr.Float64(1.0),
								},
							},
						},
					},
				},
				ReplicaProvisionedReadCapacityAutoScalingUpdate: &types.AutoScalingSettingsUpdate{
					MinimumUnits:        ptr.Int64(1),
					MaximumUnits:        ptr.Int64(1),
					AutoScalingDisabled: ptr.Bool(true),
					AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
					ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
						PolicyName: ptr.String("__PolicyName__"),
						TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
							DisableScaleIn:   ptr.Bool(true),
							ScaleInCooldown:  ptr.Int32(1),
							ScaleOutCooldown: ptr.Int32(1),
							TargetValue:      ptr.Float64(1.0),
						},
					},
				},
			},
			{
				RegionName: ptr.String("__RegionName__"),
				ReplicaGlobalSecondaryIndexUpdates: []types.ReplicaGlobalSecondaryIndexAutoScalingUpdate{
					{
						IndexName: ptr.String("__IndexName__"),
						ProvisionedReadCapacityAutoScalingUpdate: &types.AutoScalingSettingsUpdate{
							MinimumUnits:        ptr.Int64(1),
							MaximumUnits:        ptr.Int64(1),
							AutoScalingDisabled: ptr.Bool(true),
							AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
							ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
								PolicyName: ptr.String("__PolicyName__"),
								TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
									DisableScaleIn:   ptr.Bool(true),
									ScaleInCooldown:  ptr.Int32(1),
									ScaleOutCooldown: ptr.Int32(1),
									TargetValue:      ptr.Float64(1.0),
								},
							},
						},
					},
					{
						IndexName: ptr.String("__IndexName__"),
						ProvisionedReadCapacityAutoScalingUpdate: &types.AutoScalingSettingsUpdate{
							MinimumUnits:        ptr.Int64(1),
							MaximumUnits:        ptr.Int64(1),
							AutoScalingDisabled: ptr.Bool(true),
							AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
							ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
								PolicyName: ptr.String("__PolicyName__"),
								TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
									DisableScaleIn:   ptr.Bool(true),
									ScaleInCooldown:  ptr.Int32(1),
									ScaleOutCooldown: ptr.Int32(1),
									TargetValue:      ptr.Float64(1.0),
								},
							},
						},
					},
				},
				ReplicaProvisionedReadCapacityAutoScalingUpdate: &types.AutoScalingSettingsUpdate{
					MinimumUnits:        ptr.Int64(1),
					MaximumUnits:        ptr.Int64(1),
					AutoScalingDisabled: ptr.Bool(true),
					AutoScalingRoleArn:  ptr.String("__AutoScalingRoleArn__"),
					ScalingPolicyUpdate: &types.AutoScalingPolicyUpdate{
						PolicyName: ptr.String("__PolicyName__"),
						TargetTrackingScalingPolicyConfiguration: &types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate{
							DisableScaleIn:   ptr.Bool(true),
							ScaleInCooldown:  ptr.Int32(1),
							ScaleOutCooldown: ptr.Int32(1),
							TargetValue:      ptr.Float64(1.0),
						},
					},
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateTableReplicaAutoScaling(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(), "UpdateTableReplicaAutoScaling"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateTimeToLive(t *testing.T) {
	input := &UpdateTimeToLiveInput{
		TableName: ptr.String("__TableName__"),
		TimeToLiveSpecification: &types.TimeToLiveSpecification{
			Enabled:       ptr.Bool(true),
			AttributeName: ptr.String("__AttributeName__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateTimeToLive(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(), "UpdateTimeToLive"); err != nil {
		t.Fatal(err)
	}
}