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

//go:build response_snapshot

package codecommit

import (
	"bufio"
	"bytes"
	"context"
	"errors"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/codecommit/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_AssociateApprovalRuleTemplateWithRepository(t *testing.T) {
	want := &AssociateApprovalRuleTemplateWithRepositoryOutput{}
	status, header, body, err := serdeRespReadSnapshot("AssociateApprovalRuleTemplateWithRepository.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.AssociateApprovalRuleTemplateWithRepository(context.Background(), &AssociateApprovalRuleTemplateWithRepositoryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "AssociateApprovalRuleTemplateWithRepository.response", err)
	}
}

func TestCheckResponseSnapshot_BatchAssociateApprovalRuleTemplateWithRepositories(t *testing.T) {
	want := &BatchAssociateApprovalRuleTemplateWithRepositoriesOutput{
		AssociatedRepositoryNames: []string{
			"__Member__",
			"__Member__",
		},
		Errors: []types.BatchAssociateApprovalRuleTemplateWithRepositoriesError{
			{
				RepositoryName: ptr.String("__RepositoryName__"),
				ErrorCode:      ptr.String("__ErrorCode__"),
				ErrorMessage:   ptr.String("__ErrorMessage__"),
			},
			{
				RepositoryName: ptr.String("__RepositoryName__"),
				ErrorCode:      ptr.String("__ErrorCode__"),
				ErrorMessage:   ptr.String("__ErrorMessage__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("BatchAssociateApprovalRuleTemplateWithRepositories.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.BatchAssociateApprovalRuleTemplateWithRepositories(context.Background(), &BatchAssociateApprovalRuleTemplateWithRepositoriesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "BatchAssociateApprovalRuleTemplateWithRepositories.response", err)
	}
}

func TestCheckResponseSnapshot_BatchDescribeMergeConflicts(t *testing.T) {
	want := &BatchDescribeMergeConflictsOutput{
		Conflicts: []types.Conflict{
			{
				ConflictMetadata: &types.ConflictMetadata{
					FilePath: ptr.String("__FilePath__"),
					FileSizes: &types.FileSizes{
						Source:      1,
						Destination: 1,
						Base:        1,
					},
					FileModes: &types.FileModes{
						Source:      types.FileModeTypeEnum("EXECUTABLE"),
						Destination: types.FileModeTypeEnum("EXECUTABLE"),
						Base:        types.FileModeTypeEnum("EXECUTABLE"),
					},
					ObjectTypes: &types.ObjectTypes{
						Source:      types.ObjectTypeEnum("FILE"),
						Destination: types.ObjectTypeEnum("FILE"),
						Base:        types.ObjectTypeEnum("FILE"),
					},
					NumberOfConflicts: 1,
					IsBinaryFile: &types.IsBinaryFile{
						Source:      ptr.Bool(true),
						Destination: ptr.Bool(true),
						Base:        ptr.Bool(true),
					},
					ContentConflict:    true,
					FileModeConflict:   true,
					ObjectTypeConflict: true,
					MergeOperations: &types.MergeOperations{
						Source:      types.ChangeTypeEnum("A"),
						Destination: types.ChangeTypeEnum("A"),
					},
				},
				MergeHunks: []types.MergeHunk{
					{
						IsConflict: true,
						Source: &types.MergeHunkDetail{
							StartLine:   ptr.Int32(1),
							EndLine:     ptr.Int32(1),
							HunkContent: ptr.String("__HunkContent__"),
						},
						Destination: &types.MergeHunkDetail{
							StartLine:   ptr.Int32(1),
							EndLine:     ptr.Int32(1),
							HunkContent: ptr.String("__HunkContent__"),
						},
						Base: &types.MergeHunkDetail{
							StartLine:   ptr.Int32(1),
							EndLine:     ptr.Int32(1),
							HunkContent: ptr.String("__HunkContent__"),
						},
					},
					{
						IsConflict: true,
						Source: &types.MergeHunkDetail{
							StartLine:   ptr.Int32(1),
							EndLine:     ptr.Int32(1),
							HunkContent: ptr.String("__HunkContent__"),
						},
						Destination: &types.MergeHunkDetail{
							StartLine:   ptr.Int32(1),
							EndLine:     ptr.Int32(1),
							HunkContent: ptr.String("__HunkContent__"),
						},
						Base: &types.MergeHunkDetail{
							StartLine:   ptr.Int32(1),
							EndLine:     ptr.Int32(1),
							HunkContent: ptr.String("__HunkContent__"),
						},
					},
				},
			},
			{
				ConflictMetadata: &types.ConflictMetadata{
					FilePath: ptr.String("__FilePath__"),
					FileSizes: &types.FileSizes{
						Source:      1,
						Destination: 1,
						Base:        1,
					},
					FileModes: &types.FileModes{
						Source:      types.FileModeTypeEnum("EXECUTABLE"),
						Destination: types.FileModeTypeEnum("EXECUTABLE"),
						Base:        types.FileModeTypeEnum("EXECUTABLE"),
					},
					ObjectTypes: &types.ObjectTypes{
						Source:      types.ObjectTypeEnum("FILE"),
						Destination: types.ObjectTypeEnum("FILE"),
						Base:        types.ObjectTypeEnum("FILE"),
					},
					NumberOfConflicts: 1,
					IsBinaryFile: &types.IsBinaryFile{
						Source:      ptr.Bool(true),
						Destination: ptr.Bool(true),
						Base:        ptr.Bool(true),
					},
					ContentConflict:    true,
					FileModeConflict:   true,
					ObjectTypeConflict: true,
					MergeOperations: &types.MergeOperations{
						Source:      types.ChangeTypeEnum("A"),
						Destination: types.ChangeTypeEnum("A"),
					},
				},
				MergeHunks: []types.MergeHunk{
					{
						IsConflict: true,
						Source: &types.MergeHunkDetail{
							StartLine:   ptr.Int32(1),
							EndLine:     ptr.Int32(1),
							HunkContent: ptr.String("__HunkContent__"),
						},
						Destination: &types.MergeHunkDetail{
							StartLine:   ptr.Int32(1),
							EndLine:     ptr.Int32(1),
							HunkContent: ptr.String("__HunkContent__"),
						},
						Base: &types.MergeHunkDetail{
							StartLine:   ptr.Int32(1),
							EndLine:     ptr.Int32(1),
							HunkContent: ptr.String("__HunkContent__"),
						},
					},
					{
						IsConflict: true,
						Source: &types.MergeHunkDetail{
							StartLine:   ptr.Int32(1),
							EndLine:     ptr.Int32(1),
							HunkContent: ptr.String("__HunkContent__"),
						},
						Destination: &types.MergeHunkDetail{
							StartLine:   ptr.Int32(1),
							EndLine:     ptr.Int32(1),
							HunkContent: ptr.String("__HunkContent__"),
						},
						Base: &types.MergeHunkDetail{
							StartLine:   ptr.Int32(1),
							EndLine:     ptr.Int32(1),
							HunkContent: ptr.String("__HunkContent__"),
						},
					},
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
		Errors: []types.BatchDescribeMergeConflictsError{
			{
				FilePath:      ptr.String("__FilePath__"),
				ExceptionName: ptr.String("__ExceptionName__"),
				Message:       ptr.String("__Message__"),
			},
			{
				FilePath:      ptr.String("__FilePath__"),
				ExceptionName: ptr.String("__ExceptionName__"),
				Message:       ptr.String("__Message__"),
			},
		},
		DestinationCommitId: ptr.String("__DestinationCommitId__"),
		SourceCommitId:      ptr.String("__SourceCommitId__"),
		BaseCommitId:        ptr.String("__BaseCommitId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("BatchDescribeMergeConflicts.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.BatchDescribeMergeConflicts(context.Background(), &BatchDescribeMergeConflictsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "BatchDescribeMergeConflicts.response", err)
	}
}

func TestCheckResponseSnapshot_BatchDisassociateApprovalRuleTemplateFromRepositories(t *testing.T) {
	want := &BatchDisassociateApprovalRuleTemplateFromRepositoriesOutput{
		DisassociatedRepositoryNames: []string{
			"__Member__",
			"__Member__",
		},
		Errors: []types.BatchDisassociateApprovalRuleTemplateFromRepositoriesError{
			{
				RepositoryName: ptr.String("__RepositoryName__"),
				ErrorCode:      ptr.String("__ErrorCode__"),
				ErrorMessage:   ptr.String("__ErrorMessage__"),
			},
			{
				RepositoryName: ptr.String("__RepositoryName__"),
				ErrorCode:      ptr.String("__ErrorCode__"),
				ErrorMessage:   ptr.String("__ErrorMessage__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("BatchDisassociateApprovalRuleTemplateFromRepositories.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.BatchDisassociateApprovalRuleTemplateFromRepositories(context.Background(), &BatchDisassociateApprovalRuleTemplateFromRepositoriesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "BatchDisassociateApprovalRuleTemplateFromRepositories.response", err)
	}
}

func TestCheckResponseSnapshot_BatchGetCommits(t *testing.T) {
	want := &BatchGetCommitsOutput{
		Commits: []types.Commit{
			{
				CommitId: ptr.String("__CommitId__"),
				TreeId:   ptr.String("__TreeId__"),
				Parents: []string{
					"__Member__",
					"__Member__",
				},
				Message: ptr.String("__Message__"),
				Author: &types.UserInfo{
					Name:  ptr.String("__Name__"),
					Email: ptr.String("__Email__"),
					Date:  ptr.String("__Date__"),
				},
				Committer: &types.UserInfo{
					Name:  ptr.String("__Name__"),
					Email: ptr.String("__Email__"),
					Date:  ptr.String("__Date__"),
				},
				AdditionalData: ptr.String("__AdditionalData__"),
			},
			{
				CommitId: ptr.String("__CommitId__"),
				TreeId:   ptr.String("__TreeId__"),
				Parents: []string{
					"__Member__",
					"__Member__",
				},
				Message: ptr.String("__Message__"),
				Author: &types.UserInfo{
					Name:  ptr.String("__Name__"),
					Email: ptr.String("__Email__"),
					Date:  ptr.String("__Date__"),
				},
				Committer: &types.UserInfo{
					Name:  ptr.String("__Name__"),
					Email: ptr.String("__Email__"),
					Date:  ptr.String("__Date__"),
				},
				AdditionalData: ptr.String("__AdditionalData__"),
			},
		},
		Errors: []types.BatchGetCommitsError{
			{
				CommitId:     ptr.String("__CommitId__"),
				ErrorCode:    ptr.String("__ErrorCode__"),
				ErrorMessage: ptr.String("__ErrorMessage__"),
			},
			{
				CommitId:     ptr.String("__CommitId__"),
				ErrorCode:    ptr.String("__ErrorCode__"),
				ErrorMessage: ptr.String("__ErrorMessage__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("BatchGetCommits.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.BatchGetCommits(context.Background(), &BatchGetCommitsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "BatchGetCommits.response", err)
	}
}

func TestCheckResponseSnapshot_BatchGetRepositories(t *testing.T) {
	want := &BatchGetRepositoriesOutput{
		Repositories: []types.RepositoryMetadata{
			{
				AccountId:             ptr.String("__AccountId__"),
				RepositoryId:          ptr.String("__RepositoryId__"),
				RepositoryName:        ptr.String("__RepositoryName__"),
				RepositoryDescription: ptr.String("__RepositoryDescription__"),
				DefaultBranch:         ptr.String("__DefaultBranch__"),
				LastModifiedDate:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CreationDate:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CloneUrlHttp:          ptr.String("__CloneUrlHttp__"),
				CloneUrlSsh:           ptr.String("__CloneUrlSsh__"),
				Arn:                   ptr.String("__Arn__"),
				KmsKeyId:              ptr.String("__KmsKeyId__"),
			},
			{
				AccountId:             ptr.String("__AccountId__"),
				RepositoryId:          ptr.String("__RepositoryId__"),
				RepositoryName:        ptr.String("__RepositoryName__"),
				RepositoryDescription: ptr.String("__RepositoryDescription__"),
				DefaultBranch:         ptr.String("__DefaultBranch__"),
				LastModifiedDate:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CreationDate:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CloneUrlHttp:          ptr.String("__CloneUrlHttp__"),
				CloneUrlSsh:           ptr.String("__CloneUrlSsh__"),
				Arn:                   ptr.String("__Arn__"),
				KmsKeyId:              ptr.String("__KmsKeyId__"),
			},
		},
		RepositoriesNotFound: []string{
			"__Member__",
			"__Member__",
		},
		Errors: []types.BatchGetRepositoriesError{
			{
				RepositoryId:   ptr.String("__RepositoryId__"),
				RepositoryName: ptr.String("__RepositoryName__"),
				ErrorCode:      types.BatchGetRepositoriesErrorCodeEnum("EncryptionIntegrityChecksFailedException"),
				ErrorMessage:   ptr.String("__ErrorMessage__"),
			},
			{
				RepositoryId:   ptr.String("__RepositoryId__"),
				RepositoryName: ptr.String("__RepositoryName__"),
				ErrorCode:      types.BatchGetRepositoriesErrorCodeEnum("EncryptionIntegrityChecksFailedException"),
				ErrorMessage:   ptr.String("__ErrorMessage__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("BatchGetRepositories.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.BatchGetRepositories(context.Background(), &BatchGetRepositoriesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "BatchGetRepositories.response", err)
	}
}

func TestCheckResponseSnapshot_CreateApprovalRuleTemplate(t *testing.T) {
	want := &CreateApprovalRuleTemplateOutput{
		ApprovalRuleTemplate: &types.ApprovalRuleTemplate{
			ApprovalRuleTemplateId:          ptr.String("__ApprovalRuleTemplateId__"),
			ApprovalRuleTemplateName:        ptr.String("__ApprovalRuleTemplateName__"),
			ApprovalRuleTemplateDescription: ptr.String("__ApprovalRuleTemplateDescription__"),
			ApprovalRuleTemplateContent:     ptr.String("__ApprovalRuleTemplateContent__"),
			RuleContentSha256:               ptr.String("__RuleContentSha256__"),
			LastModifiedDate:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CreationDate:                    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LastModifiedUser:                ptr.String("__LastModifiedUser__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateApprovalRuleTemplate.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.CreateApprovalRuleTemplate(context.Background(), &CreateApprovalRuleTemplateInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateApprovalRuleTemplate.response", err)
	}
}

func TestCheckResponseSnapshot_CreateBranch(t *testing.T) {
	want := &CreateBranchOutput{}
	status, header, body, err := serdeRespReadSnapshot("CreateBranch.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.CreateBranch(context.Background(), &CreateBranchInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateBranch.response", err)
	}
}

func TestCheckResponseSnapshot_CreateCommit(t *testing.T) {
	want := &CreateCommitOutput{
		CommitId: ptr.String("__CommitId__"),
		TreeId:   ptr.String("__TreeId__"),
		FilesAdded: []types.FileMetadata{
			{
				AbsolutePath: ptr.String("__AbsolutePath__"),
				BlobId:       ptr.String("__BlobId__"),
				FileMode:     types.FileModeTypeEnum("EXECUTABLE"),
			},
			{
				AbsolutePath: ptr.String("__AbsolutePath__"),
				BlobId:       ptr.String("__BlobId__"),
				FileMode:     types.FileModeTypeEnum("EXECUTABLE"),
			},
		},
		FilesUpdated: []types.FileMetadata{
			{
				AbsolutePath: ptr.String("__AbsolutePath__"),
				BlobId:       ptr.String("__BlobId__"),
				FileMode:     types.FileModeTypeEnum("EXECUTABLE"),
			},
			{
				AbsolutePath: ptr.String("__AbsolutePath__"),
				BlobId:       ptr.String("__BlobId__"),
				FileMode:     types.FileModeTypeEnum("EXECUTABLE"),
			},
		},
		FilesDeleted: []types.FileMetadata{
			{
				AbsolutePath: ptr.String("__AbsolutePath__"),
				BlobId:       ptr.String("__BlobId__"),
				FileMode:     types.FileModeTypeEnum("EXECUTABLE"),
			},
			{
				AbsolutePath: ptr.String("__AbsolutePath__"),
				BlobId:       ptr.String("__BlobId__"),
				FileMode:     types.FileModeTypeEnum("EXECUTABLE"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateCommit.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateCommit.response", err)
	}
}

func TestCheckResponseSnapshot_CreatePullRequest(t *testing.T) {
	want := &CreatePullRequestOutput{
		PullRequest: &types.PullRequest{
			PullRequestId:     ptr.String("__PullRequestId__"),
			Title:             ptr.String("__Title__"),
			Description:       ptr.String("__Description__"),
			LastActivityDate:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CreationDate:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			PullRequestStatus: types.PullRequestStatusEnum("OPEN"),
			AuthorArn:         ptr.String("__AuthorArn__"),
			PullRequestTargets: []types.PullRequestTarget{
				{
					RepositoryName:       ptr.String("__RepositoryName__"),
					SourceReference:      ptr.String("__SourceReference__"),
					DestinationReference: ptr.String("__DestinationReference__"),
					DestinationCommit:    ptr.String("__DestinationCommit__"),
					SourceCommit:         ptr.String("__SourceCommit__"),
					MergeBase:            ptr.String("__MergeBase__"),
					MergeMetadata: &types.MergeMetadata{
						IsMerged:      true,
						MergedBy:      ptr.String("__MergedBy__"),
						MergeCommitId: ptr.String("__MergeCommitId__"),
						MergeOption:   types.MergeOptionTypeEnum("FAST_FORWARD_MERGE"),
					},
				},
				{
					RepositoryName:       ptr.String("__RepositoryName__"),
					SourceReference:      ptr.String("__SourceReference__"),
					DestinationReference: ptr.String("__DestinationReference__"),
					DestinationCommit:    ptr.String("__DestinationCommit__"),
					SourceCommit:         ptr.String("__SourceCommit__"),
					MergeBase:            ptr.String("__MergeBase__"),
					MergeMetadata: &types.MergeMetadata{
						IsMerged:      true,
						MergedBy:      ptr.String("__MergedBy__"),
						MergeCommitId: ptr.String("__MergeCommitId__"),
						MergeOption:   types.MergeOptionTypeEnum("FAST_FORWARD_MERGE"),
					},
				},
			},
			ClientRequestToken: ptr.String("__ClientRequestToken__"),
			RevisionId:         ptr.String("__RevisionId__"),
			ApprovalRules: []types.ApprovalRule{
				{
					ApprovalRuleId:      ptr.String("__ApprovalRuleId__"),
					ApprovalRuleName:    ptr.String("__ApprovalRuleName__"),
					ApprovalRuleContent: ptr.String("__ApprovalRuleContent__"),
					RuleContentSha256:   ptr.String("__RuleContentSha256__"),
					LastModifiedDate:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					CreationDate:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					LastModifiedUser:    ptr.String("__LastModifiedUser__"),
					OriginApprovalRuleTemplate: &types.OriginApprovalRuleTemplate{
						ApprovalRuleTemplateId:   ptr.String("__ApprovalRuleTemplateId__"),
						ApprovalRuleTemplateName: ptr.String("__ApprovalRuleTemplateName__"),
					},
				},
				{
					ApprovalRuleId:      ptr.String("__ApprovalRuleId__"),
					ApprovalRuleName:    ptr.String("__ApprovalRuleName__"),
					ApprovalRuleContent: ptr.String("__ApprovalRuleContent__"),
					RuleContentSha256:   ptr.String("__RuleContentSha256__"),
					LastModifiedDate:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					CreationDate:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					LastModifiedUser:    ptr.String("__LastModifiedUser__"),
					OriginApprovalRuleTemplate: &types.OriginApprovalRuleTemplate{
						ApprovalRuleTemplateId:   ptr.String("__ApprovalRuleTemplateId__"),
						ApprovalRuleTemplateName: ptr.String("__ApprovalRuleTemplateName__"),
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreatePullRequest.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.CreatePullRequest(context.Background(), &CreatePullRequestInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreatePullRequest.response", err)
	}
}

func TestCheckResponseSnapshot_CreatePullRequestApprovalRule(t *testing.T) {
	want := &CreatePullRequestApprovalRuleOutput{
		ApprovalRule: &types.ApprovalRule{
			ApprovalRuleId:      ptr.String("__ApprovalRuleId__"),
			ApprovalRuleName:    ptr.String("__ApprovalRuleName__"),
			ApprovalRuleContent: ptr.String("__ApprovalRuleContent__"),
			RuleContentSha256:   ptr.String("__RuleContentSha256__"),
			LastModifiedDate:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CreationDate:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LastModifiedUser:    ptr.String("__LastModifiedUser__"),
			OriginApprovalRuleTemplate: &types.OriginApprovalRuleTemplate{
				ApprovalRuleTemplateId:   ptr.String("__ApprovalRuleTemplateId__"),
				ApprovalRuleTemplateName: ptr.String("__ApprovalRuleTemplateName__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreatePullRequestApprovalRule.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.CreatePullRequestApprovalRule(context.Background(), &CreatePullRequestApprovalRuleInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreatePullRequestApprovalRule.response", err)
	}
}

func TestCheckResponseSnapshot_CreateRepository(t *testing.T) {
	want := &CreateRepositoryOutput{
		RepositoryMetadata: &types.RepositoryMetadata{
			AccountId:             ptr.String("__AccountId__"),
			RepositoryId:          ptr.String("__RepositoryId__"),
			RepositoryName:        ptr.String("__RepositoryName__"),
			RepositoryDescription: ptr.String("__RepositoryDescription__"),
			DefaultBranch:         ptr.String("__DefaultBranch__"),
			LastModifiedDate:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CreationDate:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CloneUrlHttp:          ptr.String("__CloneUrlHttp__"),
			CloneUrlSsh:           ptr.String("__CloneUrlSsh__"),
			Arn:                   ptr.String("__Arn__"),
			KmsKeyId:              ptr.String("__KmsKeyId__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateRepository.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.CreateRepository(context.Background(), &CreateRepositoryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateRepository.response", err)
	}
}

func TestCheckResponseSnapshot_CreateUnreferencedMergeCommit(t *testing.T) {
	want := &CreateUnreferencedMergeCommitOutput{
		CommitId: ptr.String("__CommitId__"),
		TreeId:   ptr.String("__TreeId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateUnreferencedMergeCommit.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.CreateUnreferencedMergeCommit(context.Background(), &CreateUnreferencedMergeCommitInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateUnreferencedMergeCommit.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteApprovalRuleTemplate(t *testing.T) {
	want := &DeleteApprovalRuleTemplateOutput{
		ApprovalRuleTemplateId: ptr.String("__ApprovalRuleTemplateId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DeleteApprovalRuleTemplate.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.DeleteApprovalRuleTemplate(context.Background(), &DeleteApprovalRuleTemplateInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteApprovalRuleTemplate.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteBranch(t *testing.T) {
	want := &DeleteBranchOutput{
		DeletedBranch: &types.BranchInfo{
			BranchName: ptr.String("__BranchName__"),
			CommitId:   ptr.String("__CommitId__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DeleteBranch.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.DeleteBranch(context.Background(), &DeleteBranchInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteBranch.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteCommentContent(t *testing.T) {
	want := &DeleteCommentContentOutput{
		Comment: &types.Comment{
			CommentId:          ptr.String("__CommentId__"),
			Content:            ptr.String("__Content__"),
			InReplyTo:          ptr.String("__InReplyTo__"),
			CreationDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LastModifiedDate:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			AuthorArn:          ptr.String("__AuthorArn__"),
			Deleted:            true,
			ClientRequestToken: ptr.String("__ClientRequestToken__"),
			CallerReactions: []string{
				"__Member__",
				"__Member__",
			},
			ReactionCounts: map[string]int32{
				"key0": 1,
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DeleteCommentContent.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.DeleteCommentContent(context.Background(), &DeleteCommentContentInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteCommentContent.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteFile(t *testing.T) {
	want := &DeleteFileOutput{
		CommitId: ptr.String("__CommitId__"),
		BlobId:   ptr.String("__BlobId__"),
		TreeId:   ptr.String("__TreeId__"),
		FilePath: ptr.String("__FilePath__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DeleteFile.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.DeleteFile(context.Background(), &DeleteFileInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteFile.response", err)
	}
}

func TestCheckResponseSnapshot_DeletePullRequestApprovalRule(t *testing.T) {
	want := &DeletePullRequestApprovalRuleOutput{
		ApprovalRuleId: ptr.String("__ApprovalRuleId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DeletePullRequestApprovalRule.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.DeletePullRequestApprovalRule(context.Background(), &DeletePullRequestApprovalRuleInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeletePullRequestApprovalRule.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteRepository(t *testing.T) {
	want := &DeleteRepositoryOutput{
		RepositoryId: ptr.String("__RepositoryId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DeleteRepository.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.DeleteRepository(context.Background(), &DeleteRepositoryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteRepository.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeMergeConflicts(t *testing.T) {
	want := &DescribeMergeConflictsOutput{
		ConflictMetadata: &types.ConflictMetadata{
			FilePath: ptr.String("__FilePath__"),
			FileSizes: &types.FileSizes{
				Source:      1,
				Destination: 1,
				Base:        1,
			},
			FileModes: &types.FileModes{
				Source:      types.FileModeTypeEnum("EXECUTABLE"),
				Destination: types.FileModeTypeEnum("EXECUTABLE"),
				Base:        types.FileModeTypeEnum("EXECUTABLE"),
			},
			ObjectTypes: &types.ObjectTypes{
				Source:      types.ObjectTypeEnum("FILE"),
				Destination: types.ObjectTypeEnum("FILE"),
				Base:        types.ObjectTypeEnum("FILE"),
			},
			NumberOfConflicts: 1,
			IsBinaryFile: &types.IsBinaryFile{
				Source:      ptr.Bool(true),
				Destination: ptr.Bool(true),
				Base:        ptr.Bool(true),
			},
			ContentConflict:    true,
			FileModeConflict:   true,
			ObjectTypeConflict: true,
			MergeOperations: &types.MergeOperations{
				Source:      types.ChangeTypeEnum("A"),
				Destination: types.ChangeTypeEnum("A"),
			},
		},
		MergeHunks: []types.MergeHunk{
			{
				IsConflict: true,
				Source: &types.MergeHunkDetail{
					StartLine:   ptr.Int32(1),
					EndLine:     ptr.Int32(1),
					HunkContent: ptr.String("__HunkContent__"),
				},
				Destination: &types.MergeHunkDetail{
					StartLine:   ptr.Int32(1),
					EndLine:     ptr.Int32(1),
					HunkContent: ptr.String("__HunkContent__"),
				},
				Base: &types.MergeHunkDetail{
					StartLine:   ptr.Int32(1),
					EndLine:     ptr.Int32(1),
					HunkContent: ptr.String("__HunkContent__"),
				},
			},
			{
				IsConflict: true,
				Source: &types.MergeHunkDetail{
					StartLine:   ptr.Int32(1),
					EndLine:     ptr.Int32(1),
					HunkContent: ptr.String("__HunkContent__"),
				},
				Destination: &types.MergeHunkDetail{
					StartLine:   ptr.Int32(1),
					EndLine:     ptr.Int32(1),
					HunkContent: ptr.String("__HunkContent__"),
				},
				Base: &types.MergeHunkDetail{
					StartLine:   ptr.Int32(1),
					EndLine:     ptr.Int32(1),
					HunkContent: ptr.String("__HunkContent__"),
				},
			},
		},
		NextToken:           ptr.String("__NextToken__"),
		DestinationCommitId: ptr.String("__DestinationCommitId__"),
		SourceCommitId:      ptr.String("__SourceCommitId__"),
		BaseCommitId:        ptr.String("__BaseCommitId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeMergeConflicts.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.DescribeMergeConflicts(context.Background(), &DescribeMergeConflictsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeMergeConflicts.response", err)
	}
}

func TestCheckResponseSnapshot_DescribePullRequestEvents(t *testing.T) {
	want := &DescribePullRequestEventsOutput{
		PullRequestEvents: []types.PullRequestEvent{
			{
				PullRequestId:        ptr.String("__PullRequestId__"),
				EventDate:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PullRequestEventType: types.PullRequestEventType("PULL_REQUEST_CREATED"),
				ActorArn:             ptr.String("__ActorArn__"),
				PullRequestCreatedEventMetadata: &types.PullRequestCreatedEventMetadata{
					RepositoryName:      ptr.String("__RepositoryName__"),
					SourceCommitId:      ptr.String("__SourceCommitId__"),
					DestinationCommitId: ptr.String("__DestinationCommitId__"),
					MergeBase:           ptr.String("__MergeBase__"),
				},
				PullRequestStatusChangedEventMetadata: &types.PullRequestStatusChangedEventMetadata{
					PullRequestStatus: types.PullRequestStatusEnum("OPEN"),
				},
				PullRequestSourceReferenceUpdatedEventMetadata: &types.PullRequestSourceReferenceUpdatedEventMetadata{
					RepositoryName: ptr.String("__RepositoryName__"),
					BeforeCommitId: ptr.String("__BeforeCommitId__"),
					AfterCommitId:  ptr.String("__AfterCommitId__"),
					MergeBase:      ptr.String("__MergeBase__"),
				},
				PullRequestMergedStateChangedEventMetadata: &types.PullRequestMergedStateChangedEventMetadata{
					RepositoryName:       ptr.String("__RepositoryName__"),
					DestinationReference: ptr.String("__DestinationReference__"),
					MergeMetadata: &types.MergeMetadata{
						IsMerged:      true,
						MergedBy:      ptr.String("__MergedBy__"),
						MergeCommitId: ptr.String("__MergeCommitId__"),
						MergeOption:   types.MergeOptionTypeEnum("FAST_FORWARD_MERGE"),
					},
				},
				ApprovalRuleEventMetadata: &types.ApprovalRuleEventMetadata{
					ApprovalRuleName:    ptr.String("__ApprovalRuleName__"),
					ApprovalRuleId:      ptr.String("__ApprovalRuleId__"),
					ApprovalRuleContent: ptr.String("__ApprovalRuleContent__"),
				},
				ApprovalStateChangedEventMetadata: &types.ApprovalStateChangedEventMetadata{
					RevisionId:     ptr.String("__RevisionId__"),
					ApprovalStatus: types.ApprovalState("APPROVE"),
				},
				ApprovalRuleOverriddenEventMetadata: &types.ApprovalRuleOverriddenEventMetadata{
					RevisionId:     ptr.String("__RevisionId__"),
					OverrideStatus: types.OverrideStatus("OVERRIDE"),
				},
			},
			{
				PullRequestId:        ptr.String("__PullRequestId__"),
				EventDate:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PullRequestEventType: types.PullRequestEventType("PULL_REQUEST_CREATED"),
				ActorArn:             ptr.String("__ActorArn__"),
				PullRequestCreatedEventMetadata: &types.PullRequestCreatedEventMetadata{
					RepositoryName:      ptr.String("__RepositoryName__"),
					SourceCommitId:      ptr.String("__SourceCommitId__"),
					DestinationCommitId: ptr.String("__DestinationCommitId__"),
					MergeBase:           ptr.String("__MergeBase__"),
				},
				PullRequestStatusChangedEventMetadata: &types.PullRequestStatusChangedEventMetadata{
					PullRequestStatus: types.PullRequestStatusEnum("OPEN"),
				},
				PullRequestSourceReferenceUpdatedEventMetadata: &types.PullRequestSourceReferenceUpdatedEventMetadata{
					RepositoryName: ptr.String("__RepositoryName__"),
					BeforeCommitId: ptr.String("__BeforeCommitId__"),
					AfterCommitId:  ptr.String("__AfterCommitId__"),
					MergeBase:      ptr.String("__MergeBase__"),
				},
				PullRequestMergedStateChangedEventMetadata: &types.PullRequestMergedStateChangedEventMetadata{
					RepositoryName:       ptr.String("__RepositoryName__"),
					DestinationReference: ptr.String("__DestinationReference__"),
					MergeMetadata: &types.MergeMetadata{
						IsMerged:      true,
						MergedBy:      ptr.String("__MergedBy__"),
						MergeCommitId: ptr.String("__MergeCommitId__"),
						MergeOption:   types.MergeOptionTypeEnum("FAST_FORWARD_MERGE"),
					},
				},
				ApprovalRuleEventMetadata: &types.ApprovalRuleEventMetadata{
					ApprovalRuleName:    ptr.String("__ApprovalRuleName__"),
					ApprovalRuleId:      ptr.String("__ApprovalRuleId__"),
					ApprovalRuleContent: ptr.String("__ApprovalRuleContent__"),
				},
				ApprovalStateChangedEventMetadata: &types.ApprovalStateChangedEventMetadata{
					RevisionId:     ptr.String("__RevisionId__"),
					ApprovalStatus: types.ApprovalState("APPROVE"),
				},
				ApprovalRuleOverriddenEventMetadata: &types.ApprovalRuleOverriddenEventMetadata{
					RevisionId:     ptr.String("__RevisionId__"),
					OverrideStatus: types.OverrideStatus("OVERRIDE"),
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribePullRequestEvents.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.DescribePullRequestEvents(context.Background(), &DescribePullRequestEventsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribePullRequestEvents.response", err)
	}
}

func TestCheckResponseSnapshot_DisassociateApprovalRuleTemplateFromRepository(t *testing.T) {
	want := &DisassociateApprovalRuleTemplateFromRepositoryOutput{}
	status, header, body, err := serdeRespReadSnapshot("DisassociateApprovalRuleTemplateFromRepository.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.DisassociateApprovalRuleTemplateFromRepository(context.Background(), &DisassociateApprovalRuleTemplateFromRepositoryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DisassociateApprovalRuleTemplateFromRepository.response", err)
	}
}

func TestCheckResponseSnapshot_EvaluatePullRequestApprovalRules(t *testing.T) {
	want := &EvaluatePullRequestApprovalRulesOutput{
		Evaluation: &types.Evaluation{
			Approved:   true,
			Overridden: true,
			ApprovalRulesSatisfied: []string{
				"__Member__",
				"__Member__",
			},
			ApprovalRulesNotSatisfied: []string{
				"__Member__",
				"__Member__",
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("EvaluatePullRequestApprovalRules.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.EvaluatePullRequestApprovalRules(context.Background(), &EvaluatePullRequestApprovalRulesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "EvaluatePullRequestApprovalRules.response", err)
	}
}

func TestCheckResponseSnapshot_GetApprovalRuleTemplate(t *testing.T) {
	want := &GetApprovalRuleTemplateOutput{
		ApprovalRuleTemplate: &types.ApprovalRuleTemplate{
			ApprovalRuleTemplateId:          ptr.String("__ApprovalRuleTemplateId__"),
			ApprovalRuleTemplateName:        ptr.String("__ApprovalRuleTemplateName__"),
			ApprovalRuleTemplateDescription: ptr.String("__ApprovalRuleTemplateDescription__"),
			ApprovalRuleTemplateContent:     ptr.String("__ApprovalRuleTemplateContent__"),
			RuleContentSha256:               ptr.String("__RuleContentSha256__"),
			LastModifiedDate:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CreationDate:                    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LastModifiedUser:                ptr.String("__LastModifiedUser__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetApprovalRuleTemplate.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.GetApprovalRuleTemplate(context.Background(), &GetApprovalRuleTemplateInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetApprovalRuleTemplate.response", err)
	}
}

func TestCheckResponseSnapshot_GetBlob(t *testing.T) {
	want := &GetBlobOutput{
		Content: []byte("blob"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetBlob.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.GetBlob(context.Background(), &GetBlobInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBlob.response", err)
	}
}

func TestCheckResponseSnapshot_GetBranch(t *testing.T) {
	want := &GetBranchOutput{
		Branch: &types.BranchInfo{
			BranchName: ptr.String("__BranchName__"),
			CommitId:   ptr.String("__CommitId__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetBranch.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.GetBranch(context.Background(), &GetBranchInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBranch.response", err)
	}
}

func TestCheckResponseSnapshot_GetComment(t *testing.T) {
	want := &GetCommentOutput{
		Comment: &types.Comment{
			CommentId:          ptr.String("__CommentId__"),
			Content:            ptr.String("__Content__"),
			InReplyTo:          ptr.String("__InReplyTo__"),
			CreationDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LastModifiedDate:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			AuthorArn:          ptr.String("__AuthorArn__"),
			Deleted:            true,
			ClientRequestToken: ptr.String("__ClientRequestToken__"),
			CallerReactions: []string{
				"__Member__",
				"__Member__",
			},
			ReactionCounts: map[string]int32{
				"key0": 1,
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetComment.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.GetComment(context.Background(), &GetCommentInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetComment.response", err)
	}
}

func TestCheckResponseSnapshot_GetCommentReactions(t *testing.T) {
	want := &GetCommentReactionsOutput{
		ReactionsForComment: []types.ReactionForComment{
			{
				Reaction: &types.ReactionValueFormats{
					Emoji:     ptr.String("__Emoji__"),
					ShortCode: ptr.String("__ShortCode__"),
					Unicode:   ptr.String("__Unicode__"),
				},
				ReactionUsers: []string{
					"__Member__",
					"__Member__",
				},
				ReactionsFromDeletedUsersCount: ptr.Int32(1),
			},
			{
				Reaction: &types.ReactionValueFormats{
					Emoji:     ptr.String("__Emoji__"),
					ShortCode: ptr.String("__ShortCode__"),
					Unicode:   ptr.String("__Unicode__"),
				},
				ReactionUsers: []string{
					"__Member__",
					"__Member__",
				},
				ReactionsFromDeletedUsersCount: ptr.Int32(1),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetCommentReactions.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.GetCommentReactions(context.Background(), &GetCommentReactionsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetCommentReactions.response", err)
	}
}

func TestCheckResponseSnapshot_GetCommentsForComparedCommit(t *testing.T) {
	want := &GetCommentsForComparedCommitOutput{
		CommentsForComparedCommitData: []types.CommentsForComparedCommit{
			{
				RepositoryName: ptr.String("__RepositoryName__"),
				BeforeCommitId: ptr.String("__BeforeCommitId__"),
				AfterCommitId:  ptr.String("__AfterCommitId__"),
				BeforeBlobId:   ptr.String("__BeforeBlobId__"),
				AfterBlobId:    ptr.String("__AfterBlobId__"),
				Location: &types.Location{
					FilePath:            ptr.String("__FilePath__"),
					FilePosition:        ptr.Int64(1),
					RelativeFileVersion: types.RelativeFileVersionEnum("BEFORE"),
				},
				Comments: []types.Comment{
					{
						CommentId:          ptr.String("__CommentId__"),
						Content:            ptr.String("__Content__"),
						InReplyTo:          ptr.String("__InReplyTo__"),
						CreationDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						LastModifiedDate:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						AuthorArn:          ptr.String("__AuthorArn__"),
						Deleted:            true,
						ClientRequestToken: ptr.String("__ClientRequestToken__"),
						CallerReactions: []string{
							"__Member__",
							"__Member__",
						},
						ReactionCounts: map[string]int32{
							"key0": 1,
						},
					},
					{
						CommentId:          ptr.String("__CommentId__"),
						Content:            ptr.String("__Content__"),
						InReplyTo:          ptr.String("__InReplyTo__"),
						CreationDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						LastModifiedDate:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						AuthorArn:          ptr.String("__AuthorArn__"),
						Deleted:            true,
						ClientRequestToken: ptr.String("__ClientRequestToken__"),
						CallerReactions: []string{
							"__Member__",
							"__Member__",
						},
						ReactionCounts: map[string]int32{
							"key0": 1,
						},
					},
				},
			},
			{
				RepositoryName: ptr.String("__RepositoryName__"),
				BeforeCommitId: ptr.String("__BeforeCommitId__"),
				AfterCommitId:  ptr.String("__AfterCommitId__"),
				BeforeBlobId:   ptr.String("__BeforeBlobId__"),
				AfterBlobId:    ptr.String("__AfterBlobId__"),
				Location: &types.Location{
					FilePath:            ptr.String("__FilePath__"),
					FilePosition:        ptr.Int64(1),
					RelativeFileVersion: types.RelativeFileVersionEnum("BEFORE"),
				},
				Comments: []types.Comment{
					{
						CommentId:          ptr.String("__CommentId__"),
						Content:            ptr.String("__Content__"),
						InReplyTo:          ptr.String("__InReplyTo__"),
						CreationDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						LastModifiedDate:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						AuthorArn:          ptr.String("__AuthorArn__"),
						Deleted:            true,
						ClientRequestToken: ptr.String("__ClientRequestToken__"),
						CallerReactions: []string{
							"__Member__",
							"__Member__",
						},
						ReactionCounts: map[string]int32{
							"key0": 1,
						},
					},
					{
						CommentId:          ptr.String("__CommentId__"),
						Content:            ptr.String("__Content__"),
						InReplyTo:          ptr.String("__InReplyTo__"),
						CreationDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						LastModifiedDate:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						AuthorArn:          ptr.String("__AuthorArn__"),
						Deleted:            true,
						ClientRequestToken: ptr.String("__ClientRequestToken__"),
						CallerReactions: []string{
							"__Member__",
							"__Member__",
						},
						ReactionCounts: map[string]int32{
							"key0": 1,
						},
					},
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetCommentsForComparedCommit.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.GetCommentsForComparedCommit(context.Background(), &GetCommentsForComparedCommitInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetCommentsForComparedCommit.response", err)
	}
}

func TestCheckResponseSnapshot_GetCommentsForPullRequest(t *testing.T) {
	want := &GetCommentsForPullRequestOutput{
		CommentsForPullRequestData: []types.CommentsForPullRequest{
			{
				PullRequestId:  ptr.String("__PullRequestId__"),
				RepositoryName: ptr.String("__RepositoryName__"),
				BeforeCommitId: ptr.String("__BeforeCommitId__"),
				AfterCommitId:  ptr.String("__AfterCommitId__"),
				BeforeBlobId:   ptr.String("__BeforeBlobId__"),
				AfterBlobId:    ptr.String("__AfterBlobId__"),
				Location: &types.Location{
					FilePath:            ptr.String("__FilePath__"),
					FilePosition:        ptr.Int64(1),
					RelativeFileVersion: types.RelativeFileVersionEnum("BEFORE"),
				},
				Comments: []types.Comment{
					{
						CommentId:          ptr.String("__CommentId__"),
						Content:            ptr.String("__Content__"),
						InReplyTo:          ptr.String("__InReplyTo__"),
						CreationDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						LastModifiedDate:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						AuthorArn:          ptr.String("__AuthorArn__"),
						Deleted:            true,
						ClientRequestToken: ptr.String("__ClientRequestToken__"),
						CallerReactions: []string{
							"__Member__",
							"__Member__",
						},
						ReactionCounts: map[string]int32{
							"key0": 1,
						},
					},
					{
						CommentId:          ptr.String("__CommentId__"),
						Content:            ptr.String("__Content__"),
						InReplyTo:          ptr.String("__InReplyTo__"),
						CreationDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						LastModifiedDate:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						AuthorArn:          ptr.String("__AuthorArn__"),
						Deleted:            true,
						ClientRequestToken: ptr.String("__ClientRequestToken__"),
						CallerReactions: []string{
							"__Member__",
							"__Member__",
						},
						ReactionCounts: map[string]int32{
							"key0": 1,
						},
					},
				},
			},
			{
				PullRequestId:  ptr.String("__PullRequestId__"),
				RepositoryName: ptr.String("__RepositoryName__"),
				BeforeCommitId: ptr.String("__BeforeCommitId__"),
				AfterCommitId:  ptr.String("__AfterCommitId__"),
				BeforeBlobId:   ptr.String("__BeforeBlobId__"),
				AfterBlobId:    ptr.String("__AfterBlobId__"),
				Location: &types.Location{
					FilePath:            ptr.String("__FilePath__"),
					FilePosition:        ptr.Int64(1),
					RelativeFileVersion: types.RelativeFileVersionEnum("BEFORE"),
				},
				Comments: []types.Comment{
					{
						CommentId:          ptr.String("__CommentId__"),
						Content:            ptr.String("__Content__"),
						InReplyTo:          ptr.String("__InReplyTo__"),
						CreationDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						LastModifiedDate:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						AuthorArn:          ptr.String("__AuthorArn__"),
						Deleted:            true,
						ClientRequestToken: ptr.String("__ClientRequestToken__"),
						CallerReactions: []string{
							"__Member__",
							"__Member__",
						},
						ReactionCounts: map[string]int32{
							"key0": 1,
						},
					},
					{
						CommentId:          ptr.String("__CommentId__"),
						Content:            ptr.String("__Content__"),
						InReplyTo:          ptr.String("__InReplyTo__"),
						CreationDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						LastModifiedDate:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						AuthorArn:          ptr.String("__AuthorArn__"),
						Deleted:            true,
						ClientRequestToken: ptr.String("__ClientRequestToken__"),
						CallerReactions: []string{
							"__Member__",
							"__Member__",
						},
						ReactionCounts: map[string]int32{
							"key0": 1,
						},
					},
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetCommentsForPullRequest.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.GetCommentsForPullRequest(context.Background(), &GetCommentsForPullRequestInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetCommentsForPullRequest.response", err)
	}
}

func TestCheckResponseSnapshot_GetCommit(t *testing.T) {
	want := &GetCommitOutput{
		Commit: &types.Commit{
			CommitId: ptr.String("__CommitId__"),
			TreeId:   ptr.String("__TreeId__"),
			Parents: []string{
				"__Member__",
				"__Member__",
			},
			Message: ptr.String("__Message__"),
			Author: &types.UserInfo{
				Name:  ptr.String("__Name__"),
				Email: ptr.String("__Email__"),
				Date:  ptr.String("__Date__"),
			},
			Committer: &types.UserInfo{
				Name:  ptr.String("__Name__"),
				Email: ptr.String("__Email__"),
				Date:  ptr.String("__Date__"),
			},
			AdditionalData: ptr.String("__AdditionalData__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetCommit.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.GetCommit(context.Background(), &GetCommitInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetCommit.response", err)
	}
}

func TestCheckResponseSnapshot_GetDifferences(t *testing.T) {
	want := &GetDifferencesOutput{
		Differences: []types.Difference{
			{
				BeforeBlob: &types.BlobMetadata{
					BlobId: ptr.String("__BlobId__"),
					Path:   ptr.String("__Path__"),
					Mode:   ptr.String("__Mode__"),
				},
				AfterBlob: &types.BlobMetadata{
					BlobId: ptr.String("__BlobId__"),
					Path:   ptr.String("__Path__"),
					Mode:   ptr.String("__Mode__"),
				},
				ChangeType: types.ChangeTypeEnum("A"),
			},
			{
				BeforeBlob: &types.BlobMetadata{
					BlobId: ptr.String("__BlobId__"),
					Path:   ptr.String("__Path__"),
					Mode:   ptr.String("__Mode__"),
				},
				AfterBlob: &types.BlobMetadata{
					BlobId: ptr.String("__BlobId__"),
					Path:   ptr.String("__Path__"),
					Mode:   ptr.String("__Mode__"),
				},
				ChangeType: types.ChangeTypeEnum("A"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetDifferences.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.GetDifferences(context.Background(), &GetDifferencesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetDifferences.response", err)
	}
}

func TestCheckResponseSnapshot_GetFile(t *testing.T) {
	want := &GetFileOutput{
		CommitId:    ptr.String("__CommitId__"),
		BlobId:      ptr.String("__BlobId__"),
		FilePath:    ptr.String("__FilePath__"),
		FileMode:    types.FileModeTypeEnum("EXECUTABLE"),
		FileSize:    1,
		FileContent: []byte("blob"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetFile.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.GetFile(context.Background(), &GetFileInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetFile.response", err)
	}
}

func TestCheckResponseSnapshot_GetFolder(t *testing.T) {
	want := &GetFolderOutput{
		CommitId:   ptr.String("__CommitId__"),
		FolderPath: ptr.String("__FolderPath__"),
		TreeId:     ptr.String("__TreeId__"),
		SubFolders: []types.Folder{
			{
				TreeId:       ptr.String("__TreeId__"),
				AbsolutePath: ptr.String("__AbsolutePath__"),
				RelativePath: ptr.String("__RelativePath__"),
			},
			{
				TreeId:       ptr.String("__TreeId__"),
				AbsolutePath: ptr.String("__AbsolutePath__"),
				RelativePath: ptr.String("__RelativePath__"),
			},
		},
		Files: []types.File{
			{
				BlobId:       ptr.String("__BlobId__"),
				AbsolutePath: ptr.String("__AbsolutePath__"),
				RelativePath: ptr.String("__RelativePath__"),
				FileMode:     types.FileModeTypeEnum("EXECUTABLE"),
			},
			{
				BlobId:       ptr.String("__BlobId__"),
				AbsolutePath: ptr.String("__AbsolutePath__"),
				RelativePath: ptr.String("__RelativePath__"),
				FileMode:     types.FileModeTypeEnum("EXECUTABLE"),
			},
		},
		SymbolicLinks: []types.SymbolicLink{
			{
				BlobId:       ptr.String("__BlobId__"),
				AbsolutePath: ptr.String("__AbsolutePath__"),
				RelativePath: ptr.String("__RelativePath__"),
				FileMode:     types.FileModeTypeEnum("EXECUTABLE"),
			},
			{
				BlobId:       ptr.String("__BlobId__"),
				AbsolutePath: ptr.String("__AbsolutePath__"),
				RelativePath: ptr.String("__RelativePath__"),
				FileMode:     types.FileModeTypeEnum("EXECUTABLE"),
			},
		},
		SubModules: []types.SubModule{
			{
				CommitId:     ptr.String("__CommitId__"),
				AbsolutePath: ptr.String("__AbsolutePath__"),
				RelativePath: ptr.String("__RelativePath__"),
			},
			{
				CommitId:     ptr.String("__CommitId__"),
				AbsolutePath: ptr.String("__AbsolutePath__"),
				RelativePath: ptr.String("__RelativePath__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetFolder.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.GetFolder(context.Background(), &GetFolderInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetFolder.response", err)
	}
}

func TestCheckResponseSnapshot_GetMergeCommit(t *testing.T) {
	want := &GetMergeCommitOutput{
		SourceCommitId:      ptr.String("__SourceCommitId__"),
		DestinationCommitId: ptr.String("__DestinationCommitId__"),
		BaseCommitId:        ptr.String("__BaseCommitId__"),
		MergedCommitId:      ptr.String("__MergedCommitId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetMergeCommit.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.GetMergeCommit(context.Background(), &GetMergeCommitInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetMergeCommit.response", err)
	}
}

func TestCheckResponseSnapshot_GetMergeConflicts(t *testing.T) {
	want := &GetMergeConflictsOutput{
		Mergeable:           true,
		DestinationCommitId: ptr.String("__DestinationCommitId__"),
		SourceCommitId:      ptr.String("__SourceCommitId__"),
		BaseCommitId:        ptr.String("__BaseCommitId__"),
		ConflictMetadataList: []types.ConflictMetadata{
			{
				FilePath: ptr.String("__FilePath__"),
				FileSizes: &types.FileSizes{
					Source:      1,
					Destination: 1,
					Base:        1,
				},
				FileModes: &types.FileModes{
					Source:      types.FileModeTypeEnum("EXECUTABLE"),
					Destination: types.FileModeTypeEnum("EXECUTABLE"),
					Base:        types.FileModeTypeEnum("EXECUTABLE"),
				},
				ObjectTypes: &types.ObjectTypes{
					Source:      types.ObjectTypeEnum("FILE"),
					Destination: types.ObjectTypeEnum("FILE"),
					Base:        types.ObjectTypeEnum("FILE"),
				},
				NumberOfConflicts: 1,
				IsBinaryFile: &types.IsBinaryFile{
					Source:      ptr.Bool(true),
					Destination: ptr.Bool(true),
					Base:        ptr.Bool(true),
				},
				ContentConflict:    true,
				FileModeConflict:   true,
				ObjectTypeConflict: true,
				MergeOperations: &types.MergeOperations{
					Source:      types.ChangeTypeEnum("A"),
					Destination: types.ChangeTypeEnum("A"),
				},
			},
			{
				FilePath: ptr.String("__FilePath__"),
				FileSizes: &types.FileSizes{
					Source:      1,
					Destination: 1,
					Base:        1,
				},
				FileModes: &types.FileModes{
					Source:      types.FileModeTypeEnum("EXECUTABLE"),
					Destination: types.FileModeTypeEnum("EXECUTABLE"),
					Base:        types.FileModeTypeEnum("EXECUTABLE"),
				},
				ObjectTypes: &types.ObjectTypes{
					Source:      types.ObjectTypeEnum("FILE"),
					Destination: types.ObjectTypeEnum("FILE"),
					Base:        types.ObjectTypeEnum("FILE"),
				},
				NumberOfConflicts: 1,
				IsBinaryFile: &types.IsBinaryFile{
					Source:      ptr.Bool(true),
					Destination: ptr.Bool(true),
					Base:        ptr.Bool(true),
				},
				ContentConflict:    true,
				FileModeConflict:   true,
				ObjectTypeConflict: true,
				MergeOperations: &types.MergeOperations{
					Source:      types.ChangeTypeEnum("A"),
					Destination: types.ChangeTypeEnum("A"),
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetMergeConflicts.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.GetMergeConflicts(context.Background(), &GetMergeConflictsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetMergeConflicts.response", err)
	}
}

func TestCheckResponseSnapshot_GetMergeOptions(t *testing.T) {
	want := &GetMergeOptionsOutput{
		MergeOptions: []types.MergeOptionTypeEnum{
			types.MergeOptionTypeEnum("FAST_FORWARD_MERGE"),
			types.MergeOptionTypeEnum("FAST_FORWARD_MERGE"),
		},
		SourceCommitId:      ptr.String("__SourceCommitId__"),
		DestinationCommitId: ptr.String("__DestinationCommitId__"),
		BaseCommitId:        ptr.String("__BaseCommitId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetMergeOptions.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.GetMergeOptions(context.Background(), &GetMergeOptionsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetMergeOptions.response", err)
	}
}

func TestCheckResponseSnapshot_GetPullRequest(t *testing.T) {
	want := &GetPullRequestOutput{
		PullRequest: &types.PullRequest{
			PullRequestId:     ptr.String("__PullRequestId__"),
			Title:             ptr.String("__Title__"),
			Description:       ptr.String("__Description__"),
			LastActivityDate:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CreationDate:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			PullRequestStatus: types.PullRequestStatusEnum("OPEN"),
			AuthorArn:         ptr.String("__AuthorArn__"),
			PullRequestTargets: []types.PullRequestTarget{
				{
					RepositoryName:       ptr.String("__RepositoryName__"),
					SourceReference:      ptr.String("__SourceReference__"),
					DestinationReference: ptr.String("__DestinationReference__"),
					DestinationCommit:    ptr.String("__DestinationCommit__"),
					SourceCommit:         ptr.String("__SourceCommit__"),
					MergeBase:            ptr.String("__MergeBase__"),
					MergeMetadata: &types.MergeMetadata{
						IsMerged:      true,
						MergedBy:      ptr.String("__MergedBy__"),
						MergeCommitId: ptr.String("__MergeCommitId__"),
						MergeOption:   types.MergeOptionTypeEnum("FAST_FORWARD_MERGE"),
					},
				},
				{
					RepositoryName:       ptr.String("__RepositoryName__"),
					SourceReference:      ptr.String("__SourceReference__"),
					DestinationReference: ptr.String("__DestinationReference__"),
					DestinationCommit:    ptr.String("__DestinationCommit__"),
					SourceCommit:         ptr.String("__SourceCommit__"),
					MergeBase:            ptr.String("__MergeBase__"),
					MergeMetadata: &types.MergeMetadata{
						IsMerged:      true,
						MergedBy:      ptr.String("__MergedBy__"),
						MergeCommitId: ptr.String("__MergeCommitId__"),
						MergeOption:   types.MergeOptionTypeEnum("FAST_FORWARD_MERGE"),
					},
				},
			},
			ClientRequestToken: ptr.String("__ClientRequestToken__"),
			RevisionId:         ptr.String("__RevisionId__"),
			ApprovalRules: []types.ApprovalRule{
				{
					ApprovalRuleId:      ptr.String("__ApprovalRuleId__"),
					ApprovalRuleName:    ptr.String("__ApprovalRuleName__"),
					ApprovalRuleContent: ptr.String("__ApprovalRuleContent__"),
					RuleContentSha256:   ptr.String("__RuleContentSha256__"),
					LastModifiedDate:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					CreationDate:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					LastModifiedUser:    ptr.String("__LastModifiedUser__"),
					OriginApprovalRuleTemplate: &types.OriginApprovalRuleTemplate{
						ApprovalRuleTemplateId:   ptr.String("__ApprovalRuleTemplateId__"),
						ApprovalRuleTemplateName: ptr.String("__ApprovalRuleTemplateName__"),
					},
				},
				{
					ApprovalRuleId:      ptr.String("__ApprovalRuleId__"),
					ApprovalRuleName:    ptr.String("__ApprovalRuleName__"),
					ApprovalRuleContent: ptr.String("__ApprovalRuleContent__"),
					RuleContentSha256:   ptr.String("__RuleContentSha256__"),
					LastModifiedDate:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					CreationDate:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					LastModifiedUser:    ptr.String("__LastModifiedUser__"),
					OriginApprovalRuleTemplate: &types.OriginApprovalRuleTemplate{
						ApprovalRuleTemplateId:   ptr.String("__ApprovalRuleTemplateId__"),
						ApprovalRuleTemplateName: ptr.String("__ApprovalRuleTemplateName__"),
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetPullRequest.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.GetPullRequest(context.Background(), &GetPullRequestInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetPullRequest.response", err)
	}
}

func TestCheckResponseSnapshot_GetPullRequestApprovalStates(t *testing.T) {
	want := &GetPullRequestApprovalStatesOutput{
		Approvals: []types.Approval{
			{
				UserArn:       ptr.String("__UserArn__"),
				ApprovalState: types.ApprovalState("APPROVE"),
			},
			{
				UserArn:       ptr.String("__UserArn__"),
				ApprovalState: types.ApprovalState("APPROVE"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetPullRequestApprovalStates.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.GetPullRequestApprovalStates(context.Background(), &GetPullRequestApprovalStatesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetPullRequestApprovalStates.response", err)
	}
}

func TestCheckResponseSnapshot_GetPullRequestOverrideState(t *testing.T) {
	want := &GetPullRequestOverrideStateOutput{
		Overridden: true,
		Overrider:  ptr.String("__Overrider__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetPullRequestOverrideState.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.GetPullRequestOverrideState(context.Background(), &GetPullRequestOverrideStateInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetPullRequestOverrideState.response", err)
	}
}

func TestCheckResponseSnapshot_GetRepository(t *testing.T) {
	want := &GetRepositoryOutput{
		RepositoryMetadata: &types.RepositoryMetadata{
			AccountId:             ptr.String("__AccountId__"),
			RepositoryId:          ptr.String("__RepositoryId__"),
			RepositoryName:        ptr.String("__RepositoryName__"),
			RepositoryDescription: ptr.String("__RepositoryDescription__"),
			DefaultBranch:         ptr.String("__DefaultBranch__"),
			LastModifiedDate:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CreationDate:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CloneUrlHttp:          ptr.String("__CloneUrlHttp__"),
			CloneUrlSsh:           ptr.String("__CloneUrlSsh__"),
			Arn:                   ptr.String("__Arn__"),
			KmsKeyId:              ptr.String("__KmsKeyId__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetRepository.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.GetRepository(context.Background(), &GetRepositoryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetRepository.response", err)
	}
}

func TestCheckResponseSnapshot_GetRepositoryTriggers(t *testing.T) {
	want := &GetRepositoryTriggersOutput{
		ConfigurationId: ptr.String("__ConfigurationId__"),
		Triggers: []types.RepositoryTrigger{
			{
				Name:           ptr.String("__Name__"),
				DestinationArn: ptr.String("__DestinationArn__"),
				CustomData:     ptr.String("__CustomData__"),
				Branches: []string{
					"__Member__",
					"__Member__",
				},
				Events: []types.RepositoryTriggerEventEnum{
					types.RepositoryTriggerEventEnum("all"),
					types.RepositoryTriggerEventEnum("all"),
				},
			},
			{
				Name:           ptr.String("__Name__"),
				DestinationArn: ptr.String("__DestinationArn__"),
				CustomData:     ptr.String("__CustomData__"),
				Branches: []string{
					"__Member__",
					"__Member__",
				},
				Events: []types.RepositoryTriggerEventEnum{
					types.RepositoryTriggerEventEnum("all"),
					types.RepositoryTriggerEventEnum("all"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetRepositoryTriggers.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.GetRepositoryTriggers(context.Background(), &GetRepositoryTriggersInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetRepositoryTriggers.response", err)
	}
}

func TestCheckResponseSnapshot_ListApprovalRuleTemplates(t *testing.T) {
	want := &ListApprovalRuleTemplatesOutput{
		ApprovalRuleTemplateNames: []string{
			"__Member__",
			"__Member__",
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListApprovalRuleTemplates.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.ListApprovalRuleTemplates(context.Background(), &ListApprovalRuleTemplatesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListApprovalRuleTemplates.response", err)
	}
}

func TestCheckResponseSnapshot_ListAssociatedApprovalRuleTemplatesForRepository(t *testing.T) {
	want := &ListAssociatedApprovalRuleTemplatesForRepositoryOutput{
		ApprovalRuleTemplateNames: []string{
			"__Member__",
			"__Member__",
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListAssociatedApprovalRuleTemplatesForRepository.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.ListAssociatedApprovalRuleTemplatesForRepository(context.Background(), &ListAssociatedApprovalRuleTemplatesForRepositoryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListAssociatedApprovalRuleTemplatesForRepository.response", err)
	}
}

func TestCheckResponseSnapshot_ListBranches(t *testing.T) {
	want := &ListBranchesOutput{
		Branches: []string{
			"__Member__",
			"__Member__",
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListBranches.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.ListBranches(context.Background(), &ListBranchesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListBranches.response", err)
	}
}

func TestCheckResponseSnapshot_ListFileCommitHistory(t *testing.T) {
	want := &ListFileCommitHistoryOutput{
		RevisionDag: []types.FileVersion{
			{
				Commit: &types.Commit{
					CommitId: ptr.String("__CommitId__"),
					TreeId:   ptr.String("__TreeId__"),
					Parents: []string{
						"__Member__",
						"__Member__",
					},
					Message: ptr.String("__Message__"),
					Author: &types.UserInfo{
						Name:  ptr.String("__Name__"),
						Email: ptr.String("__Email__"),
						Date:  ptr.String("__Date__"),
					},
					Committer: &types.UserInfo{
						Name:  ptr.String("__Name__"),
						Email: ptr.String("__Email__"),
						Date:  ptr.String("__Date__"),
					},
					AdditionalData: ptr.String("__AdditionalData__"),
				},
				BlobId: ptr.String("__BlobId__"),
				Path:   ptr.String("__Path__"),
				RevisionChildren: []string{
					"__Member__",
					"__Member__",
				},
			},
			{
				Commit: &types.Commit{
					CommitId: ptr.String("__CommitId__"),
					TreeId:   ptr.String("__TreeId__"),
					Parents: []string{
						"__Member__",
						"__Member__",
					},
					Message: ptr.String("__Message__"),
					Author: &types.UserInfo{
						Name:  ptr.String("__Name__"),
						Email: ptr.String("__Email__"),
						Date:  ptr.String("__Date__"),
					},
					Committer: &types.UserInfo{
						Name:  ptr.String("__Name__"),
						Email: ptr.String("__Email__"),
						Date:  ptr.String("__Date__"),
					},
					AdditionalData: ptr.String("__AdditionalData__"),
				},
				BlobId: ptr.String("__BlobId__"),
				Path:   ptr.String("__Path__"),
				RevisionChildren: []string{
					"__Member__",
					"__Member__",
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListFileCommitHistory.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.ListFileCommitHistory(context.Background(), &ListFileCommitHistoryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListFileCommitHistory.response", err)
	}
}

func TestCheckResponseSnapshot_ListPullRequests(t *testing.T) {
	want := &ListPullRequestsOutput{
		PullRequestIds: []string{
			"__Member__",
			"__Member__",
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListPullRequests.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.ListPullRequests(context.Background(), &ListPullRequestsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListPullRequests.response", err)
	}
}

func TestCheckResponseSnapshot_ListRepositories(t *testing.T) {
	want := &ListRepositoriesOutput{
		Repositories: []types.RepositoryNameIdPair{
			{
				RepositoryName: ptr.String("__RepositoryName__"),
				RepositoryId:   ptr.String("__RepositoryId__"),
			},
			{
				RepositoryName: ptr.String("__RepositoryName__"),
				RepositoryId:   ptr.String("__RepositoryId__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListRepositories.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.ListRepositories(context.Background(), &ListRepositoriesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListRepositories.response", err)
	}
}

func TestCheckResponseSnapshot_ListRepositoriesForApprovalRuleTemplate(t *testing.T) {
	want := &ListRepositoriesForApprovalRuleTemplateOutput{
		RepositoryNames: []string{
			"__Member__",
			"__Member__",
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListRepositoriesForApprovalRuleTemplate.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.ListRepositoriesForApprovalRuleTemplate(context.Background(), &ListRepositoriesForApprovalRuleTemplateInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListRepositoriesForApprovalRuleTemplate.response", err)
	}
}

func TestCheckResponseSnapshot_ListTagsForResource(t *testing.T) {
	want := &ListTagsForResourceOutput{
		Tags: map[string]string{
			"key0": "__Value__",
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListTagsForResource.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.ListTagsForResource(context.Background(), &ListTagsForResourceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListTagsForResource.response", err)
	}
}

func TestCheckResponseSnapshot_MergeBranchesByFastForward(t *testing.T) {
	want := &MergeBranchesByFastForwardOutput{
		CommitId: ptr.String("__CommitId__"),
		TreeId:   ptr.String("__TreeId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("MergeBranchesByFastForward.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.MergeBranchesByFastForward(context.Background(), &MergeBranchesByFastForwardInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "MergeBranchesByFastForward.response", err)
	}
}

func TestCheckResponseSnapshot_MergeBranchesBySquash(t *testing.T) {
	want := &MergeBranchesBySquashOutput{
		CommitId: ptr.String("__CommitId__"),
		TreeId:   ptr.String("__TreeId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("MergeBranchesBySquash.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.MergeBranchesBySquash(context.Background(), &MergeBranchesBySquashInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "MergeBranchesBySquash.response", err)
	}
}

func TestCheckResponseSnapshot_MergeBranchesByThreeWay(t *testing.T) {
	want := &MergeBranchesByThreeWayOutput{
		CommitId: ptr.String("__CommitId__"),
		TreeId:   ptr.String("__TreeId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("MergeBranchesByThreeWay.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.MergeBranchesByThreeWay(context.Background(), &MergeBranchesByThreeWayInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "MergeBranchesByThreeWay.response", err)
	}
}

func TestCheckResponseSnapshot_MergePullRequestByFastForward(t *testing.T) {
	want := &MergePullRequestByFastForwardOutput{
		PullRequest: &types.PullRequest{
			PullRequestId:     ptr.String("__PullRequestId__"),
			Title:             ptr.String("__Title__"),
			Description:       ptr.String("__Description__"),
			LastActivityDate:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CreationDate:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			PullRequestStatus: types.PullRequestStatusEnum("OPEN"),
			AuthorArn:         ptr.String("__AuthorArn__"),
			PullRequestTargets: []types.PullRequestTarget{
				{
					RepositoryName:       ptr.String("__RepositoryName__"),
					SourceReference:      ptr.String("__SourceReference__"),
					DestinationReference: ptr.String("__DestinationReference__"),
					DestinationCommit:    ptr.String("__DestinationCommit__"),
					SourceCommit:         ptr.String("__SourceCommit__"),
					MergeBase:            ptr.String("__MergeBase__"),
					MergeMetadata: &types.MergeMetadata{
						IsMerged:      true,
						MergedBy:      ptr.String("__MergedBy__"),
						MergeCommitId: ptr.String("__MergeCommitId__"),
						MergeOption:   types.MergeOptionTypeEnum("FAST_FORWARD_MERGE"),
					},
				},
				{
					RepositoryName:       ptr.String("__RepositoryName__"),
					SourceReference:      ptr.String("__SourceReference__"),
					DestinationReference: ptr.String("__DestinationReference__"),
					DestinationCommit:    ptr.String("__DestinationCommit__"),
					SourceCommit:         ptr.String("__SourceCommit__"),
					MergeBase:            ptr.String("__MergeBase__"),
					MergeMetadata: &types.MergeMetadata{
						IsMerged:      true,
						MergedBy:      ptr.String("__MergedBy__"),
						MergeCommitId: ptr.String("__MergeCommitId__"),
						MergeOption:   types.MergeOptionTypeEnum("FAST_FORWARD_MERGE"),
					},
				},
			},
			ClientRequestToken: ptr.String("__ClientRequestToken__"),
			RevisionId:         ptr.String("__RevisionId__"),
			ApprovalRules: []types.ApprovalRule{
				{
					ApprovalRuleId:      ptr.String("__ApprovalRuleId__"),
					ApprovalRuleName:    ptr.String("__ApprovalRuleName__"),
					ApprovalRuleContent: ptr.String("__ApprovalRuleContent__"),
					RuleContentSha256:   ptr.String("__RuleContentSha256__"),
					LastModifiedDate:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					CreationDate:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					LastModifiedUser:    ptr.String("__LastModifiedUser__"),
					OriginApprovalRuleTemplate: &types.OriginApprovalRuleTemplate{
						ApprovalRuleTemplateId:   ptr.String("__ApprovalRuleTemplateId__"),
						ApprovalRuleTemplateName: ptr.String("__ApprovalRuleTemplateName__"),
					},
				},
				{
					ApprovalRuleId:      ptr.String("__ApprovalRuleId__"),
					ApprovalRuleName:    ptr.String("__ApprovalRuleName__"),
					ApprovalRuleContent: ptr.String("__ApprovalRuleContent__"),
					RuleContentSha256:   ptr.String("__RuleContentSha256__"),
					LastModifiedDate:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					CreationDate:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					LastModifiedUser:    ptr.String("__LastModifiedUser__"),
					OriginApprovalRuleTemplate: &types.OriginApprovalRuleTemplate{
						ApprovalRuleTemplateId:   ptr.String("__ApprovalRuleTemplateId__"),
						ApprovalRuleTemplateName: ptr.String("__ApprovalRuleTemplateName__"),
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("MergePullRequestByFastForward.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.MergePullRequestByFastForward(context.Background(), &MergePullRequestByFastForwardInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "MergePullRequestByFastForward.response", err)
	}
}

func TestCheckResponseSnapshot_MergePullRequestBySquash(t *testing.T) {
	want := &MergePullRequestBySquashOutput{
		PullRequest: &types.PullRequest{
			PullRequestId:     ptr.String("__PullRequestId__"),
			Title:             ptr.String("__Title__"),
			Description:       ptr.String("__Description__"),
			LastActivityDate:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CreationDate:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			PullRequestStatus: types.PullRequestStatusEnum("OPEN"),
			AuthorArn:         ptr.String("__AuthorArn__"),
			PullRequestTargets: []types.PullRequestTarget{
				{
					RepositoryName:       ptr.String("__RepositoryName__"),
					SourceReference:      ptr.String("__SourceReference__"),
					DestinationReference: ptr.String("__DestinationReference__"),
					DestinationCommit:    ptr.String("__DestinationCommit__"),
					SourceCommit:         ptr.String("__SourceCommit__"),
					MergeBase:            ptr.String("__MergeBase__"),
					MergeMetadata: &types.MergeMetadata{
						IsMerged:      true,
						MergedBy:      ptr.String("__MergedBy__"),
						MergeCommitId: ptr.String("__MergeCommitId__"),
						MergeOption:   types.MergeOptionTypeEnum("FAST_FORWARD_MERGE"),
					},
				},
				{
					RepositoryName:       ptr.String("__RepositoryName__"),
					SourceReference:      ptr.String("__SourceReference__"),
					DestinationReference: ptr.String("__DestinationReference__"),
					DestinationCommit:    ptr.String("__DestinationCommit__"),
					SourceCommit:         ptr.String("__SourceCommit__"),
					MergeBase:            ptr.String("__MergeBase__"),
					MergeMetadata: &types.MergeMetadata{
						IsMerged:      true,
						MergedBy:      ptr.String("__MergedBy__"),
						MergeCommitId: ptr.String("__MergeCommitId__"),
						MergeOption:   types.MergeOptionTypeEnum("FAST_FORWARD_MERGE"),
					},
				},
			},
			ClientRequestToken: ptr.String("__ClientRequestToken__"),
			RevisionId:         ptr.String("__RevisionId__"),
			ApprovalRules: []types.ApprovalRule{
				{
					ApprovalRuleId:      ptr.String("__ApprovalRuleId__"),
					ApprovalRuleName:    ptr.String("__ApprovalRuleName__"),
					ApprovalRuleContent: ptr.String("__ApprovalRuleContent__"),
					RuleContentSha256:   ptr.String("__RuleContentSha256__"),
					LastModifiedDate:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					CreationDate:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					LastModifiedUser:    ptr.String("__LastModifiedUser__"),
					OriginApprovalRuleTemplate: &types.OriginApprovalRuleTemplate{
						ApprovalRuleTemplateId:   ptr.String("__ApprovalRuleTemplateId__"),
						ApprovalRuleTemplateName: ptr.String("__ApprovalRuleTemplateName__"),
					},
				},
				{
					ApprovalRuleId:      ptr.String("__ApprovalRuleId__"),
					ApprovalRuleName:    ptr.String("__ApprovalRuleName__"),
					ApprovalRuleContent: ptr.String("__ApprovalRuleContent__"),
					RuleContentSha256:   ptr.String("__RuleContentSha256__"),
					LastModifiedDate:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					CreationDate:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					LastModifiedUser:    ptr.String("__LastModifiedUser__"),
					OriginApprovalRuleTemplate: &types.OriginApprovalRuleTemplate{
						ApprovalRuleTemplateId:   ptr.String("__ApprovalRuleTemplateId__"),
						ApprovalRuleTemplateName: ptr.String("__ApprovalRuleTemplateName__"),
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("MergePullRequestBySquash.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.MergePullRequestBySquash(context.Background(), &MergePullRequestBySquashInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "MergePullRequestBySquash.response", err)
	}
}

func TestCheckResponseSnapshot_MergePullRequestByThreeWay(t *testing.T) {
	want := &MergePullRequestByThreeWayOutput{
		PullRequest: &types.PullRequest{
			PullRequestId:     ptr.String("__PullRequestId__"),
			Title:             ptr.String("__Title__"),
			Description:       ptr.String("__Description__"),
			LastActivityDate:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CreationDate:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			PullRequestStatus: types.PullRequestStatusEnum("OPEN"),
			AuthorArn:         ptr.String("__AuthorArn__"),
			PullRequestTargets: []types.PullRequestTarget{
				{
					RepositoryName:       ptr.String("__RepositoryName__"),
					SourceReference:      ptr.String("__SourceReference__"),
					DestinationReference: ptr.String("__DestinationReference__"),
					DestinationCommit:    ptr.String("__DestinationCommit__"),
					SourceCommit:         ptr.String("__SourceCommit__"),
					MergeBase:            ptr.String("__MergeBase__"),
					MergeMetadata: &types.MergeMetadata{
						IsMerged:      true,
						MergedBy:      ptr.String("__MergedBy__"),
						MergeCommitId: ptr.String("__MergeCommitId__"),
						MergeOption:   types.MergeOptionTypeEnum("FAST_FORWARD_MERGE"),
					},
				},
				{
					RepositoryName:       ptr.String("__RepositoryName__"),
					SourceReference:      ptr.String("__SourceReference__"),
					DestinationReference: ptr.String("__DestinationReference__"),
					DestinationCommit:    ptr.String("__DestinationCommit__"),
					SourceCommit:         ptr.String("__SourceCommit__"),
					MergeBase:            ptr.String("__MergeBase__"),
					MergeMetadata: &types.MergeMetadata{
						IsMerged:      true,
						MergedBy:      ptr.String("__MergedBy__"),
						MergeCommitId: ptr.String("__MergeCommitId__"),
						MergeOption:   types.MergeOptionTypeEnum("FAST_FORWARD_MERGE"),
					},
				},
			},
			ClientRequestToken: ptr.String("__ClientRequestToken__"),
			RevisionId:         ptr.String("__RevisionId__"),
			ApprovalRules: []types.ApprovalRule{
				{
					ApprovalRuleId:      ptr.String("__ApprovalRuleId__"),
					ApprovalRuleName:    ptr.String("__ApprovalRuleName__"),
					ApprovalRuleContent: ptr.String("__ApprovalRuleContent__"),
					RuleContentSha256:   ptr.String("__RuleContentSha256__"),
					LastModifiedDate:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					CreationDate:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					LastModifiedUser:    ptr.String("__LastModifiedUser__"),
					OriginApprovalRuleTemplate: &types.OriginApprovalRuleTemplate{
						ApprovalRuleTemplateId:   ptr.String("__ApprovalRuleTemplateId__"),
						ApprovalRuleTemplateName: ptr.String("__ApprovalRuleTemplateName__"),
					},
				},
				{
					ApprovalRuleId:      ptr.String("__ApprovalRuleId__"),
					ApprovalRuleName:    ptr.String("__ApprovalRuleName__"),
					ApprovalRuleContent: ptr.String("__ApprovalRuleContent__"),
					RuleContentSha256:   ptr.String("__RuleContentSha256__"),
					LastModifiedDate:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					CreationDate:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					LastModifiedUser:    ptr.String("__LastModifiedUser__"),
					OriginApprovalRuleTemplate: &types.OriginApprovalRuleTemplate{
						ApprovalRuleTemplateId:   ptr.String("__ApprovalRuleTemplateId__"),
						ApprovalRuleTemplateName: ptr.String("__ApprovalRuleTemplateName__"),
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("MergePullRequestByThreeWay.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.MergePullRequestByThreeWay(context.Background(), &MergePullRequestByThreeWayInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "MergePullRequestByThreeWay.response", err)
	}
}

func TestCheckResponseSnapshot_OverridePullRequestApprovalRules(t *testing.T) {
	want := &OverridePullRequestApprovalRulesOutput{}
	status, header, body, err := serdeRespReadSnapshot("OverridePullRequestApprovalRules.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.OverridePullRequestApprovalRules(context.Background(), &OverridePullRequestApprovalRulesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "OverridePullRequestApprovalRules.response", err)
	}
}

func TestCheckResponseSnapshot_PostCommentForComparedCommit(t *testing.T) {
	want := &PostCommentForComparedCommitOutput{
		RepositoryName: ptr.String("__RepositoryName__"),
		BeforeCommitId: ptr.String("__BeforeCommitId__"),
		AfterCommitId:  ptr.String("__AfterCommitId__"),
		BeforeBlobId:   ptr.String("__BeforeBlobId__"),
		AfterBlobId:    ptr.String("__AfterBlobId__"),
		Location: &types.Location{
			FilePath:            ptr.String("__FilePath__"),
			FilePosition:        ptr.Int64(1),
			RelativeFileVersion: types.RelativeFileVersionEnum("BEFORE"),
		},
		Comment: &types.Comment{
			CommentId:          ptr.String("__CommentId__"),
			Content:            ptr.String("__Content__"),
			InReplyTo:          ptr.String("__InReplyTo__"),
			CreationDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LastModifiedDate:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			AuthorArn:          ptr.String("__AuthorArn__"),
			Deleted:            true,
			ClientRequestToken: ptr.String("__ClientRequestToken__"),
			CallerReactions: []string{
				"__Member__",
				"__Member__",
			},
			ReactionCounts: map[string]int32{
				"key0": 1,
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("PostCommentForComparedCommit.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.PostCommentForComparedCommit(context.Background(), &PostCommentForComparedCommitInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PostCommentForComparedCommit.response", err)
	}
}

func TestCheckResponseSnapshot_PostCommentForPullRequest(t *testing.T) {
	want := &PostCommentForPullRequestOutput{
		RepositoryName: ptr.String("__RepositoryName__"),
		PullRequestId:  ptr.String("__PullRequestId__"),
		BeforeCommitId: ptr.String("__BeforeCommitId__"),
		AfterCommitId:  ptr.String("__AfterCommitId__"),
		BeforeBlobId:   ptr.String("__BeforeBlobId__"),
		AfterBlobId:    ptr.String("__AfterBlobId__"),
		Location: &types.Location{
			FilePath:            ptr.String("__FilePath__"),
			FilePosition:        ptr.Int64(1),
			RelativeFileVersion: types.RelativeFileVersionEnum("BEFORE"),
		},
		Comment: &types.Comment{
			CommentId:          ptr.String("__CommentId__"),
			Content:            ptr.String("__Content__"),
			InReplyTo:          ptr.String("__InReplyTo__"),
			CreationDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LastModifiedDate:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			AuthorArn:          ptr.String("__AuthorArn__"),
			Deleted:            true,
			ClientRequestToken: ptr.String("__ClientRequestToken__"),
			CallerReactions: []string{
				"__Member__",
				"__Member__",
			},
			ReactionCounts: map[string]int32{
				"key0": 1,
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("PostCommentForPullRequest.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.PostCommentForPullRequest(context.Background(), &PostCommentForPullRequestInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PostCommentForPullRequest.response", err)
	}
}

func TestCheckResponseSnapshot_PostCommentReply(t *testing.T) {
	want := &PostCommentReplyOutput{
		Comment: &types.Comment{
			CommentId:          ptr.String("__CommentId__"),
			Content:            ptr.String("__Content__"),
			InReplyTo:          ptr.String("__InReplyTo__"),
			CreationDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LastModifiedDate:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			AuthorArn:          ptr.String("__AuthorArn__"),
			Deleted:            true,
			ClientRequestToken: ptr.String("__ClientRequestToken__"),
			CallerReactions: []string{
				"__Member__",
				"__Member__",
			},
			ReactionCounts: map[string]int32{
				"key0": 1,
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("PostCommentReply.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.PostCommentReply(context.Background(), &PostCommentReplyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PostCommentReply.response", err)
	}
}

func TestCheckResponseSnapshot_PutCommentReaction(t *testing.T) {
	want := &PutCommentReactionOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutCommentReaction.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.PutCommentReaction(context.Background(), &PutCommentReactionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutCommentReaction.response", err)
	}
}

func TestCheckResponseSnapshot_PutFile(t *testing.T) {
	want := &PutFileOutput{
		CommitId: ptr.String("__CommitId__"),
		BlobId:   ptr.String("__BlobId__"),
		TreeId:   ptr.String("__TreeId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PutFile.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.PutFile(context.Background(), &PutFileInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutFile.response", err)
	}
}

func TestCheckResponseSnapshot_PutRepositoryTriggers(t *testing.T) {
	want := &PutRepositoryTriggersOutput{
		ConfigurationId: ptr.String("__ConfigurationId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PutRepositoryTriggers.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.PutRepositoryTriggers(context.Background(), &PutRepositoryTriggersInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutRepositoryTriggers.response", err)
	}
}

func TestCheckResponseSnapshot_TagResource(t *testing.T) {
	want := &TagResourceOutput{}
	status, header, body, err := serdeRespReadSnapshot("TagResource.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.TagResource(context.Background(), &TagResourceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "TagResource.response", err)
	}
}

func TestCheckResponseSnapshot_TestRepositoryTriggers(t *testing.T) {
	want := &TestRepositoryTriggersOutput{
		SuccessfulExecutions: []string{
			"__Member__",
			"__Member__",
		},
		FailedExecutions: []types.RepositoryTriggerExecutionFailure{
			{
				Trigger:        ptr.String("__Trigger__"),
				FailureMessage: ptr.String("__FailureMessage__"),
			},
			{
				Trigger:        ptr.String("__Trigger__"),
				FailureMessage: ptr.String("__FailureMessage__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("TestRepositoryTriggers.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.TestRepositoryTriggers(context.Background(), &TestRepositoryTriggersInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "TestRepositoryTriggers.response", err)
	}
}

func TestCheckResponseSnapshot_UntagResource(t *testing.T) {
	want := &UntagResourceOutput{}
	status, header, body, err := serdeRespReadSnapshot("UntagResource.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.UntagResource(context.Background(), &UntagResourceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UntagResource.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateApprovalRuleTemplateContent(t *testing.T) {
	want := &UpdateApprovalRuleTemplateContentOutput{
		ApprovalRuleTemplate: &types.ApprovalRuleTemplate{
			ApprovalRuleTemplateId:          ptr.String("__ApprovalRuleTemplateId__"),
			ApprovalRuleTemplateName:        ptr.String("__ApprovalRuleTemplateName__"),
			ApprovalRuleTemplateDescription: ptr.String("__ApprovalRuleTemplateDescription__"),
			ApprovalRuleTemplateContent:     ptr.String("__ApprovalRuleTemplateContent__"),
			RuleContentSha256:               ptr.String("__RuleContentSha256__"),
			LastModifiedDate:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CreationDate:                    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LastModifiedUser:                ptr.String("__LastModifiedUser__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateApprovalRuleTemplateContent.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.UpdateApprovalRuleTemplateContent(context.Background(), &UpdateApprovalRuleTemplateContentInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateApprovalRuleTemplateContent.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateApprovalRuleTemplateDescription(t *testing.T) {
	want := &UpdateApprovalRuleTemplateDescriptionOutput{
		ApprovalRuleTemplate: &types.ApprovalRuleTemplate{
			ApprovalRuleTemplateId:          ptr.String("__ApprovalRuleTemplateId__"),
			ApprovalRuleTemplateName:        ptr.String("__ApprovalRuleTemplateName__"),
			ApprovalRuleTemplateDescription: ptr.String("__ApprovalRuleTemplateDescription__"),
			ApprovalRuleTemplateContent:     ptr.String("__ApprovalRuleTemplateContent__"),
			RuleContentSha256:               ptr.String("__RuleContentSha256__"),
			LastModifiedDate:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CreationDate:                    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LastModifiedUser:                ptr.String("__LastModifiedUser__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateApprovalRuleTemplateDescription.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.UpdateApprovalRuleTemplateDescription(context.Background(), &UpdateApprovalRuleTemplateDescriptionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateApprovalRuleTemplateDescription.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateApprovalRuleTemplateName(t *testing.T) {
	want := &UpdateApprovalRuleTemplateNameOutput{
		ApprovalRuleTemplate: &types.ApprovalRuleTemplate{
			ApprovalRuleTemplateId:          ptr.String("__ApprovalRuleTemplateId__"),
			ApprovalRuleTemplateName:        ptr.String("__ApprovalRuleTemplateName__"),
			ApprovalRuleTemplateDescription: ptr.String("__ApprovalRuleTemplateDescription__"),
			ApprovalRuleTemplateContent:     ptr.String("__ApprovalRuleTemplateContent__"),
			RuleContentSha256:               ptr.String("__RuleContentSha256__"),
			LastModifiedDate:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CreationDate:                    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LastModifiedUser:                ptr.String("__LastModifiedUser__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateApprovalRuleTemplateName.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.UpdateApprovalRuleTemplateName(context.Background(), &UpdateApprovalRuleTemplateNameInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateApprovalRuleTemplateName.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateComment(t *testing.T) {
	want := &UpdateCommentOutput{
		Comment: &types.Comment{
			CommentId:          ptr.String("__CommentId__"),
			Content:            ptr.String("__Content__"),
			InReplyTo:          ptr.String("__InReplyTo__"),
			CreationDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LastModifiedDate:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			AuthorArn:          ptr.String("__AuthorArn__"),
			Deleted:            true,
			ClientRequestToken: ptr.String("__ClientRequestToken__"),
			CallerReactions: []string{
				"__Member__",
				"__Member__",
			},
			ReactionCounts: map[string]int32{
				"key0": 1,
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateComment.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.UpdateComment(context.Background(), &UpdateCommentInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateComment.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateDefaultBranch(t *testing.T) {
	want := &UpdateDefaultBranchOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdateDefaultBranch.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.UpdateDefaultBranch(context.Background(), &UpdateDefaultBranchInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateDefaultBranch.response", err)
	}
}

func TestCheckResponseSnapshot_UpdatePullRequestApprovalRuleContent(t *testing.T) {
	want := &UpdatePullRequestApprovalRuleContentOutput{
		ApprovalRule: &types.ApprovalRule{
			ApprovalRuleId:      ptr.String("__ApprovalRuleId__"),
			ApprovalRuleName:    ptr.String("__ApprovalRuleName__"),
			ApprovalRuleContent: ptr.String("__ApprovalRuleContent__"),
			RuleContentSha256:   ptr.String("__RuleContentSha256__"),
			LastModifiedDate:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CreationDate:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LastModifiedUser:    ptr.String("__LastModifiedUser__"),
			OriginApprovalRuleTemplate: &types.OriginApprovalRuleTemplate{
				ApprovalRuleTemplateId:   ptr.String("__ApprovalRuleTemplateId__"),
				ApprovalRuleTemplateName: ptr.String("__ApprovalRuleTemplateName__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdatePullRequestApprovalRuleContent.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.UpdatePullRequestApprovalRuleContent(context.Background(), &UpdatePullRequestApprovalRuleContentInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdatePullRequestApprovalRuleContent.response", err)
	}
}

func TestCheckResponseSnapshot_UpdatePullRequestApprovalState(t *testing.T) {
	want := &UpdatePullRequestApprovalStateOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdatePullRequestApprovalState.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.UpdatePullRequestApprovalState(context.Background(), &UpdatePullRequestApprovalStateInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdatePullRequestApprovalState.response", err)
	}
}

func TestCheckResponseSnapshot_UpdatePullRequestDescription(t *testing.T) {
	want := &UpdatePullRequestDescriptionOutput{
		PullRequest: &types.PullRequest{
			PullRequestId:     ptr.String("__PullRequestId__"),
			Title:             ptr.String("__Title__"),
			Description:       ptr.String("__Description__"),
			LastActivityDate:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CreationDate:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			PullRequestStatus: types.PullRequestStatusEnum("OPEN"),
			AuthorArn:         ptr.String("__AuthorArn__"),
			PullRequestTargets: []types.PullRequestTarget{
				{
					RepositoryName:       ptr.String("__RepositoryName__"),
					SourceReference:      ptr.String("__SourceReference__"),
					DestinationReference: ptr.String("__DestinationReference__"),
					DestinationCommit:    ptr.String("__DestinationCommit__"),
					SourceCommit:         ptr.String("__SourceCommit__"),
					MergeBase:            ptr.String("__MergeBase__"),
					MergeMetadata: &types.MergeMetadata{
						IsMerged:      true,
						MergedBy:      ptr.String("__MergedBy__"),
						MergeCommitId: ptr.String("__MergeCommitId__"),
						MergeOption:   types.MergeOptionTypeEnum("FAST_FORWARD_MERGE"),
					},
				},
				{
					RepositoryName:       ptr.String("__RepositoryName__"),
					SourceReference:      ptr.String("__SourceReference__"),
					DestinationReference: ptr.String("__DestinationReference__"),
					DestinationCommit:    ptr.String("__DestinationCommit__"),
					SourceCommit:         ptr.String("__SourceCommit__"),
					MergeBase:            ptr.String("__MergeBase__"),
					MergeMetadata: &types.MergeMetadata{
						IsMerged:      true,
						MergedBy:      ptr.String("__MergedBy__"),
						MergeCommitId: ptr.String("__MergeCommitId__"),
						MergeOption:   types.MergeOptionTypeEnum("FAST_FORWARD_MERGE"),
					},
				},
			},
			ClientRequestToken: ptr.String("__ClientRequestToken__"),
			RevisionId:         ptr.String("__RevisionId__"),
			ApprovalRules: []types.ApprovalRule{
				{
					ApprovalRuleId:      ptr.String("__ApprovalRuleId__"),
					ApprovalRuleName:    ptr.String("__ApprovalRuleName__"),
					ApprovalRuleContent: ptr.String("__ApprovalRuleContent__"),
					RuleContentSha256:   ptr.String("__RuleContentSha256__"),
					LastModifiedDate:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					CreationDate:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					LastModifiedUser:    ptr.String("__LastModifiedUser__"),
					OriginApprovalRuleTemplate: &types.OriginApprovalRuleTemplate{
						ApprovalRuleTemplateId:   ptr.String("__ApprovalRuleTemplateId__"),
						ApprovalRuleTemplateName: ptr.String("__ApprovalRuleTemplateName__"),
					},
				},
				{
					ApprovalRuleId:      ptr.String("__ApprovalRuleId__"),
					ApprovalRuleName:    ptr.String("__ApprovalRuleName__"),
					ApprovalRuleContent: ptr.String("__ApprovalRuleContent__"),
					RuleContentSha256:   ptr.String("__RuleContentSha256__"),
					LastModifiedDate:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					CreationDate:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					LastModifiedUser:    ptr.String("__LastModifiedUser__"),
					OriginApprovalRuleTemplate: &types.OriginApprovalRuleTemplate{
						ApprovalRuleTemplateId:   ptr.String("__ApprovalRuleTemplateId__"),
						ApprovalRuleTemplateName: ptr.String("__ApprovalRuleTemplateName__"),
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdatePullRequestDescription.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.UpdatePullRequestDescription(context.Background(), &UpdatePullRequestDescriptionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdatePullRequestDescription.response", err)
	}
}

func TestCheckResponseSnapshot_UpdatePullRequestStatus(t *testing.T) {
	want := &UpdatePullRequestStatusOutput{
		PullRequest: &types.PullRequest{
			PullRequestId:     ptr.String("__PullRequestId__"),
			Title:             ptr.String("__Title__"),
			Description:       ptr.String("__Description__"),
			LastActivityDate:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CreationDate:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			PullRequestStatus: types.PullRequestStatusEnum("OPEN"),
			AuthorArn:         ptr.String("__AuthorArn__"),
			PullRequestTargets: []types.PullRequestTarget{
				{
					RepositoryName:       ptr.String("__RepositoryName__"),
					SourceReference:      ptr.String("__SourceReference__"),
					DestinationReference: ptr.String("__DestinationReference__"),
					DestinationCommit:    ptr.String("__DestinationCommit__"),
					SourceCommit:         ptr.String("__SourceCommit__"),
					MergeBase:            ptr.String("__MergeBase__"),
					MergeMetadata: &types.MergeMetadata{
						IsMerged:      true,
						MergedBy:      ptr.String("__MergedBy__"),
						MergeCommitId: ptr.String("__MergeCommitId__"),
						MergeOption:   types.MergeOptionTypeEnum("FAST_FORWARD_MERGE"),
					},
				},
				{
					RepositoryName:       ptr.String("__RepositoryName__"),
					SourceReference:      ptr.String("__SourceReference__"),
					DestinationReference: ptr.String("__DestinationReference__"),
					DestinationCommit:    ptr.String("__DestinationCommit__"),
					SourceCommit:         ptr.String("__SourceCommit__"),
					MergeBase:            ptr.String("__MergeBase__"),
					MergeMetadata: &types.MergeMetadata{
						IsMerged:      true,
						MergedBy:      ptr.String("__MergedBy__"),
						MergeCommitId: ptr.String("__MergeCommitId__"),
						MergeOption:   types.MergeOptionTypeEnum("FAST_FORWARD_MERGE"),
					},
				},
			},
			ClientRequestToken: ptr.String("__ClientRequestToken__"),
			RevisionId:         ptr.String("__RevisionId__"),
			ApprovalRules: []types.ApprovalRule{
				{
					ApprovalRuleId:      ptr.String("__ApprovalRuleId__"),
					ApprovalRuleName:    ptr.String("__ApprovalRuleName__"),
					ApprovalRuleContent: ptr.String("__ApprovalRuleContent__"),
					RuleContentSha256:   ptr.String("__RuleContentSha256__"),
					LastModifiedDate:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					CreationDate:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					LastModifiedUser:    ptr.String("__LastModifiedUser__"),
					OriginApprovalRuleTemplate: &types.OriginApprovalRuleTemplate{
						ApprovalRuleTemplateId:   ptr.String("__ApprovalRuleTemplateId__"),
						ApprovalRuleTemplateName: ptr.String("__ApprovalRuleTemplateName__"),
					},
				},
				{
					ApprovalRuleId:      ptr.String("__ApprovalRuleId__"),
					ApprovalRuleName:    ptr.String("__ApprovalRuleName__"),
					ApprovalRuleContent: ptr.String("__ApprovalRuleContent__"),
					RuleContentSha256:   ptr.String("__RuleContentSha256__"),
					LastModifiedDate:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					CreationDate:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					LastModifiedUser:    ptr.String("__LastModifiedUser__"),
					OriginApprovalRuleTemplate: &types.OriginApprovalRuleTemplate{
						ApprovalRuleTemplateId:   ptr.String("__ApprovalRuleTemplateId__"),
						ApprovalRuleTemplateName: ptr.String("__ApprovalRuleTemplateName__"),
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdatePullRequestStatus.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.UpdatePullRequestStatus(context.Background(), &UpdatePullRequestStatusInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdatePullRequestStatus.response", err)
	}
}

func TestCheckResponseSnapshot_UpdatePullRequestTitle(t *testing.T) {
	want := &UpdatePullRequestTitleOutput{
		PullRequest: &types.PullRequest{
			PullRequestId:     ptr.String("__PullRequestId__"),
			Title:             ptr.String("__Title__"),
			Description:       ptr.String("__Description__"),
			LastActivityDate:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CreationDate:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			PullRequestStatus: types.PullRequestStatusEnum("OPEN"),
			AuthorArn:         ptr.String("__AuthorArn__"),
			PullRequestTargets: []types.PullRequestTarget{
				{
					RepositoryName:       ptr.String("__RepositoryName__"),
					SourceReference:      ptr.String("__SourceReference__"),
					DestinationReference: ptr.String("__DestinationReference__"),
					DestinationCommit:    ptr.String("__DestinationCommit__"),
					SourceCommit:         ptr.String("__SourceCommit__"),
					MergeBase:            ptr.String("__MergeBase__"),
					MergeMetadata: &types.MergeMetadata{
						IsMerged:      true,
						MergedBy:      ptr.String("__MergedBy__"),
						MergeCommitId: ptr.String("__MergeCommitId__"),
						MergeOption:   types.MergeOptionTypeEnum("FAST_FORWARD_MERGE"),
					},
				},
				{
					RepositoryName:       ptr.String("__RepositoryName__"),
					SourceReference:      ptr.String("__SourceReference__"),
					DestinationReference: ptr.String("__DestinationReference__"),
					DestinationCommit:    ptr.String("__DestinationCommit__"),
					SourceCommit:         ptr.String("__SourceCommit__"),
					MergeBase:            ptr.String("__MergeBase__"),
					MergeMetadata: &types.MergeMetadata{
						IsMerged:      true,
						MergedBy:      ptr.String("__MergedBy__"),
						MergeCommitId: ptr.String("__MergeCommitId__"),
						MergeOption:   types.MergeOptionTypeEnum("FAST_FORWARD_MERGE"),
					},
				},
			},
			ClientRequestToken: ptr.String("__ClientRequestToken__"),
			RevisionId:         ptr.String("__RevisionId__"),
			ApprovalRules: []types.ApprovalRule{
				{
					ApprovalRuleId:      ptr.String("__ApprovalRuleId__"),
					ApprovalRuleName:    ptr.String("__ApprovalRuleName__"),
					ApprovalRuleContent: ptr.String("__ApprovalRuleContent__"),
					RuleContentSha256:   ptr.String("__RuleContentSha256__"),
					LastModifiedDate:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					CreationDate:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					LastModifiedUser:    ptr.String("__LastModifiedUser__"),
					OriginApprovalRuleTemplate: &types.OriginApprovalRuleTemplate{
						ApprovalRuleTemplateId:   ptr.String("__ApprovalRuleTemplateId__"),
						ApprovalRuleTemplateName: ptr.String("__ApprovalRuleTemplateName__"),
					},
				},
				{
					ApprovalRuleId:      ptr.String("__ApprovalRuleId__"),
					ApprovalRuleName:    ptr.String("__ApprovalRuleName__"),
					ApprovalRuleContent: ptr.String("__ApprovalRuleContent__"),
					RuleContentSha256:   ptr.String("__RuleContentSha256__"),
					LastModifiedDate:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					CreationDate:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					LastModifiedUser:    ptr.String("__LastModifiedUser__"),
					OriginApprovalRuleTemplate: &types.OriginApprovalRuleTemplate{
						ApprovalRuleTemplateId:   ptr.String("__ApprovalRuleTemplateId__"),
						ApprovalRuleTemplateName: ptr.String("__ApprovalRuleTemplateName__"),
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdatePullRequestTitle.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.UpdatePullRequestTitle(context.Background(), &UpdatePullRequestTitleInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdatePullRequestTitle.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateRepositoryDescription(t *testing.T) {
	want := &UpdateRepositoryDescriptionOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdateRepositoryDescription.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.UpdateRepositoryDescription(context.Background(), &UpdateRepositoryDescriptionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateRepositoryDescription.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateRepositoryEncryptionKey(t *testing.T) {
	want := &UpdateRepositoryEncryptionKeyOutput{
		RepositoryId:     ptr.String("__RepositoryId__"),
		KmsKeyId:         ptr.String("__KmsKeyId__"),
		OriginalKmsKeyId: ptr.String("__OriginalKmsKeyId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateRepositoryEncryptionKey.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.UpdateRepositoryEncryptionKey(context.Background(), &UpdateRepositoryEncryptionKeyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateRepositoryEncryptionKey.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateRepositoryName(t *testing.T) {
	want := &UpdateRepositoryNameOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdateRepositoryName.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.UpdateRepositoryName(context.Background(), &UpdateRepositoryNameInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateRepositoryName.response", err)
	}
}

func TestCheckResponseSnapshot_Error_ActorDoesNotExistException(t *testing.T) {
	want := &types.ActorDoesNotExistException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ActorDoesNotExistException.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.DescribePullRequestEvents(context.Background(), &DescribePullRequestEventsInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ActorDoesNotExistException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ActorDoesNotExistException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ActorDoesNotExistException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ApprovalRuleContentRequiredException(t *testing.T) {
	want := &types.ApprovalRuleContentRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ApprovalRuleContentRequiredException.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.CreatePullRequestApprovalRule(context.Background(), &CreatePullRequestApprovalRuleInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ApprovalRuleContentRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ApprovalRuleContentRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ApprovalRuleContentRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ApprovalRuleDoesNotExistException(t *testing.T) {
	want := &types.ApprovalRuleDoesNotExistException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ApprovalRuleDoesNotExistException.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.UpdatePullRequestApprovalRuleContent(context.Background(), &UpdatePullRequestApprovalRuleContentInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ApprovalRuleDoesNotExistException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ApprovalRuleDoesNotExistException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ApprovalRuleDoesNotExistException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ApprovalRuleNameAlreadyExistsException(t *testing.T) {
	want := &types.ApprovalRuleNameAlreadyExistsException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ApprovalRuleNameAlreadyExistsException.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.CreatePullRequestApprovalRule(context.Background(), &CreatePullRequestApprovalRuleInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ApprovalRuleNameAlreadyExistsException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ApprovalRuleNameAlreadyExistsException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ApprovalRuleNameAlreadyExistsException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ApprovalRuleNameRequiredException(t *testing.T) {
	want := &types.ApprovalRuleNameRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ApprovalRuleNameRequiredException.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.CreatePullRequestApprovalRule(context.Background(), &CreatePullRequestApprovalRuleInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ApprovalRuleNameRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ApprovalRuleNameRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ApprovalRuleNameRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ApprovalRuleTemplateContentRequiredException(t *testing.T) {
	want := &types.ApprovalRuleTemplateContentRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ApprovalRuleTemplateContentRequiredException.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.CreateApprovalRuleTemplate(context.Background(), &CreateApprovalRuleTemplateInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ApprovalRuleTemplateContentRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ApprovalRuleTemplateContentRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ApprovalRuleTemplateContentRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ApprovalRuleTemplateDoesNotExistException(t *testing.T) {
	want := &types.ApprovalRuleTemplateDoesNotExistException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ApprovalRuleTemplateDoesNotExistException.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.AssociateApprovalRuleTemplateWithRepository(context.Background(), &AssociateApprovalRuleTemplateWithRepositoryInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ApprovalRuleTemplateDoesNotExistException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ApprovalRuleTemplateDoesNotExistException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ApprovalRuleTemplateDoesNotExistException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ApprovalRuleTemplateInUseException(t *testing.T) {
	want := &types.ApprovalRuleTemplateInUseException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ApprovalRuleTemplateInUseException.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.DeleteApprovalRuleTemplate(context.Background(), &DeleteApprovalRuleTemplateInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ApprovalRuleTemplateInUseException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ApprovalRuleTemplateInUseException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ApprovalRuleTemplateInUseException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ApprovalRuleTemplateNameAlreadyExistsException(t *testing.T) {
	want := &types.ApprovalRuleTemplateNameAlreadyExistsException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ApprovalRuleTemplateNameAlreadyExistsException.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.CreateApprovalRuleTemplate(context.Background(), &CreateApprovalRuleTemplateInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ApprovalRuleTemplateNameAlreadyExistsException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ApprovalRuleTemplateNameAlreadyExistsException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ApprovalRuleTemplateNameAlreadyExistsException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ApprovalRuleTemplateNameRequiredException(t *testing.T) {
	want := &types.ApprovalRuleTemplateNameRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ApprovalRuleTemplateNameRequiredException.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.AssociateApprovalRuleTemplateWithRepository(context.Background(), &AssociateApprovalRuleTemplateWithRepositoryInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ApprovalRuleTemplateNameRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ApprovalRuleTemplateNameRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ApprovalRuleTemplateNameRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ApprovalStateRequiredException(t *testing.T) {
	want := &types.ApprovalStateRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ApprovalStateRequiredException.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.UpdatePullRequestApprovalState(context.Background(), &UpdatePullRequestApprovalStateInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ApprovalStateRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ApprovalStateRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ApprovalStateRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_AuthorDoesNotExistException(t *testing.T) {
	want := &types.AuthorDoesNotExistException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("AuthorDoesNotExistException.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.ListPullRequests(context.Background(), &ListPullRequestsInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.AuthorDoesNotExistException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.AuthorDoesNotExistException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "AuthorDoesNotExistException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_BeforeCommitIdAndAfterCommitIdAreSameException(t *testing.T) {
	want := &types.BeforeCommitIdAndAfterCommitIdAreSameException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("BeforeCommitIdAndAfterCommitIdAreSameException.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.PostCommentForComparedCommit(context.Background(), &PostCommentForComparedCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.BeforeCommitIdAndAfterCommitIdAreSameException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.BeforeCommitIdAndAfterCommitIdAreSameException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "BeforeCommitIdAndAfterCommitIdAreSameException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_BlobIdDoesNotExistException(t *testing.T) {
	want := &types.BlobIdDoesNotExistException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("BlobIdDoesNotExistException.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.GetBlob(context.Background(), &GetBlobInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.BlobIdDoesNotExistException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.BlobIdDoesNotExistException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "BlobIdDoesNotExistException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_BlobIdRequiredException(t *testing.T) {
	want := &types.BlobIdRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("BlobIdRequiredException.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.GetBlob(context.Background(), &GetBlobInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.BlobIdRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.BlobIdRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "BlobIdRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_BranchDoesNotExistException(t *testing.T) {
	want := &types.BranchDoesNotExistException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("BranchDoesNotExistException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.BranchDoesNotExistException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.BranchDoesNotExistException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "BranchDoesNotExistException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_BranchNameExistsException(t *testing.T) {
	want := &types.BranchNameExistsException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("BranchNameExistsException.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.CreateBranch(context.Background(), &CreateBranchInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.BranchNameExistsException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.BranchNameExistsException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "BranchNameExistsException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_BranchNameIsTagNameException(t *testing.T) {
	want := &types.BranchNameIsTagNameException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("BranchNameIsTagNameException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.BranchNameIsTagNameException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.BranchNameIsTagNameException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "BranchNameIsTagNameException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_BranchNameRequiredException(t *testing.T) {
	want := &types.BranchNameRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("BranchNameRequiredException.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.CreateBranch(context.Background(), &CreateBranchInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.BranchNameRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.BranchNameRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "BranchNameRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_CannotDeleteApprovalRuleFromTemplateException(t *testing.T) {
	want := &types.CannotDeleteApprovalRuleFromTemplateException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CannotDeleteApprovalRuleFromTemplateException.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.DeletePullRequestApprovalRule(context.Background(), &DeletePullRequestApprovalRuleInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.CannotDeleteApprovalRuleFromTemplateException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.CannotDeleteApprovalRuleFromTemplateException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "CannotDeleteApprovalRuleFromTemplateException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_CannotModifyApprovalRuleFromTemplateException(t *testing.T) {
	want := &types.CannotModifyApprovalRuleFromTemplateException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CannotModifyApprovalRuleFromTemplateException.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.UpdatePullRequestApprovalRuleContent(context.Background(), &UpdatePullRequestApprovalRuleContentInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.CannotModifyApprovalRuleFromTemplateException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.CannotModifyApprovalRuleFromTemplateException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "CannotModifyApprovalRuleFromTemplateException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ClientRequestTokenRequiredException(t *testing.T) {
	want := &types.ClientRequestTokenRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ClientRequestTokenRequiredException.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.CreatePullRequest(context.Background(), &CreatePullRequestInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ClientRequestTokenRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ClientRequestTokenRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ClientRequestTokenRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_CommentContentRequiredException(t *testing.T) {
	want := &types.CommentContentRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CommentContentRequiredException.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.PostCommentForComparedCommit(context.Background(), &PostCommentForComparedCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.CommentContentRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.CommentContentRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "CommentContentRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_CommentContentSizeLimitExceededException(t *testing.T) {
	want := &types.CommentContentSizeLimitExceededException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CommentContentSizeLimitExceededException.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.PostCommentForComparedCommit(context.Background(), &PostCommentForComparedCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.CommentContentSizeLimitExceededException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.CommentContentSizeLimitExceededException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "CommentContentSizeLimitExceededException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_CommentDeletedException(t *testing.T) {
	want := &types.CommentDeletedException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CommentDeletedException.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.DeleteCommentContent(context.Background(), &DeleteCommentContentInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.CommentDeletedException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.CommentDeletedException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "CommentDeletedException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_CommentDoesNotExistException(t *testing.T) {
	want := &types.CommentDoesNotExistException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CommentDoesNotExistException.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.DeleteCommentContent(context.Background(), &DeleteCommentContentInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.CommentDoesNotExistException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.CommentDoesNotExistException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "CommentDoesNotExistException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_CommentIdRequiredException(t *testing.T) {
	want := &types.CommentIdRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CommentIdRequiredException.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.DeleteCommentContent(context.Background(), &DeleteCommentContentInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.CommentIdRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.CommentIdRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "CommentIdRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_CommentNotCreatedByCallerException(t *testing.T) {
	want := &types.CommentNotCreatedByCallerException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CommentNotCreatedByCallerException.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.UpdateComment(context.Background(), &UpdateCommentInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.CommentNotCreatedByCallerException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.CommentNotCreatedByCallerException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "CommentNotCreatedByCallerException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_CommitDoesNotExistException(t *testing.T) {
	want := &types.CommitDoesNotExistException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CommitDoesNotExistException.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.BatchDescribeMergeConflicts(context.Background(), &BatchDescribeMergeConflictsInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.CommitDoesNotExistException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.CommitDoesNotExistException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "CommitDoesNotExistException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_CommitIdDoesNotExistException(t *testing.T) {
	want := &types.CommitIdDoesNotExistException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CommitIdDoesNotExistException.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.GetCommit(context.Background(), &GetCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.CommitIdDoesNotExistException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.CommitIdDoesNotExistException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "CommitIdDoesNotExistException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_CommitIdRequiredException(t *testing.T) {
	want := &types.CommitIdRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CommitIdRequiredException.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.CreateBranch(context.Background(), &CreateBranchInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.CommitIdRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.CommitIdRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "CommitIdRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_CommitIdsLimitExceededException(t *testing.T) {
	want := &types.CommitIdsLimitExceededException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CommitIdsLimitExceededException.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.BatchGetCommits(context.Background(), &BatchGetCommitsInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.CommitIdsLimitExceededException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.CommitIdsLimitExceededException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "CommitIdsLimitExceededException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_CommitIdsListRequiredException(t *testing.T) {
	want := &types.CommitIdsListRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CommitIdsListRequiredException.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.BatchGetCommits(context.Background(), &BatchGetCommitsInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.CommitIdsListRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.CommitIdsListRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "CommitIdsListRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_CommitMessageLengthExceededException(t *testing.T) {
	want := &types.CommitMessageLengthExceededException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CommitMessageLengthExceededException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.CommitMessageLengthExceededException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.CommitMessageLengthExceededException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "CommitMessageLengthExceededException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_CommitRequiredException(t *testing.T) {
	want := &types.CommitRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CommitRequiredException.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.BatchDescribeMergeConflicts(context.Background(), &BatchDescribeMergeConflictsInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.CommitRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.CommitRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "CommitRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ConcurrentReferenceUpdateException(t *testing.T) {
	want := &types.ConcurrentReferenceUpdateException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ConcurrentReferenceUpdateException.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.CreateUnreferencedMergeCommit(context.Background(), &CreateUnreferencedMergeCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ConcurrentReferenceUpdateException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ConcurrentReferenceUpdateException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ConcurrentReferenceUpdateException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_DefaultBranchCannotBeDeletedException(t *testing.T) {
	want := &types.DefaultBranchCannotBeDeletedException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DefaultBranchCannotBeDeletedException.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.DeleteBranch(context.Background(), &DeleteBranchInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.DefaultBranchCannotBeDeletedException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.DefaultBranchCannotBeDeletedException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "DefaultBranchCannotBeDeletedException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_DirectoryNameConflictsWithFileNameException(t *testing.T) {
	want := &types.DirectoryNameConflictsWithFileNameException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DirectoryNameConflictsWithFileNameException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.DirectoryNameConflictsWithFileNameException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.DirectoryNameConflictsWithFileNameException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "DirectoryNameConflictsWithFileNameException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_EncryptionIntegrityChecksFailedException(t *testing.T) {
	want := &types.EncryptionIntegrityChecksFailedException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("EncryptionIntegrityChecksFailedException.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.AssociateApprovalRuleTemplateWithRepository(context.Background(), &AssociateApprovalRuleTemplateWithRepositoryInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.EncryptionIntegrityChecksFailedException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.EncryptionIntegrityChecksFailedException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "EncryptionIntegrityChecksFailedException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_EncryptionKeyAccessDeniedException(t *testing.T) {
	want := &types.EncryptionKeyAccessDeniedException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("EncryptionKeyAccessDeniedException.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.AssociateApprovalRuleTemplateWithRepository(context.Background(), &AssociateApprovalRuleTemplateWithRepositoryInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.EncryptionKeyAccessDeniedException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.EncryptionKeyAccessDeniedException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "EncryptionKeyAccessDeniedException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_EncryptionKeyDisabledException(t *testing.T) {
	want := &types.EncryptionKeyDisabledException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("EncryptionKeyDisabledException.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.AssociateApprovalRuleTemplateWithRepository(context.Background(), &AssociateApprovalRuleTemplateWithRepositoryInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.EncryptionKeyDisabledException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.EncryptionKeyDisabledException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "EncryptionKeyDisabledException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_EncryptionKeyInvalidIdException(t *testing.T) {
	want := &types.EncryptionKeyInvalidIdException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("EncryptionKeyInvalidIdException.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.CreateRepository(context.Background(), &CreateRepositoryInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.EncryptionKeyInvalidIdException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.EncryptionKeyInvalidIdException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "EncryptionKeyInvalidIdException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_EncryptionKeyInvalidUsageException(t *testing.T) {
	want := &types.EncryptionKeyInvalidUsageException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("EncryptionKeyInvalidUsageException.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.CreateRepository(context.Background(), &CreateRepositoryInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.EncryptionKeyInvalidUsageException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.EncryptionKeyInvalidUsageException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "EncryptionKeyInvalidUsageException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_EncryptionKeyNotFoundException(t *testing.T) {
	want := &types.EncryptionKeyNotFoundException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("EncryptionKeyNotFoundException.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.AssociateApprovalRuleTemplateWithRepository(context.Background(), &AssociateApprovalRuleTemplateWithRepositoryInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.EncryptionKeyNotFoundException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.EncryptionKeyNotFoundException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "EncryptionKeyNotFoundException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_EncryptionKeyRequiredException(t *testing.T) {
	want := &types.EncryptionKeyRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("EncryptionKeyRequiredException.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.UpdateRepositoryEncryptionKey(context.Background(), &UpdateRepositoryEncryptionKeyInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.EncryptionKeyRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.EncryptionKeyRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "EncryptionKeyRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_EncryptionKeyUnavailableException(t *testing.T) {
	want := &types.EncryptionKeyUnavailableException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("EncryptionKeyUnavailableException.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.AssociateApprovalRuleTemplateWithRepository(context.Background(), &AssociateApprovalRuleTemplateWithRepositoryInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.EncryptionKeyUnavailableException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.EncryptionKeyUnavailableException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "EncryptionKeyUnavailableException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_FileContentAndSourceFileSpecifiedException(t *testing.T) {
	want := &types.FileContentAndSourceFileSpecifiedException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("FileContentAndSourceFileSpecifiedException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.FileContentAndSourceFileSpecifiedException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.FileContentAndSourceFileSpecifiedException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "FileContentAndSourceFileSpecifiedException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_FileContentRequiredException(t *testing.T) {
	want := &types.FileContentRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("FileContentRequiredException.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.PutFile(context.Background(), &PutFileInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.FileContentRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.FileContentRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "FileContentRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_FileContentSizeLimitExceededException(t *testing.T) {
	want := &types.FileContentSizeLimitExceededException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("FileContentSizeLimitExceededException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.FileContentSizeLimitExceededException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.FileContentSizeLimitExceededException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "FileContentSizeLimitExceededException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_FileDoesNotExistException(t *testing.T) {
	want := &types.FileDoesNotExistException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("FileDoesNotExistException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.FileDoesNotExistException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.FileDoesNotExistException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "FileDoesNotExistException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_FileEntryRequiredException(t *testing.T) {
	want := &types.FileEntryRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("FileEntryRequiredException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.FileEntryRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.FileEntryRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "FileEntryRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_FileModeRequiredException(t *testing.T) {
	want := &types.FileModeRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("FileModeRequiredException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.FileModeRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.FileModeRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "FileModeRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_FileNameConflictsWithDirectoryNameException(t *testing.T) {
	want := &types.FileNameConflictsWithDirectoryNameException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("FileNameConflictsWithDirectoryNameException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.FileNameConflictsWithDirectoryNameException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.FileNameConflictsWithDirectoryNameException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "FileNameConflictsWithDirectoryNameException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_FilePathConflictsWithSubmodulePathException(t *testing.T) {
	want := &types.FilePathConflictsWithSubmodulePathException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("FilePathConflictsWithSubmodulePathException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.FilePathConflictsWithSubmodulePathException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.FilePathConflictsWithSubmodulePathException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "FilePathConflictsWithSubmodulePathException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_FileTooLargeException(t *testing.T) {
	want := &types.FileTooLargeException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("FileTooLargeException.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.GetBlob(context.Background(), &GetBlobInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.FileTooLargeException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.FileTooLargeException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "FileTooLargeException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_FolderContentSizeLimitExceededException(t *testing.T) {
	want := &types.FolderContentSizeLimitExceededException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("FolderContentSizeLimitExceededException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.FolderContentSizeLimitExceededException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.FolderContentSizeLimitExceededException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "FolderContentSizeLimitExceededException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_FolderDoesNotExistException(t *testing.T) {
	want := &types.FolderDoesNotExistException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("FolderDoesNotExistException.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.GetFolder(context.Background(), &GetFolderInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.FolderDoesNotExistException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.FolderDoesNotExistException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "FolderDoesNotExistException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_IdempotencyParameterMismatchException(t *testing.T) {
	want := &types.IdempotencyParameterMismatchException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("IdempotencyParameterMismatchException.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.CreatePullRequest(context.Background(), &CreatePullRequestInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.IdempotencyParameterMismatchException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.IdempotencyParameterMismatchException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "IdempotencyParameterMismatchException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidActorArnException(t *testing.T) {
	want := &types.InvalidActorArnException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidActorArnException.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.DescribePullRequestEvents(context.Background(), &DescribePullRequestEventsInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidActorArnException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidActorArnException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidActorArnException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidApprovalRuleContentException(t *testing.T) {
	want := &types.InvalidApprovalRuleContentException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidApprovalRuleContentException.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.CreatePullRequestApprovalRule(context.Background(), &CreatePullRequestApprovalRuleInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidApprovalRuleContentException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidApprovalRuleContentException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidApprovalRuleContentException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidApprovalRuleNameException(t *testing.T) {
	want := &types.InvalidApprovalRuleNameException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidApprovalRuleNameException.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.CreatePullRequestApprovalRule(context.Background(), &CreatePullRequestApprovalRuleInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidApprovalRuleNameException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidApprovalRuleNameException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidApprovalRuleNameException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidApprovalRuleTemplateContentException(t *testing.T) {
	want := &types.InvalidApprovalRuleTemplateContentException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidApprovalRuleTemplateContentException.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.CreateApprovalRuleTemplate(context.Background(), &CreateApprovalRuleTemplateInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidApprovalRuleTemplateContentException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidApprovalRuleTemplateContentException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidApprovalRuleTemplateContentException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidApprovalRuleTemplateDescriptionException(t *testing.T) {
	want := &types.InvalidApprovalRuleTemplateDescriptionException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidApprovalRuleTemplateDescriptionException.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.CreateApprovalRuleTemplate(context.Background(), &CreateApprovalRuleTemplateInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidApprovalRuleTemplateDescriptionException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidApprovalRuleTemplateDescriptionException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidApprovalRuleTemplateDescriptionException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidApprovalRuleTemplateNameException(t *testing.T) {
	want := &types.InvalidApprovalRuleTemplateNameException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidApprovalRuleTemplateNameException.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.AssociateApprovalRuleTemplateWithRepository(context.Background(), &AssociateApprovalRuleTemplateWithRepositoryInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidApprovalRuleTemplateNameException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidApprovalRuleTemplateNameException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidApprovalRuleTemplateNameException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidApprovalStateException(t *testing.T) {
	want := &types.InvalidApprovalStateException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidApprovalStateException.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.UpdatePullRequestApprovalState(context.Background(), &UpdatePullRequestApprovalStateInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidApprovalStateException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidApprovalStateException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidApprovalStateException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidAuthorArnException(t *testing.T) {
	want := &types.InvalidAuthorArnException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidAuthorArnException.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.ListPullRequests(context.Background(), &ListPullRequestsInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidAuthorArnException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidAuthorArnException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidAuthorArnException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidBlobIdException(t *testing.T) {
	want := &types.InvalidBlobIdException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidBlobIdException.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.GetBlob(context.Background(), &GetBlobInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidBlobIdException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidBlobIdException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidBlobIdException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidBranchNameException(t *testing.T) {
	want := &types.InvalidBranchNameException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidBranchNameException.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.CreateBranch(context.Background(), &CreateBranchInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidBranchNameException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidBranchNameException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidBranchNameException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidClientRequestTokenException(t *testing.T) {
	want := &types.InvalidClientRequestTokenException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidClientRequestTokenException.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.CreatePullRequest(context.Background(), &CreatePullRequestInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidClientRequestTokenException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidClientRequestTokenException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidClientRequestTokenException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidCommentIdException(t *testing.T) {
	want := &types.InvalidCommentIdException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidCommentIdException.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.DeleteCommentContent(context.Background(), &DeleteCommentContentInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidCommentIdException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidCommentIdException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidCommentIdException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidCommitException(t *testing.T) {
	want := &types.InvalidCommitException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidCommitException.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.BatchDescribeMergeConflicts(context.Background(), &BatchDescribeMergeConflictsInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidCommitException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidCommitException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidCommitException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidCommitIdException(t *testing.T) {
	want := &types.InvalidCommitIdException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidCommitIdException.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.CreateBranch(context.Background(), &CreateBranchInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidCommitIdException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidCommitIdException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidCommitIdException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidConflictDetailLevelException(t *testing.T) {
	want := &types.InvalidConflictDetailLevelException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidConflictDetailLevelException.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.BatchDescribeMergeConflicts(context.Background(), &BatchDescribeMergeConflictsInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidConflictDetailLevelException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidConflictDetailLevelException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidConflictDetailLevelException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidConflictResolutionException(t *testing.T) {
	want := &types.InvalidConflictResolutionException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidConflictResolutionException.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.CreateUnreferencedMergeCommit(context.Background(), &CreateUnreferencedMergeCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidConflictResolutionException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidConflictResolutionException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidConflictResolutionException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidConflictResolutionStrategyException(t *testing.T) {
	want := &types.InvalidConflictResolutionStrategyException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidConflictResolutionStrategyException.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.BatchDescribeMergeConflicts(context.Background(), &BatchDescribeMergeConflictsInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidConflictResolutionStrategyException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidConflictResolutionStrategyException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidConflictResolutionStrategyException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidContinuationTokenException(t *testing.T) {
	want := &types.InvalidContinuationTokenException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidContinuationTokenException.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.BatchDescribeMergeConflicts(context.Background(), &BatchDescribeMergeConflictsInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidContinuationTokenException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidContinuationTokenException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidContinuationTokenException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidDeletionParameterException(t *testing.T) {
	want := &types.InvalidDeletionParameterException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidDeletionParameterException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidDeletionParameterException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidDeletionParameterException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidDeletionParameterException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidDescriptionException(t *testing.T) {
	want := &types.InvalidDescriptionException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidDescriptionException.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.CreatePullRequest(context.Background(), &CreatePullRequestInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidDescriptionException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidDescriptionException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidDescriptionException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidDestinationCommitSpecifierException(t *testing.T) {
	want := &types.InvalidDestinationCommitSpecifierException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidDestinationCommitSpecifierException.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.GetMergeConflicts(context.Background(), &GetMergeConflictsInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidDestinationCommitSpecifierException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidDestinationCommitSpecifierException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidDestinationCommitSpecifierException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidEmailException(t *testing.T) {
	want := &types.InvalidEmailException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidEmailException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidEmailException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidEmailException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidEmailException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidFileLocationException(t *testing.T) {
	want := &types.InvalidFileLocationException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidFileLocationException.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.PostCommentForComparedCommit(context.Background(), &PostCommentForComparedCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidFileLocationException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidFileLocationException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidFileLocationException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidFileModeException(t *testing.T) {
	want := &types.InvalidFileModeException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidFileModeException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidFileModeException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidFileModeException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidFileModeException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidFilePositionException(t *testing.T) {
	want := &types.InvalidFilePositionException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidFilePositionException.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.PostCommentForComparedCommit(context.Background(), &PostCommentForComparedCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidFilePositionException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidFilePositionException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidFilePositionException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidMaxConflictFilesException(t *testing.T) {
	want := &types.InvalidMaxConflictFilesException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidMaxConflictFilesException.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.BatchDescribeMergeConflicts(context.Background(), &BatchDescribeMergeConflictsInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidMaxConflictFilesException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidMaxConflictFilesException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidMaxConflictFilesException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidMaxMergeHunksException(t *testing.T) {
	want := &types.InvalidMaxMergeHunksException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidMaxMergeHunksException.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.BatchDescribeMergeConflicts(context.Background(), &BatchDescribeMergeConflictsInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidMaxMergeHunksException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidMaxMergeHunksException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidMaxMergeHunksException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidMaxResultsException(t *testing.T) {
	want := &types.InvalidMaxResultsException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidMaxResultsException.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.DescribePullRequestEvents(context.Background(), &DescribePullRequestEventsInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidMaxResultsException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidMaxResultsException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidMaxResultsException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidMergeOptionException(t *testing.T) {
	want := &types.InvalidMergeOptionException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidMergeOptionException.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.BatchDescribeMergeConflicts(context.Background(), &BatchDescribeMergeConflictsInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidMergeOptionException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidMergeOptionException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidMergeOptionException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidOrderException(t *testing.T) {
	want := &types.InvalidOrderException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidOrderException.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.ListRepositories(context.Background(), &ListRepositoriesInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidOrderException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidOrderException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidOrderException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidOverrideStatusException(t *testing.T) {
	want := &types.InvalidOverrideStatusException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidOverrideStatusException.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.OverridePullRequestApprovalRules(context.Background(), &OverridePullRequestApprovalRulesInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidOverrideStatusException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidOverrideStatusException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidOverrideStatusException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidParentCommitIdException(t *testing.T) {
	want := &types.InvalidParentCommitIdException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidParentCommitIdException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidParentCommitIdException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidParentCommitIdException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidParentCommitIdException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidPathException(t *testing.T) {
	want := &types.InvalidPathException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidPathException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidPathException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidPathException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidPathException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidPullRequestEventTypeException(t *testing.T) {
	want := &types.InvalidPullRequestEventTypeException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidPullRequestEventTypeException.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.DescribePullRequestEvents(context.Background(), &DescribePullRequestEventsInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidPullRequestEventTypeException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidPullRequestEventTypeException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidPullRequestEventTypeException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidPullRequestIdException(t *testing.T) {
	want := &types.InvalidPullRequestIdException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidPullRequestIdException.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.CreatePullRequestApprovalRule(context.Background(), &CreatePullRequestApprovalRuleInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidPullRequestIdException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidPullRequestIdException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidPullRequestIdException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidPullRequestStatusException(t *testing.T) {
	want := &types.InvalidPullRequestStatusException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidPullRequestStatusException.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.ListPullRequests(context.Background(), &ListPullRequestsInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidPullRequestStatusException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidPullRequestStatusException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidPullRequestStatusException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidPullRequestStatusUpdateException(t *testing.T) {
	want := &types.InvalidPullRequestStatusUpdateException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidPullRequestStatusUpdateException.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.UpdatePullRequestStatus(context.Background(), &UpdatePullRequestStatusInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidPullRequestStatusUpdateException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidPullRequestStatusUpdateException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidPullRequestStatusUpdateException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidReactionUserArnException(t *testing.T) {
	want := &types.InvalidReactionUserArnException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidReactionUserArnException.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.GetCommentReactions(context.Background(), &GetCommentReactionsInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidReactionUserArnException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidReactionUserArnException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidReactionUserArnException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidReactionValueException(t *testing.T) {
	want := &types.InvalidReactionValueException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidReactionValueException.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.PutCommentReaction(context.Background(), &PutCommentReactionInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidReactionValueException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidReactionValueException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidReactionValueException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidReferenceNameException(t *testing.T) {
	want := &types.InvalidReferenceNameException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidReferenceNameException.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.CreatePullRequest(context.Background(), &CreatePullRequestInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidReferenceNameException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidReferenceNameException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidReferenceNameException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidRelativeFileVersionEnumException(t *testing.T) {
	want := &types.InvalidRelativeFileVersionEnumException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidRelativeFileVersionEnumException.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.PostCommentForComparedCommit(context.Background(), &PostCommentForComparedCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidRelativeFileVersionEnumException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidRelativeFileVersionEnumException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidRelativeFileVersionEnumException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidReplacementContentException(t *testing.T) {
	want := &types.InvalidReplacementContentException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidReplacementContentException.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.CreateUnreferencedMergeCommit(context.Background(), &CreateUnreferencedMergeCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidReplacementContentException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidReplacementContentException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidReplacementContentException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidReplacementTypeException(t *testing.T) {
	want := &types.InvalidReplacementTypeException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidReplacementTypeException.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.CreateUnreferencedMergeCommit(context.Background(), &CreateUnreferencedMergeCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidReplacementTypeException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidReplacementTypeException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidReplacementTypeException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidRepositoryDescriptionException(t *testing.T) {
	want := &types.InvalidRepositoryDescriptionException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidRepositoryDescriptionException.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.CreateRepository(context.Background(), &CreateRepositoryInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidRepositoryDescriptionException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidRepositoryDescriptionException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidRepositoryDescriptionException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidRepositoryNameException(t *testing.T) {
	want := &types.InvalidRepositoryNameException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidRepositoryNameException.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.AssociateApprovalRuleTemplateWithRepository(context.Background(), &AssociateApprovalRuleTemplateWithRepositoryInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidRepositoryNameException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidRepositoryNameException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidRepositoryNameException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidRepositoryTriggerBranchNameException(t *testing.T) {
	want := &types.InvalidRepositoryTriggerBranchNameException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidRepositoryTriggerBranchNameException.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.PutRepositoryTriggers(context.Background(), &PutRepositoryTriggersInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidRepositoryTriggerBranchNameException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidRepositoryTriggerBranchNameException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidRepositoryTriggerBranchNameException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidRepositoryTriggerCustomDataException(t *testing.T) {
	want := &types.InvalidRepositoryTriggerCustomDataException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidRepositoryTriggerCustomDataException.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.PutRepositoryTriggers(context.Background(), &PutRepositoryTriggersInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidRepositoryTriggerCustomDataException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidRepositoryTriggerCustomDataException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidRepositoryTriggerCustomDataException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidRepositoryTriggerDestinationArnException(t *testing.T) {
	want := &types.InvalidRepositoryTriggerDestinationArnException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidRepositoryTriggerDestinationArnException.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.PutRepositoryTriggers(context.Background(), &PutRepositoryTriggersInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidRepositoryTriggerDestinationArnException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidRepositoryTriggerDestinationArnException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidRepositoryTriggerDestinationArnException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidRepositoryTriggerEventsException(t *testing.T) {
	want := &types.InvalidRepositoryTriggerEventsException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidRepositoryTriggerEventsException.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.PutRepositoryTriggers(context.Background(), &PutRepositoryTriggersInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidRepositoryTriggerEventsException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidRepositoryTriggerEventsException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidRepositoryTriggerEventsException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidRepositoryTriggerNameException(t *testing.T) {
	want := &types.InvalidRepositoryTriggerNameException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidRepositoryTriggerNameException.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.PutRepositoryTriggers(context.Background(), &PutRepositoryTriggersInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidRepositoryTriggerNameException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidRepositoryTriggerNameException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidRepositoryTriggerNameException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidRepositoryTriggerRegionException(t *testing.T) {
	want := &types.InvalidRepositoryTriggerRegionException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidRepositoryTriggerRegionException.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.PutRepositoryTriggers(context.Background(), &PutRepositoryTriggersInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidRepositoryTriggerRegionException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidRepositoryTriggerRegionException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidRepositoryTriggerRegionException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidResourceArnException(t *testing.T) {
	want := &types.InvalidResourceArnException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidResourceArnException.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.ListTagsForResource(context.Background(), &ListTagsForResourceInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidResourceArnException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidResourceArnException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidResourceArnException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidRevisionIdException(t *testing.T) {
	want := &types.InvalidRevisionIdException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidRevisionIdException.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.EvaluatePullRequestApprovalRules(context.Background(), &EvaluatePullRequestApprovalRulesInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidRevisionIdException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidRevisionIdException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidRevisionIdException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidRuleContentSha256Exception(t *testing.T) {
	want := &types.InvalidRuleContentSha256Exception{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidRuleContentSha256Exception.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.UpdateApprovalRuleTemplateContent(context.Background(), &UpdateApprovalRuleTemplateContentInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidRuleContentSha256Exception
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidRuleContentSha256Exception, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidRuleContentSha256Exception.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidSortByException(t *testing.T) {
	want := &types.InvalidSortByException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidSortByException.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.ListRepositories(context.Background(), &ListRepositoriesInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidSortByException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidSortByException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidSortByException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidSourceCommitSpecifierException(t *testing.T) {
	want := &types.InvalidSourceCommitSpecifierException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidSourceCommitSpecifierException.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.GetMergeConflicts(context.Background(), &GetMergeConflictsInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidSourceCommitSpecifierException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidSourceCommitSpecifierException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidSourceCommitSpecifierException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidSystemTagUsageException(t *testing.T) {
	want := &types.InvalidSystemTagUsageException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidSystemTagUsageException.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.CreateRepository(context.Background(), &CreateRepositoryInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidSystemTagUsageException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidSystemTagUsageException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidSystemTagUsageException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidTagKeysListException(t *testing.T) {
	want := &types.InvalidTagKeysListException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidTagKeysListException.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.UntagResource(context.Background(), &UntagResourceInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidTagKeysListException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidTagKeysListException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidTagKeysListException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidTagsMapException(t *testing.T) {
	want := &types.InvalidTagsMapException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidTagsMapException.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.CreateRepository(context.Background(), &CreateRepositoryInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidTagsMapException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidTagsMapException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidTagsMapException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidTargetBranchException(t *testing.T) {
	want := &types.InvalidTargetBranchException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidTargetBranchException.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.MergeBranchesByFastForward(context.Background(), &MergeBranchesByFastForwardInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidTargetBranchException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidTargetBranchException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidTargetBranchException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidTargetException(t *testing.T) {
	want := &types.InvalidTargetException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidTargetException.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.CreatePullRequest(context.Background(), &CreatePullRequestInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidTargetException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidTargetException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidTargetException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidTargetsException(t *testing.T) {
	want := &types.InvalidTargetsException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidTargetsException.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.CreatePullRequest(context.Background(), &CreatePullRequestInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidTargetsException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidTargetsException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidTargetsException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidTitleException(t *testing.T) {
	want := &types.InvalidTitleException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidTitleException.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.CreatePullRequest(context.Background(), &CreatePullRequestInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidTitleException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidTitleException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidTitleException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ManualMergeRequiredException(t *testing.T) {
	want := &types.ManualMergeRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ManualMergeRequiredException.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.CreateUnreferencedMergeCommit(context.Background(), &CreateUnreferencedMergeCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ManualMergeRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ManualMergeRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ManualMergeRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_MaximumBranchesExceededException(t *testing.T) {
	want := &types.MaximumBranchesExceededException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("MaximumBranchesExceededException.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.PutRepositoryTriggers(context.Background(), &PutRepositoryTriggersInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.MaximumBranchesExceededException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.MaximumBranchesExceededException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "MaximumBranchesExceededException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_MaximumConflictResolutionEntriesExceededException(t *testing.T) {
	want := &types.MaximumConflictResolutionEntriesExceededException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("MaximumConflictResolutionEntriesExceededException.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.CreateUnreferencedMergeCommit(context.Background(), &CreateUnreferencedMergeCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.MaximumConflictResolutionEntriesExceededException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.MaximumConflictResolutionEntriesExceededException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "MaximumConflictResolutionEntriesExceededException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_MaximumFileContentToLoadExceededException(t *testing.T) {
	want := &types.MaximumFileContentToLoadExceededException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("MaximumFileContentToLoadExceededException.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.BatchDescribeMergeConflicts(context.Background(), &BatchDescribeMergeConflictsInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.MaximumFileContentToLoadExceededException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.MaximumFileContentToLoadExceededException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "MaximumFileContentToLoadExceededException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_MaximumFileEntriesExceededException(t *testing.T) {
	want := &types.MaximumFileEntriesExceededException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("MaximumFileEntriesExceededException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.MaximumFileEntriesExceededException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.MaximumFileEntriesExceededException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "MaximumFileEntriesExceededException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_MaximumItemsToCompareExceededException(t *testing.T) {
	want := &types.MaximumItemsToCompareExceededException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("MaximumItemsToCompareExceededException.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.BatchDescribeMergeConflicts(context.Background(), &BatchDescribeMergeConflictsInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.MaximumItemsToCompareExceededException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.MaximumItemsToCompareExceededException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "MaximumItemsToCompareExceededException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_MaximumNumberOfApprovalsExceededException(t *testing.T) {
	want := &types.MaximumNumberOfApprovalsExceededException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("MaximumNumberOfApprovalsExceededException.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.UpdatePullRequestApprovalState(context.Background(), &UpdatePullRequestApprovalStateInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.MaximumNumberOfApprovalsExceededException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.MaximumNumberOfApprovalsExceededException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "MaximumNumberOfApprovalsExceededException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_MaximumOpenPullRequestsExceededException(t *testing.T) {
	want := &types.MaximumOpenPullRequestsExceededException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("MaximumOpenPullRequestsExceededException.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.CreatePullRequest(context.Background(), &CreatePullRequestInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.MaximumOpenPullRequestsExceededException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.MaximumOpenPullRequestsExceededException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "MaximumOpenPullRequestsExceededException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_MaximumRepositoryNamesExceededException(t *testing.T) {
	want := &types.MaximumRepositoryNamesExceededException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("MaximumRepositoryNamesExceededException.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.BatchAssociateApprovalRuleTemplateWithRepositories(context.Background(), &BatchAssociateApprovalRuleTemplateWithRepositoriesInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.MaximumRepositoryNamesExceededException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.MaximumRepositoryNamesExceededException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "MaximumRepositoryNamesExceededException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_MaximumRepositoryTriggersExceededException(t *testing.T) {
	want := &types.MaximumRepositoryTriggersExceededException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("MaximumRepositoryTriggersExceededException.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.PutRepositoryTriggers(context.Background(), &PutRepositoryTriggersInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.MaximumRepositoryTriggersExceededException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.MaximumRepositoryTriggersExceededException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "MaximumRepositoryTriggersExceededException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_MaximumRuleTemplatesAssociatedWithRepositoryException(t *testing.T) {
	want := &types.MaximumRuleTemplatesAssociatedWithRepositoryException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("MaximumRuleTemplatesAssociatedWithRepositoryException.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.AssociateApprovalRuleTemplateWithRepository(context.Background(), &AssociateApprovalRuleTemplateWithRepositoryInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.MaximumRuleTemplatesAssociatedWithRepositoryException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.MaximumRuleTemplatesAssociatedWithRepositoryException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "MaximumRuleTemplatesAssociatedWithRepositoryException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_MergeOptionRequiredException(t *testing.T) {
	want := &types.MergeOptionRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("MergeOptionRequiredException.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.BatchDescribeMergeConflicts(context.Background(), &BatchDescribeMergeConflictsInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.MergeOptionRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.MergeOptionRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "MergeOptionRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_MultipleConflictResolutionEntriesException(t *testing.T) {
	want := &types.MultipleConflictResolutionEntriesException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("MultipleConflictResolutionEntriesException.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.CreateUnreferencedMergeCommit(context.Background(), &CreateUnreferencedMergeCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.MultipleConflictResolutionEntriesException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.MultipleConflictResolutionEntriesException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "MultipleConflictResolutionEntriesException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_MultipleRepositoriesInPullRequestException(t *testing.T) {
	want := &types.MultipleRepositoriesInPullRequestException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("MultipleRepositoriesInPullRequestException.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.CreatePullRequest(context.Background(), &CreatePullRequestInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.MultipleRepositoriesInPullRequestException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.MultipleRepositoriesInPullRequestException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "MultipleRepositoriesInPullRequestException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_NameLengthExceededException(t *testing.T) {
	want := &types.NameLengthExceededException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("NameLengthExceededException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.NameLengthExceededException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.NameLengthExceededException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "NameLengthExceededException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_NoChangeException(t *testing.T) {
	want := &types.NoChangeException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("NoChangeException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.NoChangeException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.NoChangeException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "NoChangeException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_NumberOfRuleTemplatesExceededException(t *testing.T) {
	want := &types.NumberOfRuleTemplatesExceededException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("NumberOfRuleTemplatesExceededException.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.CreateApprovalRuleTemplate(context.Background(), &CreateApprovalRuleTemplateInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.NumberOfRuleTemplatesExceededException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.NumberOfRuleTemplatesExceededException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "NumberOfRuleTemplatesExceededException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_NumberOfRulesExceededException(t *testing.T) {
	want := &types.NumberOfRulesExceededException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("NumberOfRulesExceededException.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.CreatePullRequestApprovalRule(context.Background(), &CreatePullRequestApprovalRuleInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.NumberOfRulesExceededException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.NumberOfRulesExceededException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "NumberOfRulesExceededException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_OperationNotAllowedException(t *testing.T) {
	want := &types.OperationNotAllowedException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("OperationNotAllowedException.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.CreateRepository(context.Background(), &CreateRepositoryInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.OperationNotAllowedException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.OperationNotAllowedException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "OperationNotAllowedException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_OverrideAlreadySetException(t *testing.T) {
	want := &types.OverrideAlreadySetException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("OverrideAlreadySetException.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.OverridePullRequestApprovalRules(context.Background(), &OverridePullRequestApprovalRulesInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.OverrideAlreadySetException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.OverrideAlreadySetException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "OverrideAlreadySetException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_OverrideStatusRequiredException(t *testing.T) {
	want := &types.OverrideStatusRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("OverrideStatusRequiredException.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.OverridePullRequestApprovalRules(context.Background(), &OverridePullRequestApprovalRulesInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.OverrideStatusRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.OverrideStatusRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "OverrideStatusRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ParentCommitDoesNotExistException(t *testing.T) {
	want := &types.ParentCommitDoesNotExistException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ParentCommitDoesNotExistException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ParentCommitDoesNotExistException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ParentCommitDoesNotExistException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ParentCommitDoesNotExistException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ParentCommitIdOutdatedException(t *testing.T) {
	want := &types.ParentCommitIdOutdatedException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ParentCommitIdOutdatedException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ParentCommitIdOutdatedException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ParentCommitIdOutdatedException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ParentCommitIdOutdatedException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ParentCommitIdRequiredException(t *testing.T) {
	want := &types.ParentCommitIdRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ParentCommitIdRequiredException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ParentCommitIdRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ParentCommitIdRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ParentCommitIdRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_PathDoesNotExistException(t *testing.T) {
	want := &types.PathDoesNotExistException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PathDoesNotExistException.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.GetDifferences(context.Background(), &GetDifferencesInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.PathDoesNotExistException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.PathDoesNotExistException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "PathDoesNotExistException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_PathRequiredException(t *testing.T) {
	want := &types.PathRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PathRequiredException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.PathRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.PathRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "PathRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_PullRequestAlreadyClosedException(t *testing.T) {
	want := &types.PullRequestAlreadyClosedException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PullRequestAlreadyClosedException.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.CreatePullRequestApprovalRule(context.Background(), &CreatePullRequestApprovalRuleInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.PullRequestAlreadyClosedException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.PullRequestAlreadyClosedException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "PullRequestAlreadyClosedException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_PullRequestApprovalRulesNotSatisfiedException(t *testing.T) {
	want := &types.PullRequestApprovalRulesNotSatisfiedException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PullRequestApprovalRulesNotSatisfiedException.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.MergePullRequestByFastForward(context.Background(), &MergePullRequestByFastForwardInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.PullRequestApprovalRulesNotSatisfiedException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.PullRequestApprovalRulesNotSatisfiedException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "PullRequestApprovalRulesNotSatisfiedException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_PullRequestCannotBeApprovedByAuthorException(t *testing.T) {
	want := &types.PullRequestCannotBeApprovedByAuthorException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PullRequestCannotBeApprovedByAuthorException.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.UpdatePullRequestApprovalState(context.Background(), &UpdatePullRequestApprovalStateInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.PullRequestCannotBeApprovedByAuthorException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.PullRequestCannotBeApprovedByAuthorException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "PullRequestCannotBeApprovedByAuthorException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_PullRequestDoesNotExistException(t *testing.T) {
	want := &types.PullRequestDoesNotExistException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PullRequestDoesNotExistException.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.CreatePullRequestApprovalRule(context.Background(), &CreatePullRequestApprovalRuleInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.PullRequestDoesNotExistException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.PullRequestDoesNotExistException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "PullRequestDoesNotExistException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_PullRequestIdRequiredException(t *testing.T) {
	want := &types.PullRequestIdRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PullRequestIdRequiredException.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.CreatePullRequestApprovalRule(context.Background(), &CreatePullRequestApprovalRuleInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.PullRequestIdRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.PullRequestIdRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "PullRequestIdRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_PullRequestStatusRequiredException(t *testing.T) {
	want := &types.PullRequestStatusRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PullRequestStatusRequiredException.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.UpdatePullRequestStatus(context.Background(), &UpdatePullRequestStatusInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.PullRequestStatusRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.PullRequestStatusRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "PullRequestStatusRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_PutFileEntryConflictException(t *testing.T) {
	want := &types.PutFileEntryConflictException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PutFileEntryConflictException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.PutFileEntryConflictException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.PutFileEntryConflictException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "PutFileEntryConflictException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ReactionLimitExceededException(t *testing.T) {
	want := &types.ReactionLimitExceededException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ReactionLimitExceededException.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.PutCommentReaction(context.Background(), &PutCommentReactionInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ReactionLimitExceededException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ReactionLimitExceededException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ReactionLimitExceededException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ReactionValueRequiredException(t *testing.T) {
	want := &types.ReactionValueRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ReactionValueRequiredException.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.PutCommentReaction(context.Background(), &PutCommentReactionInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ReactionValueRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ReactionValueRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ReactionValueRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ReferenceDoesNotExistException(t *testing.T) {
	want := &types.ReferenceDoesNotExistException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ReferenceDoesNotExistException.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.CreatePullRequest(context.Background(), &CreatePullRequestInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ReferenceDoesNotExistException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ReferenceDoesNotExistException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ReferenceDoesNotExistException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ReferenceNameRequiredException(t *testing.T) {
	want := &types.ReferenceNameRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ReferenceNameRequiredException.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.CreatePullRequest(context.Background(), &CreatePullRequestInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ReferenceNameRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ReferenceNameRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ReferenceNameRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ReferenceTypeNotSupportedException(t *testing.T) {
	want := &types.ReferenceTypeNotSupportedException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ReferenceTypeNotSupportedException.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.CreatePullRequest(context.Background(), &CreatePullRequestInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ReferenceTypeNotSupportedException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ReferenceTypeNotSupportedException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ReferenceTypeNotSupportedException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ReplacementContentRequiredException(t *testing.T) {
	want := &types.ReplacementContentRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ReplacementContentRequiredException.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.CreateUnreferencedMergeCommit(context.Background(), &CreateUnreferencedMergeCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ReplacementContentRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ReplacementContentRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ReplacementContentRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ReplacementTypeRequiredException(t *testing.T) {
	want := &types.ReplacementTypeRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ReplacementTypeRequiredException.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.CreateUnreferencedMergeCommit(context.Background(), &CreateUnreferencedMergeCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ReplacementTypeRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ReplacementTypeRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ReplacementTypeRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_RepositoryDoesNotExistException(t *testing.T) {
	want := &types.RepositoryDoesNotExistException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("RepositoryDoesNotExistException.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.AssociateApprovalRuleTemplateWithRepository(context.Background(), &AssociateApprovalRuleTemplateWithRepositoryInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.RepositoryDoesNotExistException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.RepositoryDoesNotExistException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "RepositoryDoesNotExistException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_RepositoryLimitExceededException(t *testing.T) {
	want := &types.RepositoryLimitExceededException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("RepositoryLimitExceededException.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.CreateRepository(context.Background(), &CreateRepositoryInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.RepositoryLimitExceededException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.RepositoryLimitExceededException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "RepositoryLimitExceededException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_RepositoryNameExistsException(t *testing.T) {
	want := &types.RepositoryNameExistsException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("RepositoryNameExistsException.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.CreateRepository(context.Background(), &CreateRepositoryInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.RepositoryNameExistsException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.RepositoryNameExistsException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "RepositoryNameExistsException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_RepositoryNameRequiredException(t *testing.T) {
	want := &types.RepositoryNameRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("RepositoryNameRequiredException.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.AssociateApprovalRuleTemplateWithRepository(context.Background(), &AssociateApprovalRuleTemplateWithRepositoryInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.RepositoryNameRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.RepositoryNameRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "RepositoryNameRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_RepositoryNamesRequiredException(t *testing.T) {
	want := &types.RepositoryNamesRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("RepositoryNamesRequiredException.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.BatchAssociateApprovalRuleTemplateWithRepositories(context.Background(), &BatchAssociateApprovalRuleTemplateWithRepositoriesInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.RepositoryNamesRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.RepositoryNamesRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "RepositoryNamesRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_RepositoryNotAssociatedWithPullRequestException(t *testing.T) {
	want := &types.RepositoryNotAssociatedWithPullRequestException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("RepositoryNotAssociatedWithPullRequestException.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.GetCommentsForPullRequest(context.Background(), &GetCommentsForPullRequestInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.RepositoryNotAssociatedWithPullRequestException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.RepositoryNotAssociatedWithPullRequestException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "RepositoryNotAssociatedWithPullRequestException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_RepositoryTriggerBranchNameListRequiredException(t *testing.T) {
	want := &types.RepositoryTriggerBranchNameListRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("RepositoryTriggerBranchNameListRequiredException.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.PutRepositoryTriggers(context.Background(), &PutRepositoryTriggersInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.RepositoryTriggerBranchNameListRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.RepositoryTriggerBranchNameListRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "RepositoryTriggerBranchNameListRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_RepositoryTriggerDestinationArnRequiredException(t *testing.T) {
	want := &types.RepositoryTriggerDestinationArnRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("RepositoryTriggerDestinationArnRequiredException.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.PutRepositoryTriggers(context.Background(), &PutRepositoryTriggersInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.RepositoryTriggerDestinationArnRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.RepositoryTriggerDestinationArnRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "RepositoryTriggerDestinationArnRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_RepositoryTriggerEventsListRequiredException(t *testing.T) {
	want := &types.RepositoryTriggerEventsListRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("RepositoryTriggerEventsListRequiredException.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.PutRepositoryTriggers(context.Background(), &PutRepositoryTriggersInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.RepositoryTriggerEventsListRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.RepositoryTriggerEventsListRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "RepositoryTriggerEventsListRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_RepositoryTriggerNameRequiredException(t *testing.T) {
	want := &types.RepositoryTriggerNameRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("RepositoryTriggerNameRequiredException.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.PutRepositoryTriggers(context.Background(), &PutRepositoryTriggersInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.RepositoryTriggerNameRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.RepositoryTriggerNameRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "RepositoryTriggerNameRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_RepositoryTriggersListRequiredException(t *testing.T) {
	want := &types.RepositoryTriggersListRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("RepositoryTriggersListRequiredException.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.PutRepositoryTriggers(context.Background(), &PutRepositoryTriggersInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.RepositoryTriggersListRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.RepositoryTriggersListRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "RepositoryTriggersListRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ResourceArnRequiredException(t *testing.T) {
	want := &types.ResourceArnRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ResourceArnRequiredException.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.ListTagsForResource(context.Background(), &ListTagsForResourceInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ResourceArnRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ResourceArnRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ResourceArnRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_RestrictedSourceFileException(t *testing.T) {
	want := &types.RestrictedSourceFileException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("RestrictedSourceFileException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.RestrictedSourceFileException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.RestrictedSourceFileException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "RestrictedSourceFileException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_RevisionIdRequiredException(t *testing.T) {
	want := &types.RevisionIdRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("RevisionIdRequiredException.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.EvaluatePullRequestApprovalRules(context.Background(), &EvaluatePullRequestApprovalRulesInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.RevisionIdRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.RevisionIdRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "RevisionIdRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_RevisionNotCurrentException(t *testing.T) {
	want := &types.RevisionNotCurrentException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("RevisionNotCurrentException.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.EvaluatePullRequestApprovalRules(context.Background(), &EvaluatePullRequestApprovalRulesInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.RevisionNotCurrentException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.RevisionNotCurrentException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "RevisionNotCurrentException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_SameFileContentException(t *testing.T) {
	want := &types.SameFileContentException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("SameFileContentException.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.PutFile(context.Background(), &PutFileInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.SameFileContentException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.SameFileContentException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "SameFileContentException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_SamePathRequestException(t *testing.T) {
	want := &types.SamePathRequestException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("SamePathRequestException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.SamePathRequestException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.SamePathRequestException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "SamePathRequestException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_SourceAndDestinationAreSameException(t *testing.T) {
	want := &types.SourceAndDestinationAreSameException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("SourceAndDestinationAreSameException.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.CreatePullRequest(context.Background(), &CreatePullRequestInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.SourceAndDestinationAreSameException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.SourceAndDestinationAreSameException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "SourceAndDestinationAreSameException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_SourceFileOrContentRequiredException(t *testing.T) {
	want := &types.SourceFileOrContentRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("SourceFileOrContentRequiredException.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.CreateCommit(context.Background(), &CreateCommitInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.SourceFileOrContentRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.SourceFileOrContentRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "SourceFileOrContentRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_TagKeysListRequiredException(t *testing.T) {
	want := &types.TagKeysListRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("TagKeysListRequiredException.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.UntagResource(context.Background(), &UntagResourceInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.TagKeysListRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.TagKeysListRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "TagKeysListRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_TagPolicyException(t *testing.T) {
	want := &types.TagPolicyException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("TagPolicyException.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.CreateRepository(context.Background(), &CreateRepositoryInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.TagPolicyException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.TagPolicyException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "TagPolicyException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_TagsMapRequiredException(t *testing.T) {
	want := &types.TagsMapRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("TagsMapRequiredException.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.TagResource(context.Background(), &TagResourceInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.TagsMapRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.TagsMapRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "TagsMapRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_TargetRequiredException(t *testing.T) {
	want := &types.TargetRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("TargetRequiredException.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.CreatePullRequest(context.Background(), &CreatePullRequestInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.TargetRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.TargetRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "TargetRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_TargetsRequiredException(t *testing.T) {
	want := &types.TargetsRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("TargetsRequiredException.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.CreatePullRequest(context.Background(), &CreatePullRequestInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.TargetsRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.TargetsRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "TargetsRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_TipOfSourceReferenceIsDifferentException(t *testing.T) {
	want := &types.TipOfSourceReferenceIsDifferentException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("TipOfSourceReferenceIsDifferentException.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.MergePullRequestByFastForward(context.Background(), &MergePullRequestByFastForwardInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.TipOfSourceReferenceIsDifferentException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.TipOfSourceReferenceIsDifferentException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "TipOfSourceReferenceIsDifferentException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_TipsDivergenceExceededException(t *testing.T) {
	want := &types.TipsDivergenceExceededException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("TipsDivergenceExceededException.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.BatchDescribeMergeConflicts(context.Background(), &BatchDescribeMergeConflictsInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.TipsDivergenceExceededException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.TipsDivergenceExceededException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "TipsDivergenceExceededException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_TitleRequiredException(t *testing.T) {
	want := &types.TitleRequiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("TitleRequiredException.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.CreatePullRequest(context.Background(), &CreatePullRequestInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.TitleRequiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.TitleRequiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "TitleRequiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_TooManyTagsException(t *testing.T) {
	want := &types.TooManyTagsException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("TooManyTagsException.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.CreateRepository(context.Background(), &CreateRepositoryInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.TooManyTagsException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.TooManyTagsException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "TooManyTagsException.error", err)
	}
}
