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

//go:build request_snapshot

package s3

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/s3/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_AbortMultipartUpload(t *testing.T) {
	input := &AbortMultipartUploadInput{
		Bucket:               ptr.String("__Bucket__"),
		Key:                  ptr.String("__Key__"),
		UploadId:             ptr.String("__UploadId__"),
		RequestPayer:         types.RequestPayer("requester"),
		ExpectedBucketOwner:  ptr.String("__ExpectedBucketOwner__"),
		IfMatchInitiatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AbortMultipartUpload(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "AbortMultipartUpload"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CompleteMultipartUpload(t *testing.T) {
	input := &CompleteMultipartUploadInput{
		Bucket: ptr.String("__Bucket__"),
		Key:    ptr.String("__Key__"),
		MultipartUpload: &types.CompletedMultipartUpload{
			Parts: []types.CompletedPart{
				{
					ETag:              ptr.String("__ETag__"),
					ChecksumCRC32:     ptr.String("__ChecksumCRC32__"),
					ChecksumCRC32C:    ptr.String("__ChecksumCRC32C__"),
					ChecksumCRC64NVME: ptr.String("__ChecksumCRC64NVME__"),
					ChecksumSHA1:      ptr.String("__ChecksumSHA1__"),
					ChecksumSHA256:    ptr.String("__ChecksumSHA256__"),
					ChecksumSHA512:    ptr.String("__ChecksumSHA512__"),
					ChecksumMD5:       ptr.String("__ChecksumMD5__"),
					ChecksumXXHASH64:  ptr.String("__ChecksumXXHASH64__"),
					ChecksumXXHASH3:   ptr.String("__ChecksumXXHASH3__"),
					ChecksumXXHASH128: ptr.String("__ChecksumXXHASH128__"),
					PartNumber:        ptr.Int32(1),
				},
				{
					ETag:              ptr.String("__ETag__"),
					ChecksumCRC32:     ptr.String("__ChecksumCRC32__"),
					ChecksumCRC32C:    ptr.String("__ChecksumCRC32C__"),
					ChecksumCRC64NVME: ptr.String("__ChecksumCRC64NVME__"),
					ChecksumSHA1:      ptr.String("__ChecksumSHA1__"),
					ChecksumSHA256:    ptr.String("__ChecksumSHA256__"),
					ChecksumSHA512:    ptr.String("__ChecksumSHA512__"),
					ChecksumMD5:       ptr.String("__ChecksumMD5__"),
					ChecksumXXHASH64:  ptr.String("__ChecksumXXHASH64__"),
					ChecksumXXHASH3:   ptr.String("__ChecksumXXHASH3__"),
					ChecksumXXHASH128: ptr.String("__ChecksumXXHASH128__"),
					PartNumber:        ptr.Int32(1),
				},
			},
		},
		UploadId:             ptr.String("__UploadId__"),
		ChecksumCRC32:        ptr.String("__ChecksumCRC32__"),
		ChecksumCRC32C:       ptr.String("__ChecksumCRC32C__"),
		ChecksumCRC64NVME:    ptr.String("__ChecksumCRC64NVME__"),
		ChecksumSHA1:         ptr.String("__ChecksumSHA1__"),
		ChecksumSHA256:       ptr.String("__ChecksumSHA256__"),
		ChecksumSHA512:       ptr.String("__ChecksumSHA512__"),
		ChecksumMD5:          ptr.String("__ChecksumMD5__"),
		ChecksumXXHASH64:     ptr.String("__ChecksumXXHASH64__"),
		ChecksumXXHASH3:      ptr.String("__ChecksumXXHASH3__"),
		ChecksumXXHASH128:    ptr.String("__ChecksumXXHASH128__"),
		ChecksumType:         types.ChecksumType("COMPOSITE"),
		MpuObjectSize:        ptr.Int64(1),
		RequestPayer:         types.RequestPayer("requester"),
		ExpectedBucketOwner:  ptr.String("__ExpectedBucketOwner__"),
		IfMatch:              ptr.String("__IfMatch__"),
		IfNoneMatch:          ptr.String("__IfNoneMatch__"),
		SSECustomerAlgorithm: ptr.String("__SSECustomerAlgorithm__"),
		SSECustomerKey:       ptr.String("__SSECustomerKey__"),
		SSECustomerKeyMD5:    ptr.String("__SSECustomerKeyMD5__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CompleteMultipartUpload(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CompleteMultipartUpload"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CopyObject(t *testing.T) {
	input := &CopyObjectInput{
		ACL:                         types.ObjectCannedACL("private"),
		Bucket:                      ptr.String("__Bucket__"),
		CacheControl:                ptr.String("__CacheControl__"),
		ChecksumAlgorithm:           types.ChecksumAlgorithm("CRC32"),
		ContentDisposition:          ptr.String("__ContentDisposition__"),
		ContentEncoding:             ptr.String("__ContentEncoding__"),
		ContentLanguage:             ptr.String("__ContentLanguage__"),
		ContentType:                 ptr.String("__ContentType__"),
		CopySource:                  ptr.String("__CopySource__"),
		CopySourceIfMatch:           ptr.String("__CopySourceIfMatch__"),
		CopySourceIfModifiedSince:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		CopySourceIfNoneMatch:       ptr.String("__CopySourceIfNoneMatch__"),
		CopySourceIfUnmodifiedSince: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		Expires:                     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		GrantFullControl:            ptr.String("__GrantFullControl__"),
		GrantRead:                   ptr.String("__GrantRead__"),
		GrantReadACP:                ptr.String("__GrantReadACP__"),
		GrantWriteACP:               ptr.String("__GrantWriteACP__"),
		IfMatch:                     ptr.String("__IfMatch__"),
		IfNoneMatch:                 ptr.String("__IfNoneMatch__"),
		Key:                         ptr.String("__Key__"),
		Metadata: map[string]string{
			"key0": "__Value__",
		},
		MetadataDirective:                types.MetadataDirective("COPY"),
		TaggingDirective:                 types.TaggingDirective("COPY"),
		AnnotationDirective:              types.AnnotationDirective("COPY"),
		ServerSideEncryption:             types.ServerSideEncryption("AES256"),
		StorageClass:                     types.StorageClass("STANDARD"),
		WebsiteRedirectLocation:          ptr.String("__WebsiteRedirectLocation__"),
		SSECustomerAlgorithm:             ptr.String("__SSECustomerAlgorithm__"),
		SSECustomerKey:                   ptr.String("__SSECustomerKey__"),
		SSECustomerKeyMD5:                ptr.String("__SSECustomerKeyMD5__"),
		SSEKMSKeyId:                      ptr.String("__SSEKMSKeyId__"),
		SSEKMSEncryptionContext:          ptr.String("__SSEKMSEncryptionContext__"),
		BucketKeyEnabled:                 ptr.Bool(true),
		CopySourceSSECustomerAlgorithm:   ptr.String("__CopySourceSSECustomerAlgorithm__"),
		CopySourceSSECustomerKey:         ptr.String("__CopySourceSSECustomerKey__"),
		CopySourceSSECustomerKeyMD5:      ptr.String("__CopySourceSSECustomerKeyMD5__"),
		RequestPayer:                     types.RequestPayer("requester"),
		Tagging:                          ptr.String("__Tagging__"),
		ObjectLockMode:                   types.ObjectLockMode("GOVERNANCE"),
		ObjectLockRetainUntilDate:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ObjectLockLegalHoldStatus:        types.ObjectLockLegalHoldStatus("ON"),
		ObjectLockEventHold:              types.ObjectLockEventHold("ON"),
		ObjectLockEventHoldDurationDays:  ptr.Int32(1),
		ObjectLockEventHoldDurationYears: ptr.Int32(1),
		ExpectedBucketOwner:              ptr.String("__ExpectedBucketOwner__"),
		ExpectedSourceBucketOwner:        ptr.String("__ExpectedSourceBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CopyObject(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CopyObject"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateBucket(t *testing.T) {
	input := &CreateBucketInput{
		ACL:    types.BucketCannedACL("private"),
		Bucket: ptr.String("__Bucket__"),
		CreateBucketConfiguration: &types.CreateBucketConfiguration{
			LocationConstraint: types.BucketLocationConstraint("af-south-1"),
			Location: &types.LocationInfo{
				Type: types.LocationType("AvailabilityZone"),
				Name: ptr.String("__Name__"),
			},
			Bucket: &types.BucketInfo{
				DataRedundancy: types.DataRedundancy("SingleAvailabilityZone"),
				Type:           types.BucketType("Directory"),
			},
			Tags: []types.Tag{
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
			},
		},
		GrantFullControl:           ptr.String("__GrantFullControl__"),
		GrantRead:                  ptr.String("__GrantRead__"),
		GrantReadACP:               ptr.String("__GrantReadACP__"),
		GrantWrite:                 ptr.String("__GrantWrite__"),
		GrantWriteACP:              ptr.String("__GrantWriteACP__"),
		ObjectLockEnabledForBucket: ptr.Bool(true),
		ObjectOwnership:            types.ObjectOwnership("BucketOwnerPreferred"),
		BucketNamespace:            types.BucketNamespace("account-regional"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateBucket(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateBucket"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateBucketMetadataConfiguration(t *testing.T) {
	input := &CreateBucketMetadataConfigurationInput{
		Bucket:            ptr.String("__Bucket__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		MetadataConfiguration: &types.MetadataConfiguration{
			JournalTableConfiguration: &types.JournalTableConfiguration{
				RecordExpiration: &types.RecordExpiration{
					Expiration: types.ExpirationState("ENABLED"),
					Days:       ptr.Int32(1),
				},
				EncryptionConfiguration: &types.MetadataTableEncryptionConfiguration{
					SseAlgorithm: types.TableSseAlgorithm("aws:kms"),
					KmsKeyArn:    ptr.String("__KmsKeyArn__"),
				},
			},
			InventoryTableConfiguration: &types.InventoryTableConfiguration{
				ConfigurationState: types.InventoryConfigurationState("ENABLED"),
				EncryptionConfiguration: &types.MetadataTableEncryptionConfiguration{
					SseAlgorithm: types.TableSseAlgorithm("aws:kms"),
					KmsKeyArn:    ptr.String("__KmsKeyArn__"),
				},
			},
			AnnotationTableConfiguration: &types.AnnotationTableConfiguration{
				ConfigurationState: types.AnnotationConfigurationState("ENABLED"),
				EncryptionConfiguration: &types.MetadataTableEncryptionConfiguration{
					SseAlgorithm: types.TableSseAlgorithm("aws:kms"),
					KmsKeyArn:    ptr.String("__KmsKeyArn__"),
				},
				Role: ptr.String("__Role__"),
			},
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateBucketMetadataConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateBucketMetadataConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateBucketMetadataTableConfiguration(t *testing.T) {
	input := &CreateBucketMetadataTableConfigurationInput{
		Bucket:            ptr.String("__Bucket__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		MetadataTableConfiguration: &types.MetadataTableConfiguration{
			S3TablesDestination: &types.S3TablesDestination{
				TableBucketArn: ptr.String("__TableBucketArn__"),
				TableName:      ptr.String("__TableName__"),
			},
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateBucketMetadataTableConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateBucketMetadataTableConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateMultipartUpload(t *testing.T) {
	input := &CreateMultipartUploadInput{
		ACL:                types.ObjectCannedACL("private"),
		Bucket:             ptr.String("__Bucket__"),
		CacheControl:       ptr.String("__CacheControl__"),
		ContentDisposition: ptr.String("__ContentDisposition__"),
		ContentEncoding:    ptr.String("__ContentEncoding__"),
		ContentLanguage:    ptr.String("__ContentLanguage__"),
		ContentType:        ptr.String("__ContentType__"),
		Expires:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		GrantFullControl:   ptr.String("__GrantFullControl__"),
		GrantRead:          ptr.String("__GrantRead__"),
		GrantReadACP:       ptr.String("__GrantReadACP__"),
		GrantWriteACP:      ptr.String("__GrantWriteACP__"),
		Key:                ptr.String("__Key__"),
		Metadata: map[string]string{
			"key0": "__Value__",
		},
		ServerSideEncryption:             types.ServerSideEncryption("AES256"),
		StorageClass:                     types.StorageClass("STANDARD"),
		WebsiteRedirectLocation:          ptr.String("__WebsiteRedirectLocation__"),
		SSECustomerAlgorithm:             ptr.String("__SSECustomerAlgorithm__"),
		SSECustomerKey:                   ptr.String("__SSECustomerKey__"),
		SSECustomerKeyMD5:                ptr.String("__SSECustomerKeyMD5__"),
		SSEKMSKeyId:                      ptr.String("__SSEKMSKeyId__"),
		SSEKMSEncryptionContext:          ptr.String("__SSEKMSEncryptionContext__"),
		BucketKeyEnabled:                 ptr.Bool(true),
		RequestPayer:                     types.RequestPayer("requester"),
		Tagging:                          ptr.String("__Tagging__"),
		ObjectLockMode:                   types.ObjectLockMode("GOVERNANCE"),
		ObjectLockRetainUntilDate:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ObjectLockLegalHoldStatus:        types.ObjectLockLegalHoldStatus("ON"),
		ObjectLockEventHold:              types.ObjectLockEventHold("ON"),
		ObjectLockEventHoldDurationDays:  ptr.Int32(1),
		ObjectLockEventHoldDurationYears: ptr.Int32(1),
		ExpectedBucketOwner:              ptr.String("__ExpectedBucketOwner__"),
		ChecksumAlgorithm:                types.ChecksumAlgorithm("CRC32"),
		ChecksumType:                     types.ChecksumType("COMPOSITE"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateMultipartUpload(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateMultipartUpload"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateSession(t *testing.T) {
	input := &CreateSessionInput{
		SessionMode:             types.SessionMode("ReadOnly"),
		Bucket:                  ptr.String("__Bucket__"),
		ServerSideEncryption:    types.ServerSideEncryption("AES256"),
		SSEKMSKeyId:             ptr.String("__SSEKMSKeyId__"),
		SSEKMSEncryptionContext: ptr.String("__SSEKMSEncryptionContext__"),
		BucketKeyEnabled:        ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateSession(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateSession"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteBucket(t *testing.T) {
	input := &DeleteBucketInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucket(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucket"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteBucketAnalyticsConfiguration(t *testing.T) {
	input := &DeleteBucketAnalyticsConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		Id:                  ptr.String("__Id__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketAnalyticsConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketAnalyticsConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteBucketCors(t *testing.T) {
	input := &DeleteBucketCorsInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketCors(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketCors"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteBucketEncryption(t *testing.T) {
	input := &DeleteBucketEncryptionInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketEncryption(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketEncryption"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteBucketIntelligentTieringConfiguration(t *testing.T) {
	input := &DeleteBucketIntelligentTieringConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		Id:                  ptr.String("__Id__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketIntelligentTieringConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketIntelligentTieringConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteBucketInventoryConfiguration(t *testing.T) {
	input := &DeleteBucketInventoryConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		Id:                  ptr.String("__Id__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketInventoryConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketInventoryConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteBucketLifecycle(t *testing.T) {
	input := &DeleteBucketLifecycleInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketLifecycle(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketLifecycle"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteBucketMetadataConfiguration(t *testing.T) {
	input := &DeleteBucketMetadataConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketMetadataConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketMetadataConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteBucketMetadataTableConfiguration(t *testing.T) {
	input := &DeleteBucketMetadataTableConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketMetadataTableConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketMetadataTableConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteBucketMetricsConfiguration(t *testing.T) {
	input := &DeleteBucketMetricsConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		Id:                  ptr.String("__Id__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketMetricsConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketMetricsConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteBucketOwnershipControls(t *testing.T) {
	input := &DeleteBucketOwnershipControlsInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketOwnershipControls(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketOwnershipControls"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteBucketPolicy(t *testing.T) {
	input := &DeleteBucketPolicyInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketPolicy(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketPolicy"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteBucketReplication(t *testing.T) {
	input := &DeleteBucketReplicationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketReplication(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketReplication"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteBucketTagging(t *testing.T) {
	input := &DeleteBucketTaggingInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketTagging(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketTagging"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteBucketWebsite(t *testing.T) {
	input := &DeleteBucketWebsiteInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketWebsite(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketWebsite"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteObject(t *testing.T) {
	input := &DeleteObjectInput{
		Bucket:                    ptr.String("__Bucket__"),
		Key:                       ptr.String("__Key__"),
		MFA:                       ptr.String("__MFA__"),
		VersionId:                 ptr.String("__VersionId__"),
		RequestPayer:              types.RequestPayer("requester"),
		BypassGovernanceRetention: ptr.Bool(true),
		ExpectedBucketOwner:       ptr.String("__ExpectedBucketOwner__"),
		IfMatch:                   ptr.String("__IfMatch__"),
		IfMatchLastModifiedTime:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		IfMatchSize:               ptr.Int64(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteObject(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteObject"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteObjectAnnotation(t *testing.T) {
	input := &DeleteObjectAnnotationInput{
		Bucket:              ptr.String("__Bucket__"),
		Key:                 ptr.String("__Key__"),
		AnnotationName:      ptr.String("__AnnotationName__"),
		VersionId:           ptr.String("__VersionId__"),
		RequestPayer:        types.RequestPayer("requester"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		ObjectIfMatch:       ptr.String("__ObjectIfMatch__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteObjectAnnotation(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteObjectAnnotation"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteObjects(t *testing.T) {
	input := &DeleteObjectsInput{
		Bucket: ptr.String("__Bucket__"),
		Delete: &types.Delete{
			Objects: []types.ObjectIdentifier{
				{
					Key:              ptr.String("__Key__"),
					VersionId:        ptr.String("__VersionId__"),
					ETag:             ptr.String("__ETag__"),
					LastModifiedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					Size:             ptr.Int64(1),
				},
				{
					Key:              ptr.String("__Key__"),
					VersionId:        ptr.String("__VersionId__"),
					ETag:             ptr.String("__ETag__"),
					LastModifiedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					Size:             ptr.Int64(1),
				},
			},
			Quiet: ptr.Bool(true),
		},
		MFA:                       ptr.String("__MFA__"),
		RequestPayer:              types.RequestPayer("requester"),
		BypassGovernanceRetention: ptr.Bool(true),
		ExpectedBucketOwner:       ptr.String("__ExpectedBucketOwner__"),
		ChecksumAlgorithm:         types.ChecksumAlgorithm("CRC32"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteObjects(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteObjects"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteObjectTagging(t *testing.T) {
	input := &DeleteObjectTaggingInput{
		Bucket:              ptr.String("__Bucket__"),
		Key:                 ptr.String("__Key__"),
		VersionId:           ptr.String("__VersionId__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteObjectTagging(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteObjectTagging"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeletePublicAccessBlock(t *testing.T) {
	input := &DeletePublicAccessBlockInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeletePublicAccessBlock(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeletePublicAccessBlock"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetBucketAbac(t *testing.T) {
	input := &GetBucketAbacInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketAbac(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketAbac"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetBucketAccelerateConfiguration(t *testing.T) {
	input := &GetBucketAccelerateConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		RequestPayer:        types.RequestPayer("requester"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketAccelerateConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketAccelerateConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetBucketAcl(t *testing.T) {
	input := &GetBucketAclInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketAcl(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketAcl"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetBucketAnalyticsConfiguration(t *testing.T) {
	input := &GetBucketAnalyticsConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		Id:                  ptr.String("__Id__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketAnalyticsConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketAnalyticsConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetBucketCors(t *testing.T) {
	input := &GetBucketCorsInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketCors(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketCors"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetBucketEncryption(t *testing.T) {
	input := &GetBucketEncryptionInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketEncryption(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketEncryption"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetBucketIntelligentTieringConfiguration(t *testing.T) {
	input := &GetBucketIntelligentTieringConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		Id:                  ptr.String("__Id__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketIntelligentTieringConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketIntelligentTieringConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetBucketInventoryConfiguration(t *testing.T) {
	input := &GetBucketInventoryConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		Id:                  ptr.String("__Id__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketInventoryConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketInventoryConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetBucketLifecycleConfiguration(t *testing.T) {
	input := &GetBucketLifecycleConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketLifecycleConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketLifecycleConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetBucketLocation(t *testing.T) {
	input := &GetBucketLocationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketLocation(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketLocation"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetBucketLogging(t *testing.T) {
	input := &GetBucketLoggingInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketLogging(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketLogging"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetBucketMetadataConfiguration(t *testing.T) {
	input := &GetBucketMetadataConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketMetadataConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketMetadataConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetBucketMetadataTableConfiguration(t *testing.T) {
	input := &GetBucketMetadataTableConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketMetadataTableConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketMetadataTableConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetBucketMetricsConfiguration(t *testing.T) {
	input := &GetBucketMetricsConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		Id:                  ptr.String("__Id__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketMetricsConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketMetricsConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetBucketNotificationConfiguration(t *testing.T) {
	input := &GetBucketNotificationConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketNotificationConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketNotificationConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetBucketOwnershipControls(t *testing.T) {
	input := &GetBucketOwnershipControlsInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketOwnershipControls(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketOwnershipControls"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetBucketPolicy(t *testing.T) {
	input := &GetBucketPolicyInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketPolicy(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketPolicy"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetBucketPolicyStatus(t *testing.T) {
	input := &GetBucketPolicyStatusInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketPolicyStatus(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketPolicyStatus"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetBucketReplication(t *testing.T) {
	input := &GetBucketReplicationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketReplication(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketReplication"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetBucketRequestPayment(t *testing.T) {
	input := &GetBucketRequestPaymentInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketRequestPayment(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketRequestPayment"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetBucketTagging(t *testing.T) {
	input := &GetBucketTaggingInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketTagging(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketTagging"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetBucketVersioning(t *testing.T) {
	input := &GetBucketVersioningInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketVersioning(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketVersioning"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetBucketWebsite(t *testing.T) {
	input := &GetBucketWebsiteInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketWebsite(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketWebsite"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetObject(t *testing.T) {
	input := &GetObjectInput{
		Bucket:                     ptr.String("__Bucket__"),
		IfMatch:                    ptr.String("__IfMatch__"),
		IfModifiedSince:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		IfNoneMatch:                ptr.String("__IfNoneMatch__"),
		IfUnmodifiedSince:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		Key:                        ptr.String("__Key__"),
		Range:                      ptr.String("__Range__"),
		ResponseCacheControl:       ptr.String("__ResponseCacheControl__"),
		ResponseContentDisposition: ptr.String("__ResponseContentDisposition__"),
		ResponseContentEncoding:    ptr.String("__ResponseContentEncoding__"),
		ResponseContentLanguage:    ptr.String("__ResponseContentLanguage__"),
		ResponseContentType:        ptr.String("__ResponseContentType__"),
		ResponseExpires:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		VersionId:                  ptr.String("__VersionId__"),
		SSECustomerAlgorithm:       ptr.String("__SSECustomerAlgorithm__"),
		SSECustomerKey:             ptr.String("__SSECustomerKey__"),
		SSECustomerKeyMD5:          ptr.String("__SSECustomerKeyMD5__"),
		RequestPayer:               types.RequestPayer("requester"),
		PartNumber:                 ptr.Int32(1),
		ExpectedBucketOwner:        ptr.String("__ExpectedBucketOwner__"),
		ChecksumMode:               types.ChecksumMode("ENABLED"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetObject(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetObject"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetObjectAcl(t *testing.T) {
	input := &GetObjectAclInput{
		Bucket:              ptr.String("__Bucket__"),
		Key:                 ptr.String("__Key__"),
		VersionId:           ptr.String("__VersionId__"),
		RequestPayer:        types.RequestPayer("requester"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetObjectAcl(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetObjectAcl"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetObjectAnnotation(t *testing.T) {
	input := &GetObjectAnnotationInput{
		Bucket:              ptr.String("__Bucket__"),
		Key:                 ptr.String("__Key__"),
		AnnotationName:      ptr.String("__AnnotationName__"),
		VersionId:           ptr.String("__VersionId__"),
		RequestPayer:        types.RequestPayer("requester"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		ChecksumMode:        types.ChecksumMode("ENABLED"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetObjectAnnotation(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetObjectAnnotation"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetObjectAttributes(t *testing.T) {
	input := &GetObjectAttributesInput{
		Bucket:               ptr.String("__Bucket__"),
		Key:                  ptr.String("__Key__"),
		VersionId:            ptr.String("__VersionId__"),
		MaxParts:             ptr.Int32(1),
		PartNumberMarker:     ptr.String("__PartNumberMarker__"),
		SSECustomerAlgorithm: ptr.String("__SSECustomerAlgorithm__"),
		SSECustomerKey:       ptr.String("__SSECustomerKey__"),
		SSECustomerKeyMD5:    ptr.String("__SSECustomerKeyMD5__"),
		RequestPayer:         types.RequestPayer("requester"),
		ExpectedBucketOwner:  ptr.String("__ExpectedBucketOwner__"),
		ObjectAttributes: []types.ObjectAttributes{
			types.ObjectAttributes("ETag"),
			types.ObjectAttributes("ETag"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetObjectAttributes(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetObjectAttributes"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetObjectLegalHold(t *testing.T) {
	input := &GetObjectLegalHoldInput{
		Bucket:              ptr.String("__Bucket__"),
		Key:                 ptr.String("__Key__"),
		VersionId:           ptr.String("__VersionId__"),
		RequestPayer:        types.RequestPayer("requester"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetObjectLegalHold(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetObjectLegalHold"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetObjectLockConfiguration(t *testing.T) {
	input := &GetObjectLockConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetObjectLockConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetObjectLockConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetObjectRetention(t *testing.T) {
	input := &GetObjectRetentionInput{
		Bucket:              ptr.String("__Bucket__"),
		Key:                 ptr.String("__Key__"),
		VersionId:           ptr.String("__VersionId__"),
		RequestPayer:        types.RequestPayer("requester"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetObjectRetention(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetObjectRetention"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetObjectTagging(t *testing.T) {
	input := &GetObjectTaggingInput{
		Bucket:              ptr.String("__Bucket__"),
		Key:                 ptr.String("__Key__"),
		VersionId:           ptr.String("__VersionId__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		RequestPayer:        types.RequestPayer("requester"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetObjectTagging(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetObjectTagging"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetObjectTorrent(t *testing.T) {
	input := &GetObjectTorrentInput{
		Bucket:              ptr.String("__Bucket__"),
		Key:                 ptr.String("__Key__"),
		RequestPayer:        types.RequestPayer("requester"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetObjectTorrent(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetObjectTorrent"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetPublicAccessBlock(t *testing.T) {
	input := &GetPublicAccessBlockInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetPublicAccessBlock(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetPublicAccessBlock"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_HeadBucket(t *testing.T) {
	input := &HeadBucketInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.HeadBucket(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "HeadBucket"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_HeadObject(t *testing.T) {
	input := &HeadObjectInput{
		Bucket:                     ptr.String("__Bucket__"),
		IfMatch:                    ptr.String("__IfMatch__"),
		IfModifiedSince:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		IfNoneMatch:                ptr.String("__IfNoneMatch__"),
		IfUnmodifiedSince:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		Key:                        ptr.String("__Key__"),
		Range:                      ptr.String("__Range__"),
		ResponseCacheControl:       ptr.String("__ResponseCacheControl__"),
		ResponseContentDisposition: ptr.String("__ResponseContentDisposition__"),
		ResponseContentEncoding:    ptr.String("__ResponseContentEncoding__"),
		ResponseContentLanguage:    ptr.String("__ResponseContentLanguage__"),
		ResponseContentType:        ptr.String("__ResponseContentType__"),
		ResponseExpires:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		VersionId:                  ptr.String("__VersionId__"),
		SSECustomerAlgorithm:       ptr.String("__SSECustomerAlgorithm__"),
		SSECustomerKey:             ptr.String("__SSECustomerKey__"),
		SSECustomerKeyMD5:          ptr.String("__SSECustomerKeyMD5__"),
		RequestPayer:               types.RequestPayer("requester"),
		PartNumber:                 ptr.Int32(1),
		ExpectedBucketOwner:        ptr.String("__ExpectedBucketOwner__"),
		ChecksumMode:               types.ChecksumMode("ENABLED"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.HeadObject(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "HeadObject"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListBucketAnalyticsConfigurations(t *testing.T) {
	input := &ListBucketAnalyticsConfigurationsInput{
		Bucket:              ptr.String("__Bucket__"),
		ContinuationToken:   ptr.String("__ContinuationToken__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBucketAnalyticsConfigurations(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListBucketAnalyticsConfigurations"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListBucketIntelligentTieringConfigurations(t *testing.T) {
	input := &ListBucketIntelligentTieringConfigurationsInput{
		Bucket:              ptr.String("__Bucket__"),
		ContinuationToken:   ptr.String("__ContinuationToken__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBucketIntelligentTieringConfigurations(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListBucketIntelligentTieringConfigurations"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListBucketInventoryConfigurations(t *testing.T) {
	input := &ListBucketInventoryConfigurationsInput{
		Bucket:              ptr.String("__Bucket__"),
		ContinuationToken:   ptr.String("__ContinuationToken__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBucketInventoryConfigurations(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListBucketInventoryConfigurations"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListBucketMetricsConfigurations(t *testing.T) {
	input := &ListBucketMetricsConfigurationsInput{
		Bucket:              ptr.String("__Bucket__"),
		ContinuationToken:   ptr.String("__ContinuationToken__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBucketMetricsConfigurations(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListBucketMetricsConfigurations"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListBuckets(t *testing.T) {
	input := &ListBucketsInput{
		MaxBuckets:        ptr.Int32(1),
		ContinuationToken: ptr.String("__ContinuationToken__"),
		Prefix:            ptr.String("__Prefix__"),
		BucketRegion:      ptr.String("__BucketRegion__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBuckets(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListBuckets"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListDirectoryBuckets(t *testing.T) {
	input := &ListDirectoryBucketsInput{
		ContinuationToken:   ptr.String("__ContinuationToken__"),
		MaxDirectoryBuckets: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListDirectoryBuckets(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListDirectoryBuckets"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListMultipartUploads(t *testing.T) {
	input := &ListMultipartUploadsInput{
		Bucket:              ptr.String("__Bucket__"),
		Delimiter:           ptr.String("__Delimiter__"),
		EncodingType:        types.EncodingType("url"),
		KeyMarker:           ptr.String("__KeyMarker__"),
		MaxUploads:          ptr.Int32(1),
		Prefix:              ptr.String("__Prefix__"),
		UploadIdMarker:      ptr.String("__UploadIdMarker__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		RequestPayer:        types.RequestPayer("requester"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListMultipartUploads(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListMultipartUploads"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListObjectAnnotations(t *testing.T) {
	input := &ListObjectAnnotationsInput{
		Bucket:               ptr.String("__Bucket__"),
		Key:                  ptr.String("__Key__"),
		VersionId:            ptr.String("__VersionId__"),
		MaxAnnotationResults: ptr.Int32(1),
		AnnotationPrefix:     ptr.String("__AnnotationPrefix__"),
		ContinuationToken:    ptr.String("__ContinuationToken__"),
		RequestPayer:         types.RequestPayer("requester"),
		ExpectedBucketOwner:  ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListObjectAnnotations(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListObjectAnnotations"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListObjects(t *testing.T) {
	input := &ListObjectsInput{
		Bucket:              ptr.String("__Bucket__"),
		Delimiter:           ptr.String("__Delimiter__"),
		EncodingType:        types.EncodingType("url"),
		Marker:              ptr.String("__Marker__"),
		MaxKeys:             ptr.Int32(1),
		Prefix:              ptr.String("__Prefix__"),
		RequestPayer:        types.RequestPayer("requester"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		OptionalObjectAttributes: []types.OptionalObjectAttributes{
			types.OptionalObjectAttributes("RestoreStatus"),
			types.OptionalObjectAttributes("RestoreStatus"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListObjects(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListObjects"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListObjectsV2(t *testing.T) {
	input := &ListObjectsV2Input{
		Bucket:              ptr.String("__Bucket__"),
		Delimiter:           ptr.String("__Delimiter__"),
		EncodingType:        types.EncodingType("url"),
		MaxKeys:             ptr.Int32(1),
		Prefix:              ptr.String("__Prefix__"),
		ContinuationToken:   ptr.String("__ContinuationToken__"),
		FetchOwner:          ptr.Bool(true),
		StartAfter:          ptr.String("__StartAfter__"),
		RequestPayer:        types.RequestPayer("requester"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		OptionalObjectAttributes: []types.OptionalObjectAttributes{
			types.OptionalObjectAttributes("RestoreStatus"),
			types.OptionalObjectAttributes("RestoreStatus"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListObjectsV2(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListObjectsV2"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListObjectVersions(t *testing.T) {
	input := &ListObjectVersionsInput{
		Bucket:              ptr.String("__Bucket__"),
		Delimiter:           ptr.String("__Delimiter__"),
		EncodingType:        types.EncodingType("url"),
		KeyMarker:           ptr.String("__KeyMarker__"),
		MaxKeys:             ptr.Int32(1),
		Prefix:              ptr.String("__Prefix__"),
		VersionIdMarker:     ptr.String("__VersionIdMarker__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		RequestPayer:        types.RequestPayer("requester"),
		OptionalObjectAttributes: []types.OptionalObjectAttributes{
			types.OptionalObjectAttributes("RestoreStatus"),
			types.OptionalObjectAttributes("RestoreStatus"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListObjectVersions(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListObjectVersions"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListParts(t *testing.T) {
	input := &ListPartsInput{
		Bucket:               ptr.String("__Bucket__"),
		Key:                  ptr.String("__Key__"),
		MaxParts:             ptr.Int32(1),
		PartNumberMarker:     ptr.String("__PartNumberMarker__"),
		UploadId:             ptr.String("__UploadId__"),
		RequestPayer:         types.RequestPayer("requester"),
		ExpectedBucketOwner:  ptr.String("__ExpectedBucketOwner__"),
		SSECustomerAlgorithm: ptr.String("__SSECustomerAlgorithm__"),
		SSECustomerKey:       ptr.String("__SSECustomerKey__"),
		SSECustomerKeyMD5:    ptr.String("__SSECustomerKeyMD5__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListParts(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListParts"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutBucketAbac(t *testing.T) {
	input := &PutBucketAbacInput{
		Bucket:              ptr.String("__Bucket__"),
		ContentMD5:          ptr.String("__ContentMD5__"),
		ChecksumAlgorithm:   types.ChecksumAlgorithm("CRC32"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		AbacStatus: &types.AbacStatus{
			Status: types.BucketAbacStatus("Enabled"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketAbac(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketAbac"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutBucketAccelerateConfiguration(t *testing.T) {
	input := &PutBucketAccelerateConfigurationInput{
		Bucket: ptr.String("__Bucket__"),
		AccelerateConfiguration: &types.AccelerateConfiguration{
			Status: types.BucketAccelerateStatus("Enabled"),
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		ChecksumAlgorithm:   types.ChecksumAlgorithm("CRC32"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketAccelerateConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketAccelerateConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutBucketAcl(t *testing.T) {
	input := &PutBucketAclInput{
		ACL: types.BucketCannedACL("private"),
		AccessControlPolicy: &types.AccessControlPolicy{
			Grants: []types.Grant{
				{
					Grantee: &types.Grantee{
						DisplayName:  ptr.String("__DisplayName__"),
						EmailAddress: ptr.String("__EmailAddress__"),
						ID:           ptr.String("__ID__"),
						URI:          ptr.String("__URI__"),
						Type:         types.Type("CanonicalUser"),
					},
					Permission: types.Permission("FULL_CONTROL"),
				},
				{
					Grantee: &types.Grantee{
						DisplayName:  ptr.String("__DisplayName__"),
						EmailAddress: ptr.String("__EmailAddress__"),
						ID:           ptr.String("__ID__"),
						URI:          ptr.String("__URI__"),
						Type:         types.Type("CanonicalUser"),
					},
					Permission: types.Permission("FULL_CONTROL"),
				},
			},
			Owner: &types.Owner{
				DisplayName: ptr.String("__DisplayName__"),
				ID:          ptr.String("__ID__"),
			},
		},
		Bucket:              ptr.String("__Bucket__"),
		ContentMD5:          ptr.String("__ContentMD5__"),
		ChecksumAlgorithm:   types.ChecksumAlgorithm("CRC32"),
		GrantFullControl:    ptr.String("__GrantFullControl__"),
		GrantRead:           ptr.String("__GrantRead__"),
		GrantReadACP:        ptr.String("__GrantReadACP__"),
		GrantWrite:          ptr.String("__GrantWrite__"),
		GrantWriteACP:       ptr.String("__GrantWriteACP__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketAcl(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketAcl"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutBucketAnalyticsConfiguration(t *testing.T) {
	input := &PutBucketAnalyticsConfigurationInput{
		Bucket: ptr.String("__Bucket__"),
		Id:     ptr.String("__Id__"),
		AnalyticsConfiguration: &types.AnalyticsConfiguration{
			Id: ptr.String("__Id__"),
			Filter: &types.AnalyticsFilterMemberPrefix{
				Value: "__AnalyticsFilterMemberPrefix__",
			},
			StorageClassAnalysis: &types.StorageClassAnalysis{
				DataExport: &types.StorageClassAnalysisDataExport{
					OutputSchemaVersion: types.StorageClassAnalysisSchemaVersion("V_1"),
					Destination: &types.AnalyticsExportDestination{
						S3BucketDestination: &types.AnalyticsS3BucketDestination{
							Format:          types.AnalyticsS3ExportFileFormat("CSV"),
							BucketAccountId: ptr.String("__BucketAccountId__"),
							Bucket:          ptr.String("__Bucket__"),
							Prefix:          ptr.String("__Prefix__"),
						},
					},
				},
			},
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketAnalyticsConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketAnalyticsConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutBucketCors(t *testing.T) {
	input := &PutBucketCorsInput{
		Bucket: ptr.String("__Bucket__"),
		CORSConfiguration: &types.CORSConfiguration{
			CORSRules: []types.CORSRule{
				{
					ID: ptr.String("__ID__"),
					AllowedHeaders: []string{
						"__Member__",
						"__Member__",
					},
					AllowedMethods: []string{
						"__Member__",
						"__Member__",
					},
					AllowedOrigins: []string{
						"__Member__",
						"__Member__",
					},
					ExposeHeaders: []string{
						"__Member__",
						"__Member__",
					},
					MaxAgeSeconds: ptr.Int32(1),
				},
				{
					ID: ptr.String("__ID__"),
					AllowedHeaders: []string{
						"__Member__",
						"__Member__",
					},
					AllowedMethods: []string{
						"__Member__",
						"__Member__",
					},
					AllowedOrigins: []string{
						"__Member__",
						"__Member__",
					},
					ExposeHeaders: []string{
						"__Member__",
						"__Member__",
					},
					MaxAgeSeconds: ptr.Int32(1),
				},
			},
		},
		ContentMD5:          ptr.String("__ContentMD5__"),
		ChecksumAlgorithm:   types.ChecksumAlgorithm("CRC32"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketCors(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketCors"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutBucketEncryption(t *testing.T) {
	input := &PutBucketEncryptionInput{
		Bucket:            ptr.String("__Bucket__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		ServerSideEncryptionConfiguration: &types.ServerSideEncryptionConfiguration{
			Rules: []types.ServerSideEncryptionRule{
				{
					ApplyServerSideEncryptionByDefault: &types.ServerSideEncryptionByDefault{
						SSEAlgorithm:   types.ServerSideEncryption("AES256"),
						KMSMasterKeyID: ptr.String("__KMSMasterKeyID__"),
					},
					BucketKeyEnabled: ptr.Bool(true),
					BlockedEncryptionTypes: &types.BlockedEncryptionTypes{
						EncryptionType: []types.EncryptionType{
							types.EncryptionType("NONE"),
							types.EncryptionType("NONE"),
						},
					},
				},
				{
					ApplyServerSideEncryptionByDefault: &types.ServerSideEncryptionByDefault{
						SSEAlgorithm:   types.ServerSideEncryption("AES256"),
						KMSMasterKeyID: ptr.String("__KMSMasterKeyID__"),
					},
					BucketKeyEnabled: ptr.Bool(true),
					BlockedEncryptionTypes: &types.BlockedEncryptionTypes{
						EncryptionType: []types.EncryptionType{
							types.EncryptionType("NONE"),
							types.EncryptionType("NONE"),
						},
					},
				},
			},
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketEncryption(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketEncryption"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutBucketIntelligentTieringConfiguration(t *testing.T) {
	input := &PutBucketIntelligentTieringConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		Id:                  ptr.String("__Id__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		IntelligentTieringConfiguration: &types.IntelligentTieringConfiguration{
			Id: ptr.String("__Id__"),
			Filter: &types.IntelligentTieringFilter{
				Prefix: ptr.String("__Prefix__"),
				Tag: &types.Tag{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
				And: &types.IntelligentTieringAndOperator{
					Prefix: ptr.String("__Prefix__"),
					Tags: []types.Tag{
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
					},
				},
			},
			Status: types.IntelligentTieringStatus("Enabled"),
			Tierings: []types.Tiering{
				{
					Days:       ptr.Int32(1),
					AccessTier: types.IntelligentTieringAccessTier("ARCHIVE_ACCESS"),
				},
				{
					Days:       ptr.Int32(1),
					AccessTier: types.IntelligentTieringAccessTier("ARCHIVE_ACCESS"),
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketIntelligentTieringConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketIntelligentTieringConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutBucketInventoryConfiguration(t *testing.T) {
	input := &PutBucketInventoryConfigurationInput{
		Bucket: ptr.String("__Bucket__"),
		Id:     ptr.String("__Id__"),
		InventoryConfiguration: &types.InventoryConfiguration{
			Destination: &types.InventoryDestination{
				S3BucketDestination: &types.InventoryS3BucketDestination{
					AccountId: ptr.String("__AccountId__"),
					Bucket:    ptr.String("__Bucket__"),
					Format:    types.InventoryFormat("CSV"),
					Prefix:    ptr.String("__Prefix__"),
					Encryption: &types.InventoryEncryption{
						SSES3: &types.SSES3{},
						SSEKMS: &types.SSEKMS{
							KeyId: ptr.String("__KeyId__"),
						},
					},
				},
			},
			IsEnabled: ptr.Bool(true),
			Filter: &types.InventoryFilter{
				Prefix: ptr.String("__Prefix__"),
			},
			Id:                     ptr.String("__Id__"),
			IncludedObjectVersions: types.InventoryIncludedObjectVersions("All"),
			OptionalFields: []types.InventoryOptionalField{
				types.InventoryOptionalField("Size"),
				types.InventoryOptionalField("Size"),
			},
			Schedule: &types.InventorySchedule{
				Frequency: types.InventoryFrequency("Daily"),
			},
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketInventoryConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketInventoryConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutBucketLifecycleConfiguration(t *testing.T) {
	input := &PutBucketLifecycleConfigurationInput{
		Bucket:            ptr.String("__Bucket__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		LifecycleConfiguration: &types.BucketLifecycleConfiguration{
			Rules: []types.LifecycleRule{
				{
					Expiration: &types.LifecycleExpiration{
						Date:                      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Days:                      ptr.Int32(1),
						ExpiredObjectDeleteMarker: ptr.Bool(true),
					},
					ID:     ptr.String("__ID__"),
					Prefix: ptr.String("__Prefix__"),
					Filter: &types.LifecycleRuleFilter{
						Prefix: ptr.String("__Prefix__"),
						Tag: &types.Tag{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
						ObjectSizeGreaterThan: ptr.Int64(1),
						ObjectSizeLessThan:    ptr.Int64(1),
						And: &types.LifecycleRuleAndOperator{
							Prefix: ptr.String("__Prefix__"),
							Tags: []types.Tag{
								{
									Key:   ptr.String("__Key__"),
									Value: ptr.String("__Value__"),
								},
								{
									Key:   ptr.String("__Key__"),
									Value: ptr.String("__Value__"),
								},
							},
							ObjectSizeGreaterThan: ptr.Int64(1),
							ObjectSizeLessThan:    ptr.Int64(1),
						},
					},
					Status: types.ExpirationStatus("Enabled"),
					Transitions: []types.Transition{
						{
							Date:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
							Days:         ptr.Int32(1),
							StorageClass: types.TransitionStorageClass("GLACIER"),
						},
						{
							Date:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
							Days:         ptr.Int32(1),
							StorageClass: types.TransitionStorageClass("GLACIER"),
						},
					},
					NoncurrentVersionTransitions: []types.NoncurrentVersionTransition{
						{
							NoncurrentDays:          ptr.Int32(1),
							StorageClass:            types.TransitionStorageClass("GLACIER"),
							NewerNoncurrentVersions: ptr.Int32(1),
						},
						{
							NoncurrentDays:          ptr.Int32(1),
							StorageClass:            types.TransitionStorageClass("GLACIER"),
							NewerNoncurrentVersions: ptr.Int32(1),
						},
					},
					NoncurrentVersionExpiration: &types.NoncurrentVersionExpiration{
						NoncurrentDays:          ptr.Int32(1),
						NewerNoncurrentVersions: ptr.Int32(1),
					},
					AbortIncompleteMultipartUpload: &types.AbortIncompleteMultipartUpload{
						DaysAfterInitiation: ptr.Int32(1),
					},
				},
				{
					Expiration: &types.LifecycleExpiration{
						Date:                      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Days:                      ptr.Int32(1),
						ExpiredObjectDeleteMarker: ptr.Bool(true),
					},
					ID:     ptr.String("__ID__"),
					Prefix: ptr.String("__Prefix__"),
					Filter: &types.LifecycleRuleFilter{
						Prefix: ptr.String("__Prefix__"),
						Tag: &types.Tag{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
						ObjectSizeGreaterThan: ptr.Int64(1),
						ObjectSizeLessThan:    ptr.Int64(1),
						And: &types.LifecycleRuleAndOperator{
							Prefix: ptr.String("__Prefix__"),
							Tags: []types.Tag{
								{
									Key:   ptr.String("__Key__"),
									Value: ptr.String("__Value__"),
								},
								{
									Key:   ptr.String("__Key__"),
									Value: ptr.String("__Value__"),
								},
							},
							ObjectSizeGreaterThan: ptr.Int64(1),
							ObjectSizeLessThan:    ptr.Int64(1),
						},
					},
					Status: types.ExpirationStatus("Enabled"),
					Transitions: []types.Transition{
						{
							Date:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
							Days:         ptr.Int32(1),
							StorageClass: types.TransitionStorageClass("GLACIER"),
						},
						{
							Date:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
							Days:         ptr.Int32(1),
							StorageClass: types.TransitionStorageClass("GLACIER"),
						},
					},
					NoncurrentVersionTransitions: []types.NoncurrentVersionTransition{
						{
							NoncurrentDays:          ptr.Int32(1),
							StorageClass:            types.TransitionStorageClass("GLACIER"),
							NewerNoncurrentVersions: ptr.Int32(1),
						},
						{
							NoncurrentDays:          ptr.Int32(1),
							StorageClass:            types.TransitionStorageClass("GLACIER"),
							NewerNoncurrentVersions: ptr.Int32(1),
						},
					},
					NoncurrentVersionExpiration: &types.NoncurrentVersionExpiration{
						NoncurrentDays:          ptr.Int32(1),
						NewerNoncurrentVersions: ptr.Int32(1),
					},
					AbortIncompleteMultipartUpload: &types.AbortIncompleteMultipartUpload{
						DaysAfterInitiation: ptr.Int32(1),
					},
				},
			},
		},
		ExpectedBucketOwner:                ptr.String("__ExpectedBucketOwner__"),
		TransitionDefaultMinimumObjectSize: types.TransitionDefaultMinimumObjectSize("varies_by_storage_class"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketLifecycleConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketLifecycleConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutBucketLogging(t *testing.T) {
	input := &PutBucketLoggingInput{
		Bucket: ptr.String("__Bucket__"),
		BucketLoggingStatus: &types.BucketLoggingStatus{
			LoggingEnabled: &types.LoggingEnabled{
				TargetBucket: ptr.String("__TargetBucket__"),
				TargetGrants: []types.TargetGrant{
					{
						Grantee: &types.Grantee{
							DisplayName:  ptr.String("__DisplayName__"),
							EmailAddress: ptr.String("__EmailAddress__"),
							ID:           ptr.String("__ID__"),
							URI:          ptr.String("__URI__"),
							Type:         types.Type("CanonicalUser"),
						},
						Permission: types.BucketLogsPermission("FULL_CONTROL"),
					},
					{
						Grantee: &types.Grantee{
							DisplayName:  ptr.String("__DisplayName__"),
							EmailAddress: ptr.String("__EmailAddress__"),
							ID:           ptr.String("__ID__"),
							URI:          ptr.String("__URI__"),
							Type:         types.Type("CanonicalUser"),
						},
						Permission: types.BucketLogsPermission("FULL_CONTROL"),
					},
				},
				TargetPrefix: ptr.String("__TargetPrefix__"),
				TargetObjectKeyFormat: &types.TargetObjectKeyFormat{
					SimplePrefix: &types.SimplePrefix{},
					PartitionedPrefix: &types.PartitionedPrefix{
						PartitionDateSource: types.PartitionDateSource("EventTime"),
					},
				},
			},
		},
		ContentMD5:          ptr.String("__ContentMD5__"),
		ChecksumAlgorithm:   types.ChecksumAlgorithm("CRC32"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketLogging(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketLogging"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutBucketMetricsConfiguration(t *testing.T) {
	input := &PutBucketMetricsConfigurationInput{
		Bucket: ptr.String("__Bucket__"),
		Id:     ptr.String("__Id__"),
		MetricsConfiguration: &types.MetricsConfiguration{
			Id: ptr.String("__Id__"),
			Filter: &types.MetricsFilterMemberPrefix{
				Value: "__MetricsFilterMemberPrefix__",
			},
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketMetricsConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketMetricsConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutBucketNotificationConfiguration(t *testing.T) {
	input := &PutBucketNotificationConfigurationInput{
		Bucket: ptr.String("__Bucket__"),
		NotificationConfiguration: &types.NotificationConfiguration{
			TopicConfigurations: []types.TopicConfiguration{
				{
					Id:       ptr.String("__Id__"),
					TopicArn: ptr.String("__TopicArn__"),
					Events: []types.Event{
						types.Event("s3:ReducedRedundancyLostObject"),
						types.Event("s3:ReducedRedundancyLostObject"),
					},
					Filter: &types.NotificationConfigurationFilter{
						Key: &types.S3KeyFilter{
							FilterRules: []types.FilterRule{
								{
									Name:  types.FilterRuleName("prefix"),
									Value: ptr.String("__Value__"),
								},
								{
									Name:  types.FilterRuleName("prefix"),
									Value: ptr.String("__Value__"),
								},
							},
						},
					},
				},
				{
					Id:       ptr.String("__Id__"),
					TopicArn: ptr.String("__TopicArn__"),
					Events: []types.Event{
						types.Event("s3:ReducedRedundancyLostObject"),
						types.Event("s3:ReducedRedundancyLostObject"),
					},
					Filter: &types.NotificationConfigurationFilter{
						Key: &types.S3KeyFilter{
							FilterRules: []types.FilterRule{
								{
									Name:  types.FilterRuleName("prefix"),
									Value: ptr.String("__Value__"),
								},
								{
									Name:  types.FilterRuleName("prefix"),
									Value: ptr.String("__Value__"),
								},
							},
						},
					},
				},
			},
			QueueConfigurations: []types.QueueConfiguration{
				{
					Id:       ptr.String("__Id__"),
					QueueArn: ptr.String("__QueueArn__"),
					Events: []types.Event{
						types.Event("s3:ReducedRedundancyLostObject"),
						types.Event("s3:ReducedRedundancyLostObject"),
					},
					Filter: &types.NotificationConfigurationFilter{
						Key: &types.S3KeyFilter{
							FilterRules: []types.FilterRule{
								{
									Name:  types.FilterRuleName("prefix"),
									Value: ptr.String("__Value__"),
								},
								{
									Name:  types.FilterRuleName("prefix"),
									Value: ptr.String("__Value__"),
								},
							},
						},
					},
				},
				{
					Id:       ptr.String("__Id__"),
					QueueArn: ptr.String("__QueueArn__"),
					Events: []types.Event{
						types.Event("s3:ReducedRedundancyLostObject"),
						types.Event("s3:ReducedRedundancyLostObject"),
					},
					Filter: &types.NotificationConfigurationFilter{
						Key: &types.S3KeyFilter{
							FilterRules: []types.FilterRule{
								{
									Name:  types.FilterRuleName("prefix"),
									Value: ptr.String("__Value__"),
								},
								{
									Name:  types.FilterRuleName("prefix"),
									Value: ptr.String("__Value__"),
								},
							},
						},
					},
				},
			},
			LambdaFunctionConfigurations: []types.LambdaFunctionConfiguration{
				{
					Id:                ptr.String("__Id__"),
					LambdaFunctionArn: ptr.String("__LambdaFunctionArn__"),
					Events: []types.Event{
						types.Event("s3:ReducedRedundancyLostObject"),
						types.Event("s3:ReducedRedundancyLostObject"),
					},
					Filter: &types.NotificationConfigurationFilter{
						Key: &types.S3KeyFilter{
							FilterRules: []types.FilterRule{
								{
									Name:  types.FilterRuleName("prefix"),
									Value: ptr.String("__Value__"),
								},
								{
									Name:  types.FilterRuleName("prefix"),
									Value: ptr.String("__Value__"),
								},
							},
						},
					},
				},
				{
					Id:                ptr.String("__Id__"),
					LambdaFunctionArn: ptr.String("__LambdaFunctionArn__"),
					Events: []types.Event{
						types.Event("s3:ReducedRedundancyLostObject"),
						types.Event("s3:ReducedRedundancyLostObject"),
					},
					Filter: &types.NotificationConfigurationFilter{
						Key: &types.S3KeyFilter{
							FilterRules: []types.FilterRule{
								{
									Name:  types.FilterRuleName("prefix"),
									Value: ptr.String("__Value__"),
								},
								{
									Name:  types.FilterRuleName("prefix"),
									Value: ptr.String("__Value__"),
								},
							},
						},
					},
				},
			},
			EventBridgeConfiguration: &types.EventBridgeConfiguration{},
		},
		ExpectedBucketOwner:       ptr.String("__ExpectedBucketOwner__"),
		SkipDestinationValidation: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketNotificationConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketNotificationConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutBucketOwnershipControls(t *testing.T) {
	input := &PutBucketOwnershipControlsInput{
		Bucket:              ptr.String("__Bucket__"),
		ContentMD5:          ptr.String("__ContentMD5__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		OwnershipControls: &types.OwnershipControls{
			Rules: []types.OwnershipControlsRule{
				{
					ObjectOwnership: types.ObjectOwnership("BucketOwnerPreferred"),
				},
				{
					ObjectOwnership: types.ObjectOwnership("BucketOwnerPreferred"),
				},
			},
		},
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketOwnershipControls(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketOwnershipControls"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutBucketPolicy(t *testing.T) {
	input := &PutBucketPolicyInput{
		Bucket:                        ptr.String("__Bucket__"),
		ContentMD5:                    ptr.String("__ContentMD5__"),
		ChecksumAlgorithm:             types.ChecksumAlgorithm("CRC32"),
		ConfirmRemoveSelfBucketAccess: ptr.Bool(true),
		Policy:                        ptr.String("__Policy__"),
		ExpectedBucketOwner:           ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketPolicy(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketPolicy"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutBucketReplication(t *testing.T) {
	input := &PutBucketReplicationInput{
		Bucket:            ptr.String("__Bucket__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		ReplicationConfiguration: &types.ReplicationConfiguration{
			Role: ptr.String("__Role__"),
			Rules: []types.ReplicationRule{
				{
					ID:       ptr.String("__ID__"),
					Priority: ptr.Int32(1),
					Prefix:   ptr.String("__Prefix__"),
					Filter: &types.ReplicationRuleFilter{
						Prefix: ptr.String("__Prefix__"),
						Tag: &types.Tag{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
						And: &types.ReplicationRuleAndOperator{
							Prefix: ptr.String("__Prefix__"),
							Tags: []types.Tag{
								{
									Key:   ptr.String("__Key__"),
									Value: ptr.String("__Value__"),
								},
								{
									Key:   ptr.String("__Key__"),
									Value: ptr.String("__Value__"),
								},
							},
						},
					},
					Status: types.ReplicationRuleStatus("Enabled"),
					SourceSelectionCriteria: &types.SourceSelectionCriteria{
						SseKmsEncryptedObjects: &types.SseKmsEncryptedObjects{
							Status: types.SseKmsEncryptedObjectsStatus("Enabled"),
						},
						ReplicaModifications: &types.ReplicaModifications{
							Status: types.ReplicaModificationsStatus("Enabled"),
						},
					},
					ExistingObjectReplication: &types.ExistingObjectReplication{
						Status: types.ExistingObjectReplicationStatus("Enabled"),
					},
					Destination: &types.Destination{
						Bucket:       ptr.String("__Bucket__"),
						Account:      ptr.String("__Account__"),
						StorageClass: types.StorageClass("STANDARD"),
						AccessControlTranslation: &types.AccessControlTranslation{
							Owner: types.OwnerOverride("Destination"),
						},
						EncryptionConfiguration: &types.EncryptionConfiguration{
							ReplicaKmsKeyID: ptr.String("__ReplicaKmsKeyID__"),
						},
						ReplicationTime: &types.ReplicationTime{
							Status: types.ReplicationTimeStatus("Enabled"),
							Time: &types.ReplicationTimeValue{
								Minutes: ptr.Int32(1),
							},
						},
						Metrics: &types.Metrics{
							Status: types.MetricsStatus("Enabled"),
							EventThreshold: &types.ReplicationTimeValue{
								Minutes: ptr.Int32(1),
							},
						},
					},
					DeleteMarkerReplication: &types.DeleteMarkerReplication{
						Status: types.DeleteMarkerReplicationStatus("Enabled"),
					},
				},
				{
					ID:       ptr.String("__ID__"),
					Priority: ptr.Int32(1),
					Prefix:   ptr.String("__Prefix__"),
					Filter: &types.ReplicationRuleFilter{
						Prefix: ptr.String("__Prefix__"),
						Tag: &types.Tag{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
						And: &types.ReplicationRuleAndOperator{
							Prefix: ptr.String("__Prefix__"),
							Tags: []types.Tag{
								{
									Key:   ptr.String("__Key__"),
									Value: ptr.String("__Value__"),
								},
								{
									Key:   ptr.String("__Key__"),
									Value: ptr.String("__Value__"),
								},
							},
						},
					},
					Status: types.ReplicationRuleStatus("Enabled"),
					SourceSelectionCriteria: &types.SourceSelectionCriteria{
						SseKmsEncryptedObjects: &types.SseKmsEncryptedObjects{
							Status: types.SseKmsEncryptedObjectsStatus("Enabled"),
						},
						ReplicaModifications: &types.ReplicaModifications{
							Status: types.ReplicaModificationsStatus("Enabled"),
						},
					},
					ExistingObjectReplication: &types.ExistingObjectReplication{
						Status: types.ExistingObjectReplicationStatus("Enabled"),
					},
					Destination: &types.Destination{
						Bucket:       ptr.String("__Bucket__"),
						Account:      ptr.String("__Account__"),
						StorageClass: types.StorageClass("STANDARD"),
						AccessControlTranslation: &types.AccessControlTranslation{
							Owner: types.OwnerOverride("Destination"),
						},
						EncryptionConfiguration: &types.EncryptionConfiguration{
							ReplicaKmsKeyID: ptr.String("__ReplicaKmsKeyID__"),
						},
						ReplicationTime: &types.ReplicationTime{
							Status: types.ReplicationTimeStatus("Enabled"),
							Time: &types.ReplicationTimeValue{
								Minutes: ptr.Int32(1),
							},
						},
						Metrics: &types.Metrics{
							Status: types.MetricsStatus("Enabled"),
							EventThreshold: &types.ReplicationTimeValue{
								Minutes: ptr.Int32(1),
							},
						},
					},
					DeleteMarkerReplication: &types.DeleteMarkerReplication{
						Status: types.DeleteMarkerReplicationStatus("Enabled"),
					},
				},
			},
		},
		Token:               ptr.String("__Token__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketReplication(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketReplication"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutBucketRequestPayment(t *testing.T) {
	input := &PutBucketRequestPaymentInput{
		Bucket:            ptr.String("__Bucket__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		RequestPaymentConfiguration: &types.RequestPaymentConfiguration{
			Payer: types.Payer("Requester"),
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketRequestPayment(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketRequestPayment"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutBucketTagging(t *testing.T) {
	input := &PutBucketTaggingInput{
		Bucket:            ptr.String("__Bucket__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		Tagging: &types.Tagging{
			TagSet: []types.Tag{
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
			},
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketTagging(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketTagging"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutBucketVersioning(t *testing.T) {
	input := &PutBucketVersioningInput{
		Bucket:            ptr.String("__Bucket__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		MFA:               ptr.String("__MFA__"),
		VersioningConfiguration: &types.VersioningConfiguration{
			MFADelete: types.MFADelete("Enabled"),
			Status:    types.BucketVersioningStatus("Enabled"),
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketVersioning(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketVersioning"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutBucketWebsite(t *testing.T) {
	input := &PutBucketWebsiteInput{
		Bucket:            ptr.String("__Bucket__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		WebsiteConfiguration: &types.WebsiteConfiguration{
			ErrorDocument: &types.ErrorDocument{
				Key: ptr.String("__Key__"),
			},
			IndexDocument: &types.IndexDocument{
				Suffix: ptr.String("__Suffix__"),
			},
			RedirectAllRequestsTo: &types.RedirectAllRequestsTo{
				HostName: ptr.String("__HostName__"),
				Protocol: types.Protocol("http"),
			},
			RoutingRules: []types.RoutingRule{
				{
					Condition: &types.Condition{
						HttpErrorCodeReturnedEquals: ptr.String("__HttpErrorCodeReturnedEquals__"),
						KeyPrefixEquals:             ptr.String("__KeyPrefixEquals__"),
					},
					Redirect: &types.Redirect{
						HostName:             ptr.String("__HostName__"),
						HttpRedirectCode:     ptr.String("__HttpRedirectCode__"),
						Protocol:             types.Protocol("http"),
						ReplaceKeyPrefixWith: ptr.String("__ReplaceKeyPrefixWith__"),
						ReplaceKeyWith:       ptr.String("__ReplaceKeyWith__"),
					},
				},
				{
					Condition: &types.Condition{
						HttpErrorCodeReturnedEquals: ptr.String("__HttpErrorCodeReturnedEquals__"),
						KeyPrefixEquals:             ptr.String("__KeyPrefixEquals__"),
					},
					Redirect: &types.Redirect{
						HostName:             ptr.String("__HostName__"),
						HttpRedirectCode:     ptr.String("__HttpRedirectCode__"),
						Protocol:             types.Protocol("http"),
						ReplaceKeyPrefixWith: ptr.String("__ReplaceKeyPrefixWith__"),
						ReplaceKeyWith:       ptr.String("__ReplaceKeyWith__"),
					},
				},
			},
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketWebsite(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketWebsite"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutObject(t *testing.T) {
	input := &PutObjectInput{
		ACL:                types.ObjectCannedACL("private"),
		Body:               io.NopCloser(bytes.NewReader([]byte("__Body__"))),
		Bucket:             ptr.String("__Bucket__"),
		CacheControl:       ptr.String("__CacheControl__"),
		ContentDisposition: ptr.String("__ContentDisposition__"),
		ContentEncoding:    ptr.String("__ContentEncoding__"),
		ContentLanguage:    ptr.String("__ContentLanguage__"),
		ContentLength:      ptr.Int64(1),
		ContentMD5:         ptr.String("__ContentMD5__"),
		ContentType:        ptr.String("__ContentType__"),
		ChecksumAlgorithm:  types.ChecksumAlgorithm("CRC32"),
		ChecksumCRC32:      ptr.String("__ChecksumCRC32__"),
		ChecksumCRC32C:     ptr.String("__ChecksumCRC32C__"),
		ChecksumCRC64NVME:  ptr.String("__ChecksumCRC64NVME__"),
		ChecksumSHA1:       ptr.String("__ChecksumSHA1__"),
		ChecksumSHA256:     ptr.String("__ChecksumSHA256__"),
		ChecksumSHA512:     ptr.String("__ChecksumSHA512__"),
		ChecksumMD5:        ptr.String("__ChecksumMD5__"),
		ChecksumXXHASH64:   ptr.String("__ChecksumXXHASH64__"),
		ChecksumXXHASH3:    ptr.String("__ChecksumXXHASH3__"),
		ChecksumXXHASH128:  ptr.String("__ChecksumXXHASH128__"),
		Expires:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		IfMatch:            ptr.String("__IfMatch__"),
		IfNoneMatch:        ptr.String("__IfNoneMatch__"),
		GrantFullControl:   ptr.String("__GrantFullControl__"),
		GrantRead:          ptr.String("__GrantRead__"),
		GrantReadACP:       ptr.String("__GrantReadACP__"),
		GrantWriteACP:      ptr.String("__GrantWriteACP__"),
		Key:                ptr.String("__Key__"),
		WriteOffsetBytes:   ptr.Int64(1),
		Metadata: map[string]string{
			"key0": "__Value__",
		},
		ServerSideEncryption:             types.ServerSideEncryption("AES256"),
		StorageClass:                     types.StorageClass("STANDARD"),
		WebsiteRedirectLocation:          ptr.String("__WebsiteRedirectLocation__"),
		SSECustomerAlgorithm:             ptr.String("__SSECustomerAlgorithm__"),
		SSECustomerKey:                   ptr.String("__SSECustomerKey__"),
		SSECustomerKeyMD5:                ptr.String("__SSECustomerKeyMD5__"),
		SSEKMSKeyId:                      ptr.String("__SSEKMSKeyId__"),
		SSEKMSEncryptionContext:          ptr.String("__SSEKMSEncryptionContext__"),
		BucketKeyEnabled:                 ptr.Bool(true),
		RequestPayer:                     types.RequestPayer("requester"),
		Tagging:                          ptr.String("__Tagging__"),
		ObjectLockMode:                   types.ObjectLockMode("GOVERNANCE"),
		ObjectLockRetainUntilDate:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ObjectLockLegalHoldStatus:        types.ObjectLockLegalHoldStatus("ON"),
		ObjectLockEventHold:              types.ObjectLockEventHold("ON"),
		ObjectLockEventHoldDurationDays:  ptr.Int32(1),
		ObjectLockEventHoldDurationYears: ptr.Int32(1),
		ExpectedBucketOwner:              ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutObject(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutObject"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutObjectAcl(t *testing.T) {
	input := &PutObjectAclInput{
		ACL: types.ObjectCannedACL("private"),
		AccessControlPolicy: &types.AccessControlPolicy{
			Grants: []types.Grant{
				{
					Grantee: &types.Grantee{
						DisplayName:  ptr.String("__DisplayName__"),
						EmailAddress: ptr.String("__EmailAddress__"),
						ID:           ptr.String("__ID__"),
						URI:          ptr.String("__URI__"),
						Type:         types.Type("CanonicalUser"),
					},
					Permission: types.Permission("FULL_CONTROL"),
				},
				{
					Grantee: &types.Grantee{
						DisplayName:  ptr.String("__DisplayName__"),
						EmailAddress: ptr.String("__EmailAddress__"),
						ID:           ptr.String("__ID__"),
						URI:          ptr.String("__URI__"),
						Type:         types.Type("CanonicalUser"),
					},
					Permission: types.Permission("FULL_CONTROL"),
				},
			},
			Owner: &types.Owner{
				DisplayName: ptr.String("__DisplayName__"),
				ID:          ptr.String("__ID__"),
			},
		},
		Bucket:              ptr.String("__Bucket__"),
		ContentMD5:          ptr.String("__ContentMD5__"),
		ChecksumAlgorithm:   types.ChecksumAlgorithm("CRC32"),
		GrantFullControl:    ptr.String("__GrantFullControl__"),
		GrantRead:           ptr.String("__GrantRead__"),
		GrantReadACP:        ptr.String("__GrantReadACP__"),
		GrantWrite:          ptr.String("__GrantWrite__"),
		GrantWriteACP:       ptr.String("__GrantWriteACP__"),
		Key:                 ptr.String("__Key__"),
		RequestPayer:        types.RequestPayer("requester"),
		VersionId:           ptr.String("__VersionId__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutObjectAcl(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutObjectAcl"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutObjectAnnotation(t *testing.T) {
	input := &PutObjectAnnotationInput{
		Bucket:              ptr.String("__Bucket__"),
		Key:                 ptr.String("__Key__"),
		VersionId:           ptr.String("__VersionId__"),
		AnnotationName:      ptr.String("__AnnotationName__"),
		AnnotationPayload:   io.NopCloser(bytes.NewReader([]byte("__AnnotationPayload__"))),
		ObjectIfMatch:       ptr.String("__ObjectIfMatch__"),
		ChecksumAlgorithm:   types.ChecksumAlgorithm("CRC32"),
		ChecksumCRC32:       ptr.String("__ChecksumCRC32__"),
		ChecksumCRC32C:      ptr.String("__ChecksumCRC32C__"),
		ChecksumCRC64NVME:   ptr.String("__ChecksumCRC64NVME__"),
		ChecksumSHA1:        ptr.String("__ChecksumSHA1__"),
		ChecksumSHA256:      ptr.String("__ChecksumSHA256__"),
		ChecksumSHA512:      ptr.String("__ChecksumSHA512__"),
		ChecksumMD5:         ptr.String("__ChecksumMD5__"),
		ChecksumXXHASH64:    ptr.String("__ChecksumXXHASH64__"),
		ChecksumXXHASH3:     ptr.String("__ChecksumXXHASH3__"),
		ChecksumXXHASH128:   ptr.String("__ChecksumXXHASH128__"),
		ContentMD5:          ptr.String("__ContentMD5__"),
		RequestPayer:        types.RequestPayer("requester"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutObjectAnnotation(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutObjectAnnotation"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutObjectLegalHold(t *testing.T) {
	input := &PutObjectLegalHoldInput{
		Bucket: ptr.String("__Bucket__"),
		Key:    ptr.String("__Key__"),
		LegalHold: &types.ObjectLockLegalHold{
			Status: types.ObjectLockLegalHoldStatus("ON"),
		},
		RequestPayer:        types.RequestPayer("requester"),
		VersionId:           ptr.String("__VersionId__"),
		ContentMD5:          ptr.String("__ContentMD5__"),
		ChecksumAlgorithm:   types.ChecksumAlgorithm("CRC32"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutObjectLegalHold(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutObjectLegalHold"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutObjectLockConfiguration(t *testing.T) {
	input := &PutObjectLockConfigurationInput{
		Bucket: ptr.String("__Bucket__"),
		ObjectLockConfiguration: &types.ObjectLockConfiguration{
			ObjectLockEnabled: types.ObjectLockEnabled("Enabled"),
			Rule: &types.ObjectLockRule{
				DefaultRetention: &types.DefaultRetention{
					Mode:  types.ObjectLockRetentionMode("GOVERNANCE"),
					Days:  ptr.Int32(1),
					Years: ptr.Int32(1),
					DefaultEventHold: &types.EventHoldDuration{
						Days:  ptr.Int32(1),
						Years: ptr.Int32(1),
					},
				},
			},
		},
		RequestPayer:        types.RequestPayer("requester"),
		Token:               ptr.String("__Token__"),
		ContentMD5:          ptr.String("__ContentMD5__"),
		ChecksumAlgorithm:   types.ChecksumAlgorithm("CRC32"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutObjectLockConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutObjectLockConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutObjectRetention(t *testing.T) {
	input := &PutObjectRetentionInput{
		Bucket: ptr.String("__Bucket__"),
		Key:    ptr.String("__Key__"),
		Retention: &types.ObjectLockRetention{
			Mode:            types.ObjectLockRetentionMode("GOVERNANCE"),
			RetainUntilDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			EventHold:       types.ObjectLockEventHold("ON"),
			EventHoldDuration: &types.EventHoldDuration{
				Days:  ptr.Int32(1),
				Years: ptr.Int32(1),
			},
		},
		RequestPayer:              types.RequestPayer("requester"),
		VersionId:                 ptr.String("__VersionId__"),
		BypassGovernanceRetention: ptr.Bool(true),
		ContentMD5:                ptr.String("__ContentMD5__"),
		ChecksumAlgorithm:         types.ChecksumAlgorithm("CRC32"),
		ExpectedBucketOwner:       ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutObjectRetention(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutObjectRetention"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutObjectTagging(t *testing.T) {
	input := &PutObjectTaggingInput{
		Bucket:            ptr.String("__Bucket__"),
		Key:               ptr.String("__Key__"),
		VersionId:         ptr.String("__VersionId__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		Tagging: &types.Tagging{
			TagSet: []types.Tag{
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
			},
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		RequestPayer:        types.RequestPayer("requester"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutObjectTagging(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutObjectTagging"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutPublicAccessBlock(t *testing.T) {
	input := &PutPublicAccessBlockInput{
		Bucket:            ptr.String("__Bucket__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		PublicAccessBlockConfiguration: &types.PublicAccessBlockConfiguration{
			BlockPublicAcls:       ptr.Bool(true),
			IgnorePublicAcls:      ptr.Bool(true),
			BlockPublicPolicy:     ptr.Bool(true),
			RestrictPublicBuckets: ptr.Bool(true),
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutPublicAccessBlock(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutPublicAccessBlock"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_RenameObject(t *testing.T) {
	input := &RenameObjectInput{
		Bucket:                       ptr.String("__Bucket__"),
		Key:                          ptr.String("__Key__"),
		RenameSource:                 ptr.String("__RenameSource__"),
		DestinationIfMatch:           ptr.String("__DestinationIfMatch__"),
		DestinationIfNoneMatch:       ptr.String("__DestinationIfNoneMatch__"),
		DestinationIfModifiedSince:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		DestinationIfUnmodifiedSince: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		SourceIfMatch:                ptr.String("__SourceIfMatch__"),
		SourceIfNoneMatch:            ptr.String("__SourceIfNoneMatch__"),
		SourceIfModifiedSince:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		SourceIfUnmodifiedSince:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ClientToken:                  ptr.String("__ClientToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.RenameObject(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "RenameObject"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_RestoreObject(t *testing.T) {
	input := &RestoreObjectInput{
		Bucket:    ptr.String("__Bucket__"),
		Key:       ptr.String("__Key__"),
		VersionId: ptr.String("__VersionId__"),
		RestoreRequest: &types.RestoreRequest{
			Days: ptr.Int32(1),
			GlacierJobParameters: &types.GlacierJobParameters{
				Tier: types.Tier("Standard"),
			},
			Type:        types.RestoreRequestType("SELECT"),
			Tier:        types.Tier("Standard"),
			Description: ptr.String("__Description__"),
			SelectParameters: &types.SelectParameters{
				InputSerialization: &types.InputSerialization{
					CSV: &types.CSVInput{
						FileHeaderInfo:             types.FileHeaderInfo("USE"),
						Comments:                   ptr.String("__Comments__"),
						QuoteEscapeCharacter:       ptr.String("__QuoteEscapeCharacter__"),
						RecordDelimiter:            ptr.String("__RecordDelimiter__"),
						FieldDelimiter:             ptr.String("__FieldDelimiter__"),
						QuoteCharacter:             ptr.String("__QuoteCharacter__"),
						AllowQuotedRecordDelimiter: ptr.Bool(true),
					},
					CompressionType: types.CompressionType("NONE"),
					JSON: &types.JSONInput{
						Type: types.JSONType("DOCUMENT"),
					},
					Parquet: &types.ParquetInput{},
				},
				ExpressionType: types.ExpressionType("SQL"),
				Expression:     ptr.String("__Expression__"),
				OutputSerialization: &types.OutputSerialization{
					CSV: &types.CSVOutput{
						QuoteFields:          types.QuoteFields("ALWAYS"),
						QuoteEscapeCharacter: ptr.String("__QuoteEscapeCharacter__"),
						RecordDelimiter:      ptr.String("__RecordDelimiter__"),
						FieldDelimiter:       ptr.String("__FieldDelimiter__"),
						QuoteCharacter:       ptr.String("__QuoteCharacter__"),
					},
					JSON: &types.JSONOutput{
						RecordDelimiter: ptr.String("__RecordDelimiter__"),
					},
				},
			},
			OutputLocation: &types.OutputLocation{
				S3: &types.S3Location{
					BucketName: ptr.String("__BucketName__"),
					Prefix:     ptr.String("__Prefix__"),
					Encryption: &types.Encryption{
						EncryptionType: types.ServerSideEncryption("AES256"),
						KMSKeyId:       ptr.String("__KMSKeyId__"),
						KMSContext:     ptr.String("__KMSContext__"),
					},
					CannedACL: types.ObjectCannedACL("private"),
					AccessControlList: []types.Grant{
						{
							Grantee: &types.Grantee{
								DisplayName:  ptr.String("__DisplayName__"),
								EmailAddress: ptr.String("__EmailAddress__"),
								ID:           ptr.String("__ID__"),
								URI:          ptr.String("__URI__"),
								Type:         types.Type("CanonicalUser"),
							},
							Permission: types.Permission("FULL_CONTROL"),
						},
						{
							Grantee: &types.Grantee{
								DisplayName:  ptr.String("__DisplayName__"),
								EmailAddress: ptr.String("__EmailAddress__"),
								ID:           ptr.String("__ID__"),
								URI:          ptr.String("__URI__"),
								Type:         types.Type("CanonicalUser"),
							},
							Permission: types.Permission("FULL_CONTROL"),
						},
					},
					Tagging: &types.Tagging{
						TagSet: []types.Tag{
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
						},
					},
					UserMetadata: []types.MetadataEntry{
						{
							Name:  ptr.String("__Name__"),
							Value: ptr.String("__Value__"),
						},
						{
							Name:  ptr.String("__Name__"),
							Value: ptr.String("__Value__"),
						},
					},
					StorageClass: types.StorageClass("STANDARD"),
				},
			},
		},
		RequestPayer:        types.RequestPayer("requester"),
		ChecksumAlgorithm:   types.ChecksumAlgorithm("CRC32"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.RestoreObject(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "RestoreObject"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateBucketMetadataAnnotationTableConfiguration(t *testing.T) {
	input := &UpdateBucketMetadataAnnotationTableConfigurationInput{
		Bucket:            ptr.String("__Bucket__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		AnnotationTableConfiguration: &types.AnnotationTableConfigurationUpdates{
			ConfigurationState: types.AnnotationConfigurationState("ENABLED"),
			EncryptionConfiguration: &types.MetadataTableEncryptionConfiguration{
				SseAlgorithm: types.TableSseAlgorithm("aws:kms"),
				KmsKeyArn:    ptr.String("__KmsKeyArn__"),
			},
			Role: ptr.String("__Role__"),
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateBucketMetadataAnnotationTableConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UpdateBucketMetadataAnnotationTableConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateBucketMetadataInventoryTableConfiguration(t *testing.T) {
	input := &UpdateBucketMetadataInventoryTableConfigurationInput{
		Bucket:            ptr.String("__Bucket__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		InventoryTableConfiguration: &types.InventoryTableConfigurationUpdates{
			ConfigurationState: types.InventoryConfigurationState("ENABLED"),
			EncryptionConfiguration: &types.MetadataTableEncryptionConfiguration{
				SseAlgorithm: types.TableSseAlgorithm("aws:kms"),
				KmsKeyArn:    ptr.String("__KmsKeyArn__"),
			},
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateBucketMetadataInventoryTableConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UpdateBucketMetadataInventoryTableConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateBucketMetadataJournalTableConfiguration(t *testing.T) {
	input := &UpdateBucketMetadataJournalTableConfigurationInput{
		Bucket:            ptr.String("__Bucket__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		JournalTableConfiguration: &types.JournalTableConfigurationUpdates{
			RecordExpiration: &types.RecordExpiration{
				Expiration: types.ExpirationState("ENABLED"),
				Days:       ptr.Int32(1),
			},
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateBucketMetadataJournalTableConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UpdateBucketMetadataJournalTableConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateObjectEncryption(t *testing.T) {
	input := &UpdateObjectEncryptionInput{
		Bucket:    ptr.String("__Bucket__"),
		Key:       ptr.String("__Key__"),
		VersionId: ptr.String("__VersionId__"),
		ObjectEncryption: &types.ObjectEncryptionMemberSSEKMS{
			Value: types.SSEKMSEncryption{
				KMSKeyArn:        ptr.String("__KMSKeyArn__"),
				BucketKeyEnabled: ptr.Bool(true),
			},
		},
		RequestPayer:        types.RequestPayer("requester"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		ContentMD5:          ptr.String("__ContentMD5__"),
		ChecksumAlgorithm:   types.ChecksumAlgorithm("CRC32"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateObjectEncryption(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UpdateObjectEncryption"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UploadPart(t *testing.T) {
	input := &UploadPartInput{
		Body:                 io.NopCloser(bytes.NewReader([]byte("__Body__"))),
		Bucket:               ptr.String("__Bucket__"),
		ContentLength:        ptr.Int64(1),
		ContentMD5:           ptr.String("__ContentMD5__"),
		ChecksumAlgorithm:    types.ChecksumAlgorithm("CRC32"),
		ChecksumCRC32:        ptr.String("__ChecksumCRC32__"),
		ChecksumCRC32C:       ptr.String("__ChecksumCRC32C__"),
		ChecksumCRC64NVME:    ptr.String("__ChecksumCRC64NVME__"),
		ChecksumSHA1:         ptr.String("__ChecksumSHA1__"),
		ChecksumSHA256:       ptr.String("__ChecksumSHA256__"),
		ChecksumSHA512:       ptr.String("__ChecksumSHA512__"),
		ChecksumMD5:          ptr.String("__ChecksumMD5__"),
		ChecksumXXHASH64:     ptr.String("__ChecksumXXHASH64__"),
		ChecksumXXHASH3:      ptr.String("__ChecksumXXHASH3__"),
		ChecksumXXHASH128:    ptr.String("__ChecksumXXHASH128__"),
		Key:                  ptr.String("__Key__"),
		PartNumber:           ptr.Int32(1),
		UploadId:             ptr.String("__UploadId__"),
		SSECustomerAlgorithm: ptr.String("__SSECustomerAlgorithm__"),
		SSECustomerKey:       ptr.String("__SSECustomerKey__"),
		SSECustomerKeyMD5:    ptr.String("__SSECustomerKeyMD5__"),
		RequestPayer:         types.RequestPayer("requester"),
		ExpectedBucketOwner:  ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UploadPart(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UploadPart"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UploadPartCopy(t *testing.T) {
	input := &UploadPartCopyInput{
		Bucket:                         ptr.String("__Bucket__"),
		CopySource:                     ptr.String("__CopySource__"),
		CopySourceIfMatch:              ptr.String("__CopySourceIfMatch__"),
		CopySourceIfModifiedSince:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		CopySourceIfNoneMatch:          ptr.String("__CopySourceIfNoneMatch__"),
		CopySourceIfUnmodifiedSince:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		CopySourceRange:                ptr.String("__CopySourceRange__"),
		Key:                            ptr.String("__Key__"),
		PartNumber:                     ptr.Int32(1),
		UploadId:                       ptr.String("__UploadId__"),
		SSECustomerAlgorithm:           ptr.String("__SSECustomerAlgorithm__"),
		SSECustomerKey:                 ptr.String("__SSECustomerKey__"),
		SSECustomerKeyMD5:              ptr.String("__SSECustomerKeyMD5__"),
		CopySourceSSECustomerAlgorithm: ptr.String("__CopySourceSSECustomerAlgorithm__"),
		CopySourceSSECustomerKey:       ptr.String("__CopySourceSSECustomerKey__"),
		CopySourceSSECustomerKeyMD5:    ptr.String("__CopySourceSSECustomerKeyMD5__"),
		RequestPayer:                   types.RequestPayer("requester"),
		ExpectedBucketOwner:            ptr.String("__ExpectedBucketOwner__"),
		ExpectedSourceBucketOwner:      ptr.String("__ExpectedSourceBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UploadPartCopy(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UploadPartCopy"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_WriteGetObjectResponse(t *testing.T) {
	input := &WriteGetObjectResponseInput{
		RequestRoute:       ptr.String("RequestRoute-value"),
		RequestToken:       ptr.String("__RequestToken__"),
		Body:               io.NopCloser(bytes.NewReader([]byte("__Body__"))),
		StatusCode:         ptr.Int32(1),
		ErrorCode:          ptr.String("__ErrorCode__"),
		ErrorMessage:       ptr.String("__ErrorMessage__"),
		AcceptRanges:       ptr.String("__AcceptRanges__"),
		CacheControl:       ptr.String("__CacheControl__"),
		ContentDisposition: ptr.String("__ContentDisposition__"),
		ContentEncoding:    ptr.String("__ContentEncoding__"),
		ContentLanguage:    ptr.String("__ContentLanguage__"),
		ContentLength:      ptr.Int64(1),
		ContentRange:       ptr.String("__ContentRange__"),
		ContentType:        ptr.String("__ContentType__"),
		ChecksumCRC32:      ptr.String("__ChecksumCRC32__"),
		ChecksumCRC32C:     ptr.String("__ChecksumCRC32C__"),
		ChecksumCRC64NVME:  ptr.String("__ChecksumCRC64NVME__"),
		ChecksumSHA1:       ptr.String("__ChecksumSHA1__"),
		ChecksumSHA256:     ptr.String("__ChecksumSHA256__"),
		ChecksumSHA512:     ptr.String("__ChecksumSHA512__"),
		ChecksumMD5:        ptr.String("__ChecksumMD5__"),
		ChecksumXXHASH64:   ptr.String("__ChecksumXXHASH64__"),
		ChecksumXXHASH3:    ptr.String("__ChecksumXXHASH3__"),
		ChecksumXXHASH128:  ptr.String("__ChecksumXXHASH128__"),
		DeleteMarker:       ptr.Bool(true),
		ETag:               ptr.String("__ETag__"),
		Expires:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		Expiration:         ptr.String("__Expiration__"),
		LastModified:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		MissingMeta:        ptr.Int32(1),
		Metadata: map[string]string{
			"key0": "__Value__",
		},
		ObjectLockMode:            types.ObjectLockMode("GOVERNANCE"),
		ObjectLockLegalHoldStatus: types.ObjectLockLegalHoldStatus("ON"),
		ObjectLockRetainUntilDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		PartsCount:                ptr.Int32(1),
		ReplicationStatus:         types.ReplicationStatus("COMPLETE"),
		RequestCharged:            types.RequestCharged("requester"),
		Restore:                   ptr.String("__Restore__"),
		ServerSideEncryption:      types.ServerSideEncryption("AES256"),
		SSECustomerAlgorithm:      ptr.String("__SSECustomerAlgorithm__"),
		SSEKMSKeyId:               ptr.String("__SSEKMSKeyId__"),
		SSECustomerKeyMD5:         ptr.String("__SSECustomerKeyMD5__"),
		StorageClass:              types.StorageClass("STANDARD"),
		TagCount:                  ptr.Int32(1),
		VersionId:                 ptr.String("__VersionId__"),
		BucketKeyEnabled:          ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.WriteGetObjectResponse(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "WriteGetObjectResponse"); err != nil {
		t.Fatal(err)
	}
}
func TestUpdateRequestSnapshot_AbortMultipartUpload(t *testing.T) {
	input := &AbortMultipartUploadInput{
		Bucket:               ptr.String("__Bucket__"),
		Key:                  ptr.String("__Key__"),
		UploadId:             ptr.String("__UploadId__"),
		RequestPayer:         types.RequestPayer("requester"),
		ExpectedBucketOwner:  ptr.String("__ExpectedBucketOwner__"),
		IfMatchInitiatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AbortMultipartUpload(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "AbortMultipartUpload"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CompleteMultipartUpload(t *testing.T) {
	input := &CompleteMultipartUploadInput{
		Bucket: ptr.String("__Bucket__"),
		Key:    ptr.String("__Key__"),
		MultipartUpload: &types.CompletedMultipartUpload{
			Parts: []types.CompletedPart{
				{
					ETag:              ptr.String("__ETag__"),
					ChecksumCRC32:     ptr.String("__ChecksumCRC32__"),
					ChecksumCRC32C:    ptr.String("__ChecksumCRC32C__"),
					ChecksumCRC64NVME: ptr.String("__ChecksumCRC64NVME__"),
					ChecksumSHA1:      ptr.String("__ChecksumSHA1__"),
					ChecksumSHA256:    ptr.String("__ChecksumSHA256__"),
					ChecksumSHA512:    ptr.String("__ChecksumSHA512__"),
					ChecksumMD5:       ptr.String("__ChecksumMD5__"),
					ChecksumXXHASH64:  ptr.String("__ChecksumXXHASH64__"),
					ChecksumXXHASH3:   ptr.String("__ChecksumXXHASH3__"),
					ChecksumXXHASH128: ptr.String("__ChecksumXXHASH128__"),
					PartNumber:        ptr.Int32(1),
				},
				{
					ETag:              ptr.String("__ETag__"),
					ChecksumCRC32:     ptr.String("__ChecksumCRC32__"),
					ChecksumCRC32C:    ptr.String("__ChecksumCRC32C__"),
					ChecksumCRC64NVME: ptr.String("__ChecksumCRC64NVME__"),
					ChecksumSHA1:      ptr.String("__ChecksumSHA1__"),
					ChecksumSHA256:    ptr.String("__ChecksumSHA256__"),
					ChecksumSHA512:    ptr.String("__ChecksumSHA512__"),
					ChecksumMD5:       ptr.String("__ChecksumMD5__"),
					ChecksumXXHASH64:  ptr.String("__ChecksumXXHASH64__"),
					ChecksumXXHASH3:   ptr.String("__ChecksumXXHASH3__"),
					ChecksumXXHASH128: ptr.String("__ChecksumXXHASH128__"),
					PartNumber:        ptr.Int32(1),
				},
			},
		},
		UploadId:             ptr.String("__UploadId__"),
		ChecksumCRC32:        ptr.String("__ChecksumCRC32__"),
		ChecksumCRC32C:       ptr.String("__ChecksumCRC32C__"),
		ChecksumCRC64NVME:    ptr.String("__ChecksumCRC64NVME__"),
		ChecksumSHA1:         ptr.String("__ChecksumSHA1__"),
		ChecksumSHA256:       ptr.String("__ChecksumSHA256__"),
		ChecksumSHA512:       ptr.String("__ChecksumSHA512__"),
		ChecksumMD5:          ptr.String("__ChecksumMD5__"),
		ChecksumXXHASH64:     ptr.String("__ChecksumXXHASH64__"),
		ChecksumXXHASH3:      ptr.String("__ChecksumXXHASH3__"),
		ChecksumXXHASH128:    ptr.String("__ChecksumXXHASH128__"),
		ChecksumType:         types.ChecksumType("COMPOSITE"),
		MpuObjectSize:        ptr.Int64(1),
		RequestPayer:         types.RequestPayer("requester"),
		ExpectedBucketOwner:  ptr.String("__ExpectedBucketOwner__"),
		IfMatch:              ptr.String("__IfMatch__"),
		IfNoneMatch:          ptr.String("__IfNoneMatch__"),
		SSECustomerAlgorithm: ptr.String("__SSECustomerAlgorithm__"),
		SSECustomerKey:       ptr.String("__SSECustomerKey__"),
		SSECustomerKeyMD5:    ptr.String("__SSECustomerKeyMD5__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CompleteMultipartUpload(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CompleteMultipartUpload"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CopyObject(t *testing.T) {
	input := &CopyObjectInput{
		ACL:                         types.ObjectCannedACL("private"),
		Bucket:                      ptr.String("__Bucket__"),
		CacheControl:                ptr.String("__CacheControl__"),
		ChecksumAlgorithm:           types.ChecksumAlgorithm("CRC32"),
		ContentDisposition:          ptr.String("__ContentDisposition__"),
		ContentEncoding:             ptr.String("__ContentEncoding__"),
		ContentLanguage:             ptr.String("__ContentLanguage__"),
		ContentType:                 ptr.String("__ContentType__"),
		CopySource:                  ptr.String("__CopySource__"),
		CopySourceIfMatch:           ptr.String("__CopySourceIfMatch__"),
		CopySourceIfModifiedSince:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		CopySourceIfNoneMatch:       ptr.String("__CopySourceIfNoneMatch__"),
		CopySourceIfUnmodifiedSince: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		Expires:                     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		GrantFullControl:            ptr.String("__GrantFullControl__"),
		GrantRead:                   ptr.String("__GrantRead__"),
		GrantReadACP:                ptr.String("__GrantReadACP__"),
		GrantWriteACP:               ptr.String("__GrantWriteACP__"),
		IfMatch:                     ptr.String("__IfMatch__"),
		IfNoneMatch:                 ptr.String("__IfNoneMatch__"),
		Key:                         ptr.String("__Key__"),
		Metadata: map[string]string{
			"key0": "__Value__",
		},
		MetadataDirective:                types.MetadataDirective("COPY"),
		TaggingDirective:                 types.TaggingDirective("COPY"),
		AnnotationDirective:              types.AnnotationDirective("COPY"),
		ServerSideEncryption:             types.ServerSideEncryption("AES256"),
		StorageClass:                     types.StorageClass("STANDARD"),
		WebsiteRedirectLocation:          ptr.String("__WebsiteRedirectLocation__"),
		SSECustomerAlgorithm:             ptr.String("__SSECustomerAlgorithm__"),
		SSECustomerKey:                   ptr.String("__SSECustomerKey__"),
		SSECustomerKeyMD5:                ptr.String("__SSECustomerKeyMD5__"),
		SSEKMSKeyId:                      ptr.String("__SSEKMSKeyId__"),
		SSEKMSEncryptionContext:          ptr.String("__SSEKMSEncryptionContext__"),
		BucketKeyEnabled:                 ptr.Bool(true),
		CopySourceSSECustomerAlgorithm:   ptr.String("__CopySourceSSECustomerAlgorithm__"),
		CopySourceSSECustomerKey:         ptr.String("__CopySourceSSECustomerKey__"),
		CopySourceSSECustomerKeyMD5:      ptr.String("__CopySourceSSECustomerKeyMD5__"),
		RequestPayer:                     types.RequestPayer("requester"),
		Tagging:                          ptr.String("__Tagging__"),
		ObjectLockMode:                   types.ObjectLockMode("GOVERNANCE"),
		ObjectLockRetainUntilDate:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ObjectLockLegalHoldStatus:        types.ObjectLockLegalHoldStatus("ON"),
		ObjectLockEventHold:              types.ObjectLockEventHold("ON"),
		ObjectLockEventHoldDurationDays:  ptr.Int32(1),
		ObjectLockEventHoldDurationYears: ptr.Int32(1),
		ExpectedBucketOwner:              ptr.String("__ExpectedBucketOwner__"),
		ExpectedSourceBucketOwner:        ptr.String("__ExpectedSourceBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CopyObject(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CopyObject"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateBucket(t *testing.T) {
	input := &CreateBucketInput{
		ACL:    types.BucketCannedACL("private"),
		Bucket: ptr.String("__Bucket__"),
		CreateBucketConfiguration: &types.CreateBucketConfiguration{
			LocationConstraint: types.BucketLocationConstraint("af-south-1"),
			Location: &types.LocationInfo{
				Type: types.LocationType("AvailabilityZone"),
				Name: ptr.String("__Name__"),
			},
			Bucket: &types.BucketInfo{
				DataRedundancy: types.DataRedundancy("SingleAvailabilityZone"),
				Type:           types.BucketType("Directory"),
			},
			Tags: []types.Tag{
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
			},
		},
		GrantFullControl:           ptr.String("__GrantFullControl__"),
		GrantRead:                  ptr.String("__GrantRead__"),
		GrantReadACP:               ptr.String("__GrantReadACP__"),
		GrantWrite:                 ptr.String("__GrantWrite__"),
		GrantWriteACP:              ptr.String("__GrantWriteACP__"),
		ObjectLockEnabledForBucket: ptr.Bool(true),
		ObjectOwnership:            types.ObjectOwnership("BucketOwnerPreferred"),
		BucketNamespace:            types.BucketNamespace("account-regional"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateBucket(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateBucket"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateBucketMetadataConfiguration(t *testing.T) {
	input := &CreateBucketMetadataConfigurationInput{
		Bucket:            ptr.String("__Bucket__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		MetadataConfiguration: &types.MetadataConfiguration{
			JournalTableConfiguration: &types.JournalTableConfiguration{
				RecordExpiration: &types.RecordExpiration{
					Expiration: types.ExpirationState("ENABLED"),
					Days:       ptr.Int32(1),
				},
				EncryptionConfiguration: &types.MetadataTableEncryptionConfiguration{
					SseAlgorithm: types.TableSseAlgorithm("aws:kms"),
					KmsKeyArn:    ptr.String("__KmsKeyArn__"),
				},
			},
			InventoryTableConfiguration: &types.InventoryTableConfiguration{
				ConfigurationState: types.InventoryConfigurationState("ENABLED"),
				EncryptionConfiguration: &types.MetadataTableEncryptionConfiguration{
					SseAlgorithm: types.TableSseAlgorithm("aws:kms"),
					KmsKeyArn:    ptr.String("__KmsKeyArn__"),
				},
			},
			AnnotationTableConfiguration: &types.AnnotationTableConfiguration{
				ConfigurationState: types.AnnotationConfigurationState("ENABLED"),
				EncryptionConfiguration: &types.MetadataTableEncryptionConfiguration{
					SseAlgorithm: types.TableSseAlgorithm("aws:kms"),
					KmsKeyArn:    ptr.String("__KmsKeyArn__"),
				},
				Role: ptr.String("__Role__"),
			},
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateBucketMetadataConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateBucketMetadataConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateBucketMetadataTableConfiguration(t *testing.T) {
	input := &CreateBucketMetadataTableConfigurationInput{
		Bucket:            ptr.String("__Bucket__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		MetadataTableConfiguration: &types.MetadataTableConfiguration{
			S3TablesDestination: &types.S3TablesDestination{
				TableBucketArn: ptr.String("__TableBucketArn__"),
				TableName:      ptr.String("__TableName__"),
			},
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateBucketMetadataTableConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateBucketMetadataTableConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateMultipartUpload(t *testing.T) {
	input := &CreateMultipartUploadInput{
		ACL:                types.ObjectCannedACL("private"),
		Bucket:             ptr.String("__Bucket__"),
		CacheControl:       ptr.String("__CacheControl__"),
		ContentDisposition: ptr.String("__ContentDisposition__"),
		ContentEncoding:    ptr.String("__ContentEncoding__"),
		ContentLanguage:    ptr.String("__ContentLanguage__"),
		ContentType:        ptr.String("__ContentType__"),
		Expires:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		GrantFullControl:   ptr.String("__GrantFullControl__"),
		GrantRead:          ptr.String("__GrantRead__"),
		GrantReadACP:       ptr.String("__GrantReadACP__"),
		GrantWriteACP:      ptr.String("__GrantWriteACP__"),
		Key:                ptr.String("__Key__"),
		Metadata: map[string]string{
			"key0": "__Value__",
		},
		ServerSideEncryption:             types.ServerSideEncryption("AES256"),
		StorageClass:                     types.StorageClass("STANDARD"),
		WebsiteRedirectLocation:          ptr.String("__WebsiteRedirectLocation__"),
		SSECustomerAlgorithm:             ptr.String("__SSECustomerAlgorithm__"),
		SSECustomerKey:                   ptr.String("__SSECustomerKey__"),
		SSECustomerKeyMD5:                ptr.String("__SSECustomerKeyMD5__"),
		SSEKMSKeyId:                      ptr.String("__SSEKMSKeyId__"),
		SSEKMSEncryptionContext:          ptr.String("__SSEKMSEncryptionContext__"),
		BucketKeyEnabled:                 ptr.Bool(true),
		RequestPayer:                     types.RequestPayer("requester"),
		Tagging:                          ptr.String("__Tagging__"),
		ObjectLockMode:                   types.ObjectLockMode("GOVERNANCE"),
		ObjectLockRetainUntilDate:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ObjectLockLegalHoldStatus:        types.ObjectLockLegalHoldStatus("ON"),
		ObjectLockEventHold:              types.ObjectLockEventHold("ON"),
		ObjectLockEventHoldDurationDays:  ptr.Int32(1),
		ObjectLockEventHoldDurationYears: ptr.Int32(1),
		ExpectedBucketOwner:              ptr.String("__ExpectedBucketOwner__"),
		ChecksumAlgorithm:                types.ChecksumAlgorithm("CRC32"),
		ChecksumType:                     types.ChecksumType("COMPOSITE"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateMultipartUpload(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateMultipartUpload"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateSession(t *testing.T) {
	input := &CreateSessionInput{
		SessionMode:             types.SessionMode("ReadOnly"),
		Bucket:                  ptr.String("__Bucket__"),
		ServerSideEncryption:    types.ServerSideEncryption("AES256"),
		SSEKMSKeyId:             ptr.String("__SSEKMSKeyId__"),
		SSEKMSEncryptionContext: ptr.String("__SSEKMSEncryptionContext__"),
		BucketKeyEnabled:        ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateSession(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateSession"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteBucket(t *testing.T) {
	input := &DeleteBucketInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucket(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucket"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteBucketAnalyticsConfiguration(t *testing.T) {
	input := &DeleteBucketAnalyticsConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		Id:                  ptr.String("__Id__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketAnalyticsConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketAnalyticsConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteBucketCors(t *testing.T) {
	input := &DeleteBucketCorsInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketCors(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketCors"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteBucketEncryption(t *testing.T) {
	input := &DeleteBucketEncryptionInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketEncryption(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketEncryption"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteBucketIntelligentTieringConfiguration(t *testing.T) {
	input := &DeleteBucketIntelligentTieringConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		Id:                  ptr.String("__Id__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketIntelligentTieringConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketIntelligentTieringConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteBucketInventoryConfiguration(t *testing.T) {
	input := &DeleteBucketInventoryConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		Id:                  ptr.String("__Id__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketInventoryConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketInventoryConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteBucketLifecycle(t *testing.T) {
	input := &DeleteBucketLifecycleInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketLifecycle(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketLifecycle"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteBucketMetadataConfiguration(t *testing.T) {
	input := &DeleteBucketMetadataConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketMetadataConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketMetadataConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteBucketMetadataTableConfiguration(t *testing.T) {
	input := &DeleteBucketMetadataTableConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketMetadataTableConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketMetadataTableConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteBucketMetricsConfiguration(t *testing.T) {
	input := &DeleteBucketMetricsConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		Id:                  ptr.String("__Id__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketMetricsConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketMetricsConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteBucketOwnershipControls(t *testing.T) {
	input := &DeleteBucketOwnershipControlsInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketOwnershipControls(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketOwnershipControls"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteBucketPolicy(t *testing.T) {
	input := &DeleteBucketPolicyInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketPolicy(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketPolicy"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteBucketReplication(t *testing.T) {
	input := &DeleteBucketReplicationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketReplication(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketReplication"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteBucketTagging(t *testing.T) {
	input := &DeleteBucketTaggingInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketTagging(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketTagging"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteBucketWebsite(t *testing.T) {
	input := &DeleteBucketWebsiteInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteBucketWebsite(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteBucketWebsite"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteObject(t *testing.T) {
	input := &DeleteObjectInput{
		Bucket:                    ptr.String("__Bucket__"),
		Key:                       ptr.String("__Key__"),
		MFA:                       ptr.String("__MFA__"),
		VersionId:                 ptr.String("__VersionId__"),
		RequestPayer:              types.RequestPayer("requester"),
		BypassGovernanceRetention: ptr.Bool(true),
		ExpectedBucketOwner:       ptr.String("__ExpectedBucketOwner__"),
		IfMatch:                   ptr.String("__IfMatch__"),
		IfMatchLastModifiedTime:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		IfMatchSize:               ptr.Int64(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteObject(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteObject"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteObjectAnnotation(t *testing.T) {
	input := &DeleteObjectAnnotationInput{
		Bucket:              ptr.String("__Bucket__"),
		Key:                 ptr.String("__Key__"),
		AnnotationName:      ptr.String("__AnnotationName__"),
		VersionId:           ptr.String("__VersionId__"),
		RequestPayer:        types.RequestPayer("requester"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		ObjectIfMatch:       ptr.String("__ObjectIfMatch__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteObjectAnnotation(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteObjectAnnotation"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteObjects(t *testing.T) {
	input := &DeleteObjectsInput{
		Bucket: ptr.String("__Bucket__"),
		Delete: &types.Delete{
			Objects: []types.ObjectIdentifier{
				{
					Key:              ptr.String("__Key__"),
					VersionId:        ptr.String("__VersionId__"),
					ETag:             ptr.String("__ETag__"),
					LastModifiedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					Size:             ptr.Int64(1),
				},
				{
					Key:              ptr.String("__Key__"),
					VersionId:        ptr.String("__VersionId__"),
					ETag:             ptr.String("__ETag__"),
					LastModifiedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					Size:             ptr.Int64(1),
				},
			},
			Quiet: ptr.Bool(true),
		},
		MFA:                       ptr.String("__MFA__"),
		RequestPayer:              types.RequestPayer("requester"),
		BypassGovernanceRetention: ptr.Bool(true),
		ExpectedBucketOwner:       ptr.String("__ExpectedBucketOwner__"),
		ChecksumAlgorithm:         types.ChecksumAlgorithm("CRC32"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteObjects(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteObjects"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteObjectTagging(t *testing.T) {
	input := &DeleteObjectTaggingInput{
		Bucket:              ptr.String("__Bucket__"),
		Key:                 ptr.String("__Key__"),
		VersionId:           ptr.String("__VersionId__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteObjectTagging(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteObjectTagging"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeletePublicAccessBlock(t *testing.T) {
	input := &DeletePublicAccessBlockInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeletePublicAccessBlock(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeletePublicAccessBlock"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetBucketAbac(t *testing.T) {
	input := &GetBucketAbacInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketAbac(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketAbac"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetBucketAccelerateConfiguration(t *testing.T) {
	input := &GetBucketAccelerateConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		RequestPayer:        types.RequestPayer("requester"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketAccelerateConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketAccelerateConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetBucketAcl(t *testing.T) {
	input := &GetBucketAclInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketAcl(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketAcl"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetBucketAnalyticsConfiguration(t *testing.T) {
	input := &GetBucketAnalyticsConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		Id:                  ptr.String("__Id__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketAnalyticsConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketAnalyticsConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetBucketCors(t *testing.T) {
	input := &GetBucketCorsInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketCors(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketCors"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetBucketEncryption(t *testing.T) {
	input := &GetBucketEncryptionInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketEncryption(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketEncryption"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetBucketIntelligentTieringConfiguration(t *testing.T) {
	input := &GetBucketIntelligentTieringConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		Id:                  ptr.String("__Id__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketIntelligentTieringConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketIntelligentTieringConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetBucketInventoryConfiguration(t *testing.T) {
	input := &GetBucketInventoryConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		Id:                  ptr.String("__Id__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketInventoryConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketInventoryConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetBucketLifecycleConfiguration(t *testing.T) {
	input := &GetBucketLifecycleConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketLifecycleConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketLifecycleConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetBucketLocation(t *testing.T) {
	input := &GetBucketLocationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketLocation(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketLocation"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetBucketLogging(t *testing.T) {
	input := &GetBucketLoggingInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketLogging(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketLogging"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetBucketMetadataConfiguration(t *testing.T) {
	input := &GetBucketMetadataConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketMetadataConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketMetadataConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetBucketMetadataTableConfiguration(t *testing.T) {
	input := &GetBucketMetadataTableConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketMetadataTableConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketMetadataTableConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetBucketMetricsConfiguration(t *testing.T) {
	input := &GetBucketMetricsConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		Id:                  ptr.String("__Id__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketMetricsConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketMetricsConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetBucketNotificationConfiguration(t *testing.T) {
	input := &GetBucketNotificationConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketNotificationConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketNotificationConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetBucketOwnershipControls(t *testing.T) {
	input := &GetBucketOwnershipControlsInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketOwnershipControls(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketOwnershipControls"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetBucketPolicy(t *testing.T) {
	input := &GetBucketPolicyInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketPolicy(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketPolicy"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetBucketPolicyStatus(t *testing.T) {
	input := &GetBucketPolicyStatusInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketPolicyStatus(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketPolicyStatus"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetBucketReplication(t *testing.T) {
	input := &GetBucketReplicationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketReplication(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketReplication"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetBucketRequestPayment(t *testing.T) {
	input := &GetBucketRequestPaymentInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketRequestPayment(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketRequestPayment"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetBucketTagging(t *testing.T) {
	input := &GetBucketTaggingInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketTagging(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketTagging"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetBucketVersioning(t *testing.T) {
	input := &GetBucketVersioningInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketVersioning(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketVersioning"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetBucketWebsite(t *testing.T) {
	input := &GetBucketWebsiteInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetBucketWebsite(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetBucketWebsite"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetObject(t *testing.T) {
	input := &GetObjectInput{
		Bucket:                     ptr.String("__Bucket__"),
		IfMatch:                    ptr.String("__IfMatch__"),
		IfModifiedSince:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		IfNoneMatch:                ptr.String("__IfNoneMatch__"),
		IfUnmodifiedSince:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		Key:                        ptr.String("__Key__"),
		Range:                      ptr.String("__Range__"),
		ResponseCacheControl:       ptr.String("__ResponseCacheControl__"),
		ResponseContentDisposition: ptr.String("__ResponseContentDisposition__"),
		ResponseContentEncoding:    ptr.String("__ResponseContentEncoding__"),
		ResponseContentLanguage:    ptr.String("__ResponseContentLanguage__"),
		ResponseContentType:        ptr.String("__ResponseContentType__"),
		ResponseExpires:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		VersionId:                  ptr.String("__VersionId__"),
		SSECustomerAlgorithm:       ptr.String("__SSECustomerAlgorithm__"),
		SSECustomerKey:             ptr.String("__SSECustomerKey__"),
		SSECustomerKeyMD5:          ptr.String("__SSECustomerKeyMD5__"),
		RequestPayer:               types.RequestPayer("requester"),
		PartNumber:                 ptr.Int32(1),
		ExpectedBucketOwner:        ptr.String("__ExpectedBucketOwner__"),
		ChecksumMode:               types.ChecksumMode("ENABLED"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetObject(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetObject"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetObjectAcl(t *testing.T) {
	input := &GetObjectAclInput{
		Bucket:              ptr.String("__Bucket__"),
		Key:                 ptr.String("__Key__"),
		VersionId:           ptr.String("__VersionId__"),
		RequestPayer:        types.RequestPayer("requester"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetObjectAcl(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetObjectAcl"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetObjectAnnotation(t *testing.T) {
	input := &GetObjectAnnotationInput{
		Bucket:              ptr.String("__Bucket__"),
		Key:                 ptr.String("__Key__"),
		AnnotationName:      ptr.String("__AnnotationName__"),
		VersionId:           ptr.String("__VersionId__"),
		RequestPayer:        types.RequestPayer("requester"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		ChecksumMode:        types.ChecksumMode("ENABLED"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetObjectAnnotation(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetObjectAnnotation"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetObjectAttributes(t *testing.T) {
	input := &GetObjectAttributesInput{
		Bucket:               ptr.String("__Bucket__"),
		Key:                  ptr.String("__Key__"),
		VersionId:            ptr.String("__VersionId__"),
		MaxParts:             ptr.Int32(1),
		PartNumberMarker:     ptr.String("__PartNumberMarker__"),
		SSECustomerAlgorithm: ptr.String("__SSECustomerAlgorithm__"),
		SSECustomerKey:       ptr.String("__SSECustomerKey__"),
		SSECustomerKeyMD5:    ptr.String("__SSECustomerKeyMD5__"),
		RequestPayer:         types.RequestPayer("requester"),
		ExpectedBucketOwner:  ptr.String("__ExpectedBucketOwner__"),
		ObjectAttributes: []types.ObjectAttributes{
			types.ObjectAttributes("ETag"),
			types.ObjectAttributes("ETag"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetObjectAttributes(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetObjectAttributes"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetObjectLegalHold(t *testing.T) {
	input := &GetObjectLegalHoldInput{
		Bucket:              ptr.String("__Bucket__"),
		Key:                 ptr.String("__Key__"),
		VersionId:           ptr.String("__VersionId__"),
		RequestPayer:        types.RequestPayer("requester"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetObjectLegalHold(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetObjectLegalHold"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetObjectLockConfiguration(t *testing.T) {
	input := &GetObjectLockConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetObjectLockConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetObjectLockConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetObjectRetention(t *testing.T) {
	input := &GetObjectRetentionInput{
		Bucket:              ptr.String("__Bucket__"),
		Key:                 ptr.String("__Key__"),
		VersionId:           ptr.String("__VersionId__"),
		RequestPayer:        types.RequestPayer("requester"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetObjectRetention(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetObjectRetention"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetObjectTagging(t *testing.T) {
	input := &GetObjectTaggingInput{
		Bucket:              ptr.String("__Bucket__"),
		Key:                 ptr.String("__Key__"),
		VersionId:           ptr.String("__VersionId__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		RequestPayer:        types.RequestPayer("requester"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetObjectTagging(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetObjectTagging"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetObjectTorrent(t *testing.T) {
	input := &GetObjectTorrentInput{
		Bucket:              ptr.String("__Bucket__"),
		Key:                 ptr.String("__Key__"),
		RequestPayer:        types.RequestPayer("requester"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetObjectTorrent(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetObjectTorrent"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetPublicAccessBlock(t *testing.T) {
	input := &GetPublicAccessBlockInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetPublicAccessBlock(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetPublicAccessBlock"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_HeadBucket(t *testing.T) {
	input := &HeadBucketInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.HeadBucket(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "HeadBucket"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_HeadObject(t *testing.T) {
	input := &HeadObjectInput{
		Bucket:                     ptr.String("__Bucket__"),
		IfMatch:                    ptr.String("__IfMatch__"),
		IfModifiedSince:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		IfNoneMatch:                ptr.String("__IfNoneMatch__"),
		IfUnmodifiedSince:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		Key:                        ptr.String("__Key__"),
		Range:                      ptr.String("__Range__"),
		ResponseCacheControl:       ptr.String("__ResponseCacheControl__"),
		ResponseContentDisposition: ptr.String("__ResponseContentDisposition__"),
		ResponseContentEncoding:    ptr.String("__ResponseContentEncoding__"),
		ResponseContentLanguage:    ptr.String("__ResponseContentLanguage__"),
		ResponseContentType:        ptr.String("__ResponseContentType__"),
		ResponseExpires:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		VersionId:                  ptr.String("__VersionId__"),
		SSECustomerAlgorithm:       ptr.String("__SSECustomerAlgorithm__"),
		SSECustomerKey:             ptr.String("__SSECustomerKey__"),
		SSECustomerKeyMD5:          ptr.String("__SSECustomerKeyMD5__"),
		RequestPayer:               types.RequestPayer("requester"),
		PartNumber:                 ptr.Int32(1),
		ExpectedBucketOwner:        ptr.String("__ExpectedBucketOwner__"),
		ChecksumMode:               types.ChecksumMode("ENABLED"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.HeadObject(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "HeadObject"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListBucketAnalyticsConfigurations(t *testing.T) {
	input := &ListBucketAnalyticsConfigurationsInput{
		Bucket:              ptr.String("__Bucket__"),
		ContinuationToken:   ptr.String("__ContinuationToken__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBucketAnalyticsConfigurations(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListBucketAnalyticsConfigurations"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListBucketIntelligentTieringConfigurations(t *testing.T) {
	input := &ListBucketIntelligentTieringConfigurationsInput{
		Bucket:              ptr.String("__Bucket__"),
		ContinuationToken:   ptr.String("__ContinuationToken__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBucketIntelligentTieringConfigurations(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListBucketIntelligentTieringConfigurations"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListBucketInventoryConfigurations(t *testing.T) {
	input := &ListBucketInventoryConfigurationsInput{
		Bucket:              ptr.String("__Bucket__"),
		ContinuationToken:   ptr.String("__ContinuationToken__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBucketInventoryConfigurations(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListBucketInventoryConfigurations"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListBucketMetricsConfigurations(t *testing.T) {
	input := &ListBucketMetricsConfigurationsInput{
		Bucket:              ptr.String("__Bucket__"),
		ContinuationToken:   ptr.String("__ContinuationToken__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBucketMetricsConfigurations(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListBucketMetricsConfigurations"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListBuckets(t *testing.T) {
	input := &ListBucketsInput{
		MaxBuckets:        ptr.Int32(1),
		ContinuationToken: ptr.String("__ContinuationToken__"),
		Prefix:            ptr.String("__Prefix__"),
		BucketRegion:      ptr.String("__BucketRegion__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBuckets(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListBuckets"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListDirectoryBuckets(t *testing.T) {
	input := &ListDirectoryBucketsInput{
		ContinuationToken:   ptr.String("__ContinuationToken__"),
		MaxDirectoryBuckets: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListDirectoryBuckets(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListDirectoryBuckets"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListMultipartUploads(t *testing.T) {
	input := &ListMultipartUploadsInput{
		Bucket:              ptr.String("__Bucket__"),
		Delimiter:           ptr.String("__Delimiter__"),
		EncodingType:        types.EncodingType("url"),
		KeyMarker:           ptr.String("__KeyMarker__"),
		MaxUploads:          ptr.Int32(1),
		Prefix:              ptr.String("__Prefix__"),
		UploadIdMarker:      ptr.String("__UploadIdMarker__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		RequestPayer:        types.RequestPayer("requester"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListMultipartUploads(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListMultipartUploads"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListObjectAnnotations(t *testing.T) {
	input := &ListObjectAnnotationsInput{
		Bucket:               ptr.String("__Bucket__"),
		Key:                  ptr.String("__Key__"),
		VersionId:            ptr.String("__VersionId__"),
		MaxAnnotationResults: ptr.Int32(1),
		AnnotationPrefix:     ptr.String("__AnnotationPrefix__"),
		ContinuationToken:    ptr.String("__ContinuationToken__"),
		RequestPayer:         types.RequestPayer("requester"),
		ExpectedBucketOwner:  ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListObjectAnnotations(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListObjectAnnotations"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListObjects(t *testing.T) {
	input := &ListObjectsInput{
		Bucket:              ptr.String("__Bucket__"),
		Delimiter:           ptr.String("__Delimiter__"),
		EncodingType:        types.EncodingType("url"),
		Marker:              ptr.String("__Marker__"),
		MaxKeys:             ptr.Int32(1),
		Prefix:              ptr.String("__Prefix__"),
		RequestPayer:        types.RequestPayer("requester"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		OptionalObjectAttributes: []types.OptionalObjectAttributes{
			types.OptionalObjectAttributes("RestoreStatus"),
			types.OptionalObjectAttributes("RestoreStatus"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListObjects(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListObjects"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListObjectsV2(t *testing.T) {
	input := &ListObjectsV2Input{
		Bucket:              ptr.String("__Bucket__"),
		Delimiter:           ptr.String("__Delimiter__"),
		EncodingType:        types.EncodingType("url"),
		MaxKeys:             ptr.Int32(1),
		Prefix:              ptr.String("__Prefix__"),
		ContinuationToken:   ptr.String("__ContinuationToken__"),
		FetchOwner:          ptr.Bool(true),
		StartAfter:          ptr.String("__StartAfter__"),
		RequestPayer:        types.RequestPayer("requester"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		OptionalObjectAttributes: []types.OptionalObjectAttributes{
			types.OptionalObjectAttributes("RestoreStatus"),
			types.OptionalObjectAttributes("RestoreStatus"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListObjectsV2(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListObjectsV2"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListObjectVersions(t *testing.T) {
	input := &ListObjectVersionsInput{
		Bucket:              ptr.String("__Bucket__"),
		Delimiter:           ptr.String("__Delimiter__"),
		EncodingType:        types.EncodingType("url"),
		KeyMarker:           ptr.String("__KeyMarker__"),
		MaxKeys:             ptr.Int32(1),
		Prefix:              ptr.String("__Prefix__"),
		VersionIdMarker:     ptr.String("__VersionIdMarker__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		RequestPayer:        types.RequestPayer("requester"),
		OptionalObjectAttributes: []types.OptionalObjectAttributes{
			types.OptionalObjectAttributes("RestoreStatus"),
			types.OptionalObjectAttributes("RestoreStatus"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListObjectVersions(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListObjectVersions"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListParts(t *testing.T) {
	input := &ListPartsInput{
		Bucket:               ptr.String("__Bucket__"),
		Key:                  ptr.String("__Key__"),
		MaxParts:             ptr.Int32(1),
		PartNumberMarker:     ptr.String("__PartNumberMarker__"),
		UploadId:             ptr.String("__UploadId__"),
		RequestPayer:         types.RequestPayer("requester"),
		ExpectedBucketOwner:  ptr.String("__ExpectedBucketOwner__"),
		SSECustomerAlgorithm: ptr.String("__SSECustomerAlgorithm__"),
		SSECustomerKey:       ptr.String("__SSECustomerKey__"),
		SSECustomerKeyMD5:    ptr.String("__SSECustomerKeyMD5__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListParts(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListParts"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutBucketAbac(t *testing.T) {
	input := &PutBucketAbacInput{
		Bucket:              ptr.String("__Bucket__"),
		ContentMD5:          ptr.String("__ContentMD5__"),
		ChecksumAlgorithm:   types.ChecksumAlgorithm("CRC32"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		AbacStatus: &types.AbacStatus{
			Status: types.BucketAbacStatus("Enabled"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketAbac(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketAbac"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutBucketAccelerateConfiguration(t *testing.T) {
	input := &PutBucketAccelerateConfigurationInput{
		Bucket: ptr.String("__Bucket__"),
		AccelerateConfiguration: &types.AccelerateConfiguration{
			Status: types.BucketAccelerateStatus("Enabled"),
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		ChecksumAlgorithm:   types.ChecksumAlgorithm("CRC32"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketAccelerateConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketAccelerateConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutBucketAcl(t *testing.T) {
	input := &PutBucketAclInput{
		ACL: types.BucketCannedACL("private"),
		AccessControlPolicy: &types.AccessControlPolicy{
			Grants: []types.Grant{
				{
					Grantee: &types.Grantee{
						DisplayName:  ptr.String("__DisplayName__"),
						EmailAddress: ptr.String("__EmailAddress__"),
						ID:           ptr.String("__ID__"),
						URI:          ptr.String("__URI__"),
						Type:         types.Type("CanonicalUser"),
					},
					Permission: types.Permission("FULL_CONTROL"),
				},
				{
					Grantee: &types.Grantee{
						DisplayName:  ptr.String("__DisplayName__"),
						EmailAddress: ptr.String("__EmailAddress__"),
						ID:           ptr.String("__ID__"),
						URI:          ptr.String("__URI__"),
						Type:         types.Type("CanonicalUser"),
					},
					Permission: types.Permission("FULL_CONTROL"),
				},
			},
			Owner: &types.Owner{
				DisplayName: ptr.String("__DisplayName__"),
				ID:          ptr.String("__ID__"),
			},
		},
		Bucket:              ptr.String("__Bucket__"),
		ContentMD5:          ptr.String("__ContentMD5__"),
		ChecksumAlgorithm:   types.ChecksumAlgorithm("CRC32"),
		GrantFullControl:    ptr.String("__GrantFullControl__"),
		GrantRead:           ptr.String("__GrantRead__"),
		GrantReadACP:        ptr.String("__GrantReadACP__"),
		GrantWrite:          ptr.String("__GrantWrite__"),
		GrantWriteACP:       ptr.String("__GrantWriteACP__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketAcl(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketAcl"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutBucketAnalyticsConfiguration(t *testing.T) {
	input := &PutBucketAnalyticsConfigurationInput{
		Bucket: ptr.String("__Bucket__"),
		Id:     ptr.String("__Id__"),
		AnalyticsConfiguration: &types.AnalyticsConfiguration{
			Id: ptr.String("__Id__"),
			Filter: &types.AnalyticsFilterMemberPrefix{
				Value: "__AnalyticsFilterMemberPrefix__",
			},
			StorageClassAnalysis: &types.StorageClassAnalysis{
				DataExport: &types.StorageClassAnalysisDataExport{
					OutputSchemaVersion: types.StorageClassAnalysisSchemaVersion("V_1"),
					Destination: &types.AnalyticsExportDestination{
						S3BucketDestination: &types.AnalyticsS3BucketDestination{
							Format:          types.AnalyticsS3ExportFileFormat("CSV"),
							BucketAccountId: ptr.String("__BucketAccountId__"),
							Bucket:          ptr.String("__Bucket__"),
							Prefix:          ptr.String("__Prefix__"),
						},
					},
				},
			},
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketAnalyticsConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketAnalyticsConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutBucketCors(t *testing.T) {
	input := &PutBucketCorsInput{
		Bucket: ptr.String("__Bucket__"),
		CORSConfiguration: &types.CORSConfiguration{
			CORSRules: []types.CORSRule{
				{
					ID: ptr.String("__ID__"),
					AllowedHeaders: []string{
						"__Member__",
						"__Member__",
					},
					AllowedMethods: []string{
						"__Member__",
						"__Member__",
					},
					AllowedOrigins: []string{
						"__Member__",
						"__Member__",
					},
					ExposeHeaders: []string{
						"__Member__",
						"__Member__",
					},
					MaxAgeSeconds: ptr.Int32(1),
				},
				{
					ID: ptr.String("__ID__"),
					AllowedHeaders: []string{
						"__Member__",
						"__Member__",
					},
					AllowedMethods: []string{
						"__Member__",
						"__Member__",
					},
					AllowedOrigins: []string{
						"__Member__",
						"__Member__",
					},
					ExposeHeaders: []string{
						"__Member__",
						"__Member__",
					},
					MaxAgeSeconds: ptr.Int32(1),
				},
			},
		},
		ContentMD5:          ptr.String("__ContentMD5__"),
		ChecksumAlgorithm:   types.ChecksumAlgorithm("CRC32"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketCors(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketCors"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutBucketEncryption(t *testing.T) {
	input := &PutBucketEncryptionInput{
		Bucket:            ptr.String("__Bucket__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		ServerSideEncryptionConfiguration: &types.ServerSideEncryptionConfiguration{
			Rules: []types.ServerSideEncryptionRule{
				{
					ApplyServerSideEncryptionByDefault: &types.ServerSideEncryptionByDefault{
						SSEAlgorithm:   types.ServerSideEncryption("AES256"),
						KMSMasterKeyID: ptr.String("__KMSMasterKeyID__"),
					},
					BucketKeyEnabled: ptr.Bool(true),
					BlockedEncryptionTypes: &types.BlockedEncryptionTypes{
						EncryptionType: []types.EncryptionType{
							types.EncryptionType("NONE"),
							types.EncryptionType("NONE"),
						},
					},
				},
				{
					ApplyServerSideEncryptionByDefault: &types.ServerSideEncryptionByDefault{
						SSEAlgorithm:   types.ServerSideEncryption("AES256"),
						KMSMasterKeyID: ptr.String("__KMSMasterKeyID__"),
					},
					BucketKeyEnabled: ptr.Bool(true),
					BlockedEncryptionTypes: &types.BlockedEncryptionTypes{
						EncryptionType: []types.EncryptionType{
							types.EncryptionType("NONE"),
							types.EncryptionType("NONE"),
						},
					},
				},
			},
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketEncryption(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketEncryption"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutBucketIntelligentTieringConfiguration(t *testing.T) {
	input := &PutBucketIntelligentTieringConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		Id:                  ptr.String("__Id__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		IntelligentTieringConfiguration: &types.IntelligentTieringConfiguration{
			Id: ptr.String("__Id__"),
			Filter: &types.IntelligentTieringFilter{
				Prefix: ptr.String("__Prefix__"),
				Tag: &types.Tag{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
				And: &types.IntelligentTieringAndOperator{
					Prefix: ptr.String("__Prefix__"),
					Tags: []types.Tag{
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
					},
				},
			},
			Status: types.IntelligentTieringStatus("Enabled"),
			Tierings: []types.Tiering{
				{
					Days:       ptr.Int32(1),
					AccessTier: types.IntelligentTieringAccessTier("ARCHIVE_ACCESS"),
				},
				{
					Days:       ptr.Int32(1),
					AccessTier: types.IntelligentTieringAccessTier("ARCHIVE_ACCESS"),
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketIntelligentTieringConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketIntelligentTieringConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutBucketInventoryConfiguration(t *testing.T) {
	input := &PutBucketInventoryConfigurationInput{
		Bucket: ptr.String("__Bucket__"),
		Id:     ptr.String("__Id__"),
		InventoryConfiguration: &types.InventoryConfiguration{
			Destination: &types.InventoryDestination{
				S3BucketDestination: &types.InventoryS3BucketDestination{
					AccountId: ptr.String("__AccountId__"),
					Bucket:    ptr.String("__Bucket__"),
					Format:    types.InventoryFormat("CSV"),
					Prefix:    ptr.String("__Prefix__"),
					Encryption: &types.InventoryEncryption{
						SSES3: &types.SSES3{},
						SSEKMS: &types.SSEKMS{
							KeyId: ptr.String("__KeyId__"),
						},
					},
				},
			},
			IsEnabled: ptr.Bool(true),
			Filter: &types.InventoryFilter{
				Prefix: ptr.String("__Prefix__"),
			},
			Id:                     ptr.String("__Id__"),
			IncludedObjectVersions: types.InventoryIncludedObjectVersions("All"),
			OptionalFields: []types.InventoryOptionalField{
				types.InventoryOptionalField("Size"),
				types.InventoryOptionalField("Size"),
			},
			Schedule: &types.InventorySchedule{
				Frequency: types.InventoryFrequency("Daily"),
			},
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketInventoryConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketInventoryConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutBucketLifecycleConfiguration(t *testing.T) {
	input := &PutBucketLifecycleConfigurationInput{
		Bucket:            ptr.String("__Bucket__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		LifecycleConfiguration: &types.BucketLifecycleConfiguration{
			Rules: []types.LifecycleRule{
				{
					Expiration: &types.LifecycleExpiration{
						Date:                      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Days:                      ptr.Int32(1),
						ExpiredObjectDeleteMarker: ptr.Bool(true),
					},
					ID:     ptr.String("__ID__"),
					Prefix: ptr.String("__Prefix__"),
					Filter: &types.LifecycleRuleFilter{
						Prefix: ptr.String("__Prefix__"),
						Tag: &types.Tag{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
						ObjectSizeGreaterThan: ptr.Int64(1),
						ObjectSizeLessThan:    ptr.Int64(1),
						And: &types.LifecycleRuleAndOperator{
							Prefix: ptr.String("__Prefix__"),
							Tags: []types.Tag{
								{
									Key:   ptr.String("__Key__"),
									Value: ptr.String("__Value__"),
								},
								{
									Key:   ptr.String("__Key__"),
									Value: ptr.String("__Value__"),
								},
							},
							ObjectSizeGreaterThan: ptr.Int64(1),
							ObjectSizeLessThan:    ptr.Int64(1),
						},
					},
					Status: types.ExpirationStatus("Enabled"),
					Transitions: []types.Transition{
						{
							Date:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
							Days:         ptr.Int32(1),
							StorageClass: types.TransitionStorageClass("GLACIER"),
						},
						{
							Date:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
							Days:         ptr.Int32(1),
							StorageClass: types.TransitionStorageClass("GLACIER"),
						},
					},
					NoncurrentVersionTransitions: []types.NoncurrentVersionTransition{
						{
							NoncurrentDays:          ptr.Int32(1),
							StorageClass:            types.TransitionStorageClass("GLACIER"),
							NewerNoncurrentVersions: ptr.Int32(1),
						},
						{
							NoncurrentDays:          ptr.Int32(1),
							StorageClass:            types.TransitionStorageClass("GLACIER"),
							NewerNoncurrentVersions: ptr.Int32(1),
						},
					},
					NoncurrentVersionExpiration: &types.NoncurrentVersionExpiration{
						NoncurrentDays:          ptr.Int32(1),
						NewerNoncurrentVersions: ptr.Int32(1),
					},
					AbortIncompleteMultipartUpload: &types.AbortIncompleteMultipartUpload{
						DaysAfterInitiation: ptr.Int32(1),
					},
				},
				{
					Expiration: &types.LifecycleExpiration{
						Date:                      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Days:                      ptr.Int32(1),
						ExpiredObjectDeleteMarker: ptr.Bool(true),
					},
					ID:     ptr.String("__ID__"),
					Prefix: ptr.String("__Prefix__"),
					Filter: &types.LifecycleRuleFilter{
						Prefix: ptr.String("__Prefix__"),
						Tag: &types.Tag{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
						ObjectSizeGreaterThan: ptr.Int64(1),
						ObjectSizeLessThan:    ptr.Int64(1),
						And: &types.LifecycleRuleAndOperator{
							Prefix: ptr.String("__Prefix__"),
							Tags: []types.Tag{
								{
									Key:   ptr.String("__Key__"),
									Value: ptr.String("__Value__"),
								},
								{
									Key:   ptr.String("__Key__"),
									Value: ptr.String("__Value__"),
								},
							},
							ObjectSizeGreaterThan: ptr.Int64(1),
							ObjectSizeLessThan:    ptr.Int64(1),
						},
					},
					Status: types.ExpirationStatus("Enabled"),
					Transitions: []types.Transition{
						{
							Date:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
							Days:         ptr.Int32(1),
							StorageClass: types.TransitionStorageClass("GLACIER"),
						},
						{
							Date:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
							Days:         ptr.Int32(1),
							StorageClass: types.TransitionStorageClass("GLACIER"),
						},
					},
					NoncurrentVersionTransitions: []types.NoncurrentVersionTransition{
						{
							NoncurrentDays:          ptr.Int32(1),
							StorageClass:            types.TransitionStorageClass("GLACIER"),
							NewerNoncurrentVersions: ptr.Int32(1),
						},
						{
							NoncurrentDays:          ptr.Int32(1),
							StorageClass:            types.TransitionStorageClass("GLACIER"),
							NewerNoncurrentVersions: ptr.Int32(1),
						},
					},
					NoncurrentVersionExpiration: &types.NoncurrentVersionExpiration{
						NoncurrentDays:          ptr.Int32(1),
						NewerNoncurrentVersions: ptr.Int32(1),
					},
					AbortIncompleteMultipartUpload: &types.AbortIncompleteMultipartUpload{
						DaysAfterInitiation: ptr.Int32(1),
					},
				},
			},
		},
		ExpectedBucketOwner:                ptr.String("__ExpectedBucketOwner__"),
		TransitionDefaultMinimumObjectSize: types.TransitionDefaultMinimumObjectSize("varies_by_storage_class"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketLifecycleConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketLifecycleConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutBucketLogging(t *testing.T) {
	input := &PutBucketLoggingInput{
		Bucket: ptr.String("__Bucket__"),
		BucketLoggingStatus: &types.BucketLoggingStatus{
			LoggingEnabled: &types.LoggingEnabled{
				TargetBucket: ptr.String("__TargetBucket__"),
				TargetGrants: []types.TargetGrant{
					{
						Grantee: &types.Grantee{
							DisplayName:  ptr.String("__DisplayName__"),
							EmailAddress: ptr.String("__EmailAddress__"),
							ID:           ptr.String("__ID__"),
							URI:          ptr.String("__URI__"),
							Type:         types.Type("CanonicalUser"),
						},
						Permission: types.BucketLogsPermission("FULL_CONTROL"),
					},
					{
						Grantee: &types.Grantee{
							DisplayName:  ptr.String("__DisplayName__"),
							EmailAddress: ptr.String("__EmailAddress__"),
							ID:           ptr.String("__ID__"),
							URI:          ptr.String("__URI__"),
							Type:         types.Type("CanonicalUser"),
						},
						Permission: types.BucketLogsPermission("FULL_CONTROL"),
					},
				},
				TargetPrefix: ptr.String("__TargetPrefix__"),
				TargetObjectKeyFormat: &types.TargetObjectKeyFormat{
					SimplePrefix: &types.SimplePrefix{},
					PartitionedPrefix: &types.PartitionedPrefix{
						PartitionDateSource: types.PartitionDateSource("EventTime"),
					},
				},
			},
		},
		ContentMD5:          ptr.String("__ContentMD5__"),
		ChecksumAlgorithm:   types.ChecksumAlgorithm("CRC32"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketLogging(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketLogging"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutBucketMetricsConfiguration(t *testing.T) {
	input := &PutBucketMetricsConfigurationInput{
		Bucket: ptr.String("__Bucket__"),
		Id:     ptr.String("__Id__"),
		MetricsConfiguration: &types.MetricsConfiguration{
			Id: ptr.String("__Id__"),
			Filter: &types.MetricsFilterMemberPrefix{
				Value: "__MetricsFilterMemberPrefix__",
			},
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketMetricsConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketMetricsConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutBucketNotificationConfiguration(t *testing.T) {
	input := &PutBucketNotificationConfigurationInput{
		Bucket: ptr.String("__Bucket__"),
		NotificationConfiguration: &types.NotificationConfiguration{
			TopicConfigurations: []types.TopicConfiguration{
				{
					Id:       ptr.String("__Id__"),
					TopicArn: ptr.String("__TopicArn__"),
					Events: []types.Event{
						types.Event("s3:ReducedRedundancyLostObject"),
						types.Event("s3:ReducedRedundancyLostObject"),
					},
					Filter: &types.NotificationConfigurationFilter{
						Key: &types.S3KeyFilter{
							FilterRules: []types.FilterRule{
								{
									Name:  types.FilterRuleName("prefix"),
									Value: ptr.String("__Value__"),
								},
								{
									Name:  types.FilterRuleName("prefix"),
									Value: ptr.String("__Value__"),
								},
							},
						},
					},
				},
				{
					Id:       ptr.String("__Id__"),
					TopicArn: ptr.String("__TopicArn__"),
					Events: []types.Event{
						types.Event("s3:ReducedRedundancyLostObject"),
						types.Event("s3:ReducedRedundancyLostObject"),
					},
					Filter: &types.NotificationConfigurationFilter{
						Key: &types.S3KeyFilter{
							FilterRules: []types.FilterRule{
								{
									Name:  types.FilterRuleName("prefix"),
									Value: ptr.String("__Value__"),
								},
								{
									Name:  types.FilterRuleName("prefix"),
									Value: ptr.String("__Value__"),
								},
							},
						},
					},
				},
			},
			QueueConfigurations: []types.QueueConfiguration{
				{
					Id:       ptr.String("__Id__"),
					QueueArn: ptr.String("__QueueArn__"),
					Events: []types.Event{
						types.Event("s3:ReducedRedundancyLostObject"),
						types.Event("s3:ReducedRedundancyLostObject"),
					},
					Filter: &types.NotificationConfigurationFilter{
						Key: &types.S3KeyFilter{
							FilterRules: []types.FilterRule{
								{
									Name:  types.FilterRuleName("prefix"),
									Value: ptr.String("__Value__"),
								},
								{
									Name:  types.FilterRuleName("prefix"),
									Value: ptr.String("__Value__"),
								},
							},
						},
					},
				},
				{
					Id:       ptr.String("__Id__"),
					QueueArn: ptr.String("__QueueArn__"),
					Events: []types.Event{
						types.Event("s3:ReducedRedundancyLostObject"),
						types.Event("s3:ReducedRedundancyLostObject"),
					},
					Filter: &types.NotificationConfigurationFilter{
						Key: &types.S3KeyFilter{
							FilterRules: []types.FilterRule{
								{
									Name:  types.FilterRuleName("prefix"),
									Value: ptr.String("__Value__"),
								},
								{
									Name:  types.FilterRuleName("prefix"),
									Value: ptr.String("__Value__"),
								},
							},
						},
					},
				},
			},
			LambdaFunctionConfigurations: []types.LambdaFunctionConfiguration{
				{
					Id:                ptr.String("__Id__"),
					LambdaFunctionArn: ptr.String("__LambdaFunctionArn__"),
					Events: []types.Event{
						types.Event("s3:ReducedRedundancyLostObject"),
						types.Event("s3:ReducedRedundancyLostObject"),
					},
					Filter: &types.NotificationConfigurationFilter{
						Key: &types.S3KeyFilter{
							FilterRules: []types.FilterRule{
								{
									Name:  types.FilterRuleName("prefix"),
									Value: ptr.String("__Value__"),
								},
								{
									Name:  types.FilterRuleName("prefix"),
									Value: ptr.String("__Value__"),
								},
							},
						},
					},
				},
				{
					Id:                ptr.String("__Id__"),
					LambdaFunctionArn: ptr.String("__LambdaFunctionArn__"),
					Events: []types.Event{
						types.Event("s3:ReducedRedundancyLostObject"),
						types.Event("s3:ReducedRedundancyLostObject"),
					},
					Filter: &types.NotificationConfigurationFilter{
						Key: &types.S3KeyFilter{
							FilterRules: []types.FilterRule{
								{
									Name:  types.FilterRuleName("prefix"),
									Value: ptr.String("__Value__"),
								},
								{
									Name:  types.FilterRuleName("prefix"),
									Value: ptr.String("__Value__"),
								},
							},
						},
					},
				},
			},
			EventBridgeConfiguration: &types.EventBridgeConfiguration{},
		},
		ExpectedBucketOwner:       ptr.String("__ExpectedBucketOwner__"),
		SkipDestinationValidation: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketNotificationConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketNotificationConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutBucketOwnershipControls(t *testing.T) {
	input := &PutBucketOwnershipControlsInput{
		Bucket:              ptr.String("__Bucket__"),
		ContentMD5:          ptr.String("__ContentMD5__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		OwnershipControls: &types.OwnershipControls{
			Rules: []types.OwnershipControlsRule{
				{
					ObjectOwnership: types.ObjectOwnership("BucketOwnerPreferred"),
				},
				{
					ObjectOwnership: types.ObjectOwnership("BucketOwnerPreferred"),
				},
			},
		},
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketOwnershipControls(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketOwnershipControls"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutBucketPolicy(t *testing.T) {
	input := &PutBucketPolicyInput{
		Bucket:                        ptr.String("__Bucket__"),
		ContentMD5:                    ptr.String("__ContentMD5__"),
		ChecksumAlgorithm:             types.ChecksumAlgorithm("CRC32"),
		ConfirmRemoveSelfBucketAccess: ptr.Bool(true),
		Policy:                        ptr.String("__Policy__"),
		ExpectedBucketOwner:           ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketPolicy(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketPolicy"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutBucketReplication(t *testing.T) {
	input := &PutBucketReplicationInput{
		Bucket:            ptr.String("__Bucket__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		ReplicationConfiguration: &types.ReplicationConfiguration{
			Role: ptr.String("__Role__"),
			Rules: []types.ReplicationRule{
				{
					ID:       ptr.String("__ID__"),
					Priority: ptr.Int32(1),
					Prefix:   ptr.String("__Prefix__"),
					Filter: &types.ReplicationRuleFilter{
						Prefix: ptr.String("__Prefix__"),
						Tag: &types.Tag{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
						And: &types.ReplicationRuleAndOperator{
							Prefix: ptr.String("__Prefix__"),
							Tags: []types.Tag{
								{
									Key:   ptr.String("__Key__"),
									Value: ptr.String("__Value__"),
								},
								{
									Key:   ptr.String("__Key__"),
									Value: ptr.String("__Value__"),
								},
							},
						},
					},
					Status: types.ReplicationRuleStatus("Enabled"),
					SourceSelectionCriteria: &types.SourceSelectionCriteria{
						SseKmsEncryptedObjects: &types.SseKmsEncryptedObjects{
							Status: types.SseKmsEncryptedObjectsStatus("Enabled"),
						},
						ReplicaModifications: &types.ReplicaModifications{
							Status: types.ReplicaModificationsStatus("Enabled"),
						},
					},
					ExistingObjectReplication: &types.ExistingObjectReplication{
						Status: types.ExistingObjectReplicationStatus("Enabled"),
					},
					Destination: &types.Destination{
						Bucket:       ptr.String("__Bucket__"),
						Account:      ptr.String("__Account__"),
						StorageClass: types.StorageClass("STANDARD"),
						AccessControlTranslation: &types.AccessControlTranslation{
							Owner: types.OwnerOverride("Destination"),
						},
						EncryptionConfiguration: &types.EncryptionConfiguration{
							ReplicaKmsKeyID: ptr.String("__ReplicaKmsKeyID__"),
						},
						ReplicationTime: &types.ReplicationTime{
							Status: types.ReplicationTimeStatus("Enabled"),
							Time: &types.ReplicationTimeValue{
								Minutes: ptr.Int32(1),
							},
						},
						Metrics: &types.Metrics{
							Status: types.MetricsStatus("Enabled"),
							EventThreshold: &types.ReplicationTimeValue{
								Minutes: ptr.Int32(1),
							},
						},
					},
					DeleteMarkerReplication: &types.DeleteMarkerReplication{
						Status: types.DeleteMarkerReplicationStatus("Enabled"),
					},
				},
				{
					ID:       ptr.String("__ID__"),
					Priority: ptr.Int32(1),
					Prefix:   ptr.String("__Prefix__"),
					Filter: &types.ReplicationRuleFilter{
						Prefix: ptr.String("__Prefix__"),
						Tag: &types.Tag{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
						And: &types.ReplicationRuleAndOperator{
							Prefix: ptr.String("__Prefix__"),
							Tags: []types.Tag{
								{
									Key:   ptr.String("__Key__"),
									Value: ptr.String("__Value__"),
								},
								{
									Key:   ptr.String("__Key__"),
									Value: ptr.String("__Value__"),
								},
							},
						},
					},
					Status: types.ReplicationRuleStatus("Enabled"),
					SourceSelectionCriteria: &types.SourceSelectionCriteria{
						SseKmsEncryptedObjects: &types.SseKmsEncryptedObjects{
							Status: types.SseKmsEncryptedObjectsStatus("Enabled"),
						},
						ReplicaModifications: &types.ReplicaModifications{
							Status: types.ReplicaModificationsStatus("Enabled"),
						},
					},
					ExistingObjectReplication: &types.ExistingObjectReplication{
						Status: types.ExistingObjectReplicationStatus("Enabled"),
					},
					Destination: &types.Destination{
						Bucket:       ptr.String("__Bucket__"),
						Account:      ptr.String("__Account__"),
						StorageClass: types.StorageClass("STANDARD"),
						AccessControlTranslation: &types.AccessControlTranslation{
							Owner: types.OwnerOverride("Destination"),
						},
						EncryptionConfiguration: &types.EncryptionConfiguration{
							ReplicaKmsKeyID: ptr.String("__ReplicaKmsKeyID__"),
						},
						ReplicationTime: &types.ReplicationTime{
							Status: types.ReplicationTimeStatus("Enabled"),
							Time: &types.ReplicationTimeValue{
								Minutes: ptr.Int32(1),
							},
						},
						Metrics: &types.Metrics{
							Status: types.MetricsStatus("Enabled"),
							EventThreshold: &types.ReplicationTimeValue{
								Minutes: ptr.Int32(1),
							},
						},
					},
					DeleteMarkerReplication: &types.DeleteMarkerReplication{
						Status: types.DeleteMarkerReplicationStatus("Enabled"),
					},
				},
			},
		},
		Token:               ptr.String("__Token__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketReplication(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketReplication"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutBucketRequestPayment(t *testing.T) {
	input := &PutBucketRequestPaymentInput{
		Bucket:            ptr.String("__Bucket__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		RequestPaymentConfiguration: &types.RequestPaymentConfiguration{
			Payer: types.Payer("Requester"),
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketRequestPayment(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketRequestPayment"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutBucketTagging(t *testing.T) {
	input := &PutBucketTaggingInput{
		Bucket:            ptr.String("__Bucket__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		Tagging: &types.Tagging{
			TagSet: []types.Tag{
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
			},
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketTagging(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketTagging"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutBucketVersioning(t *testing.T) {
	input := &PutBucketVersioningInput{
		Bucket:            ptr.String("__Bucket__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		MFA:               ptr.String("__MFA__"),
		VersioningConfiguration: &types.VersioningConfiguration{
			MFADelete: types.MFADelete("Enabled"),
			Status:    types.BucketVersioningStatus("Enabled"),
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketVersioning(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketVersioning"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutBucketWebsite(t *testing.T) {
	input := &PutBucketWebsiteInput{
		Bucket:            ptr.String("__Bucket__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		WebsiteConfiguration: &types.WebsiteConfiguration{
			ErrorDocument: &types.ErrorDocument{
				Key: ptr.String("__Key__"),
			},
			IndexDocument: &types.IndexDocument{
				Suffix: ptr.String("__Suffix__"),
			},
			RedirectAllRequestsTo: &types.RedirectAllRequestsTo{
				HostName: ptr.String("__HostName__"),
				Protocol: types.Protocol("http"),
			},
			RoutingRules: []types.RoutingRule{
				{
					Condition: &types.Condition{
						HttpErrorCodeReturnedEquals: ptr.String("__HttpErrorCodeReturnedEquals__"),
						KeyPrefixEquals:             ptr.String("__KeyPrefixEquals__"),
					},
					Redirect: &types.Redirect{
						HostName:             ptr.String("__HostName__"),
						HttpRedirectCode:     ptr.String("__HttpRedirectCode__"),
						Protocol:             types.Protocol("http"),
						ReplaceKeyPrefixWith: ptr.String("__ReplaceKeyPrefixWith__"),
						ReplaceKeyWith:       ptr.String("__ReplaceKeyWith__"),
					},
				},
				{
					Condition: &types.Condition{
						HttpErrorCodeReturnedEquals: ptr.String("__HttpErrorCodeReturnedEquals__"),
						KeyPrefixEquals:             ptr.String("__KeyPrefixEquals__"),
					},
					Redirect: &types.Redirect{
						HostName:             ptr.String("__HostName__"),
						HttpRedirectCode:     ptr.String("__HttpRedirectCode__"),
						Protocol:             types.Protocol("http"),
						ReplaceKeyPrefixWith: ptr.String("__ReplaceKeyPrefixWith__"),
						ReplaceKeyWith:       ptr.String("__ReplaceKeyWith__"),
					},
				},
			},
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutBucketWebsite(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutBucketWebsite"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutObject(t *testing.T) {
	input := &PutObjectInput{
		ACL:                types.ObjectCannedACL("private"),
		Body:               io.NopCloser(bytes.NewReader([]byte("__Body__"))),
		Bucket:             ptr.String("__Bucket__"),
		CacheControl:       ptr.String("__CacheControl__"),
		ContentDisposition: ptr.String("__ContentDisposition__"),
		ContentEncoding:    ptr.String("__ContentEncoding__"),
		ContentLanguage:    ptr.String("__ContentLanguage__"),
		ContentLength:      ptr.Int64(1),
		ContentMD5:         ptr.String("__ContentMD5__"),
		ContentType:        ptr.String("__ContentType__"),
		ChecksumAlgorithm:  types.ChecksumAlgorithm("CRC32"),
		ChecksumCRC32:      ptr.String("__ChecksumCRC32__"),
		ChecksumCRC32C:     ptr.String("__ChecksumCRC32C__"),
		ChecksumCRC64NVME:  ptr.String("__ChecksumCRC64NVME__"),
		ChecksumSHA1:       ptr.String("__ChecksumSHA1__"),
		ChecksumSHA256:     ptr.String("__ChecksumSHA256__"),
		ChecksumSHA512:     ptr.String("__ChecksumSHA512__"),
		ChecksumMD5:        ptr.String("__ChecksumMD5__"),
		ChecksumXXHASH64:   ptr.String("__ChecksumXXHASH64__"),
		ChecksumXXHASH3:    ptr.String("__ChecksumXXHASH3__"),
		ChecksumXXHASH128:  ptr.String("__ChecksumXXHASH128__"),
		Expires:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		IfMatch:            ptr.String("__IfMatch__"),
		IfNoneMatch:        ptr.String("__IfNoneMatch__"),
		GrantFullControl:   ptr.String("__GrantFullControl__"),
		GrantRead:          ptr.String("__GrantRead__"),
		GrantReadACP:       ptr.String("__GrantReadACP__"),
		GrantWriteACP:      ptr.String("__GrantWriteACP__"),
		Key:                ptr.String("__Key__"),
		WriteOffsetBytes:   ptr.Int64(1),
		Metadata: map[string]string{
			"key0": "__Value__",
		},
		ServerSideEncryption:             types.ServerSideEncryption("AES256"),
		StorageClass:                     types.StorageClass("STANDARD"),
		WebsiteRedirectLocation:          ptr.String("__WebsiteRedirectLocation__"),
		SSECustomerAlgorithm:             ptr.String("__SSECustomerAlgorithm__"),
		SSECustomerKey:                   ptr.String("__SSECustomerKey__"),
		SSECustomerKeyMD5:                ptr.String("__SSECustomerKeyMD5__"),
		SSEKMSKeyId:                      ptr.String("__SSEKMSKeyId__"),
		SSEKMSEncryptionContext:          ptr.String("__SSEKMSEncryptionContext__"),
		BucketKeyEnabled:                 ptr.Bool(true),
		RequestPayer:                     types.RequestPayer("requester"),
		Tagging:                          ptr.String("__Tagging__"),
		ObjectLockMode:                   types.ObjectLockMode("GOVERNANCE"),
		ObjectLockRetainUntilDate:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ObjectLockLegalHoldStatus:        types.ObjectLockLegalHoldStatus("ON"),
		ObjectLockEventHold:              types.ObjectLockEventHold("ON"),
		ObjectLockEventHoldDurationDays:  ptr.Int32(1),
		ObjectLockEventHoldDurationYears: ptr.Int32(1),
		ExpectedBucketOwner:              ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutObject(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutObject"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutObjectAcl(t *testing.T) {
	input := &PutObjectAclInput{
		ACL: types.ObjectCannedACL("private"),
		AccessControlPolicy: &types.AccessControlPolicy{
			Grants: []types.Grant{
				{
					Grantee: &types.Grantee{
						DisplayName:  ptr.String("__DisplayName__"),
						EmailAddress: ptr.String("__EmailAddress__"),
						ID:           ptr.String("__ID__"),
						URI:          ptr.String("__URI__"),
						Type:         types.Type("CanonicalUser"),
					},
					Permission: types.Permission("FULL_CONTROL"),
				},
				{
					Grantee: &types.Grantee{
						DisplayName:  ptr.String("__DisplayName__"),
						EmailAddress: ptr.String("__EmailAddress__"),
						ID:           ptr.String("__ID__"),
						URI:          ptr.String("__URI__"),
						Type:         types.Type("CanonicalUser"),
					},
					Permission: types.Permission("FULL_CONTROL"),
				},
			},
			Owner: &types.Owner{
				DisplayName: ptr.String("__DisplayName__"),
				ID:          ptr.String("__ID__"),
			},
		},
		Bucket:              ptr.String("__Bucket__"),
		ContentMD5:          ptr.String("__ContentMD5__"),
		ChecksumAlgorithm:   types.ChecksumAlgorithm("CRC32"),
		GrantFullControl:    ptr.String("__GrantFullControl__"),
		GrantRead:           ptr.String("__GrantRead__"),
		GrantReadACP:        ptr.String("__GrantReadACP__"),
		GrantWrite:          ptr.String("__GrantWrite__"),
		GrantWriteACP:       ptr.String("__GrantWriteACP__"),
		Key:                 ptr.String("__Key__"),
		RequestPayer:        types.RequestPayer("requester"),
		VersionId:           ptr.String("__VersionId__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutObjectAcl(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutObjectAcl"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutObjectAnnotation(t *testing.T) {
	input := &PutObjectAnnotationInput{
		Bucket:              ptr.String("__Bucket__"),
		Key:                 ptr.String("__Key__"),
		VersionId:           ptr.String("__VersionId__"),
		AnnotationName:      ptr.String("__AnnotationName__"),
		AnnotationPayload:   io.NopCloser(bytes.NewReader([]byte("__AnnotationPayload__"))),
		ObjectIfMatch:       ptr.String("__ObjectIfMatch__"),
		ChecksumAlgorithm:   types.ChecksumAlgorithm("CRC32"),
		ChecksumCRC32:       ptr.String("__ChecksumCRC32__"),
		ChecksumCRC32C:      ptr.String("__ChecksumCRC32C__"),
		ChecksumCRC64NVME:   ptr.String("__ChecksumCRC64NVME__"),
		ChecksumSHA1:        ptr.String("__ChecksumSHA1__"),
		ChecksumSHA256:      ptr.String("__ChecksumSHA256__"),
		ChecksumSHA512:      ptr.String("__ChecksumSHA512__"),
		ChecksumMD5:         ptr.String("__ChecksumMD5__"),
		ChecksumXXHASH64:    ptr.String("__ChecksumXXHASH64__"),
		ChecksumXXHASH3:     ptr.String("__ChecksumXXHASH3__"),
		ChecksumXXHASH128:   ptr.String("__ChecksumXXHASH128__"),
		ContentMD5:          ptr.String("__ContentMD5__"),
		RequestPayer:        types.RequestPayer("requester"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutObjectAnnotation(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutObjectAnnotation"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutObjectLegalHold(t *testing.T) {
	input := &PutObjectLegalHoldInput{
		Bucket: ptr.String("__Bucket__"),
		Key:    ptr.String("__Key__"),
		LegalHold: &types.ObjectLockLegalHold{
			Status: types.ObjectLockLegalHoldStatus("ON"),
		},
		RequestPayer:        types.RequestPayer("requester"),
		VersionId:           ptr.String("__VersionId__"),
		ContentMD5:          ptr.String("__ContentMD5__"),
		ChecksumAlgorithm:   types.ChecksumAlgorithm("CRC32"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutObjectLegalHold(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutObjectLegalHold"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutObjectLockConfiguration(t *testing.T) {
	input := &PutObjectLockConfigurationInput{
		Bucket: ptr.String("__Bucket__"),
		ObjectLockConfiguration: &types.ObjectLockConfiguration{
			ObjectLockEnabled: types.ObjectLockEnabled("Enabled"),
			Rule: &types.ObjectLockRule{
				DefaultRetention: &types.DefaultRetention{
					Mode:  types.ObjectLockRetentionMode("GOVERNANCE"),
					Days:  ptr.Int32(1),
					Years: ptr.Int32(1),
					DefaultEventHold: &types.EventHoldDuration{
						Days:  ptr.Int32(1),
						Years: ptr.Int32(1),
					},
				},
			},
		},
		RequestPayer:        types.RequestPayer("requester"),
		Token:               ptr.String("__Token__"),
		ContentMD5:          ptr.String("__ContentMD5__"),
		ChecksumAlgorithm:   types.ChecksumAlgorithm("CRC32"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutObjectLockConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutObjectLockConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutObjectRetention(t *testing.T) {
	input := &PutObjectRetentionInput{
		Bucket: ptr.String("__Bucket__"),
		Key:    ptr.String("__Key__"),
		Retention: &types.ObjectLockRetention{
			Mode:            types.ObjectLockRetentionMode("GOVERNANCE"),
			RetainUntilDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			EventHold:       types.ObjectLockEventHold("ON"),
			EventHoldDuration: &types.EventHoldDuration{
				Days:  ptr.Int32(1),
				Years: ptr.Int32(1),
			},
		},
		RequestPayer:              types.RequestPayer("requester"),
		VersionId:                 ptr.String("__VersionId__"),
		BypassGovernanceRetention: ptr.Bool(true),
		ContentMD5:                ptr.String("__ContentMD5__"),
		ChecksumAlgorithm:         types.ChecksumAlgorithm("CRC32"),
		ExpectedBucketOwner:       ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutObjectRetention(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutObjectRetention"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutObjectTagging(t *testing.T) {
	input := &PutObjectTaggingInput{
		Bucket:            ptr.String("__Bucket__"),
		Key:               ptr.String("__Key__"),
		VersionId:         ptr.String("__VersionId__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		Tagging: &types.Tagging{
			TagSet: []types.Tag{
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
			},
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		RequestPayer:        types.RequestPayer("requester"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutObjectTagging(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutObjectTagging"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutPublicAccessBlock(t *testing.T) {
	input := &PutPublicAccessBlockInput{
		Bucket:            ptr.String("__Bucket__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		PublicAccessBlockConfiguration: &types.PublicAccessBlockConfiguration{
			BlockPublicAcls:       ptr.Bool(true),
			IgnorePublicAcls:      ptr.Bool(true),
			BlockPublicPolicy:     ptr.Bool(true),
			RestrictPublicBuckets: ptr.Bool(true),
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutPublicAccessBlock(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutPublicAccessBlock"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_RenameObject(t *testing.T) {
	input := &RenameObjectInput{
		Bucket:                       ptr.String("__Bucket__"),
		Key:                          ptr.String("__Key__"),
		RenameSource:                 ptr.String("__RenameSource__"),
		DestinationIfMatch:           ptr.String("__DestinationIfMatch__"),
		DestinationIfNoneMatch:       ptr.String("__DestinationIfNoneMatch__"),
		DestinationIfModifiedSince:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		DestinationIfUnmodifiedSince: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		SourceIfMatch:                ptr.String("__SourceIfMatch__"),
		SourceIfNoneMatch:            ptr.String("__SourceIfNoneMatch__"),
		SourceIfModifiedSince:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		SourceIfUnmodifiedSince:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ClientToken:                  ptr.String("__ClientToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.RenameObject(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "RenameObject"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_RestoreObject(t *testing.T) {
	input := &RestoreObjectInput{
		Bucket:    ptr.String("__Bucket__"),
		Key:       ptr.String("__Key__"),
		VersionId: ptr.String("__VersionId__"),
		RestoreRequest: &types.RestoreRequest{
			Days: ptr.Int32(1),
			GlacierJobParameters: &types.GlacierJobParameters{
				Tier: types.Tier("Standard"),
			},
			Type:        types.RestoreRequestType("SELECT"),
			Tier:        types.Tier("Standard"),
			Description: ptr.String("__Description__"),
			SelectParameters: &types.SelectParameters{
				InputSerialization: &types.InputSerialization{
					CSV: &types.CSVInput{
						FileHeaderInfo:             types.FileHeaderInfo("USE"),
						Comments:                   ptr.String("__Comments__"),
						QuoteEscapeCharacter:       ptr.String("__QuoteEscapeCharacter__"),
						RecordDelimiter:            ptr.String("__RecordDelimiter__"),
						FieldDelimiter:             ptr.String("__FieldDelimiter__"),
						QuoteCharacter:             ptr.String("__QuoteCharacter__"),
						AllowQuotedRecordDelimiter: ptr.Bool(true),
					},
					CompressionType: types.CompressionType("NONE"),
					JSON: &types.JSONInput{
						Type: types.JSONType("DOCUMENT"),
					},
					Parquet: &types.ParquetInput{},
				},
				ExpressionType: types.ExpressionType("SQL"),
				Expression:     ptr.String("__Expression__"),
				OutputSerialization: &types.OutputSerialization{
					CSV: &types.CSVOutput{
						QuoteFields:          types.QuoteFields("ALWAYS"),
						QuoteEscapeCharacter: ptr.String("__QuoteEscapeCharacter__"),
						RecordDelimiter:      ptr.String("__RecordDelimiter__"),
						FieldDelimiter:       ptr.String("__FieldDelimiter__"),
						QuoteCharacter:       ptr.String("__QuoteCharacter__"),
					},
					JSON: &types.JSONOutput{
						RecordDelimiter: ptr.String("__RecordDelimiter__"),
					},
				},
			},
			OutputLocation: &types.OutputLocation{
				S3: &types.S3Location{
					BucketName: ptr.String("__BucketName__"),
					Prefix:     ptr.String("__Prefix__"),
					Encryption: &types.Encryption{
						EncryptionType: types.ServerSideEncryption("AES256"),
						KMSKeyId:       ptr.String("__KMSKeyId__"),
						KMSContext:     ptr.String("__KMSContext__"),
					},
					CannedACL: types.ObjectCannedACL("private"),
					AccessControlList: []types.Grant{
						{
							Grantee: &types.Grantee{
								DisplayName:  ptr.String("__DisplayName__"),
								EmailAddress: ptr.String("__EmailAddress__"),
								ID:           ptr.String("__ID__"),
								URI:          ptr.String("__URI__"),
								Type:         types.Type("CanonicalUser"),
							},
							Permission: types.Permission("FULL_CONTROL"),
						},
						{
							Grantee: &types.Grantee{
								DisplayName:  ptr.String("__DisplayName__"),
								EmailAddress: ptr.String("__EmailAddress__"),
								ID:           ptr.String("__ID__"),
								URI:          ptr.String("__URI__"),
								Type:         types.Type("CanonicalUser"),
							},
							Permission: types.Permission("FULL_CONTROL"),
						},
					},
					Tagging: &types.Tagging{
						TagSet: []types.Tag{
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
						},
					},
					UserMetadata: []types.MetadataEntry{
						{
							Name:  ptr.String("__Name__"),
							Value: ptr.String("__Value__"),
						},
						{
							Name:  ptr.String("__Name__"),
							Value: ptr.String("__Value__"),
						},
					},
					StorageClass: types.StorageClass("STANDARD"),
				},
			},
		},
		RequestPayer:        types.RequestPayer("requester"),
		ChecksumAlgorithm:   types.ChecksumAlgorithm("CRC32"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.RestoreObject(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "RestoreObject"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateBucketMetadataAnnotationTableConfiguration(t *testing.T) {
	input := &UpdateBucketMetadataAnnotationTableConfigurationInput{
		Bucket:            ptr.String("__Bucket__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		AnnotationTableConfiguration: &types.AnnotationTableConfigurationUpdates{
			ConfigurationState: types.AnnotationConfigurationState("ENABLED"),
			EncryptionConfiguration: &types.MetadataTableEncryptionConfiguration{
				SseAlgorithm: types.TableSseAlgorithm("aws:kms"),
				KmsKeyArn:    ptr.String("__KmsKeyArn__"),
			},
			Role: ptr.String("__Role__"),
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateBucketMetadataAnnotationTableConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UpdateBucketMetadataAnnotationTableConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateBucketMetadataInventoryTableConfiguration(t *testing.T) {
	input := &UpdateBucketMetadataInventoryTableConfigurationInput{
		Bucket:            ptr.String("__Bucket__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		InventoryTableConfiguration: &types.InventoryTableConfigurationUpdates{
			ConfigurationState: types.InventoryConfigurationState("ENABLED"),
			EncryptionConfiguration: &types.MetadataTableEncryptionConfiguration{
				SseAlgorithm: types.TableSseAlgorithm("aws:kms"),
				KmsKeyArn:    ptr.String("__KmsKeyArn__"),
			},
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateBucketMetadataInventoryTableConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UpdateBucketMetadataInventoryTableConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateBucketMetadataJournalTableConfiguration(t *testing.T) {
	input := &UpdateBucketMetadataJournalTableConfigurationInput{
		Bucket:            ptr.String("__Bucket__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		JournalTableConfiguration: &types.JournalTableConfigurationUpdates{
			RecordExpiration: &types.RecordExpiration{
				Expiration: types.ExpirationState("ENABLED"),
				Days:       ptr.Int32(1),
			},
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateBucketMetadataJournalTableConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UpdateBucketMetadataJournalTableConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateObjectEncryption(t *testing.T) {
	input := &UpdateObjectEncryptionInput{
		Bucket:    ptr.String("__Bucket__"),
		Key:       ptr.String("__Key__"),
		VersionId: ptr.String("__VersionId__"),
		ObjectEncryption: &types.ObjectEncryptionMemberSSEKMS{
			Value: types.SSEKMSEncryption{
				KMSKeyArn:        ptr.String("__KMSKeyArn__"),
				BucketKeyEnabled: ptr.Bool(true),
			},
		},
		RequestPayer:        types.RequestPayer("requester"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		ContentMD5:          ptr.String("__ContentMD5__"),
		ChecksumAlgorithm:   types.ChecksumAlgorithm("CRC32"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateObjectEncryption(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UpdateObjectEncryption"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UploadPart(t *testing.T) {
	input := &UploadPartInput{
		Body:                 io.NopCloser(bytes.NewReader([]byte("__Body__"))),
		Bucket:               ptr.String("__Bucket__"),
		ContentLength:        ptr.Int64(1),
		ContentMD5:           ptr.String("__ContentMD5__"),
		ChecksumAlgorithm:    types.ChecksumAlgorithm("CRC32"),
		ChecksumCRC32:        ptr.String("__ChecksumCRC32__"),
		ChecksumCRC32C:       ptr.String("__ChecksumCRC32C__"),
		ChecksumCRC64NVME:    ptr.String("__ChecksumCRC64NVME__"),
		ChecksumSHA1:         ptr.String("__ChecksumSHA1__"),
		ChecksumSHA256:       ptr.String("__ChecksumSHA256__"),
		ChecksumSHA512:       ptr.String("__ChecksumSHA512__"),
		ChecksumMD5:          ptr.String("__ChecksumMD5__"),
		ChecksumXXHASH64:     ptr.String("__ChecksumXXHASH64__"),
		ChecksumXXHASH3:      ptr.String("__ChecksumXXHASH3__"),
		ChecksumXXHASH128:    ptr.String("__ChecksumXXHASH128__"),
		Key:                  ptr.String("__Key__"),
		PartNumber:           ptr.Int32(1),
		UploadId:             ptr.String("__UploadId__"),
		SSECustomerAlgorithm: ptr.String("__SSECustomerAlgorithm__"),
		SSECustomerKey:       ptr.String("__SSECustomerKey__"),
		SSECustomerKeyMD5:    ptr.String("__SSECustomerKeyMD5__"),
		RequestPayer:         types.RequestPayer("requester"),
		ExpectedBucketOwner:  ptr.String("__ExpectedBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UploadPart(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UploadPart"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UploadPartCopy(t *testing.T) {
	input := &UploadPartCopyInput{
		Bucket:                         ptr.String("__Bucket__"),
		CopySource:                     ptr.String("__CopySource__"),
		CopySourceIfMatch:              ptr.String("__CopySourceIfMatch__"),
		CopySourceIfModifiedSince:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		CopySourceIfNoneMatch:          ptr.String("__CopySourceIfNoneMatch__"),
		CopySourceIfUnmodifiedSince:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		CopySourceRange:                ptr.String("__CopySourceRange__"),
		Key:                            ptr.String("__Key__"),
		PartNumber:                     ptr.Int32(1),
		UploadId:                       ptr.String("__UploadId__"),
		SSECustomerAlgorithm:           ptr.String("__SSECustomerAlgorithm__"),
		SSECustomerKey:                 ptr.String("__SSECustomerKey__"),
		SSECustomerKeyMD5:              ptr.String("__SSECustomerKeyMD5__"),
		CopySourceSSECustomerAlgorithm: ptr.String("__CopySourceSSECustomerAlgorithm__"),
		CopySourceSSECustomerKey:       ptr.String("__CopySourceSSECustomerKey__"),
		CopySourceSSECustomerKeyMD5:    ptr.String("__CopySourceSSECustomerKeyMD5__"),
		RequestPayer:                   types.RequestPayer("requester"),
		ExpectedBucketOwner:            ptr.String("__ExpectedBucketOwner__"),
		ExpectedSourceBucketOwner:      ptr.String("__ExpectedSourceBucketOwner__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UploadPartCopy(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UploadPartCopy"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_WriteGetObjectResponse(t *testing.T) {
	input := &WriteGetObjectResponseInput{
		RequestRoute:       ptr.String("RequestRoute-value"),
		RequestToken:       ptr.String("__RequestToken__"),
		Body:               io.NopCloser(bytes.NewReader([]byte("__Body__"))),
		StatusCode:         ptr.Int32(1),
		ErrorCode:          ptr.String("__ErrorCode__"),
		ErrorMessage:       ptr.String("__ErrorMessage__"),
		AcceptRanges:       ptr.String("__AcceptRanges__"),
		CacheControl:       ptr.String("__CacheControl__"),
		ContentDisposition: ptr.String("__ContentDisposition__"),
		ContentEncoding:    ptr.String("__ContentEncoding__"),
		ContentLanguage:    ptr.String("__ContentLanguage__"),
		ContentLength:      ptr.Int64(1),
		ContentRange:       ptr.String("__ContentRange__"),
		ContentType:        ptr.String("__ContentType__"),
		ChecksumCRC32:      ptr.String("__ChecksumCRC32__"),
		ChecksumCRC32C:     ptr.String("__ChecksumCRC32C__"),
		ChecksumCRC64NVME:  ptr.String("__ChecksumCRC64NVME__"),
		ChecksumSHA1:       ptr.String("__ChecksumSHA1__"),
		ChecksumSHA256:     ptr.String("__ChecksumSHA256__"),
		ChecksumSHA512:     ptr.String("__ChecksumSHA512__"),
		ChecksumMD5:        ptr.String("__ChecksumMD5__"),
		ChecksumXXHASH64:   ptr.String("__ChecksumXXHASH64__"),
		ChecksumXXHASH3:    ptr.String("__ChecksumXXHASH3__"),
		ChecksumXXHASH128:  ptr.String("__ChecksumXXHASH128__"),
		DeleteMarker:       ptr.Bool(true),
		ETag:               ptr.String("__ETag__"),
		Expires:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		Expiration:         ptr.String("__Expiration__"),
		LastModified:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		MissingMeta:        ptr.Int32(1),
		Metadata: map[string]string{
			"key0": "__Value__",
		},
		ObjectLockMode:            types.ObjectLockMode("GOVERNANCE"),
		ObjectLockLegalHoldStatus: types.ObjectLockLegalHoldStatus("ON"),
		ObjectLockRetainUntilDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		PartsCount:                ptr.Int32(1),
		ReplicationStatus:         types.ReplicationStatus("COMPLETE"),
		RequestCharged:            types.RequestCharged("requester"),
		Restore:                   ptr.String("__Restore__"),
		ServerSideEncryption:      types.ServerSideEncryption("AES256"),
		SSECustomerAlgorithm:      ptr.String("__SSECustomerAlgorithm__"),
		SSEKMSKeyId:               ptr.String("__SSEKMSKeyId__"),
		SSECustomerKeyMD5:         ptr.String("__SSECustomerKeyMD5__"),
		StorageClass:              types.StorageClass("STANDARD"),
		TagCount:                  ptr.Int32(1),
		VersionId:                 ptr.String("__VersionId__"),
		BucketKeyEnabled:          ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.WriteGetObjectResponse(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "WriteGetObjectResponse"); err != nil {
		t.Fatal(err)
	}
}