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

//go:build response_snapshot

package s3

import (
	"bufio"
	"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"
	smithytesting "github.com/aws/smithy-go/testing"
	smithyhttp "github.com/aws/smithy-go/transport/http"
	"io"
	"io/fs"
	"net/http"
	"net/url"
	"os"
	"strconv"
	"strings"
	"testing"
	"time"
)

const serdeRespSSPrefix = "response_snapshot"

func serdeRespSSPath(op string) string {
	return fmt.Sprintf("%s/%s.snap", serdeRespSSPrefix, op)
}

// serdeRespReadSnapshot parses a frozen wire response fixture: a status-code
// line, HTTP headers, a blank line, then the raw body.
func serdeRespReadSnapshot(op string) (int, http.Header, []byte, error) {
	raw, err := os.ReadFile(serdeRespSSPath(op))
	if err != nil {
		return 0, nil, nil, err
	}

	r := bufio.NewReader(bytes.NewReader(raw))
	statusLine, err := r.ReadString('\n')
	if err != nil {
		return 0, nil, nil, fmt.Errorf("read status line: %w", err)
	}
	status, err := strconv.Atoi(strings.TrimSpace(statusLine))
	if err != nil {
		return 0, nil, nil, fmt.Errorf("parse status: %w", err)
	}

	header := http.Header{}
	for {
		line, err := r.ReadString('\n')
		if err != nil && err != io.EOF {
			return 0, nil, nil, err
		}
		trimmed := strings.TrimRight(line, "\r\n")
		if trimmed == "" {
			break
		}
		k, v, ok := strings.Cut(trimmed, ": ")
		if !ok {
			return 0, nil, nil, fmt.Errorf("malformed header %q", trimmed)
		}
		header.Add(k, v)
		if err == io.EOF {
			break
		}
	}

	body, err := io.ReadAll(r)
	if err != nil {
		return 0, nil, nil, err
	}
	return status, header, body, nil
}

type serdeRespEndpointResolver struct{}

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

func serdeRespClient(status int, header http.Header, body []byte) *Client {
	return New(Options{
		Region: "us-east-1",
		HTTPClient: smithyhttp.ClientDoFunc(func(req *http.Request) (*http.Response, error) {
			resp := &http.Response{StatusCode: status, Header: header, Request: req}
			if len(body) > 0 {
				resp.ContentLength = int64(len(body))
				resp.Body = io.NopCloser(bytes.NewReader(body))
			} else {
				resp.Body = http.NoBody
			}
			return resp, nil
		}),
		EndpointResolverV2: &serdeRespEndpointResolver{},
		APIOptions: []func(*middleware.Stack) error{
			func(s *middleware.Stack) error {
				s.Finalize.Clear()
				s.Initialize.Remove("OperationInputValidation")
				return nil
			},
		},
	})
}
func TestCheckResponseSnapshot_AbortMultipartUpload(t *testing.T) {
	want := &AbortMultipartUploadOutput{
		RequestCharged: types.RequestCharged("requester"),
	}
	status, header, body, err := serdeRespReadSnapshot("AbortMultipartUpload.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.AbortMultipartUpload(context.Background(), &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)),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "AbortMultipartUpload.response", err)
	}
}

func TestCheckResponseSnapshot_CompleteMultipartUpload(t *testing.T) {
	want := &CompleteMultipartUploadOutput{
		Location:             ptr.String("__Location__"),
		Bucket:               ptr.String("__Bucket__"),
		Key:                  ptr.String("__Key__"),
		Expiration:           ptr.String("__Expiration__"),
		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__"),
		ChecksumType:         types.ChecksumType("COMPOSITE"),
		ServerSideEncryption: types.ServerSideEncryption("AES256"),
		VersionId:            ptr.String("__VersionId__"),
		SSEKMSKeyId:          ptr.String("__SSEKMSKeyId__"),
		BucketKeyEnabled:     ptr.Bool(true),
		RequestCharged:       types.RequestCharged("requester"),
	}
	status, header, body, err := serdeRespReadSnapshot("CompleteMultipartUpload.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CompleteMultipartUpload(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CompleteMultipartUpload.response", err)
	}
}

func TestCheckResponseSnapshot_CopyObject(t *testing.T) {
	want := &CopyObjectOutput{
		CopyObjectResult: &types.CopyObjectResult{
			ETag:              ptr.String("__ETag__"),
			LastModified:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			ChecksumType:      types.ChecksumType("COMPOSITE"),
			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__"),
		},
		Expiration:              ptr.String("__Expiration__"),
		CopySourceVersionId:     ptr.String("__CopySourceVersionId__"),
		VersionId:               ptr.String("__VersionId__"),
		ServerSideEncryption:    types.ServerSideEncryption("AES256"),
		SSECustomerAlgorithm:    ptr.String("__SSECustomerAlgorithm__"),
		SSECustomerKeyMD5:       ptr.String("__SSECustomerKeyMD5__"),
		SSEKMSKeyId:             ptr.String("__SSEKMSKeyId__"),
		SSEKMSEncryptionContext: ptr.String("__SSEKMSEncryptionContext__"),
		BucketKeyEnabled:        ptr.Bool(true),
		RequestCharged:          types.RequestCharged("requester"),
	}
	status, header, body, err := serdeRespReadSnapshot("CopyObject.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CopyObject(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CopyObject.response", err)
	}
}

func TestCheckResponseSnapshot_CreateBucket(t *testing.T) {
	want := &CreateBucketOutput{
		Location:  ptr.String("__Location__"),
		BucketArn: ptr.String("__BucketArn__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateBucket.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateBucket(context.Background(), &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"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateBucket.response", err)
	}
}

func TestCheckResponseSnapshot_CreateBucketMetadataConfiguration(t *testing.T) {
	want := &CreateBucketMetadataConfigurationOutput{}
	status, header, body, err := serdeRespReadSnapshot("CreateBucketMetadataConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateBucketMetadataConfiguration(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateBucketMetadataConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_CreateBucketMetadataTableConfiguration(t *testing.T) {
	want := &CreateBucketMetadataTableConfigurationOutput{}
	status, header, body, err := serdeRespReadSnapshot("CreateBucketMetadataTableConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateBucketMetadataTableConfiguration(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateBucketMetadataTableConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_CreateMultipartUpload(t *testing.T) {
	want := &CreateMultipartUploadOutput{
		AbortDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		AbortRuleId:             ptr.String("__AbortRuleId__"),
		Bucket:                  ptr.String("__Bucket__"),
		Key:                     ptr.String("__Key__"),
		UploadId:                ptr.String("__UploadId__"),
		ServerSideEncryption:    types.ServerSideEncryption("AES256"),
		SSECustomerAlgorithm:    ptr.String("__SSECustomerAlgorithm__"),
		SSECustomerKeyMD5:       ptr.String("__SSECustomerKeyMD5__"),
		SSEKMSKeyId:             ptr.String("__SSEKMSKeyId__"),
		SSEKMSEncryptionContext: ptr.String("__SSEKMSEncryptionContext__"),
		BucketKeyEnabled:        ptr.Bool(true),
		RequestCharged:          types.RequestCharged("requester"),
		ChecksumAlgorithm:       types.ChecksumAlgorithm("CRC32"),
		ChecksumType:            types.ChecksumType("COMPOSITE"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateMultipartUpload.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateMultipartUpload(context.Background(), &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"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateMultipartUpload.response", err)
	}
}

func TestCheckResponseSnapshot_CreateSession(t *testing.T) {
	want := &CreateSessionOutput{
		ServerSideEncryption:    types.ServerSideEncryption("AES256"),
		SSEKMSKeyId:             ptr.String("__SSEKMSKeyId__"),
		SSEKMSEncryptionContext: ptr.String("__SSEKMSEncryptionContext__"),
		BucketKeyEnabled:        ptr.Bool(true),
		Credentials: &types.SessionCredentials{
			AccessKeyId:     ptr.String("__AccessKeyId__"),
			SecretAccessKey: ptr.String("__SecretAccessKey__"),
			SessionToken:    ptr.String("__SessionToken__"),
			Expiration:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateSession.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateSession(context.Background(), &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),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateSession.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteBucket(t *testing.T) {
	want := &DeleteBucketOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteBucket.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteBucket(context.Background(), &DeleteBucketInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteBucket.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteBucketAnalyticsConfiguration(t *testing.T) {
	want := &DeleteBucketAnalyticsConfigurationOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteBucketAnalyticsConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteBucketAnalyticsConfiguration(context.Background(), &DeleteBucketAnalyticsConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		Id:                  ptr.String("__Id__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteBucketAnalyticsConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteBucketCors(t *testing.T) {
	want := &DeleteBucketCorsOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteBucketCors.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteBucketCors(context.Background(), &DeleteBucketCorsInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteBucketCors.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteBucketEncryption(t *testing.T) {
	want := &DeleteBucketEncryptionOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteBucketEncryption.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteBucketEncryption(context.Background(), &DeleteBucketEncryptionInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteBucketEncryption.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteBucketIntelligentTieringConfiguration(t *testing.T) {
	want := &DeleteBucketIntelligentTieringConfigurationOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteBucketIntelligentTieringConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteBucketIntelligentTieringConfiguration(context.Background(), &DeleteBucketIntelligentTieringConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		Id:                  ptr.String("__Id__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteBucketIntelligentTieringConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteBucketInventoryConfiguration(t *testing.T) {
	want := &DeleteBucketInventoryConfigurationOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteBucketInventoryConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteBucketInventoryConfiguration(context.Background(), &DeleteBucketInventoryConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		Id:                  ptr.String("__Id__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteBucketInventoryConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteBucketLifecycle(t *testing.T) {
	want := &DeleteBucketLifecycleOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteBucketLifecycle.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteBucketLifecycle(context.Background(), &DeleteBucketLifecycleInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteBucketLifecycle.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteBucketMetadataConfiguration(t *testing.T) {
	want := &DeleteBucketMetadataConfigurationOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteBucketMetadataConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteBucketMetadataConfiguration(context.Background(), &DeleteBucketMetadataConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteBucketMetadataConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteBucketMetadataTableConfiguration(t *testing.T) {
	want := &DeleteBucketMetadataTableConfigurationOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteBucketMetadataTableConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteBucketMetadataTableConfiguration(context.Background(), &DeleteBucketMetadataTableConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteBucketMetadataTableConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteBucketMetricsConfiguration(t *testing.T) {
	want := &DeleteBucketMetricsConfigurationOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteBucketMetricsConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteBucketMetricsConfiguration(context.Background(), &DeleteBucketMetricsConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		Id:                  ptr.String("__Id__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteBucketMetricsConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteBucketOwnershipControls(t *testing.T) {
	want := &DeleteBucketOwnershipControlsOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteBucketOwnershipControls.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteBucketOwnershipControls(context.Background(), &DeleteBucketOwnershipControlsInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteBucketOwnershipControls.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteBucketPolicy(t *testing.T) {
	want := &DeleteBucketPolicyOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteBucketPolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteBucketPolicy(context.Background(), &DeleteBucketPolicyInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteBucketPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteBucketReplication(t *testing.T) {
	want := &DeleteBucketReplicationOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteBucketReplication.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteBucketReplication(context.Background(), &DeleteBucketReplicationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteBucketReplication.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteBucketTagging(t *testing.T) {
	want := &DeleteBucketTaggingOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteBucketTagging.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteBucketTagging(context.Background(), &DeleteBucketTaggingInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteBucketTagging.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteBucketWebsite(t *testing.T) {
	want := &DeleteBucketWebsiteOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteBucketWebsite.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteBucketWebsite(context.Background(), &DeleteBucketWebsiteInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteBucketWebsite.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteObject(t *testing.T) {
	want := &DeleteObjectOutput{
		DeleteMarker:   ptr.Bool(true),
		VersionId:      ptr.String("__VersionId__"),
		RequestCharged: types.RequestCharged("requester"),
	}
	status, header, body, err := serdeRespReadSnapshot("DeleteObject.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteObject(context.Background(), &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),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteObject.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteObjectAnnotation(t *testing.T) {
	want := &DeleteObjectAnnotationOutput{
		ObjectVersionId: ptr.String("__ObjectVersionId__"),
		RequestCharged:  types.RequestCharged("requester"),
	}
	status, header, body, err := serdeRespReadSnapshot("DeleteObjectAnnotation.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteObjectAnnotation(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteObjectAnnotation.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteObjectTagging(t *testing.T) {
	want := &DeleteObjectTaggingOutput{
		VersionId: ptr.String("__VersionId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DeleteObjectTagging.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteObjectTagging(context.Background(), &DeleteObjectTaggingInput{
		Bucket:              ptr.String("__Bucket__"),
		Key:                 ptr.String("__Key__"),
		VersionId:           ptr.String("__VersionId__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteObjectTagging.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteObjects(t *testing.T) {
	want := &DeleteObjectsOutput{
		Deleted: []types.DeletedObject{
			{
				Key:                   ptr.String("__Key__"),
				VersionId:             ptr.String("__VersionId__"),
				DeleteMarker:          ptr.Bool(true),
				DeleteMarkerVersionId: ptr.String("__DeleteMarkerVersionId__"),
			},
			{
				Key:                   ptr.String("__Key__"),
				VersionId:             ptr.String("__VersionId__"),
				DeleteMarker:          ptr.Bool(true),
				DeleteMarkerVersionId: ptr.String("__DeleteMarkerVersionId__"),
			},
		},
		RequestCharged: types.RequestCharged("requester"),
		Errors: []types.Error{
			{
				Key:       ptr.String("__Key__"),
				VersionId: ptr.String("__VersionId__"),
				Code:      ptr.String("__Code__"),
				Message:   ptr.String("__Message__"),
			},
			{
				Key:       ptr.String("__Key__"),
				VersionId: ptr.String("__VersionId__"),
				Code:      ptr.String("__Code__"),
				Message:   ptr.String("__Message__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DeleteObjects.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteObjects(context.Background(), &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"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteObjects.response", err)
	}
}

func TestCheckResponseSnapshot_DeletePublicAccessBlock(t *testing.T) {
	want := &DeletePublicAccessBlockOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeletePublicAccessBlock.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeletePublicAccessBlock(context.Background(), &DeletePublicAccessBlockInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeletePublicAccessBlock.response", err)
	}
}

func TestCheckResponseSnapshot_GetBucketAbac(t *testing.T) {
	want := &GetBucketAbacOutput{
		AbacStatus: &types.AbacStatus{
			Status: types.BucketAbacStatus("Enabled"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetBucketAbac.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetBucketAbac(context.Background(), &GetBucketAbacInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBucketAbac.response", err)
	}
}

func TestCheckResponseSnapshot_GetBucketAccelerateConfiguration(t *testing.T) {
	want := &GetBucketAccelerateConfigurationOutput{
		Status:         types.BucketAccelerateStatus("Enabled"),
		RequestCharged: types.RequestCharged("requester"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetBucketAccelerateConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetBucketAccelerateConfiguration(context.Background(), &GetBucketAccelerateConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		RequestPayer:        types.RequestPayer("requester"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBucketAccelerateConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_GetBucketAcl(t *testing.T) {
	want := &GetBucketAclOutput{
		Owner: &types.Owner{
			DisplayName: ptr.String("__DisplayName__"),
			ID:          ptr.String("__ID__"),
		},
		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"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetBucketAcl.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetBucketAcl(context.Background(), &GetBucketAclInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBucketAcl.response", err)
	}
}

func TestCheckResponseSnapshot_GetBucketAnalyticsConfiguration(t *testing.T) {
	want := &GetBucketAnalyticsConfigurationOutput{
		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__"),
						},
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetBucketAnalyticsConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetBucketAnalyticsConfiguration(context.Background(), &GetBucketAnalyticsConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		Id:                  ptr.String("__Id__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBucketAnalyticsConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_GetBucketCors(t *testing.T) {
	want := &GetBucketCorsOutput{
		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),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetBucketCors.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetBucketCors(context.Background(), &GetBucketCorsInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBucketCors.response", err)
	}
}

func TestCheckResponseSnapshot_GetBucketEncryption(t *testing.T) {
	want := &GetBucketEncryptionOutput{
		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"),
						},
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetBucketEncryption.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetBucketEncryption(context.Background(), &GetBucketEncryptionInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBucketEncryption.response", err)
	}
}

func TestCheckResponseSnapshot_GetBucketIntelligentTieringConfiguration(t *testing.T) {
	want := &GetBucketIntelligentTieringConfigurationOutput{
		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"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetBucketIntelligentTieringConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetBucketIntelligentTieringConfiguration(context.Background(), &GetBucketIntelligentTieringConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		Id:                  ptr.String("__Id__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBucketIntelligentTieringConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_GetBucketInventoryConfiguration(t *testing.T) {
	want := &GetBucketInventoryConfigurationOutput{
		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"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetBucketInventoryConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetBucketInventoryConfiguration(context.Background(), &GetBucketInventoryConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		Id:                  ptr.String("__Id__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBucketInventoryConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_GetBucketLifecycleConfiguration(t *testing.T) {
	want := &GetBucketLifecycleConfigurationOutput{
		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),
				},
			},
		},
		TransitionDefaultMinimumObjectSize: types.TransitionDefaultMinimumObjectSize("varies_by_storage_class"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetBucketLifecycleConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetBucketLifecycleConfiguration(context.Background(), &GetBucketLifecycleConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBucketLifecycleConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_GetBucketLocation(t *testing.T) {
	want := &GetBucketLocationOutput{
		LocationConstraint: types.BucketLocationConstraint("af-south-1"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetBucketLocation.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetBucketLocation(context.Background(), &GetBucketLocationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBucketLocation.response", err)
	}
}

func TestCheckResponseSnapshot_GetBucketLogging(t *testing.T) {
	want := &GetBucketLoggingOutput{
		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"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetBucketLogging.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetBucketLogging(context.Background(), &GetBucketLoggingInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBucketLogging.response", err)
	}
}

func TestCheckResponseSnapshot_GetBucketMetadataConfiguration(t *testing.T) {
	want := &GetBucketMetadataConfigurationOutput{
		GetBucketMetadataConfigurationResult: &types.GetBucketMetadataConfigurationResult{
			MetadataConfigurationResult: &types.MetadataConfigurationResult{
				DestinationResult: &types.DestinationResult{
					TableBucketType: types.S3TablesBucketType("aws"),
					TableBucketArn:  ptr.String("__TableBucketArn__"),
					TableNamespace:  ptr.String("__TableNamespace__"),
				},
				JournalTableConfigurationResult: &types.JournalTableConfigurationResult{
					TableStatus: ptr.String("__TableStatus__"),
					Error: &types.ErrorDetails{
						ErrorCode:    ptr.String("__ErrorCode__"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
					TableName: ptr.String("__TableName__"),
					TableArn:  ptr.String("__TableArn__"),
					RecordExpiration: &types.RecordExpiration{
						Expiration: types.ExpirationState("ENABLED"),
						Days:       ptr.Int32(1),
					},
				},
				InventoryTableConfigurationResult: &types.InventoryTableConfigurationResult{
					ConfigurationState: types.InventoryConfigurationState("ENABLED"),
					TableStatus:        ptr.String("__TableStatus__"),
					Error: &types.ErrorDetails{
						ErrorCode:    ptr.String("__ErrorCode__"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
					TableName: ptr.String("__TableName__"),
					TableArn:  ptr.String("__TableArn__"),
				},
				AnnotationTableConfigurationResult: &types.AnnotationTableConfigurationResult{
					ConfigurationState: types.AnnotationConfigurationState("ENABLED"),
					TableStatus:        ptr.String("__TableStatus__"),
					Error: &types.ErrorDetails{
						ErrorCode:    ptr.String("__ErrorCode__"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
					TableName: ptr.String("__TableName__"),
					TableArn:  ptr.String("__TableArn__"),
					Role:      ptr.String("__Role__"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetBucketMetadataConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetBucketMetadataConfiguration(context.Background(), &GetBucketMetadataConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBucketMetadataConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_GetBucketMetadataTableConfiguration(t *testing.T) {
	want := &GetBucketMetadataTableConfigurationOutput{
		GetBucketMetadataTableConfigurationResult: &types.GetBucketMetadataTableConfigurationResult{
			MetadataTableConfigurationResult: &types.MetadataTableConfigurationResult{
				S3TablesDestinationResult: &types.S3TablesDestinationResult{
					TableBucketArn: ptr.String("__TableBucketArn__"),
					TableName:      ptr.String("__TableName__"),
					TableArn:       ptr.String("__TableArn__"),
					TableNamespace: ptr.String("__TableNamespace__"),
				},
			},
			Status: ptr.String("__Status__"),
			Error: &types.ErrorDetails{
				ErrorCode:    ptr.String("__ErrorCode__"),
				ErrorMessage: ptr.String("__ErrorMessage__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetBucketMetadataTableConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetBucketMetadataTableConfiguration(context.Background(), &GetBucketMetadataTableConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBucketMetadataTableConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_GetBucketMetricsConfiguration(t *testing.T) {
	want := &GetBucketMetricsConfigurationOutput{
		MetricsConfiguration: &types.MetricsConfiguration{
			Id: ptr.String("__Id__"),
			Filter: &types.MetricsFilterMemberPrefix{
				Value: "__MetricsFilterMemberPrefix__",
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetBucketMetricsConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetBucketMetricsConfiguration(context.Background(), &GetBucketMetricsConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		Id:                  ptr.String("__Id__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBucketMetricsConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_GetBucketNotificationConfiguration(t *testing.T) {
	want := &GetBucketNotificationConfigurationOutput{
		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{},
	}
	status, header, body, err := serdeRespReadSnapshot("GetBucketNotificationConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetBucketNotificationConfiguration(context.Background(), &GetBucketNotificationConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBucketNotificationConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_GetBucketOwnershipControls(t *testing.T) {
	want := &GetBucketOwnershipControlsOutput{
		OwnershipControls: &types.OwnershipControls{
			Rules: []types.OwnershipControlsRule{
				{
					ObjectOwnership: types.ObjectOwnership("BucketOwnerPreferred"),
				},
				{
					ObjectOwnership: types.ObjectOwnership("BucketOwnerPreferred"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetBucketOwnershipControls.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetBucketOwnershipControls(context.Background(), &GetBucketOwnershipControlsInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBucketOwnershipControls.response", err)
	}
}

func TestCheckResponseSnapshot_GetBucketPolicy(t *testing.T) {
	want := &GetBucketPolicyOutput{
		Policy: ptr.String("__Policy__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetBucketPolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetBucketPolicy(context.Background(), &GetBucketPolicyInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBucketPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_GetBucketPolicyStatus(t *testing.T) {
	want := &GetBucketPolicyStatusOutput{
		PolicyStatus: &types.PolicyStatus{
			IsPublic: ptr.Bool(true),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetBucketPolicyStatus.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetBucketPolicyStatus(context.Background(), &GetBucketPolicyStatusInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBucketPolicyStatus.response", err)
	}
}

func TestCheckResponseSnapshot_GetBucketReplication(t *testing.T) {
	want := &GetBucketReplicationOutput{
		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"),
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetBucketReplication.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetBucketReplication(context.Background(), &GetBucketReplicationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBucketReplication.response", err)
	}
}

func TestCheckResponseSnapshot_GetBucketRequestPayment(t *testing.T) {
	want := &GetBucketRequestPaymentOutput{
		Payer: types.Payer("Requester"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetBucketRequestPayment.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetBucketRequestPayment(context.Background(), &GetBucketRequestPaymentInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBucketRequestPayment.response", err)
	}
}

func TestCheckResponseSnapshot_GetBucketTagging(t *testing.T) {
	want := &GetBucketTaggingOutput{
		TagSet: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetBucketTagging.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetBucketTagging(context.Background(), &GetBucketTaggingInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBucketTagging.response", err)
	}
}

func TestCheckResponseSnapshot_GetBucketVersioning(t *testing.T) {
	want := &GetBucketVersioningOutput{
		Status:    types.BucketVersioningStatus("Enabled"),
		MFADelete: types.MFADeleteStatus("Enabled"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetBucketVersioning.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetBucketVersioning(context.Background(), &GetBucketVersioningInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBucketVersioning.response", err)
	}
}

func TestCheckResponseSnapshot_GetBucketWebsite(t *testing.T) {
	want := &GetBucketWebsiteOutput{
		RedirectAllRequestsTo: &types.RedirectAllRequestsTo{
			HostName: ptr.String("__HostName__"),
			Protocol: types.Protocol("http"),
		},
		IndexDocument: &types.IndexDocument{
			Suffix: ptr.String("__Suffix__"),
		},
		ErrorDocument: &types.ErrorDocument{
			Key: ptr.String("__Key__"),
		},
		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__"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetBucketWebsite.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetBucketWebsite(context.Background(), &GetBucketWebsiteInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBucketWebsite.response", err)
	}
}

func TestCheckResponseSnapshot_GetObject(t *testing.T) {
	t.Skip("asymmetric")
}

func TestCheckResponseSnapshot_GetObjectAcl(t *testing.T) {
	want := &GetObjectAclOutput{
		Owner: &types.Owner{
			DisplayName: ptr.String("__DisplayName__"),
			ID:          ptr.String("__ID__"),
		},
		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"),
			},
		},
		RequestCharged: types.RequestCharged("requester"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetObjectAcl.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetObjectAcl(context.Background(), &GetObjectAclInput{
		Bucket:              ptr.String("__Bucket__"),
		Key:                 ptr.String("__Key__"),
		VersionId:           ptr.String("__VersionId__"),
		RequestPayer:        types.RequestPayer("requester"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetObjectAcl.response", err)
	}
}

func TestCheckResponseSnapshot_GetObjectAnnotation(t *testing.T) {
	t.Skip("asymmetric")
}

func TestCheckResponseSnapshot_GetObjectAttributes(t *testing.T) {
	want := &GetObjectAttributesOutput{
		DeleteMarker:   ptr.Bool(true),
		LastModified:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		VersionId:      ptr.String("__VersionId__"),
		RequestCharged: types.RequestCharged("requester"),
		ETag:           ptr.String("__ETag__"),
		Checksum: &types.Checksum{
			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"),
		},
		ObjectParts: &types.GetObjectAttributesParts{
			TotalPartsCount:      ptr.Int32(1),
			PartNumberMarker:     ptr.String("__PartNumberMarker__"),
			NextPartNumberMarker: ptr.String("__NextPartNumberMarker__"),
			MaxParts:             ptr.Int32(1),
			IsTruncated:          ptr.Bool(true),
			Parts: []types.ObjectPart{
				{
					PartNumber:        ptr.Int32(1),
					Size:              ptr.Int64(1),
					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),
					Size:              ptr.Int64(1),
					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__"),
				},
			},
		},
		StorageClass: types.StorageClass("STANDARD"),
		ObjectSize:   ptr.Int64(1),
	}
	status, header, body, err := serdeRespReadSnapshot("GetObjectAttributes.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetObjectAttributes(context.Background(), &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"),
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetObjectAttributes.response", err)
	}
}

func TestCheckResponseSnapshot_GetObjectLegalHold(t *testing.T) {
	want := &GetObjectLegalHoldOutput{
		LegalHold: &types.ObjectLockLegalHold{
			Status: types.ObjectLockLegalHoldStatus("ON"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetObjectLegalHold.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetObjectLegalHold(context.Background(), &GetObjectLegalHoldInput{
		Bucket:              ptr.String("__Bucket__"),
		Key:                 ptr.String("__Key__"),
		VersionId:           ptr.String("__VersionId__"),
		RequestPayer:        types.RequestPayer("requester"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetObjectLegalHold.response", err)
	}
}

func TestCheckResponseSnapshot_GetObjectLockConfiguration(t *testing.T) {
	want := &GetObjectLockConfigurationOutput{
		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),
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetObjectLockConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetObjectLockConfiguration(context.Background(), &GetObjectLockConfigurationInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetObjectLockConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_GetObjectRetention(t *testing.T) {
	want := &GetObjectRetentionOutput{
		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),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetObjectRetention.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetObjectRetention(context.Background(), &GetObjectRetentionInput{
		Bucket:              ptr.String("__Bucket__"),
		Key:                 ptr.String("__Key__"),
		VersionId:           ptr.String("__VersionId__"),
		RequestPayer:        types.RequestPayer("requester"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetObjectRetention.response", err)
	}
}

func TestCheckResponseSnapshot_GetObjectTagging(t *testing.T) {
	want := &GetObjectTaggingOutput{
		VersionId: ptr.String("__VersionId__"),
		TagSet: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetObjectTagging.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetObjectTagging(context.Background(), &GetObjectTaggingInput{
		Bucket:              ptr.String("__Bucket__"),
		Key:                 ptr.String("__Key__"),
		VersionId:           ptr.String("__VersionId__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		RequestPayer:        types.RequestPayer("requester"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetObjectTagging.response", err)
	}
}

func TestCheckResponseSnapshot_GetObjectTorrent(t *testing.T) {
	want := &GetObjectTorrentOutput{
		Body:           io.NopCloser(bytes.NewReader([]byte("__Body__"))),
		RequestCharged: types.RequestCharged("requester"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetObjectTorrent.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetObjectTorrent(context.Background(), &GetObjectTorrentInput{
		Bucket:              ptr.String("__Bucket__"),
		Key:                 ptr.String("__Key__"),
		RequestPayer:        types.RequestPayer("requester"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetObjectTorrent.response", err)
	}
}

func TestCheckResponseSnapshot_GetPublicAccessBlock(t *testing.T) {
	want := &GetPublicAccessBlockOutput{
		PublicAccessBlockConfiguration: &types.PublicAccessBlockConfiguration{
			BlockPublicAcls:       ptr.Bool(true),
			IgnorePublicAcls:      ptr.Bool(true),
			BlockPublicPolicy:     ptr.Bool(true),
			RestrictPublicBuckets: ptr.Bool(true),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetPublicAccessBlock.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetPublicAccessBlock(context.Background(), &GetPublicAccessBlockInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetPublicAccessBlock.response", err)
	}
}

func TestCheckResponseSnapshot_HeadBucket(t *testing.T) {
	want := &HeadBucketOutput{
		BucketArn:          ptr.String("__BucketArn__"),
		BucketLocationType: types.LocationType("AvailabilityZone"),
		BucketLocationName: ptr.String("__BucketLocationName__"),
		BucketRegion:       ptr.String("__BucketRegion__"),
		AccessPointAlias:   ptr.Bool(true),
	}
	status, header, body, err := serdeRespReadSnapshot("HeadBucket.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.HeadBucket(context.Background(), &HeadBucketInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "HeadBucket.response", err)
	}
}

func TestCheckResponseSnapshot_HeadObject(t *testing.T) {
	t.Skip("asymmetric")
}

func TestCheckResponseSnapshot_ListBucketAnalyticsConfigurations(t *testing.T) {
	want := &ListBucketAnalyticsConfigurationsOutput{
		IsTruncated:           ptr.Bool(true),
		ContinuationToken:     ptr.String("__ContinuationToken__"),
		NextContinuationToken: ptr.String("__NextContinuationToken__"),
		AnalyticsConfigurationList: []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__"),
							},
						},
					},
				},
			},
			{
				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__"),
							},
						},
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListBucketAnalyticsConfigurations.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListBucketAnalyticsConfigurations(context.Background(), &ListBucketAnalyticsConfigurationsInput{
		Bucket:              ptr.String("__Bucket__"),
		ContinuationToken:   ptr.String("__ContinuationToken__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListBucketAnalyticsConfigurations.response", err)
	}
}

func TestCheckResponseSnapshot_ListBucketIntelligentTieringConfigurations(t *testing.T) {
	want := &ListBucketIntelligentTieringConfigurationsOutput{
		IsTruncated:           ptr.Bool(true),
		ContinuationToken:     ptr.String("__ContinuationToken__"),
		NextContinuationToken: ptr.String("__NextContinuationToken__"),
		IntelligentTieringConfigurationList: []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"),
					},
				},
			},
			{
				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"),
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListBucketIntelligentTieringConfigurations.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListBucketIntelligentTieringConfigurations(context.Background(), &ListBucketIntelligentTieringConfigurationsInput{
		Bucket:              ptr.String("__Bucket__"),
		ContinuationToken:   ptr.String("__ContinuationToken__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListBucketIntelligentTieringConfigurations.response", err)
	}
}

func TestCheckResponseSnapshot_ListBucketInventoryConfigurations(t *testing.T) {
	want := &ListBucketInventoryConfigurationsOutput{
		ContinuationToken: ptr.String("__ContinuationToken__"),
		InventoryConfigurationList: []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"),
				},
			},
			{
				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"),
				},
			},
		},
		IsTruncated:           ptr.Bool(true),
		NextContinuationToken: ptr.String("__NextContinuationToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListBucketInventoryConfigurations.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListBucketInventoryConfigurations(context.Background(), &ListBucketInventoryConfigurationsInput{
		Bucket:              ptr.String("__Bucket__"),
		ContinuationToken:   ptr.String("__ContinuationToken__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListBucketInventoryConfigurations.response", err)
	}
}

func TestCheckResponseSnapshot_ListBucketMetricsConfigurations(t *testing.T) {
	want := &ListBucketMetricsConfigurationsOutput{
		IsTruncated:           ptr.Bool(true),
		ContinuationToken:     ptr.String("__ContinuationToken__"),
		NextContinuationToken: ptr.String("__NextContinuationToken__"),
		MetricsConfigurationList: []types.MetricsConfiguration{
			{
				Id: ptr.String("__Id__"),
				Filter: &types.MetricsFilterMemberPrefix{
					Value: "__MetricsFilterMemberPrefix__",
				},
			},
			{
				Id: ptr.String("__Id__"),
				Filter: &types.MetricsFilterMemberPrefix{
					Value: "__MetricsFilterMemberPrefix__",
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListBucketMetricsConfigurations.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListBucketMetricsConfigurations(context.Background(), &ListBucketMetricsConfigurationsInput{
		Bucket:              ptr.String("__Bucket__"),
		ContinuationToken:   ptr.String("__ContinuationToken__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListBucketMetricsConfigurations.response", err)
	}
}

func TestCheckResponseSnapshot_ListBuckets(t *testing.T) {
	want := &ListBucketsOutput{
		Buckets: []types.Bucket{
			{
				Name:         ptr.String("__Name__"),
				CreationDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				BucketRegion: ptr.String("__BucketRegion__"),
				BucketArn:    ptr.String("__BucketArn__"),
			},
			{
				Name:         ptr.String("__Name__"),
				CreationDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				BucketRegion: ptr.String("__BucketRegion__"),
				BucketArn:    ptr.String("__BucketArn__"),
			},
		},
		Owner: &types.Owner{
			DisplayName: ptr.String("__DisplayName__"),
			ID:          ptr.String("__ID__"),
		},
		ContinuationToken: ptr.String("__ContinuationToken__"),
		Prefix:            ptr.String("__Prefix__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListBuckets.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListBuckets(context.Background(), &ListBucketsInput{
		MaxBuckets:        ptr.Int32(1),
		ContinuationToken: ptr.String("__ContinuationToken__"),
		Prefix:            ptr.String("__Prefix__"),
		BucketRegion:      ptr.String("__BucketRegion__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListBuckets.response", err)
	}
}

func TestCheckResponseSnapshot_ListDirectoryBuckets(t *testing.T) {
	want := &ListDirectoryBucketsOutput{
		Buckets: []types.Bucket{
			{
				Name:         ptr.String("__Name__"),
				CreationDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				BucketRegion: ptr.String("__BucketRegion__"),
				BucketArn:    ptr.String("__BucketArn__"),
			},
			{
				Name:         ptr.String("__Name__"),
				CreationDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				BucketRegion: ptr.String("__BucketRegion__"),
				BucketArn:    ptr.String("__BucketArn__"),
			},
		},
		ContinuationToken: ptr.String("__ContinuationToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListDirectoryBuckets.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListDirectoryBuckets(context.Background(), &ListDirectoryBucketsInput{
		ContinuationToken:   ptr.String("__ContinuationToken__"),
		MaxDirectoryBuckets: ptr.Int32(1),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListDirectoryBuckets.response", err)
	}
}

func TestCheckResponseSnapshot_ListMultipartUploads(t *testing.T) {
	want := &ListMultipartUploadsOutput{
		Bucket:             ptr.String("__Bucket__"),
		KeyMarker:          ptr.String("__KeyMarker__"),
		UploadIdMarker:     ptr.String("__UploadIdMarker__"),
		NextKeyMarker:      ptr.String("__NextKeyMarker__"),
		Prefix:             ptr.String("__Prefix__"),
		Delimiter:          ptr.String("__Delimiter__"),
		NextUploadIdMarker: ptr.String("__NextUploadIdMarker__"),
		MaxUploads:         ptr.Int32(1),
		IsTruncated:        ptr.Bool(true),
		Uploads: []types.MultipartUpload{
			{
				UploadId:     ptr.String("__UploadId__"),
				Key:          ptr.String("__Key__"),
				Initiated:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				StorageClass: types.StorageClass("STANDARD"),
				Owner: &types.Owner{
					DisplayName: ptr.String("__DisplayName__"),
					ID:          ptr.String("__ID__"),
				},
				Initiator: &types.Initiator{
					ID:          ptr.String("__ID__"),
					DisplayName: ptr.String("__DisplayName__"),
				},
				ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
				ChecksumType:      types.ChecksumType("COMPOSITE"),
			},
			{
				UploadId:     ptr.String("__UploadId__"),
				Key:          ptr.String("__Key__"),
				Initiated:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				StorageClass: types.StorageClass("STANDARD"),
				Owner: &types.Owner{
					DisplayName: ptr.String("__DisplayName__"),
					ID:          ptr.String("__ID__"),
				},
				Initiator: &types.Initiator{
					ID:          ptr.String("__ID__"),
					DisplayName: ptr.String("__DisplayName__"),
				},
				ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
				ChecksumType:      types.ChecksumType("COMPOSITE"),
			},
		},
		CommonPrefixes: []types.CommonPrefix{
			{
				Prefix: ptr.String("__Prefix__"),
			},
			{
				Prefix: ptr.String("__Prefix__"),
			},
		},
		EncodingType:   types.EncodingType("url"),
		RequestCharged: types.RequestCharged("requester"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListMultipartUploads.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListMultipartUploads(context.Background(), &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"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListMultipartUploads.response", err)
	}
}

func TestCheckResponseSnapshot_ListObjectAnnotations(t *testing.T) {
	want := &ListObjectAnnotationsOutput{
		Annotations: []types.AnnotationEntry{
			{
				AnnotationName: ptr.String("__AnnotationName__"),
				LastModified:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ETag:           ptr.String("__ETag__"),
				ChecksumAlgorithm: []types.ChecksumAlgorithm{
					types.ChecksumAlgorithm("CRC32"),
					types.ChecksumAlgorithm("CRC32"),
				},
				Size:              ptr.Int64(1),
				ReplicationStatus: types.ReplicationStatus("COMPLETE"),
			},
			{
				AnnotationName: ptr.String("__AnnotationName__"),
				LastModified:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ETag:           ptr.String("__ETag__"),
				ChecksumAlgorithm: []types.ChecksumAlgorithm{
					types.ChecksumAlgorithm("CRC32"),
					types.ChecksumAlgorithm("CRC32"),
				},
				Size:              ptr.Int64(1),
				ReplicationStatus: types.ReplicationStatus("COMPLETE"),
			},
		},
		Bucket:                ptr.String("__Bucket__"),
		Key:                   ptr.String("__Key__"),
		ObjectVersionId:       ptr.String("__ObjectVersionId__"),
		AnnotationPrefix:      ptr.String("__AnnotationPrefix__"),
		MaxAnnotationResults:  ptr.Int32(1),
		AnnotationCount:       ptr.Int32(1),
		ContinuationToken:     ptr.String("__ContinuationToken__"),
		NextContinuationToken: ptr.String("__NextContinuationToken__"),
		RequestCharged:        types.RequestCharged("requester"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListObjectAnnotations.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListObjectAnnotations(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListObjectAnnotations.response", err)
	}
}

func TestCheckResponseSnapshot_ListObjectVersions(t *testing.T) {
	want := &ListObjectVersionsOutput{
		IsTruncated:         ptr.Bool(true),
		KeyMarker:           ptr.String("__KeyMarker__"),
		VersionIdMarker:     ptr.String("__VersionIdMarker__"),
		NextKeyMarker:       ptr.String("__NextKeyMarker__"),
		NextVersionIdMarker: ptr.String("__NextVersionIdMarker__"),
		Versions: []types.ObjectVersion{
			{
				ETag: ptr.String("__ETag__"),
				ChecksumAlgorithm: []types.ChecksumAlgorithm{
					types.ChecksumAlgorithm("CRC32"),
					types.ChecksumAlgorithm("CRC32"),
				},
				ChecksumType: types.ChecksumType("COMPOSITE"),
				Size:         ptr.Int64(1),
				StorageClass: types.ObjectVersionStorageClass("STANDARD"),
				Key:          ptr.String("__Key__"),
				VersionId:    ptr.String("__VersionId__"),
				IsLatest:     ptr.Bool(true),
				LastModified: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Owner: &types.Owner{
					DisplayName: ptr.String("__DisplayName__"),
					ID:          ptr.String("__ID__"),
				},
				RestoreStatus: &types.RestoreStatus{
					IsRestoreInProgress: ptr.Bool(true),
					RestoreExpiryDate:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
			{
				ETag: ptr.String("__ETag__"),
				ChecksumAlgorithm: []types.ChecksumAlgorithm{
					types.ChecksumAlgorithm("CRC32"),
					types.ChecksumAlgorithm("CRC32"),
				},
				ChecksumType: types.ChecksumType("COMPOSITE"),
				Size:         ptr.Int64(1),
				StorageClass: types.ObjectVersionStorageClass("STANDARD"),
				Key:          ptr.String("__Key__"),
				VersionId:    ptr.String("__VersionId__"),
				IsLatest:     ptr.Bool(true),
				LastModified: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Owner: &types.Owner{
					DisplayName: ptr.String("__DisplayName__"),
					ID:          ptr.String("__ID__"),
				},
				RestoreStatus: &types.RestoreStatus{
					IsRestoreInProgress: ptr.Bool(true),
					RestoreExpiryDate:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
		},
		DeleteMarkers: []types.DeleteMarkerEntry{
			{
				Owner: &types.Owner{
					DisplayName: ptr.String("__DisplayName__"),
					ID:          ptr.String("__ID__"),
				},
				Key:          ptr.String("__Key__"),
				VersionId:    ptr.String("__VersionId__"),
				IsLatest:     ptr.Bool(true),
				LastModified: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				Owner: &types.Owner{
					DisplayName: ptr.String("__DisplayName__"),
					ID:          ptr.String("__ID__"),
				},
				Key:          ptr.String("__Key__"),
				VersionId:    ptr.String("__VersionId__"),
				IsLatest:     ptr.Bool(true),
				LastModified: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		Name:      ptr.String("__Name__"),
		Prefix:    ptr.String("__Prefix__"),
		Delimiter: ptr.String("__Delimiter__"),
		MaxKeys:   ptr.Int32(1),
		CommonPrefixes: []types.CommonPrefix{
			{
				Prefix: ptr.String("__Prefix__"),
			},
			{
				Prefix: ptr.String("__Prefix__"),
			},
		},
		EncodingType:   types.EncodingType("url"),
		RequestCharged: types.RequestCharged("requester"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListObjectVersions.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListObjectVersions(context.Background(), &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"),
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListObjectVersions.response", err)
	}
}

func TestCheckResponseSnapshot_ListObjects(t *testing.T) {
	want := &ListObjectsOutput{
		IsTruncated: ptr.Bool(true),
		Marker:      ptr.String("__Marker__"),
		NextMarker:  ptr.String("__NextMarker__"),
		Contents: []types.Object{
			{
				Key:          ptr.String("__Key__"),
				LastModified: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ETag:         ptr.String("__ETag__"),
				ChecksumAlgorithm: []types.ChecksumAlgorithm{
					types.ChecksumAlgorithm("CRC32"),
					types.ChecksumAlgorithm("CRC32"),
				},
				ChecksumType: types.ChecksumType("COMPOSITE"),
				Size:         ptr.Int64(1),
				StorageClass: types.ObjectStorageClass("STANDARD"),
				Owner: &types.Owner{
					DisplayName: ptr.String("__DisplayName__"),
					ID:          ptr.String("__ID__"),
				},
				RestoreStatus: &types.RestoreStatus{
					IsRestoreInProgress: ptr.Bool(true),
					RestoreExpiryDate:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
			{
				Key:          ptr.String("__Key__"),
				LastModified: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ETag:         ptr.String("__ETag__"),
				ChecksumAlgorithm: []types.ChecksumAlgorithm{
					types.ChecksumAlgorithm("CRC32"),
					types.ChecksumAlgorithm("CRC32"),
				},
				ChecksumType: types.ChecksumType("COMPOSITE"),
				Size:         ptr.Int64(1),
				StorageClass: types.ObjectStorageClass("STANDARD"),
				Owner: &types.Owner{
					DisplayName: ptr.String("__DisplayName__"),
					ID:          ptr.String("__ID__"),
				},
				RestoreStatus: &types.RestoreStatus{
					IsRestoreInProgress: ptr.Bool(true),
					RestoreExpiryDate:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
		},
		Name:      ptr.String("__Name__"),
		Prefix:    ptr.String("__Prefix__"),
		Delimiter: ptr.String("__Delimiter__"),
		MaxKeys:   ptr.Int32(1),
		CommonPrefixes: []types.CommonPrefix{
			{
				Prefix: ptr.String("__Prefix__"),
			},
			{
				Prefix: ptr.String("__Prefix__"),
			},
		},
		EncodingType:   types.EncodingType("url"),
		RequestCharged: types.RequestCharged("requester"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListObjects.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListObjects(context.Background(), &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"),
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListObjects.response", err)
	}
}

func TestCheckResponseSnapshot_ListObjectsV2(t *testing.T) {
	want := &ListObjectsV2Output{
		IsTruncated: ptr.Bool(true),
		Contents: []types.Object{
			{
				Key:          ptr.String("__Key__"),
				LastModified: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ETag:         ptr.String("__ETag__"),
				ChecksumAlgorithm: []types.ChecksumAlgorithm{
					types.ChecksumAlgorithm("CRC32"),
					types.ChecksumAlgorithm("CRC32"),
				},
				ChecksumType: types.ChecksumType("COMPOSITE"),
				Size:         ptr.Int64(1),
				StorageClass: types.ObjectStorageClass("STANDARD"),
				Owner: &types.Owner{
					DisplayName: ptr.String("__DisplayName__"),
					ID:          ptr.String("__ID__"),
				},
				RestoreStatus: &types.RestoreStatus{
					IsRestoreInProgress: ptr.Bool(true),
					RestoreExpiryDate:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
			{
				Key:          ptr.String("__Key__"),
				LastModified: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ETag:         ptr.String("__ETag__"),
				ChecksumAlgorithm: []types.ChecksumAlgorithm{
					types.ChecksumAlgorithm("CRC32"),
					types.ChecksumAlgorithm("CRC32"),
				},
				ChecksumType: types.ChecksumType("COMPOSITE"),
				Size:         ptr.Int64(1),
				StorageClass: types.ObjectStorageClass("STANDARD"),
				Owner: &types.Owner{
					DisplayName: ptr.String("__DisplayName__"),
					ID:          ptr.String("__ID__"),
				},
				RestoreStatus: &types.RestoreStatus{
					IsRestoreInProgress: ptr.Bool(true),
					RestoreExpiryDate:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
		},
		Name:      ptr.String("__Name__"),
		Prefix:    ptr.String("__Prefix__"),
		Delimiter: ptr.String("__Delimiter__"),
		MaxKeys:   ptr.Int32(1),
		CommonPrefixes: []types.CommonPrefix{
			{
				Prefix: ptr.String("__Prefix__"),
			},
			{
				Prefix: ptr.String("__Prefix__"),
			},
		},
		EncodingType:          types.EncodingType("url"),
		KeyCount:              ptr.Int32(1),
		ContinuationToken:     ptr.String("__ContinuationToken__"),
		NextContinuationToken: ptr.String("__NextContinuationToken__"),
		StartAfter:            ptr.String("__StartAfter__"),
		RequestCharged:        types.RequestCharged("requester"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListObjectsV2.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListObjectsV2(context.Background(), &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"),
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListObjectsV2.response", err)
	}
}

func TestCheckResponseSnapshot_ListParts(t *testing.T) {
	want := &ListPartsOutput{
		AbortDate:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		AbortRuleId:          ptr.String("__AbortRuleId__"),
		Bucket:               ptr.String("__Bucket__"),
		Key:                  ptr.String("__Key__"),
		UploadId:             ptr.String("__UploadId__"),
		PartNumberMarker:     ptr.String("__PartNumberMarker__"),
		NextPartNumberMarker: ptr.String("__NextPartNumberMarker__"),
		MaxParts:             ptr.Int32(1),
		IsTruncated:          ptr.Bool(true),
		Parts: []types.Part{
			{
				PartNumber:        ptr.Int32(1),
				LastModified:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ETag:              ptr.String("__ETag__"),
				Size:              ptr.Int64(1),
				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),
				LastModified:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ETag:              ptr.String("__ETag__"),
				Size:              ptr.Int64(1),
				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__"),
			},
		},
		Initiator: &types.Initiator{
			ID:          ptr.String("__ID__"),
			DisplayName: ptr.String("__DisplayName__"),
		},
		Owner: &types.Owner{
			DisplayName: ptr.String("__DisplayName__"),
			ID:          ptr.String("__ID__"),
		},
		StorageClass:      types.StorageClass("STANDARD"),
		RequestCharged:    types.RequestCharged("requester"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		ChecksumType:      types.ChecksumType("COMPOSITE"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListParts.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListParts(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListParts.response", err)
	}
}

func TestCheckResponseSnapshot_PutBucketAbac(t *testing.T) {
	want := &PutBucketAbacOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutBucketAbac.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutBucketAbac(context.Background(), &PutBucketAbacInput{
		Bucket:              ptr.String("__Bucket__"),
		ContentMD5:          ptr.String("__ContentMD5__"),
		ChecksumAlgorithm:   types.ChecksumAlgorithm("CRC32"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		AbacStatus: &types.AbacStatus{
			Status: types.BucketAbacStatus("Enabled"),
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutBucketAbac.response", err)
	}
}

func TestCheckResponseSnapshot_PutBucketAccelerateConfiguration(t *testing.T) {
	want := &PutBucketAccelerateConfigurationOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutBucketAccelerateConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutBucketAccelerateConfiguration(context.Background(), &PutBucketAccelerateConfigurationInput{
		Bucket: ptr.String("__Bucket__"),
		AccelerateConfiguration: &types.AccelerateConfiguration{
			Status: types.BucketAccelerateStatus("Enabled"),
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
		ChecksumAlgorithm:   types.ChecksumAlgorithm("CRC32"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutBucketAccelerateConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_PutBucketAcl(t *testing.T) {
	want := &PutBucketAclOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutBucketAcl.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutBucketAcl(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutBucketAcl.response", err)
	}
}

func TestCheckResponseSnapshot_PutBucketAnalyticsConfiguration(t *testing.T) {
	want := &PutBucketAnalyticsConfigurationOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutBucketAnalyticsConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutBucketAnalyticsConfiguration(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutBucketAnalyticsConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_PutBucketCors(t *testing.T) {
	want := &PutBucketCorsOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutBucketCors.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutBucketCors(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutBucketCors.response", err)
	}
}

func TestCheckResponseSnapshot_PutBucketEncryption(t *testing.T) {
	want := &PutBucketEncryptionOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutBucketEncryption.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutBucketEncryption(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutBucketEncryption.response", err)
	}
}

func TestCheckResponseSnapshot_PutBucketIntelligentTieringConfiguration(t *testing.T) {
	want := &PutBucketIntelligentTieringConfigurationOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutBucketIntelligentTieringConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutBucketIntelligentTieringConfiguration(context.Background(), &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"),
				},
			},
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutBucketIntelligentTieringConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_PutBucketInventoryConfiguration(t *testing.T) {
	want := &PutBucketInventoryConfigurationOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutBucketInventoryConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutBucketInventoryConfiguration(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutBucketInventoryConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_PutBucketLifecycleConfiguration(t *testing.T) {
	want := &PutBucketLifecycleConfigurationOutput{
		TransitionDefaultMinimumObjectSize: types.TransitionDefaultMinimumObjectSize("varies_by_storage_class"),
	}
	status, header, body, err := serdeRespReadSnapshot("PutBucketLifecycleConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutBucketLifecycleConfiguration(context.Background(), &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"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutBucketLifecycleConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_PutBucketLogging(t *testing.T) {
	want := &PutBucketLoggingOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutBucketLogging.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutBucketLogging(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutBucketLogging.response", err)
	}
}

func TestCheckResponseSnapshot_PutBucketMetricsConfiguration(t *testing.T) {
	want := &PutBucketMetricsConfigurationOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutBucketMetricsConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutBucketMetricsConfiguration(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutBucketMetricsConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_PutBucketNotificationConfiguration(t *testing.T) {
	want := &PutBucketNotificationConfigurationOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutBucketNotificationConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutBucketNotificationConfiguration(context.Background(), &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),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutBucketNotificationConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_PutBucketOwnershipControls(t *testing.T) {
	want := &PutBucketOwnershipControlsOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutBucketOwnershipControls.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutBucketOwnershipControls(context.Background(), &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"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutBucketOwnershipControls.response", err)
	}
}

func TestCheckResponseSnapshot_PutBucketPolicy(t *testing.T) {
	want := &PutBucketPolicyOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutBucketPolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutBucketPolicy(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutBucketPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_PutBucketReplication(t *testing.T) {
	want := &PutBucketReplicationOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutBucketReplication.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutBucketReplication(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutBucketReplication.response", err)
	}
}

func TestCheckResponseSnapshot_PutBucketRequestPayment(t *testing.T) {
	want := &PutBucketRequestPaymentOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutBucketRequestPayment.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutBucketRequestPayment(context.Background(), &PutBucketRequestPaymentInput{
		Bucket:            ptr.String("__Bucket__"),
		ContentMD5:        ptr.String("__ContentMD5__"),
		ChecksumAlgorithm: types.ChecksumAlgorithm("CRC32"),
		RequestPaymentConfiguration: &types.RequestPaymentConfiguration{
			Payer: types.Payer("Requester"),
		},
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutBucketRequestPayment.response", err)
	}
}

func TestCheckResponseSnapshot_PutBucketTagging(t *testing.T) {
	want := &PutBucketTaggingOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutBucketTagging.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutBucketTagging(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutBucketTagging.response", err)
	}
}

func TestCheckResponseSnapshot_PutBucketVersioning(t *testing.T) {
	want := &PutBucketVersioningOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutBucketVersioning.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutBucketVersioning(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutBucketVersioning.response", err)
	}
}

func TestCheckResponseSnapshot_PutBucketWebsite(t *testing.T) {
	want := &PutBucketWebsiteOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutBucketWebsite.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutBucketWebsite(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutBucketWebsite.response", err)
	}
}

func TestCheckResponseSnapshot_PutObject(t *testing.T) {
	want := &PutObjectOutput{
		Expiration:              ptr.String("__Expiration__"),
		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__"),
		ChecksumType:            types.ChecksumType("COMPOSITE"),
		ServerSideEncryption:    types.ServerSideEncryption("AES256"),
		VersionId:               ptr.String("__VersionId__"),
		SSECustomerAlgorithm:    ptr.String("__SSECustomerAlgorithm__"),
		SSECustomerKeyMD5:       ptr.String("__SSECustomerKeyMD5__"),
		SSEKMSKeyId:             ptr.String("__SSEKMSKeyId__"),
		SSEKMSEncryptionContext: ptr.String("__SSEKMSEncryptionContext__"),
		BucketKeyEnabled:        ptr.Bool(true),
		Size:                    ptr.Int64(1),
		RequestCharged:          types.RequestCharged("requester"),
	}
	status, header, body, err := serdeRespReadSnapshot("PutObject.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutObject(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutObject.response", err)
	}
}

func TestCheckResponseSnapshot_PutObjectAcl(t *testing.T) {
	want := &PutObjectAclOutput{
		RequestCharged: types.RequestCharged("requester"),
	}
	status, header, body, err := serdeRespReadSnapshot("PutObjectAcl.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutObjectAcl(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutObjectAcl.response", err)
	}
}

func TestCheckResponseSnapshot_PutObjectAnnotation(t *testing.T) {
	want := &PutObjectAnnotationOutput{
		Key:                  ptr.String("__Key__"),
		AnnotationName:       ptr.String("__AnnotationName__"),
		ObjectVersionId:      ptr.String("__ObjectVersionId__"),
		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__"),
		ChecksumType:         types.ChecksumType("COMPOSITE"),
		ServerSideEncryption: types.ServerSideEncryption("AES256"),
		RequestCharged:       types.RequestCharged("requester"),
	}
	status, header, body, err := serdeRespReadSnapshot("PutObjectAnnotation.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutObjectAnnotation(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutObjectAnnotation.response", err)
	}
}

func TestCheckResponseSnapshot_PutObjectLegalHold(t *testing.T) {
	want := &PutObjectLegalHoldOutput{
		RequestCharged: types.RequestCharged("requester"),
	}
	status, header, body, err := serdeRespReadSnapshot("PutObjectLegalHold.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutObjectLegalHold(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutObjectLegalHold.response", err)
	}
}

func TestCheckResponseSnapshot_PutObjectLockConfiguration(t *testing.T) {
	want := &PutObjectLockConfigurationOutput{
		RequestCharged: types.RequestCharged("requester"),
	}
	status, header, body, err := serdeRespReadSnapshot("PutObjectLockConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutObjectLockConfiguration(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutObjectLockConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_PutObjectRetention(t *testing.T) {
	want := &PutObjectRetentionOutput{
		RequestCharged: types.RequestCharged("requester"),
	}
	status, header, body, err := serdeRespReadSnapshot("PutObjectRetention.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutObjectRetention(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutObjectRetention.response", err)
	}
}

func TestCheckResponseSnapshot_PutObjectTagging(t *testing.T) {
	want := &PutObjectTaggingOutput{
		VersionId: ptr.String("__VersionId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PutObjectTagging.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutObjectTagging(context.Background(), &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"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutObjectTagging.response", err)
	}
}

func TestCheckResponseSnapshot_PutPublicAccessBlock(t *testing.T) {
	want := &PutPublicAccessBlockOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutPublicAccessBlock.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutPublicAccessBlock(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutPublicAccessBlock.response", err)
	}
}

func TestCheckResponseSnapshot_RenameObject(t *testing.T) {
	want := &RenameObjectOutput{}
	status, header, body, err := serdeRespReadSnapshot("RenameObject.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.RenameObject(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "RenameObject.response", err)
	}
}

func TestCheckResponseSnapshot_RestoreObject(t *testing.T) {
	want := &RestoreObjectOutput{
		RequestCharged:    types.RequestCharged("requester"),
		RestoreOutputPath: ptr.String("__RestoreOutputPath__"),
	}
	status, header, body, err := serdeRespReadSnapshot("RestoreObject.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.RestoreObject(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "RestoreObject.response", err)
	}
}

func TestCheckResponseSnapshot_SelectObjectContent(t *testing.T) {
	t.Skip("event stream operation")
}

func TestCheckResponseSnapshot_UpdateBucketMetadataAnnotationTableConfiguration(t *testing.T) {
	want := &UpdateBucketMetadataAnnotationTableConfigurationOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdateBucketMetadataAnnotationTableConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateBucketMetadataAnnotationTableConfiguration(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateBucketMetadataAnnotationTableConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateBucketMetadataInventoryTableConfiguration(t *testing.T) {
	want := &UpdateBucketMetadataInventoryTableConfigurationOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdateBucketMetadataInventoryTableConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateBucketMetadataInventoryTableConfiguration(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateBucketMetadataInventoryTableConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateBucketMetadataJournalTableConfiguration(t *testing.T) {
	want := &UpdateBucketMetadataJournalTableConfigurationOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdateBucketMetadataJournalTableConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateBucketMetadataJournalTableConfiguration(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateBucketMetadataJournalTableConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateObjectEncryption(t *testing.T) {
	want := &UpdateObjectEncryptionOutput{
		RequestCharged: types.RequestCharged("requester"),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateObjectEncryption.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateObjectEncryption(context.Background(), &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"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateObjectEncryption.response", err)
	}
}

func TestCheckResponseSnapshot_UploadPart(t *testing.T) {
	want := &UploadPartOutput{
		ServerSideEncryption: types.ServerSideEncryption("AES256"),
		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__"),
		SSECustomerAlgorithm: ptr.String("__SSECustomerAlgorithm__"),
		SSECustomerKeyMD5:    ptr.String("__SSECustomerKeyMD5__"),
		SSEKMSKeyId:          ptr.String("__SSEKMSKeyId__"),
		BucketKeyEnabled:     ptr.Bool(true),
		RequestCharged:       types.RequestCharged("requester"),
	}
	status, header, body, err := serdeRespReadSnapshot("UploadPart.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UploadPart(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UploadPart.response", err)
	}
}

func TestCheckResponseSnapshot_UploadPartCopy(t *testing.T) {
	want := &UploadPartCopyOutput{
		CopySourceVersionId: ptr.String("__CopySourceVersionId__"),
		CopyPartResult: &types.CopyPartResult{
			ETag:              ptr.String("__ETag__"),
			LastModified:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			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__"),
		},
		ServerSideEncryption: types.ServerSideEncryption("AES256"),
		SSECustomerAlgorithm: ptr.String("__SSECustomerAlgorithm__"),
		SSECustomerKeyMD5:    ptr.String("__SSECustomerKeyMD5__"),
		SSEKMSKeyId:          ptr.String("__SSEKMSKeyId__"),
		BucketKeyEnabled:     ptr.Bool(true),
		RequestCharged:       types.RequestCharged("requester"),
	}
	status, header, body, err := serdeRespReadSnapshot("UploadPartCopy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UploadPartCopy(context.Background(), &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__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UploadPartCopy.response", err)
	}
}

func TestCheckResponseSnapshot_WriteGetObjectResponse(t *testing.T) {
	want := &WriteGetObjectResponseOutput{}
	status, header, body, err := serdeRespReadSnapshot("WriteGetObjectResponse.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.WriteGetObjectResponse(context.Background(), &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),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "WriteGetObjectResponse.response", err)
	}
}

func TestCheckResponseSnapshot_Error_AccessDenied(t *testing.T) {
	want := &types.AccessDenied{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("AccessDenied.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.UpdateObjectEncryption(context.Background(), &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"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.AccessDenied
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.AccessDenied, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "AccessDenied.error", err)
	}
}

func TestCheckResponseSnapshot_Error_AnnotationLimitExceeded(t *testing.T) {
	want := &types.AnnotationLimitExceeded{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("AnnotationLimitExceeded.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.PutObjectAnnotation(context.Background(), &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__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.AnnotationLimitExceeded
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.AnnotationLimitExceeded, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "AnnotationLimitExceeded.error", err)
	}
}

func TestCheckResponseSnapshot_Error_AnnotationNameTooLong(t *testing.T) {
	want := &types.AnnotationNameTooLong{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("AnnotationNameTooLong.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.PutObjectAnnotation(context.Background(), &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__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.AnnotationNameTooLong
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.AnnotationNameTooLong, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "AnnotationNameTooLong.error", err)
	}
}

func TestCheckResponseSnapshot_Error_BucketAlreadyExists(t *testing.T) {
	want := &types.BucketAlreadyExists{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("BucketAlreadyExists.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.CreateBucket(context.Background(), &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"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.BucketAlreadyExists
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.BucketAlreadyExists, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "BucketAlreadyExists.error", err)
	}
}

func TestCheckResponseSnapshot_Error_BucketAlreadyOwnedByYou(t *testing.T) {
	want := &types.BucketAlreadyOwnedByYou{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("BucketAlreadyOwnedByYou.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.CreateBucket(context.Background(), &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"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.BucketAlreadyOwnedByYou
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.BucketAlreadyOwnedByYou, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "BucketAlreadyOwnedByYou.error", err)
	}
}

func TestCheckResponseSnapshot_Error_EncryptionTypeMismatch(t *testing.T) {
	want := &types.EncryptionTypeMismatch{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("EncryptionTypeMismatch.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.PutObject(context.Background(), &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__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.EncryptionTypeMismatch
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.EncryptionTypeMismatch, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "EncryptionTypeMismatch.error", err)
	}
}

func TestCheckResponseSnapshot_Error_IdempotencyParameterMismatch(t *testing.T) {
	want := &types.IdempotencyParameterMismatch{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("IdempotencyParameterMismatch.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.RenameObject(context.Background(), &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__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.IdempotencyParameterMismatch
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.IdempotencyParameterMismatch, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "IdempotencyParameterMismatch.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidAnnotationName(t *testing.T) {
	want := &types.InvalidAnnotationName{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidAnnotationName.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.PutObjectAnnotation(context.Background(), &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__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidAnnotationName
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidAnnotationName, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidAnnotationName.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidPrefix(t *testing.T) {
	want := &types.InvalidPrefix{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidPrefix.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.ListObjectAnnotations(context.Background(), &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__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidPrefix
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidPrefix, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidPrefix.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidRequest(t *testing.T) {
	want := &types.InvalidRequest{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidRequest.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.PutObject(context.Background(), &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__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidRequest
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidRequest, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidRequest.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidWriteOffset(t *testing.T) {
	want := &types.InvalidWriteOffset{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidWriteOffset.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.PutObject(context.Background(), &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__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidWriteOffset
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidWriteOffset, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidWriteOffset.error", err)
	}
}

func TestCheckResponseSnapshot_Error_NoSuchBucket(t *testing.T) {
	want := &types.NoSuchBucket{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("NoSuchBucket.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.CreateSession(context.Background(), &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),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.NoSuchBucket
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.NoSuchBucket, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "NoSuchBucket.error", err)
	}
}

func TestCheckResponseSnapshot_Error_NoSuchKey(t *testing.T) {
	want := &types.NoSuchKey{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("NoSuchKey.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.DeleteObjectAnnotation(context.Background(), &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__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.NoSuchKey
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.NoSuchKey, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "NoSuchKey.error", err)
	}
}

func TestCheckResponseSnapshot_Error_NoSuchUpload(t *testing.T) {
	want := &types.NoSuchUpload{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("NoSuchUpload.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.AbortMultipartUpload(context.Background(), &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)),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.NoSuchUpload
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.NoSuchUpload, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "NoSuchUpload.error", err)
	}
}

func TestCheckResponseSnapshot_Error_NotFound(t *testing.T) {
	want := &types.NotFound{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("NotFound.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.HeadBucket(context.Background(), &HeadBucketInput{
		Bucket:              ptr.String("__Bucket__"),
		ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.NotFound
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.NotFound, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "NotFound.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ObjectAlreadyInActiveTierError(t *testing.T) {
	want := &types.ObjectAlreadyInActiveTierError{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ObjectAlreadyInActiveTierError.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.RestoreObject(context.Background(), &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__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ObjectAlreadyInActiveTierError
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ObjectAlreadyInActiveTierError, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ObjectAlreadyInActiveTierError.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ObjectNotInActiveTierError(t *testing.T) {
	want := &types.ObjectNotInActiveTierError{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ObjectNotInActiveTierError.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.CopyObject(context.Background(), &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__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ObjectNotInActiveTierError
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ObjectNotInActiveTierError, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ObjectNotInActiveTierError.error", err)
	}
}

func TestCheckResponseSnapshot_Error_TooManyParts(t *testing.T) {
	want := &types.TooManyParts{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("TooManyParts.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.PutObject(context.Background(), &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__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.TooManyParts
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.TooManyParts, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "TooManyParts.error", err)
	}
}

func TestCheckResponseSnapshot_Error_UnsupportedMediaType(t *testing.T) {
	want := &types.UnsupportedMediaType{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UnsupportedMediaType.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.PutObjectAnnotation(context.Background(), &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__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.UnsupportedMediaType
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.UnsupportedMediaType, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "UnsupportedMediaType.error", err)
	}
}