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

//go:build response_snapshot

package ecr

import (
	"bufio"
	"bytes"
	"context"
	"errors"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/ecr/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_BatchCheckLayerAvailability(t *testing.T) {
	want := &BatchCheckLayerAvailabilityOutput{
		Layers: []types.Layer{
			{
				LayerDigest:       ptr.String("__LayerDigest__"),
				LayerAvailability: types.LayerAvailability("AVAILABLE"),
				LayerSize:         ptr.Int64(1),
				MediaType:         ptr.String("__MediaType__"),
			},
			{
				LayerDigest:       ptr.String("__LayerDigest__"),
				LayerAvailability: types.LayerAvailability("AVAILABLE"),
				LayerSize:         ptr.Int64(1),
				MediaType:         ptr.String("__MediaType__"),
			},
		},
		Failures: []types.LayerFailure{
			{
				LayerDigest:   ptr.String("__LayerDigest__"),
				FailureCode:   types.LayerFailureCode("InvalidLayerDigest"),
				FailureReason: ptr.String("__FailureReason__"),
			},
			{
				LayerDigest:   ptr.String("__LayerDigest__"),
				FailureCode:   types.LayerFailureCode("InvalidLayerDigest"),
				FailureReason: ptr.String("__FailureReason__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("BatchCheckLayerAvailability.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.BatchCheckLayerAvailability(context.Background(), &BatchCheckLayerAvailabilityInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		LayerDigests: []string{
			"__Member__",
			"__Member__",
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "BatchCheckLayerAvailability.response", err)
	}
}

func TestCheckResponseSnapshot_BatchDeleteImage(t *testing.T) {
	want := &BatchDeleteImageOutput{
		ImageIds: []types.ImageIdentifier{
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
		},
		Failures: []types.ImageFailure{
			{
				ImageId: &types.ImageIdentifier{
					ImageDigest: ptr.String("__ImageDigest__"),
					ImageTag:    ptr.String("__ImageTag__"),
				},
				FailureCode:   types.ImageFailureCode("InvalidImageDigest"),
				FailureReason: ptr.String("__FailureReason__"),
			},
			{
				ImageId: &types.ImageIdentifier{
					ImageDigest: ptr.String("__ImageDigest__"),
					ImageTag:    ptr.String("__ImageTag__"),
				},
				FailureCode:   types.ImageFailureCode("InvalidImageDigest"),
				FailureReason: ptr.String("__FailureReason__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("BatchDeleteImage.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.BatchDeleteImage(context.Background(), &BatchDeleteImageInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageIds: []types.ImageIdentifier{
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "BatchDeleteImage.response", err)
	}
}

func TestCheckResponseSnapshot_BatchGetImage(t *testing.T) {
	want := &BatchGetImageOutput{
		Images: []types.Image{
			{
				RegistryId:     ptr.String("__RegistryId__"),
				RepositoryName: ptr.String("__RepositoryName__"),
				ImageId: &types.ImageIdentifier{
					ImageDigest: ptr.String("__ImageDigest__"),
					ImageTag:    ptr.String("__ImageTag__"),
				},
				ImageManifest:          ptr.String("__ImageManifest__"),
				ImageManifestMediaType: ptr.String("__ImageManifestMediaType__"),
			},
			{
				RegistryId:     ptr.String("__RegistryId__"),
				RepositoryName: ptr.String("__RepositoryName__"),
				ImageId: &types.ImageIdentifier{
					ImageDigest: ptr.String("__ImageDigest__"),
					ImageTag:    ptr.String("__ImageTag__"),
				},
				ImageManifest:          ptr.String("__ImageManifest__"),
				ImageManifestMediaType: ptr.String("__ImageManifestMediaType__"),
			},
		},
		Failures: []types.ImageFailure{
			{
				ImageId: &types.ImageIdentifier{
					ImageDigest: ptr.String("__ImageDigest__"),
					ImageTag:    ptr.String("__ImageTag__"),
				},
				FailureCode:   types.ImageFailureCode("InvalidImageDigest"),
				FailureReason: ptr.String("__FailureReason__"),
			},
			{
				ImageId: &types.ImageIdentifier{
					ImageDigest: ptr.String("__ImageDigest__"),
					ImageTag:    ptr.String("__ImageTag__"),
				},
				FailureCode:   types.ImageFailureCode("InvalidImageDigest"),
				FailureReason: ptr.String("__FailureReason__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("BatchGetImage.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.BatchGetImage(context.Background(), &BatchGetImageInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageIds: []types.ImageIdentifier{
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
		},
		AcceptedMediaTypes: []string{
			"__Member__",
			"__Member__",
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "BatchGetImage.response", err)
	}
}

func TestCheckResponseSnapshot_BatchGetRepositoryScanningConfiguration(t *testing.T) {
	want := &BatchGetRepositoryScanningConfigurationOutput{
		ScanningConfigurations: []types.RepositoryScanningConfiguration{
			{
				RepositoryArn:  ptr.String("__RepositoryArn__"),
				RepositoryName: ptr.String("__RepositoryName__"),
				ScanOnPush:     true,
				ScanFrequency:  types.ScanFrequency("SCAN_ON_PUSH"),
				AppliedScanFilters: []types.ScanningRepositoryFilter{
					{
						Filter:     ptr.String("__Filter__"),
						FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
					},
					{
						Filter:     ptr.String("__Filter__"),
						FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
					},
				},
			},
			{
				RepositoryArn:  ptr.String("__RepositoryArn__"),
				RepositoryName: ptr.String("__RepositoryName__"),
				ScanOnPush:     true,
				ScanFrequency:  types.ScanFrequency("SCAN_ON_PUSH"),
				AppliedScanFilters: []types.ScanningRepositoryFilter{
					{
						Filter:     ptr.String("__Filter__"),
						FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
					},
					{
						Filter:     ptr.String("__Filter__"),
						FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
					},
				},
			},
		},
		Failures: []types.RepositoryScanningConfigurationFailure{
			{
				RepositoryName: ptr.String("__RepositoryName__"),
				FailureCode:    types.ScanningConfigurationFailureCode("REPOSITORY_NOT_FOUND"),
				FailureReason:  ptr.String("__FailureReason__"),
			},
			{
				RepositoryName: ptr.String("__RepositoryName__"),
				FailureCode:    types.ScanningConfigurationFailureCode("REPOSITORY_NOT_FOUND"),
				FailureReason:  ptr.String("__FailureReason__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("BatchGetRepositoryScanningConfiguration.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.BatchGetRepositoryScanningConfiguration(context.Background(), &BatchGetRepositoryScanningConfigurationInput{
		RepositoryNames: []string{
			"__Member__",
			"__Member__",
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "BatchGetRepositoryScanningConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_CompleteLayerUpload(t *testing.T) {
	want := &CompleteLayerUploadOutput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		UploadId:       ptr.String("__UploadId__"),
		LayerDigest:    ptr.String("__LayerDigest__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CompleteLayerUpload.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.CompleteLayerUpload(context.Background(), &CompleteLayerUploadInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		UploadId:       ptr.String("__UploadId__"),
		LayerDigests: []string{
			"__Member__",
			"__Member__",
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CompleteLayerUpload.response", err)
	}
}

func TestCheckResponseSnapshot_CreatePullThroughCacheRule(t *testing.T) {
	want := &CreatePullThroughCacheRuleOutput{
		EcrRepositoryPrefix:      ptr.String("__EcrRepositoryPrefix__"),
		UpstreamRegistryUrl:      ptr.String("__UpstreamRegistryUrl__"),
		CreatedAt:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		RegistryId:               ptr.String("__RegistryId__"),
		UpstreamRegistry:         types.UpstreamRegistry("ecr"),
		CredentialArn:            ptr.String("__CredentialArn__"),
		CustomRoleArn:            ptr.String("__CustomRoleArn__"),
		UpstreamRepositoryPrefix: ptr.String("__UpstreamRepositoryPrefix__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreatePullThroughCacheRule.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.CreatePullThroughCacheRule(context.Background(), &CreatePullThroughCacheRuleInput{
		EcrRepositoryPrefix:      ptr.String("__EcrRepositoryPrefix__"),
		UpstreamRegistryUrl:      ptr.String("__UpstreamRegistryUrl__"),
		RegistryId:               ptr.String("__RegistryId__"),
		UpstreamRegistry:         types.UpstreamRegistry("ecr"),
		CredentialArn:            ptr.String("__CredentialArn__"),
		CustomRoleArn:            ptr.String("__CustomRoleArn__"),
		UpstreamRepositoryPrefix: ptr.String("__UpstreamRepositoryPrefix__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreatePullThroughCacheRule.response", err)
	}
}

func TestCheckResponseSnapshot_CreateRepository(t *testing.T) {
	want := &CreateRepositoryOutput{
		Repository: &types.Repository{
			RepositoryArn:      ptr.String("__RepositoryArn__"),
			RegistryId:         ptr.String("__RegistryId__"),
			RepositoryName:     ptr.String("__RepositoryName__"),
			RepositoryUri:      ptr.String("__RepositoryUri__"),
			CreatedAt:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			ImageTagMutability: types.ImageTagMutability("MUTABLE"),
			ImageTagMutabilityExclusionFilters: []types.ImageTagMutabilityExclusionFilter{
				{
					FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
					Filter:     ptr.String("__Filter__"),
				},
				{
					FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
					Filter:     ptr.String("__Filter__"),
				},
			},
			ImageScanningConfiguration: &types.ImageScanningConfiguration{
				ScanOnPush: true,
			},
			EncryptionConfiguration: &types.EncryptionConfiguration{
				EncryptionType: types.EncryptionType("AES256"),
				KmsKey:         ptr.String("__KmsKey__"),
			},
		},
	}
	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{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		ImageTagMutability: types.ImageTagMutability("MUTABLE"),
		ImageTagMutabilityExclusionFilters: []types.ImageTagMutabilityExclusionFilter{
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
		},
		ImageScanningConfiguration: &types.ImageScanningConfiguration{
			ScanOnPush: true,
		},
		EncryptionConfiguration: &types.EncryptionConfiguration{
			EncryptionType: types.EncryptionType("AES256"),
			KmsKey:         ptr.String("__KmsKey__"),
		},
	})
	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_CreateRepositoryCreationTemplate(t *testing.T) {
	want := &CreateRepositoryCreationTemplateOutput{
		RegistryId: ptr.String("__RegistryId__"),
		RepositoryCreationTemplate: &types.RepositoryCreationTemplate{
			Prefix:      ptr.String("__Prefix__"),
			Description: ptr.String("__Description__"),
			EncryptionConfiguration: &types.EncryptionConfigurationForRepositoryCreationTemplate{
				EncryptionType: types.EncryptionType("AES256"),
				KmsKey:         ptr.String("__KmsKey__"),
			},
			ResourceTags: []types.Tag{
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
			},
			ImageTagMutability: types.ImageTagMutability("MUTABLE"),
			ImageTagMutabilityExclusionFilters: []types.ImageTagMutabilityExclusionFilter{
				{
					FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
					Filter:     ptr.String("__Filter__"),
				},
				{
					FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
					Filter:     ptr.String("__Filter__"),
				},
			},
			RepositoryPolicy: ptr.String("__RepositoryPolicy__"),
			LifecyclePolicy:  ptr.String("__LifecyclePolicy__"),
			AppliedFor: []types.RCTAppliedFor{
				types.RCTAppliedFor("REPLICATION"),
				types.RCTAppliedFor("REPLICATION"),
			},
			CustomRoleArn: ptr.String("__CustomRoleArn__"),
			CreatedAt:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			UpdatedAt:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateRepositoryCreationTemplate.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.CreateRepositoryCreationTemplate(context.Background(), &CreateRepositoryCreationTemplateInput{
		Prefix:      ptr.String("__Prefix__"),
		Description: ptr.String("__Description__"),
		EncryptionConfiguration: &types.EncryptionConfigurationForRepositoryCreationTemplate{
			EncryptionType: types.EncryptionType("AES256"),
			KmsKey:         ptr.String("__KmsKey__"),
		},
		ResourceTags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		ImageTagMutability: types.ImageTagMutability("MUTABLE"),
		ImageTagMutabilityExclusionFilters: []types.ImageTagMutabilityExclusionFilter{
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
		},
		RepositoryPolicy: ptr.String("__RepositoryPolicy__"),
		LifecyclePolicy:  ptr.String("__LifecyclePolicy__"),
		AppliedFor: []types.RCTAppliedFor{
			types.RCTAppliedFor("REPLICATION"),
			types.RCTAppliedFor("REPLICATION"),
		},
		CustomRoleArn: ptr.String("__CustomRoleArn__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateRepositoryCreationTemplate.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteLifecyclePolicy(t *testing.T) {
	want := &DeleteLifecyclePolicyOutput{
		RegistryId:          ptr.String("__RegistryId__"),
		RepositoryName:      ptr.String("__RepositoryName__"),
		LifecyclePolicyText: ptr.String("__LifecyclePolicyText__"),
		LastEvaluatedAt:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("DeleteLifecyclePolicy.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.DeleteLifecyclePolicy(context.Background(), &DeleteLifecyclePolicyInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteLifecyclePolicy.response", err)
	}
}

func TestCheckResponseSnapshot_DeletePullThroughCacheRule(t *testing.T) {
	want := &DeletePullThroughCacheRuleOutput{
		EcrRepositoryPrefix:      ptr.String("__EcrRepositoryPrefix__"),
		UpstreamRegistryUrl:      ptr.String("__UpstreamRegistryUrl__"),
		CreatedAt:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		RegistryId:               ptr.String("__RegistryId__"),
		CredentialArn:            ptr.String("__CredentialArn__"),
		CustomRoleArn:            ptr.String("__CustomRoleArn__"),
		UpstreamRepositoryPrefix: ptr.String("__UpstreamRepositoryPrefix__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DeletePullThroughCacheRule.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.DeletePullThroughCacheRule(context.Background(), &DeletePullThroughCacheRuleInput{
		EcrRepositoryPrefix: ptr.String("__EcrRepositoryPrefix__"),
		RegistryId:          ptr.String("__RegistryId__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeletePullThroughCacheRule.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteRegistryPolicy(t *testing.T) {
	want := &DeleteRegistryPolicyOutput{
		RegistryId: ptr.String("__RegistryId__"),
		PolicyText: ptr.String("__PolicyText__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DeleteRegistryPolicy.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.DeleteRegistryPolicy(context.Background(), &DeleteRegistryPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteRegistryPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteRepository(t *testing.T) {
	want := &DeleteRepositoryOutput{
		Repository: &types.Repository{
			RepositoryArn:      ptr.String("__RepositoryArn__"),
			RegistryId:         ptr.String("__RegistryId__"),
			RepositoryName:     ptr.String("__RepositoryName__"),
			RepositoryUri:      ptr.String("__RepositoryUri__"),
			CreatedAt:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			ImageTagMutability: types.ImageTagMutability("MUTABLE"),
			ImageTagMutabilityExclusionFilters: []types.ImageTagMutabilityExclusionFilter{
				{
					FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
					Filter:     ptr.String("__Filter__"),
				},
				{
					FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
					Filter:     ptr.String("__Filter__"),
				},
			},
			ImageScanningConfiguration: &types.ImageScanningConfiguration{
				ScanOnPush: true,
			},
			EncryptionConfiguration: &types.EncryptionConfiguration{
				EncryptionType: types.EncryptionType("AES256"),
				KmsKey:         ptr.String("__KmsKey__"),
			},
		},
	}
	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{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		Force:          true,
	})
	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_DeleteRepositoryCreationTemplate(t *testing.T) {
	want := &DeleteRepositoryCreationTemplateOutput{
		RegistryId: ptr.String("__RegistryId__"),
		RepositoryCreationTemplate: &types.RepositoryCreationTemplate{
			Prefix:      ptr.String("__Prefix__"),
			Description: ptr.String("__Description__"),
			EncryptionConfiguration: &types.EncryptionConfigurationForRepositoryCreationTemplate{
				EncryptionType: types.EncryptionType("AES256"),
				KmsKey:         ptr.String("__KmsKey__"),
			},
			ResourceTags: []types.Tag{
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
			},
			ImageTagMutability: types.ImageTagMutability("MUTABLE"),
			ImageTagMutabilityExclusionFilters: []types.ImageTagMutabilityExclusionFilter{
				{
					FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
					Filter:     ptr.String("__Filter__"),
				},
				{
					FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
					Filter:     ptr.String("__Filter__"),
				},
			},
			RepositoryPolicy: ptr.String("__RepositoryPolicy__"),
			LifecyclePolicy:  ptr.String("__LifecyclePolicy__"),
			AppliedFor: []types.RCTAppliedFor{
				types.RCTAppliedFor("REPLICATION"),
				types.RCTAppliedFor("REPLICATION"),
			},
			CustomRoleArn: ptr.String("__CustomRoleArn__"),
			CreatedAt:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			UpdatedAt:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DeleteRepositoryCreationTemplate.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.DeleteRepositoryCreationTemplate(context.Background(), &DeleteRepositoryCreationTemplateInput{
		Prefix: ptr.String("__Prefix__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteRepositoryCreationTemplate.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteRepositoryPolicy(t *testing.T) {
	want := &DeleteRepositoryPolicyOutput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		PolicyText:     ptr.String("__PolicyText__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DeleteRepositoryPolicy.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.DeleteRepositoryPolicy(context.Background(), &DeleteRepositoryPolicyInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteRepositoryPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteSigningConfiguration(t *testing.T) {
	want := &DeleteSigningConfigurationOutput{
		RegistryId: ptr.String("__RegistryId__"),
		SigningConfiguration: &types.SigningConfiguration{
			Rules: []types.SigningRule{
				{
					SigningProfileArn: ptr.String("__SigningProfileArn__"),
					RepositoryFilters: []types.SigningRepositoryFilter{
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.SigningRepositoryFilterType("WILDCARD_MATCH"),
						},
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.SigningRepositoryFilterType("WILDCARD_MATCH"),
						},
					},
				},
				{
					SigningProfileArn: ptr.String("__SigningProfileArn__"),
					RepositoryFilters: []types.SigningRepositoryFilter{
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.SigningRepositoryFilterType("WILDCARD_MATCH"),
						},
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.SigningRepositoryFilterType("WILDCARD_MATCH"),
						},
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DeleteSigningConfiguration.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.DeleteSigningConfiguration(context.Background(), &DeleteSigningConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteSigningConfiguration.response", err)
	}
}

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

func TestCheckResponseSnapshot_DescribeImageReplicationStatus(t *testing.T) {
	want := &DescribeImageReplicationStatusOutput{
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageId: &types.ImageIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
			ImageTag:    ptr.String("__ImageTag__"),
		},
		ReplicationStatuses: []types.ImageReplicationStatus{
			{
				Region:      ptr.String("__Region__"),
				RegistryId:  ptr.String("__RegistryId__"),
				Status:      types.ReplicationStatus("IN_PROGRESS"),
				FailureCode: ptr.String("__FailureCode__"),
			},
			{
				Region:      ptr.String("__Region__"),
				RegistryId:  ptr.String("__RegistryId__"),
				Status:      types.ReplicationStatus("IN_PROGRESS"),
				FailureCode: ptr.String("__FailureCode__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeImageReplicationStatus.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.DescribeImageReplicationStatus(context.Background(), &DescribeImageReplicationStatusInput{
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageId: &types.ImageIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
			ImageTag:    ptr.String("__ImageTag__"),
		},
		RegistryId: ptr.String("__RegistryId__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeImageReplicationStatus.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeImageScanFindings(t *testing.T) {
	want := &DescribeImageScanFindingsOutput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageId: &types.ImageIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
			ImageTag:    ptr.String("__ImageTag__"),
		},
		ImageScanStatus: &types.ImageScanStatus{
			Status:      types.ScanStatus("IN_PROGRESS"),
			Description: ptr.String("__Description__"),
		},
		ImageScanFindings: &types.ImageScanFindings{
			ImageScanCompletedAt:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			VulnerabilitySourceUpdatedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			FindingSeverityCounts: map[string]int32{
				"key0": 1,
			},
			Findings: []types.ImageScanFinding{
				{
					Name:        ptr.String("__Name__"),
					Description: ptr.String("__Description__"),
					Uri:         ptr.String("__Uri__"),
					Severity:    types.FindingSeverity("INFORMATIONAL"),
					Attributes: []types.Attribute{
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
					},
				},
				{
					Name:        ptr.String("__Name__"),
					Description: ptr.String("__Description__"),
					Uri:         ptr.String("__Uri__"),
					Severity:    types.FindingSeverity("INFORMATIONAL"),
					Attributes: []types.Attribute{
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
					},
				},
			},
			EnhancedFindings: []types.EnhancedImageScanFinding{
				{
					AwsAccountId:    ptr.String("__AwsAccountId__"),
					Description:     ptr.String("__Description__"),
					FindingArn:      ptr.String("__FindingArn__"),
					FirstObservedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					LastObservedAt:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					PackageVulnerabilityDetails: &types.PackageVulnerabilityDetails{
						Cvss: []types.CvssScore{
							{
								BaseScore:     1.0,
								ScoringVector: ptr.String("__ScoringVector__"),
								Source:        ptr.String("__Source__"),
								Version:       ptr.String("__Version__"),
							},
							{
								BaseScore:     1.0,
								ScoringVector: ptr.String("__ScoringVector__"),
								Source:        ptr.String("__Source__"),
								Version:       ptr.String("__Version__"),
							},
						},
						ReferenceUrls: []string{
							"__Member__",
							"__Member__",
						},
						RelatedVulnerabilities: []string{
							"__Member__",
							"__Member__",
						},
						Source:          ptr.String("__Source__"),
						SourceUrl:       ptr.String("__SourceUrl__"),
						VendorCreatedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						VendorSeverity:  ptr.String("__VendorSeverity__"),
						VendorUpdatedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						VulnerabilityId: ptr.String("__VulnerabilityId__"),
						VulnerablePackages: []types.VulnerablePackage{
							{
								Arch:            ptr.String("__Arch__"),
								Epoch:           ptr.Int32(1),
								FilePath:        ptr.String("__FilePath__"),
								Name:            ptr.String("__Name__"),
								PackageManager:  ptr.String("__PackageManager__"),
								Release:         ptr.String("__Release__"),
								SourceLayerHash: ptr.String("__SourceLayerHash__"),
								Version:         ptr.String("__Version__"),
								FixedInVersion:  ptr.String("__FixedInVersion__"),
							},
							{
								Arch:            ptr.String("__Arch__"),
								Epoch:           ptr.Int32(1),
								FilePath:        ptr.String("__FilePath__"),
								Name:            ptr.String("__Name__"),
								PackageManager:  ptr.String("__PackageManager__"),
								Release:         ptr.String("__Release__"),
								SourceLayerHash: ptr.String("__SourceLayerHash__"),
								Version:         ptr.String("__Version__"),
								FixedInVersion:  ptr.String("__FixedInVersion__"),
							},
						},
					},
					Remediation: &types.Remediation{
						Recommendation: &types.Recommendation{
							Url:  ptr.String("__Url__"),
							Text: ptr.String("__Text__"),
						},
					},
					Resources: []types.Resource{
						{
							Details: &types.ResourceDetails{
								AwsEcrContainerImage: &types.AwsEcrContainerImageDetails{
									Architecture: ptr.String("__Architecture__"),
									Author:       ptr.String("__Author__"),
									ImageHash:    ptr.String("__ImageHash__"),
									ImageTags: []string{
										"__Member__",
										"__Member__",
									},
									Platform:       ptr.String("__Platform__"),
									PushedAt:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
									LastInUseAt:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
									InUseCount:     ptr.Int64(1),
									Registry:       ptr.String("__Registry__"),
									RepositoryName: ptr.String("__RepositoryName__"),
								},
							},
							Id: ptr.String("__Id__"),
							Tags: map[string]string{
								"key0": "__Value__",
							},
							Type: ptr.String("__Type__"),
						},
						{
							Details: &types.ResourceDetails{
								AwsEcrContainerImage: &types.AwsEcrContainerImageDetails{
									Architecture: ptr.String("__Architecture__"),
									Author:       ptr.String("__Author__"),
									ImageHash:    ptr.String("__ImageHash__"),
									ImageTags: []string{
										"__Member__",
										"__Member__",
									},
									Platform:       ptr.String("__Platform__"),
									PushedAt:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
									LastInUseAt:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
									InUseCount:     ptr.Int64(1),
									Registry:       ptr.String("__Registry__"),
									RepositoryName: ptr.String("__RepositoryName__"),
								},
							},
							Id: ptr.String("__Id__"),
							Tags: map[string]string{
								"key0": "__Value__",
							},
							Type: ptr.String("__Type__"),
						},
					},
					Score: 1.0,
					ScoreDetails: &types.ScoreDetails{
						Cvss: &types.CvssScoreDetails{
							Adjustments: []types.CvssScoreAdjustment{
								{
									Metric: ptr.String("__Metric__"),
									Reason: ptr.String("__Reason__"),
								},
								{
									Metric: ptr.String("__Metric__"),
									Reason: ptr.String("__Reason__"),
								},
							},
							Score:         1.0,
							ScoreSource:   ptr.String("__ScoreSource__"),
							ScoringVector: ptr.String("__ScoringVector__"),
							Version:       ptr.String("__Version__"),
						},
					},
					Severity:         ptr.String("__Severity__"),
					Status:           ptr.String("__Status__"),
					Title:            ptr.String("__Title__"),
					Type:             ptr.String("__Type__"),
					UpdatedAt:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					FixAvailable:     ptr.String("__FixAvailable__"),
					ExploitAvailable: ptr.String("__ExploitAvailable__"),
				},
				{
					AwsAccountId:    ptr.String("__AwsAccountId__"),
					Description:     ptr.String("__Description__"),
					FindingArn:      ptr.String("__FindingArn__"),
					FirstObservedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					LastObservedAt:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					PackageVulnerabilityDetails: &types.PackageVulnerabilityDetails{
						Cvss: []types.CvssScore{
							{
								BaseScore:     1.0,
								ScoringVector: ptr.String("__ScoringVector__"),
								Source:        ptr.String("__Source__"),
								Version:       ptr.String("__Version__"),
							},
							{
								BaseScore:     1.0,
								ScoringVector: ptr.String("__ScoringVector__"),
								Source:        ptr.String("__Source__"),
								Version:       ptr.String("__Version__"),
							},
						},
						ReferenceUrls: []string{
							"__Member__",
							"__Member__",
						},
						RelatedVulnerabilities: []string{
							"__Member__",
							"__Member__",
						},
						Source:          ptr.String("__Source__"),
						SourceUrl:       ptr.String("__SourceUrl__"),
						VendorCreatedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						VendorSeverity:  ptr.String("__VendorSeverity__"),
						VendorUpdatedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						VulnerabilityId: ptr.String("__VulnerabilityId__"),
						VulnerablePackages: []types.VulnerablePackage{
							{
								Arch:            ptr.String("__Arch__"),
								Epoch:           ptr.Int32(1),
								FilePath:        ptr.String("__FilePath__"),
								Name:            ptr.String("__Name__"),
								PackageManager:  ptr.String("__PackageManager__"),
								Release:         ptr.String("__Release__"),
								SourceLayerHash: ptr.String("__SourceLayerHash__"),
								Version:         ptr.String("__Version__"),
								FixedInVersion:  ptr.String("__FixedInVersion__"),
							},
							{
								Arch:            ptr.String("__Arch__"),
								Epoch:           ptr.Int32(1),
								FilePath:        ptr.String("__FilePath__"),
								Name:            ptr.String("__Name__"),
								PackageManager:  ptr.String("__PackageManager__"),
								Release:         ptr.String("__Release__"),
								SourceLayerHash: ptr.String("__SourceLayerHash__"),
								Version:         ptr.String("__Version__"),
								FixedInVersion:  ptr.String("__FixedInVersion__"),
							},
						},
					},
					Remediation: &types.Remediation{
						Recommendation: &types.Recommendation{
							Url:  ptr.String("__Url__"),
							Text: ptr.String("__Text__"),
						},
					},
					Resources: []types.Resource{
						{
							Details: &types.ResourceDetails{
								AwsEcrContainerImage: &types.AwsEcrContainerImageDetails{
									Architecture: ptr.String("__Architecture__"),
									Author:       ptr.String("__Author__"),
									ImageHash:    ptr.String("__ImageHash__"),
									ImageTags: []string{
										"__Member__",
										"__Member__",
									},
									Platform:       ptr.String("__Platform__"),
									PushedAt:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
									LastInUseAt:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
									InUseCount:     ptr.Int64(1),
									Registry:       ptr.String("__Registry__"),
									RepositoryName: ptr.String("__RepositoryName__"),
								},
							},
							Id: ptr.String("__Id__"),
							Tags: map[string]string{
								"key0": "__Value__",
							},
							Type: ptr.String("__Type__"),
						},
						{
							Details: &types.ResourceDetails{
								AwsEcrContainerImage: &types.AwsEcrContainerImageDetails{
									Architecture: ptr.String("__Architecture__"),
									Author:       ptr.String("__Author__"),
									ImageHash:    ptr.String("__ImageHash__"),
									ImageTags: []string{
										"__Member__",
										"__Member__",
									},
									Platform:       ptr.String("__Platform__"),
									PushedAt:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
									LastInUseAt:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
									InUseCount:     ptr.Int64(1),
									Registry:       ptr.String("__Registry__"),
									RepositoryName: ptr.String("__RepositoryName__"),
								},
							},
							Id: ptr.String("__Id__"),
							Tags: map[string]string{
								"key0": "__Value__",
							},
							Type: ptr.String("__Type__"),
						},
					},
					Score: 1.0,
					ScoreDetails: &types.ScoreDetails{
						Cvss: &types.CvssScoreDetails{
							Adjustments: []types.CvssScoreAdjustment{
								{
									Metric: ptr.String("__Metric__"),
									Reason: ptr.String("__Reason__"),
								},
								{
									Metric: ptr.String("__Metric__"),
									Reason: ptr.String("__Reason__"),
								},
							},
							Score:         1.0,
							ScoreSource:   ptr.String("__ScoreSource__"),
							ScoringVector: ptr.String("__ScoringVector__"),
							Version:       ptr.String("__Version__"),
						},
					},
					Severity:         ptr.String("__Severity__"),
					Status:           ptr.String("__Status__"),
					Title:            ptr.String("__Title__"),
					Type:             ptr.String("__Type__"),
					UpdatedAt:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					FixAvailable:     ptr.String("__FixAvailable__"),
					ExploitAvailable: ptr.String("__ExploitAvailable__"),
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeImageScanFindings.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.DescribeImageScanFindings(context.Background(), &DescribeImageScanFindingsInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageId: &types.ImageIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
			ImageTag:    ptr.String("__ImageTag__"),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeImageScanFindings.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeImageSigningStatus(t *testing.T) {
	want := &DescribeImageSigningStatusOutput{
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageId: &types.ImageIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
			ImageTag:    ptr.String("__ImageTag__"),
		},
		RegistryId: ptr.String("__RegistryId__"),
		SigningStatuses: []types.ImageSigningStatus{
			{
				SigningProfileArn: ptr.String("__SigningProfileArn__"),
				FailureCode:       ptr.String("__FailureCode__"),
				FailureReason:     ptr.String("__FailureReason__"),
				Status:            types.SigningStatus("IN_PROGRESS"),
			},
			{
				SigningProfileArn: ptr.String("__SigningProfileArn__"),
				FailureCode:       ptr.String("__FailureCode__"),
				FailureReason:     ptr.String("__FailureReason__"),
				Status:            types.SigningStatus("IN_PROGRESS"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeImageSigningStatus.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.DescribeImageSigningStatus(context.Background(), &DescribeImageSigningStatusInput{
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageId: &types.ImageIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
			ImageTag:    ptr.String("__ImageTag__"),
		},
		RegistryId: ptr.String("__RegistryId__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeImageSigningStatus.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeImages(t *testing.T) {
	want := &DescribeImagesOutput{
		ImageDetails: []types.ImageDetail{
			{
				RegistryId:     ptr.String("__RegistryId__"),
				RepositoryName: ptr.String("__RepositoryName__"),
				ImageDigest:    ptr.String("__ImageDigest__"),
				ImageTags: []string{
					"__Member__",
					"__Member__",
				},
				ImageSizeInBytes: ptr.Int64(1),
				ImagePushedAt:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ImageScanStatus: &types.ImageScanStatus{
					Status:      types.ScanStatus("IN_PROGRESS"),
					Description: ptr.String("__Description__"),
				},
				ImageScanFindingsSummary: &types.ImageScanFindingsSummary{
					ImageScanCompletedAt:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					VulnerabilitySourceUpdatedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					FindingSeverityCounts: map[string]int32{
						"key0": 1,
					},
				},
				ImageManifestMediaType: ptr.String("__ImageManifestMediaType__"),
				ArtifactMediaType:      ptr.String("__ArtifactMediaType__"),
				LastRecordedPullTime:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				SubjectManifestDigest:  ptr.String("__SubjectManifestDigest__"),
				ImageStatus:            types.ImageStatus("ACTIVE"),
				LastArchivedAt:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastActivatedAt:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				RegistryId:     ptr.String("__RegistryId__"),
				RepositoryName: ptr.String("__RepositoryName__"),
				ImageDigest:    ptr.String("__ImageDigest__"),
				ImageTags: []string{
					"__Member__",
					"__Member__",
				},
				ImageSizeInBytes: ptr.Int64(1),
				ImagePushedAt:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ImageScanStatus: &types.ImageScanStatus{
					Status:      types.ScanStatus("IN_PROGRESS"),
					Description: ptr.String("__Description__"),
				},
				ImageScanFindingsSummary: &types.ImageScanFindingsSummary{
					ImageScanCompletedAt:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					VulnerabilitySourceUpdatedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					FindingSeverityCounts: map[string]int32{
						"key0": 1,
					},
				},
				ImageManifestMediaType: ptr.String("__ImageManifestMediaType__"),
				ArtifactMediaType:      ptr.String("__ArtifactMediaType__"),
				LastRecordedPullTime:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				SubjectManifestDigest:  ptr.String("__SubjectManifestDigest__"),
				ImageStatus:            types.ImageStatus("ACTIVE"),
				LastArchivedAt:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastActivatedAt:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeImages.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.DescribeImages(context.Background(), &DescribeImagesInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageIds: []types.ImageIdentifier{
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
		Filter: &types.DescribeImagesFilter{
			TagStatus:   types.TagStatus("TAGGED"),
			ImageStatus: types.ImageStatusFilter("ACTIVE"),
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeImages.response", err)
	}
}

func TestCheckResponseSnapshot_DescribePullThroughCacheRules(t *testing.T) {
	want := &DescribePullThroughCacheRulesOutput{
		PullThroughCacheRules: []types.PullThroughCacheRule{
			{
				EcrRepositoryPrefix:      ptr.String("__EcrRepositoryPrefix__"),
				UpstreamRegistryUrl:      ptr.String("__UpstreamRegistryUrl__"),
				CreatedAt:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				RegistryId:               ptr.String("__RegistryId__"),
				CredentialArn:            ptr.String("__CredentialArn__"),
				CustomRoleArn:            ptr.String("__CustomRoleArn__"),
				UpstreamRepositoryPrefix: ptr.String("__UpstreamRepositoryPrefix__"),
				UpstreamRegistry:         types.UpstreamRegistry("ecr"),
				UpdatedAt:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				EcrRepositoryPrefix:      ptr.String("__EcrRepositoryPrefix__"),
				UpstreamRegistryUrl:      ptr.String("__UpstreamRegistryUrl__"),
				CreatedAt:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				RegistryId:               ptr.String("__RegistryId__"),
				CredentialArn:            ptr.String("__CredentialArn__"),
				CustomRoleArn:            ptr.String("__CustomRoleArn__"),
				UpstreamRepositoryPrefix: ptr.String("__UpstreamRepositoryPrefix__"),
				UpstreamRegistry:         types.UpstreamRegistry("ecr"),
				UpdatedAt:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribePullThroughCacheRules.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.DescribePullThroughCacheRules(context.Background(), &DescribePullThroughCacheRulesInput{
		RegistryId: ptr.String("__RegistryId__"),
		EcrRepositoryPrefixes: []string{
			"__Member__",
			"__Member__",
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribePullThroughCacheRules.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeRegistry(t *testing.T) {
	want := &DescribeRegistryOutput{
		RegistryId: ptr.String("__RegistryId__"),
		ReplicationConfiguration: &types.ReplicationConfiguration{
			Rules: []types.ReplicationRule{
				{
					Destinations: []types.ReplicationDestination{
						{
							Region:     ptr.String("__Region__"),
							RegistryId: ptr.String("__RegistryId__"),
						},
						{
							Region:     ptr.String("__Region__"),
							RegistryId: ptr.String("__RegistryId__"),
						},
					},
					RepositoryFilters: []types.RepositoryFilter{
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.RepositoryFilterType("PREFIX_MATCH"),
						},
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.RepositoryFilterType("PREFIX_MATCH"),
						},
					},
				},
				{
					Destinations: []types.ReplicationDestination{
						{
							Region:     ptr.String("__Region__"),
							RegistryId: ptr.String("__RegistryId__"),
						},
						{
							Region:     ptr.String("__Region__"),
							RegistryId: ptr.String("__RegistryId__"),
						},
					},
					RepositoryFilters: []types.RepositoryFilter{
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.RepositoryFilterType("PREFIX_MATCH"),
						},
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.RepositoryFilterType("PREFIX_MATCH"),
						},
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeRegistry.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.DescribeRegistry(context.Background(), &DescribeRegistryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeRegistry.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeRepositories(t *testing.T) {
	want := &DescribeRepositoriesOutput{
		Repositories: []types.Repository{
			{
				RepositoryArn:      ptr.String("__RepositoryArn__"),
				RegistryId:         ptr.String("__RegistryId__"),
				RepositoryName:     ptr.String("__RepositoryName__"),
				RepositoryUri:      ptr.String("__RepositoryUri__"),
				CreatedAt:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ImageTagMutability: types.ImageTagMutability("MUTABLE"),
				ImageTagMutabilityExclusionFilters: []types.ImageTagMutabilityExclusionFilter{
					{
						FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
						Filter:     ptr.String("__Filter__"),
					},
					{
						FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
						Filter:     ptr.String("__Filter__"),
					},
				},
				ImageScanningConfiguration: &types.ImageScanningConfiguration{
					ScanOnPush: true,
				},
				EncryptionConfiguration: &types.EncryptionConfiguration{
					EncryptionType: types.EncryptionType("AES256"),
					KmsKey:         ptr.String("__KmsKey__"),
				},
			},
			{
				RepositoryArn:      ptr.String("__RepositoryArn__"),
				RegistryId:         ptr.String("__RegistryId__"),
				RepositoryName:     ptr.String("__RepositoryName__"),
				RepositoryUri:      ptr.String("__RepositoryUri__"),
				CreatedAt:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ImageTagMutability: types.ImageTagMutability("MUTABLE"),
				ImageTagMutabilityExclusionFilters: []types.ImageTagMutabilityExclusionFilter{
					{
						FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
						Filter:     ptr.String("__Filter__"),
					},
					{
						FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
						Filter:     ptr.String("__Filter__"),
					},
				},
				ImageScanningConfiguration: &types.ImageScanningConfiguration{
					ScanOnPush: true,
				},
				EncryptionConfiguration: &types.EncryptionConfiguration{
					EncryptionType: types.EncryptionType("AES256"),
					KmsKey:         ptr.String("__KmsKey__"),
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeRepositories.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.DescribeRepositories(context.Background(), &DescribeRepositoriesInput{
		RegistryId: ptr.String("__RegistryId__"),
		RepositoryNames: []string{
			"__Member__",
			"__Member__",
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeRepositories.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeRepositoryCreationTemplates(t *testing.T) {
	want := &DescribeRepositoryCreationTemplatesOutput{
		RegistryId: ptr.String("__RegistryId__"),
		RepositoryCreationTemplates: []types.RepositoryCreationTemplate{
			{
				Prefix:      ptr.String("__Prefix__"),
				Description: ptr.String("__Description__"),
				EncryptionConfiguration: &types.EncryptionConfigurationForRepositoryCreationTemplate{
					EncryptionType: types.EncryptionType("AES256"),
					KmsKey:         ptr.String("__KmsKey__"),
				},
				ResourceTags: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
				ImageTagMutability: types.ImageTagMutability("MUTABLE"),
				ImageTagMutabilityExclusionFilters: []types.ImageTagMutabilityExclusionFilter{
					{
						FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
						Filter:     ptr.String("__Filter__"),
					},
					{
						FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
						Filter:     ptr.String("__Filter__"),
					},
				},
				RepositoryPolicy: ptr.String("__RepositoryPolicy__"),
				LifecyclePolicy:  ptr.String("__LifecyclePolicy__"),
				AppliedFor: []types.RCTAppliedFor{
					types.RCTAppliedFor("REPLICATION"),
					types.RCTAppliedFor("REPLICATION"),
				},
				CustomRoleArn: ptr.String("__CustomRoleArn__"),
				CreatedAt:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedAt:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				Prefix:      ptr.String("__Prefix__"),
				Description: ptr.String("__Description__"),
				EncryptionConfiguration: &types.EncryptionConfigurationForRepositoryCreationTemplate{
					EncryptionType: types.EncryptionType("AES256"),
					KmsKey:         ptr.String("__KmsKey__"),
				},
				ResourceTags: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
				ImageTagMutability: types.ImageTagMutability("MUTABLE"),
				ImageTagMutabilityExclusionFilters: []types.ImageTagMutabilityExclusionFilter{
					{
						FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
						Filter:     ptr.String("__Filter__"),
					},
					{
						FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
						Filter:     ptr.String("__Filter__"),
					},
				},
				RepositoryPolicy: ptr.String("__RepositoryPolicy__"),
				LifecyclePolicy:  ptr.String("__LifecyclePolicy__"),
				AppliedFor: []types.RCTAppliedFor{
					types.RCTAppliedFor("REPLICATION"),
					types.RCTAppliedFor("REPLICATION"),
				},
				CustomRoleArn: ptr.String("__CustomRoleArn__"),
				CreatedAt:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedAt:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeRepositoryCreationTemplates.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.DescribeRepositoryCreationTemplates(context.Background(), &DescribeRepositoryCreationTemplatesInput{
		Prefixes: []string{
			"__Member__",
			"__Member__",
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeRepositoryCreationTemplates.response", err)
	}
}

func TestCheckResponseSnapshot_GetAccountSetting(t *testing.T) {
	want := &GetAccountSettingOutput{
		Name:  ptr.String("__Name__"),
		Value: ptr.String("__Value__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetAccountSetting.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.GetAccountSetting(context.Background(), &GetAccountSettingInput{
		Name: ptr.String("__Name__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetAccountSetting.response", err)
	}
}

func TestCheckResponseSnapshot_GetAuthorizationToken(t *testing.T) {
	want := &GetAuthorizationTokenOutput{
		AuthorizationData: []types.AuthorizationData{
			{
				AuthorizationToken: ptr.String("__AuthorizationToken__"),
				ExpiresAt:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ProxyEndpoint:      ptr.String("__ProxyEndpoint__"),
			},
			{
				AuthorizationToken: ptr.String("__AuthorizationToken__"),
				ExpiresAt:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ProxyEndpoint:      ptr.String("__ProxyEndpoint__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetAuthorizationToken.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.GetAuthorizationToken(context.Background(), &GetAuthorizationTokenInput{
		RegistryIds: []string{
			"__Member__",
			"__Member__",
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetAuthorizationToken.response", err)
	}
}

func TestCheckResponseSnapshot_GetDownloadUrlForLayer(t *testing.T) {
	want := &GetDownloadUrlForLayerOutput{
		DownloadUrl: ptr.String("__DownloadUrl__"),
		LayerDigest: ptr.String("__LayerDigest__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetDownloadUrlForLayer.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.GetDownloadUrlForLayer(context.Background(), &GetDownloadUrlForLayerInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		LayerDigest:    ptr.String("__LayerDigest__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetDownloadUrlForLayer.response", err)
	}
}

func TestCheckResponseSnapshot_GetLifecyclePolicy(t *testing.T) {
	want := &GetLifecyclePolicyOutput{
		RegistryId:          ptr.String("__RegistryId__"),
		RepositoryName:      ptr.String("__RepositoryName__"),
		LifecyclePolicyText: ptr.String("__LifecyclePolicyText__"),
		LastEvaluatedAt:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("GetLifecyclePolicy.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.GetLifecyclePolicy(context.Background(), &GetLifecyclePolicyInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetLifecyclePolicy.response", err)
	}
}

func TestCheckResponseSnapshot_GetLifecyclePolicyPreview(t *testing.T) {
	want := &GetLifecyclePolicyPreviewOutput{
		RegistryId:          ptr.String("__RegistryId__"),
		RepositoryName:      ptr.String("__RepositoryName__"),
		LifecyclePolicyText: ptr.String("__LifecyclePolicyText__"),
		Status:              types.LifecyclePolicyPreviewStatus("IN_PROGRESS"),
		NextToken:           ptr.String("__NextToken__"),
		PreviewResults: []types.LifecyclePolicyPreviewResult{
			{
				ImageTags: []string{
					"__Member__",
					"__Member__",
				},
				ImageDigest:   ptr.String("__ImageDigest__"),
				ImagePushedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Action: &types.LifecyclePolicyRuleAction{
					Type:               types.ImageActionType("EXPIRE"),
					TargetStorageClass: types.LifecyclePolicyTargetStorageClass("ARCHIVE"),
				},
				AppliedRulePriority: ptr.Int32(1),
				StorageClass:        types.LifecyclePolicyStorageClass("ARCHIVE"),
			},
			{
				ImageTags: []string{
					"__Member__",
					"__Member__",
				},
				ImageDigest:   ptr.String("__ImageDigest__"),
				ImagePushedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Action: &types.LifecyclePolicyRuleAction{
					Type:               types.ImageActionType("EXPIRE"),
					TargetStorageClass: types.LifecyclePolicyTargetStorageClass("ARCHIVE"),
				},
				AppliedRulePriority: ptr.Int32(1),
				StorageClass:        types.LifecyclePolicyStorageClass("ARCHIVE"),
			},
		},
		Summary: &types.LifecyclePolicyPreviewSummary{
			ExpiringImageTotalCount: ptr.Int32(1),
			TransitioningImageTotalCounts: []types.TransitioningImageTotalCount{
				{
					TargetStorageClass: types.LifecyclePolicyTargetStorageClass("ARCHIVE"),
					ImageTotalCount:    ptr.Int32(1),
				},
				{
					TargetStorageClass: types.LifecyclePolicyTargetStorageClass("ARCHIVE"),
					ImageTotalCount:    ptr.Int32(1),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetLifecyclePolicyPreview.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.GetLifecyclePolicyPreview(context.Background(), &GetLifecyclePolicyPreviewInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageIds: []types.ImageIdentifier{
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
		Filter: &types.LifecyclePolicyPreviewFilter{
			TagStatus: types.TagStatus("TAGGED"),
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetLifecyclePolicyPreview.response", err)
	}
}

func TestCheckResponseSnapshot_GetRegistryPolicy(t *testing.T) {
	want := &GetRegistryPolicyOutput{
		RegistryId: ptr.String("__RegistryId__"),
		PolicyText: ptr.String("__PolicyText__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetRegistryPolicy.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.GetRegistryPolicy(context.Background(), &GetRegistryPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetRegistryPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_GetRegistryScanningConfiguration(t *testing.T) {
	want := &GetRegistryScanningConfigurationOutput{
		RegistryId: ptr.String("__RegistryId__"),
		ScanningConfiguration: &types.RegistryScanningConfiguration{
			ScanType: types.ScanType("BASIC"),
			Rules: []types.RegistryScanningRule{
				{
					ScanFrequency: types.ScanFrequency("SCAN_ON_PUSH"),
					RepositoryFilters: []types.ScanningRepositoryFilter{
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
						},
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
						},
					},
				},
				{
					ScanFrequency: types.ScanFrequency("SCAN_ON_PUSH"),
					RepositoryFilters: []types.ScanningRepositoryFilter{
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
						},
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
						},
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetRegistryScanningConfiguration.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.GetRegistryScanningConfiguration(context.Background(), &GetRegistryScanningConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetRegistryScanningConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_GetRepositoryPolicy(t *testing.T) {
	want := &GetRepositoryPolicyOutput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		PolicyText:     ptr.String("__PolicyText__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetRepositoryPolicy.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.GetRepositoryPolicy(context.Background(), &GetRepositoryPolicyInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetRepositoryPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_GetSigningConfiguration(t *testing.T) {
	want := &GetSigningConfigurationOutput{
		RegistryId: ptr.String("__RegistryId__"),
		SigningConfiguration: &types.SigningConfiguration{
			Rules: []types.SigningRule{
				{
					SigningProfileArn: ptr.String("__SigningProfileArn__"),
					RepositoryFilters: []types.SigningRepositoryFilter{
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.SigningRepositoryFilterType("WILDCARD_MATCH"),
						},
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.SigningRepositoryFilterType("WILDCARD_MATCH"),
						},
					},
				},
				{
					SigningProfileArn: ptr.String("__SigningProfileArn__"),
					RepositoryFilters: []types.SigningRepositoryFilter{
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.SigningRepositoryFilterType("WILDCARD_MATCH"),
						},
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.SigningRepositoryFilterType("WILDCARD_MATCH"),
						},
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetSigningConfiguration.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.GetSigningConfiguration(context.Background(), &GetSigningConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetSigningConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_InitiateLayerUpload(t *testing.T) {
	want := &InitiateLayerUploadOutput{
		UploadId: ptr.String("__UploadId__"),
		PartSize: ptr.Int64(1),
	}
	status, header, body, err := serdeRespReadSnapshot("InitiateLayerUpload.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.InitiateLayerUpload(context.Background(), &InitiateLayerUploadInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "InitiateLayerUpload.response", err)
	}
}

func TestCheckResponseSnapshot_ListImageReferrers(t *testing.T) {
	want := &ListImageReferrersOutput{
		Referrers: []types.ImageReferrer{
			{
				Digest:       ptr.String("__Digest__"),
				MediaType:    ptr.String("__MediaType__"),
				ArtifactType: ptr.String("__ArtifactType__"),
				Size:         ptr.Int64(1),
				Annotations: map[string]string{
					"key0": "__Value__",
				},
				ArtifactStatus: types.ArtifactStatus("ACTIVE"),
			},
			{
				Digest:       ptr.String("__Digest__"),
				MediaType:    ptr.String("__MediaType__"),
				ArtifactType: ptr.String("__ArtifactType__"),
				Size:         ptr.Int64(1),
				Annotations: map[string]string{
					"key0": "__Value__",
				},
				ArtifactStatus: types.ArtifactStatus("ACTIVE"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListImageReferrers.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.ListImageReferrers(context.Background(), &ListImageReferrersInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		SubjectId: &types.SubjectIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
		},
		Filter: &types.ListImageReferrersFilter{
			ArtifactTypes: []string{
				"__Member__",
				"__Member__",
			},
			ArtifactStatus: types.ArtifactStatusFilter("ACTIVE"),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListImageReferrers.response", err)
	}
}

func TestCheckResponseSnapshot_ListImages(t *testing.T) {
	want := &ListImagesOutput{
		ImageIds: []types.ImageIdentifier{
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListImages.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.ListImages(context.Background(), &ListImagesInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		NextToken:      ptr.String("__NextToken__"),
		MaxResults:     ptr.Int32(1),
		Filter: &types.ListImagesFilter{
			TagStatus:   types.TagStatus("TAGGED"),
			ImageStatus: types.ImageStatusFilter("ACTIVE"),
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListImages.response", err)
	}
}

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

func TestCheckResponseSnapshot_ListTagsForResource(t *testing.T) {
	want := &ListTagsForResourceOutput{
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	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{
		ResourceArn: ptr.String("__ResourceArn__"),
	})
	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_PutAccountSetting(t *testing.T) {
	want := &PutAccountSettingOutput{
		Name:  ptr.String("__Name__"),
		Value: ptr.String("__Value__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PutAccountSetting.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.PutAccountSetting(context.Background(), &PutAccountSettingInput{
		Name:  ptr.String("__Name__"),
		Value: ptr.String("__Value__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutAccountSetting.response", err)
	}
}

func TestCheckResponseSnapshot_PutImage(t *testing.T) {
	want := &PutImageOutput{
		Image: &types.Image{
			RegistryId:     ptr.String("__RegistryId__"),
			RepositoryName: ptr.String("__RepositoryName__"),
			ImageId: &types.ImageIdentifier{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
			ImageManifest:          ptr.String("__ImageManifest__"),
			ImageManifestMediaType: ptr.String("__ImageManifestMediaType__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("PutImage.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.PutImage(context.Background(), &PutImageInput{
		RegistryId:             ptr.String("__RegistryId__"),
		RepositoryName:         ptr.String("__RepositoryName__"),
		ImageManifest:          ptr.String("__ImageManifest__"),
		ImageManifestMediaType: ptr.String("__ImageManifestMediaType__"),
		ImageTag:               ptr.String("__ImageTag__"),
		ImageDigest:            ptr.String("__ImageDigest__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutImage.response", err)
	}
}

func TestCheckResponseSnapshot_PutImageScanningConfiguration(t *testing.T) {
	want := &PutImageScanningConfigurationOutput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageScanningConfiguration: &types.ImageScanningConfiguration{
			ScanOnPush: true,
		},
	}
	status, header, body, err := serdeRespReadSnapshot("PutImageScanningConfiguration.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.PutImageScanningConfiguration(context.Background(), &PutImageScanningConfigurationInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageScanningConfiguration: &types.ImageScanningConfiguration{
			ScanOnPush: true,
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutImageScanningConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_PutImageTagMutability(t *testing.T) {
	want := &PutImageTagMutabilityOutput{
		RegistryId:         ptr.String("__RegistryId__"),
		RepositoryName:     ptr.String("__RepositoryName__"),
		ImageTagMutability: types.ImageTagMutability("MUTABLE"),
		ImageTagMutabilityExclusionFilters: []types.ImageTagMutabilityExclusionFilter{
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("PutImageTagMutability.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.PutImageTagMutability(context.Background(), &PutImageTagMutabilityInput{
		RegistryId:         ptr.String("__RegistryId__"),
		RepositoryName:     ptr.String("__RepositoryName__"),
		ImageTagMutability: types.ImageTagMutability("MUTABLE"),
		ImageTagMutabilityExclusionFilters: []types.ImageTagMutabilityExclusionFilter{
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutImageTagMutability.response", err)
	}
}

func TestCheckResponseSnapshot_PutLifecyclePolicy(t *testing.T) {
	want := &PutLifecyclePolicyOutput{
		RegistryId:          ptr.String("__RegistryId__"),
		RepositoryName:      ptr.String("__RepositoryName__"),
		LifecyclePolicyText: ptr.String("__LifecyclePolicyText__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PutLifecyclePolicy.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.PutLifecyclePolicy(context.Background(), &PutLifecyclePolicyInput{
		RegistryId:          ptr.String("__RegistryId__"),
		RepositoryName:      ptr.String("__RepositoryName__"),
		LifecyclePolicyText: ptr.String("__LifecyclePolicyText__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutLifecyclePolicy.response", err)
	}
}

func TestCheckResponseSnapshot_PutRegistryPolicy(t *testing.T) {
	want := &PutRegistryPolicyOutput{
		RegistryId: ptr.String("__RegistryId__"),
		PolicyText: ptr.String("__PolicyText__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PutRegistryPolicy.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.PutRegistryPolicy(context.Background(), &PutRegistryPolicyInput{
		PolicyText: ptr.String("__PolicyText__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutRegistryPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_PutRegistryScanningConfiguration(t *testing.T) {
	want := &PutRegistryScanningConfigurationOutput{
		RegistryScanningConfiguration: &types.RegistryScanningConfiguration{
			ScanType: types.ScanType("BASIC"),
			Rules: []types.RegistryScanningRule{
				{
					ScanFrequency: types.ScanFrequency("SCAN_ON_PUSH"),
					RepositoryFilters: []types.ScanningRepositoryFilter{
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
						},
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
						},
					},
				},
				{
					ScanFrequency: types.ScanFrequency("SCAN_ON_PUSH"),
					RepositoryFilters: []types.ScanningRepositoryFilter{
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
						},
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
						},
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("PutRegistryScanningConfiguration.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.PutRegistryScanningConfiguration(context.Background(), &PutRegistryScanningConfigurationInput{
		ScanType: types.ScanType("BASIC"),
		Rules: []types.RegistryScanningRule{
			{
				ScanFrequency: types.ScanFrequency("SCAN_ON_PUSH"),
				RepositoryFilters: []types.ScanningRepositoryFilter{
					{
						Filter:     ptr.String("__Filter__"),
						FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
					},
					{
						Filter:     ptr.String("__Filter__"),
						FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
					},
				},
			},
			{
				ScanFrequency: types.ScanFrequency("SCAN_ON_PUSH"),
				RepositoryFilters: []types.ScanningRepositoryFilter{
					{
						Filter:     ptr.String("__Filter__"),
						FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
					},
					{
						Filter:     ptr.String("__Filter__"),
						FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
					},
				},
			},
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutRegistryScanningConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_PutReplicationConfiguration(t *testing.T) {
	want := &PutReplicationConfigurationOutput{
		ReplicationConfiguration: &types.ReplicationConfiguration{
			Rules: []types.ReplicationRule{
				{
					Destinations: []types.ReplicationDestination{
						{
							Region:     ptr.String("__Region__"),
							RegistryId: ptr.String("__RegistryId__"),
						},
						{
							Region:     ptr.String("__Region__"),
							RegistryId: ptr.String("__RegistryId__"),
						},
					},
					RepositoryFilters: []types.RepositoryFilter{
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.RepositoryFilterType("PREFIX_MATCH"),
						},
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.RepositoryFilterType("PREFIX_MATCH"),
						},
					},
				},
				{
					Destinations: []types.ReplicationDestination{
						{
							Region:     ptr.String("__Region__"),
							RegistryId: ptr.String("__RegistryId__"),
						},
						{
							Region:     ptr.String("__Region__"),
							RegistryId: ptr.String("__RegistryId__"),
						},
					},
					RepositoryFilters: []types.RepositoryFilter{
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.RepositoryFilterType("PREFIX_MATCH"),
						},
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.RepositoryFilterType("PREFIX_MATCH"),
						},
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("PutReplicationConfiguration.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.PutReplicationConfiguration(context.Background(), &PutReplicationConfigurationInput{
		ReplicationConfiguration: &types.ReplicationConfiguration{
			Rules: []types.ReplicationRule{
				{
					Destinations: []types.ReplicationDestination{
						{
							Region:     ptr.String("__Region__"),
							RegistryId: ptr.String("__RegistryId__"),
						},
						{
							Region:     ptr.String("__Region__"),
							RegistryId: ptr.String("__RegistryId__"),
						},
					},
					RepositoryFilters: []types.RepositoryFilter{
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.RepositoryFilterType("PREFIX_MATCH"),
						},
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.RepositoryFilterType("PREFIX_MATCH"),
						},
					},
				},
				{
					Destinations: []types.ReplicationDestination{
						{
							Region:     ptr.String("__Region__"),
							RegistryId: ptr.String("__RegistryId__"),
						},
						{
							Region:     ptr.String("__Region__"),
							RegistryId: ptr.String("__RegistryId__"),
						},
					},
					RepositoryFilters: []types.RepositoryFilter{
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.RepositoryFilterType("PREFIX_MATCH"),
						},
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.RepositoryFilterType("PREFIX_MATCH"),
						},
					},
				},
			},
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutReplicationConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_PutSigningConfiguration(t *testing.T) {
	want := &PutSigningConfigurationOutput{
		SigningConfiguration: &types.SigningConfiguration{
			Rules: []types.SigningRule{
				{
					SigningProfileArn: ptr.String("__SigningProfileArn__"),
					RepositoryFilters: []types.SigningRepositoryFilter{
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.SigningRepositoryFilterType("WILDCARD_MATCH"),
						},
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.SigningRepositoryFilterType("WILDCARD_MATCH"),
						},
					},
				},
				{
					SigningProfileArn: ptr.String("__SigningProfileArn__"),
					RepositoryFilters: []types.SigningRepositoryFilter{
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.SigningRepositoryFilterType("WILDCARD_MATCH"),
						},
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.SigningRepositoryFilterType("WILDCARD_MATCH"),
						},
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("PutSigningConfiguration.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.PutSigningConfiguration(context.Background(), &PutSigningConfigurationInput{
		SigningConfiguration: &types.SigningConfiguration{
			Rules: []types.SigningRule{
				{
					SigningProfileArn: ptr.String("__SigningProfileArn__"),
					RepositoryFilters: []types.SigningRepositoryFilter{
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.SigningRepositoryFilterType("WILDCARD_MATCH"),
						},
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.SigningRepositoryFilterType("WILDCARD_MATCH"),
						},
					},
				},
				{
					SigningProfileArn: ptr.String("__SigningProfileArn__"),
					RepositoryFilters: []types.SigningRepositoryFilter{
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.SigningRepositoryFilterType("WILDCARD_MATCH"),
						},
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.SigningRepositoryFilterType("WILDCARD_MATCH"),
						},
					},
				},
			},
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutSigningConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_RegisterPullTimeUpdateExclusion(t *testing.T) {
	want := &RegisterPullTimeUpdateExclusionOutput{
		PrincipalArn: ptr.String("__PrincipalArn__"),
		CreatedAt:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("RegisterPullTimeUpdateExclusion.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.RegisterPullTimeUpdateExclusion(context.Background(), &RegisterPullTimeUpdateExclusionInput{
		PrincipalArn: ptr.String("__PrincipalArn__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "RegisterPullTimeUpdateExclusion.response", err)
	}
}

func TestCheckResponseSnapshot_SetRepositoryPolicy(t *testing.T) {
	want := &SetRepositoryPolicyOutput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		PolicyText:     ptr.String("__PolicyText__"),
	}
	status, header, body, err := serdeRespReadSnapshot("SetRepositoryPolicy.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.SetRepositoryPolicy(context.Background(), &SetRepositoryPolicyInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		PolicyText:     ptr.String("__PolicyText__"),
		Force:          true,
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "SetRepositoryPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_StartImageScan(t *testing.T) {
	want := &StartImageScanOutput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageId: &types.ImageIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
			ImageTag:    ptr.String("__ImageTag__"),
		},
		ImageScanStatus: &types.ImageScanStatus{
			Status:      types.ScanStatus("IN_PROGRESS"),
			Description: ptr.String("__Description__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("StartImageScan.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.StartImageScan(context.Background(), &StartImageScanInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageId: &types.ImageIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
			ImageTag:    ptr.String("__ImageTag__"),
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StartImageScan.response", err)
	}
}

func TestCheckResponseSnapshot_StartLifecyclePolicyPreview(t *testing.T) {
	want := &StartLifecyclePolicyPreviewOutput{
		RegistryId:          ptr.String("__RegistryId__"),
		RepositoryName:      ptr.String("__RepositoryName__"),
		LifecyclePolicyText: ptr.String("__LifecyclePolicyText__"),
		Status:              types.LifecyclePolicyPreviewStatus("IN_PROGRESS"),
	}
	status, header, body, err := serdeRespReadSnapshot("StartLifecyclePolicyPreview.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.StartLifecyclePolicyPreview(context.Background(), &StartLifecyclePolicyPreviewInput{
		RegistryId:          ptr.String("__RegistryId__"),
		RepositoryName:      ptr.String("__RepositoryName__"),
		LifecyclePolicyText: ptr.String("__LifecyclePolicyText__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StartLifecyclePolicyPreview.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{
		ResourceArn: ptr.String("__ResourceArn__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	})
	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_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{
		ResourceArn: ptr.String("__ResourceArn__"),
		TagKeys: []string{
			"__Member__",
			"__Member__",
		},
	})
	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_UpdateImageStorageClass(t *testing.T) {
	want := &UpdateImageStorageClassOutput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageId: &types.ImageIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
			ImageTag:    ptr.String("__ImageTag__"),
		},
		ImageStatus: types.ImageStatus("ACTIVE"),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateImageStorageClass.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.UpdateImageStorageClass(context.Background(), &UpdateImageStorageClassInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageId: &types.ImageIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
			ImageTag:    ptr.String("__ImageTag__"),
		},
		TargetStorageClass: types.TargetStorageClass("STANDARD"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateImageStorageClass.response", err)
	}
}

func TestCheckResponseSnapshot_UpdatePullThroughCacheRule(t *testing.T) {
	want := &UpdatePullThroughCacheRuleOutput{
		EcrRepositoryPrefix:      ptr.String("__EcrRepositoryPrefix__"),
		RegistryId:               ptr.String("__RegistryId__"),
		UpdatedAt:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		CredentialArn:            ptr.String("__CredentialArn__"),
		CustomRoleArn:            ptr.String("__CustomRoleArn__"),
		UpstreamRepositoryPrefix: ptr.String("__UpstreamRepositoryPrefix__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdatePullThroughCacheRule.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.UpdatePullThroughCacheRule(context.Background(), &UpdatePullThroughCacheRuleInput{
		RegistryId:          ptr.String("__RegistryId__"),
		EcrRepositoryPrefix: ptr.String("__EcrRepositoryPrefix__"),
		CredentialArn:       ptr.String("__CredentialArn__"),
		CustomRoleArn:       ptr.String("__CustomRoleArn__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdatePullThroughCacheRule.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateRepositoryCreationTemplate(t *testing.T) {
	want := &UpdateRepositoryCreationTemplateOutput{
		RegistryId: ptr.String("__RegistryId__"),
		RepositoryCreationTemplate: &types.RepositoryCreationTemplate{
			Prefix:      ptr.String("__Prefix__"),
			Description: ptr.String("__Description__"),
			EncryptionConfiguration: &types.EncryptionConfigurationForRepositoryCreationTemplate{
				EncryptionType: types.EncryptionType("AES256"),
				KmsKey:         ptr.String("__KmsKey__"),
			},
			ResourceTags: []types.Tag{
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
			},
			ImageTagMutability: types.ImageTagMutability("MUTABLE"),
			ImageTagMutabilityExclusionFilters: []types.ImageTagMutabilityExclusionFilter{
				{
					FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
					Filter:     ptr.String("__Filter__"),
				},
				{
					FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
					Filter:     ptr.String("__Filter__"),
				},
			},
			RepositoryPolicy: ptr.String("__RepositoryPolicy__"),
			LifecyclePolicy:  ptr.String("__LifecyclePolicy__"),
			AppliedFor: []types.RCTAppliedFor{
				types.RCTAppliedFor("REPLICATION"),
				types.RCTAppliedFor("REPLICATION"),
			},
			CustomRoleArn: ptr.String("__CustomRoleArn__"),
			CreatedAt:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			UpdatedAt:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateRepositoryCreationTemplate.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.UpdateRepositoryCreationTemplate(context.Background(), &UpdateRepositoryCreationTemplateInput{
		Prefix:      ptr.String("__Prefix__"),
		Description: ptr.String("__Description__"),
		EncryptionConfiguration: &types.EncryptionConfigurationForRepositoryCreationTemplate{
			EncryptionType: types.EncryptionType("AES256"),
			KmsKey:         ptr.String("__KmsKey__"),
		},
		ResourceTags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		ImageTagMutability: types.ImageTagMutability("MUTABLE"),
		ImageTagMutabilityExclusionFilters: []types.ImageTagMutabilityExclusionFilter{
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
		},
		RepositoryPolicy: ptr.String("__RepositoryPolicy__"),
		LifecyclePolicy:  ptr.String("__LifecyclePolicy__"),
		AppliedFor: []types.RCTAppliedFor{
			types.RCTAppliedFor("REPLICATION"),
			types.RCTAppliedFor("REPLICATION"),
		},
		CustomRoleArn: ptr.String("__CustomRoleArn__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateRepositoryCreationTemplate.response", err)
	}
}

func TestCheckResponseSnapshot_UploadLayerPart(t *testing.T) {
	want := &UploadLayerPartOutput{
		RegistryId:       ptr.String("__RegistryId__"),
		RepositoryName:   ptr.String("__RepositoryName__"),
		UploadId:         ptr.String("__UploadId__"),
		LastByteReceived: ptr.Int64(1),
	}
	status, header, body, err := serdeRespReadSnapshot("UploadLayerPart.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.UploadLayerPart(context.Background(), &UploadLayerPartInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		UploadId:       ptr.String("__UploadId__"),
		PartFirstByte:  ptr.Int64(1),
		PartLastByte:   ptr.Int64(1),
		LayerPartBlob:  []byte("blob"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UploadLayerPart.response", err)
	}
}

func TestCheckResponseSnapshot_ValidatePullThroughCacheRule(t *testing.T) {
	want := &ValidatePullThroughCacheRuleOutput{
		EcrRepositoryPrefix:      ptr.String("__EcrRepositoryPrefix__"),
		RegistryId:               ptr.String("__RegistryId__"),
		UpstreamRegistryUrl:      ptr.String("__UpstreamRegistryUrl__"),
		CredentialArn:            ptr.String("__CredentialArn__"),
		CustomRoleArn:            ptr.String("__CustomRoleArn__"),
		UpstreamRepositoryPrefix: ptr.String("__UpstreamRepositoryPrefix__"),
		IsValid:                  true,
		Failure:                  ptr.String("__Failure__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ValidatePullThroughCacheRule.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.ValidatePullThroughCacheRule(context.Background(), &ValidatePullThroughCacheRuleInput{
		EcrRepositoryPrefix: ptr.String("__EcrRepositoryPrefix__"),
		RegistryId:          ptr.String("__RegistryId__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ValidatePullThroughCacheRule.response", err)
	}
}

func TestCheckResponseSnapshot_Error_BlockedByOrganizationPolicyException(t *testing.T) {
	want := &types.BlockedByOrganizationPolicyException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("BlockedByOrganizationPolicyException.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.PutRegistryScanningConfiguration(context.Background(), &PutRegistryScanningConfigurationInput{
		ScanType: types.ScanType("BASIC"),
		Rules: []types.RegistryScanningRule{
			{
				ScanFrequency: types.ScanFrequency("SCAN_ON_PUSH"),
				RepositoryFilters: []types.ScanningRepositoryFilter{
					{
						Filter:     ptr.String("__Filter__"),
						FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
					},
					{
						Filter:     ptr.String("__Filter__"),
						FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
					},
				},
			},
			{
				ScanFrequency: types.ScanFrequency("SCAN_ON_PUSH"),
				RepositoryFilters: []types.ScanningRepositoryFilter{
					{
						Filter:     ptr.String("__Filter__"),
						FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
					},
					{
						Filter:     ptr.String("__Filter__"),
						FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
					},
				},
			},
		},
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.BlockedByOrganizationPolicyException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.BlockedByOrganizationPolicyException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "BlockedByOrganizationPolicyException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_EmptyUploadException(t *testing.T) {
	want := &types.EmptyUploadException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("EmptyUploadException.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.CompleteLayerUpload(context.Background(), &CompleteLayerUploadInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		UploadId:       ptr.String("__UploadId__"),
		LayerDigests: []string{
			"__Member__",
			"__Member__",
		},
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.EmptyUploadException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.EmptyUploadException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "EmptyUploadException.error", err)
	}
}

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

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

func TestCheckResponseSnapshot_Error_ImageAlreadyExistsException(t *testing.T) {
	want := &types.ImageAlreadyExistsException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ImageAlreadyExistsException.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.PutImage(context.Background(), &PutImageInput{
		RegistryId:             ptr.String("__RegistryId__"),
		RepositoryName:         ptr.String("__RepositoryName__"),
		ImageManifest:          ptr.String("__ImageManifest__"),
		ImageManifestMediaType: ptr.String("__ImageManifestMediaType__"),
		ImageTag:               ptr.String("__ImageTag__"),
		ImageDigest:            ptr.String("__ImageDigest__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ImageAlreadyExistsException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ImageAlreadyExistsException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ImageAlreadyExistsException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ImageArchivedException(t *testing.T) {
	want := &types.ImageArchivedException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ImageArchivedException.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.StartImageScan(context.Background(), &StartImageScanInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageId: &types.ImageIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
			ImageTag:    ptr.String("__ImageTag__"),
		},
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ImageArchivedException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ImageArchivedException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ImageArchivedException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ImageDigestDoesNotMatchException(t *testing.T) {
	want := &types.ImageDigestDoesNotMatchException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ImageDigestDoesNotMatchException.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.PutImage(context.Background(), &PutImageInput{
		RegistryId:             ptr.String("__RegistryId__"),
		RepositoryName:         ptr.String("__RepositoryName__"),
		ImageManifest:          ptr.String("__ImageManifest__"),
		ImageManifestMediaType: ptr.String("__ImageManifestMediaType__"),
		ImageTag:               ptr.String("__ImageTag__"),
		ImageDigest:            ptr.String("__ImageDigest__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ImageDigestDoesNotMatchException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ImageDigestDoesNotMatchException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ImageDigestDoesNotMatchException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ImageNotFoundException(t *testing.T) {
	want := &types.ImageNotFoundException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ImageNotFoundException.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.DescribeImageReplicationStatus(context.Background(), &DescribeImageReplicationStatusInput{
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageId: &types.ImageIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
			ImageTag:    ptr.String("__ImageTag__"),
		},
		RegistryId: ptr.String("__RegistryId__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ImageNotFoundException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ImageNotFoundException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ImageNotFoundException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ImageStorageClassUpdateNotSupportedException(t *testing.T) {
	want := &types.ImageStorageClassUpdateNotSupportedException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ImageStorageClassUpdateNotSupportedException.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.UpdateImageStorageClass(context.Background(), &UpdateImageStorageClassInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageId: &types.ImageIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
			ImageTag:    ptr.String("__ImageTag__"),
		},
		TargetStorageClass: types.TargetStorageClass("STANDARD"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ImageStorageClassUpdateNotSupportedException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ImageStorageClassUpdateNotSupportedException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ImageStorageClassUpdateNotSupportedException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ImageTagAlreadyExistsException(t *testing.T) {
	want := &types.ImageTagAlreadyExistsException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ImageTagAlreadyExistsException.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.PutImage(context.Background(), &PutImageInput{
		RegistryId:             ptr.String("__RegistryId__"),
		RepositoryName:         ptr.String("__RepositoryName__"),
		ImageManifest:          ptr.String("__ImageManifest__"),
		ImageManifestMediaType: ptr.String("__ImageManifestMediaType__"),
		ImageTag:               ptr.String("__ImageTag__"),
		ImageDigest:            ptr.String("__ImageDigest__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ImageTagAlreadyExistsException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ImageTagAlreadyExistsException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ImageTagAlreadyExistsException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidLayerException(t *testing.T) {
	want := &types.InvalidLayerException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidLayerException.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.CompleteLayerUpload(context.Background(), &CompleteLayerUploadInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		UploadId:       ptr.String("__UploadId__"),
		LayerDigests: []string{
			"__Member__",
			"__Member__",
		},
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidLayerException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidLayerException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidLayerException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidLayerPartException(t *testing.T) {
	want := &types.InvalidLayerPartException{
		RegistryId:            ptr.String("__RegistryId__"),
		RepositoryName:        ptr.String("__RepositoryName__"),
		UploadId:              ptr.String("__UploadId__"),
		LastValidByteReceived: ptr.Int64(1),
		Message:               ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidLayerPartException.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.UploadLayerPart(context.Background(), &UploadLayerPartInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		UploadId:       ptr.String("__UploadId__"),
		PartFirstByte:  ptr.Int64(1),
		PartLastByte:   ptr.Int64(1),
		LayerPartBlob:  []byte("blob"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidLayerPartException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidLayerPartException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidLayerPartException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidParameterException(t *testing.T) {
	want := &types.InvalidParameterException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidParameterException.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.BatchCheckLayerAvailability(context.Background(), &BatchCheckLayerAvailabilityInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		LayerDigests: []string{
			"__Member__",
			"__Member__",
		},
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidParameterException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidParameterException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidParameterException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidTagParameterException(t *testing.T) {
	want := &types.InvalidTagParameterException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidTagParameterException.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{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		ImageTagMutability: types.ImageTagMutability("MUTABLE"),
		ImageTagMutabilityExclusionFilters: []types.ImageTagMutabilityExclusionFilter{
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
		},
		ImageScanningConfiguration: &types.ImageScanningConfiguration{
			ScanOnPush: true,
		},
		EncryptionConfiguration: &types.EncryptionConfiguration{
			EncryptionType: types.EncryptionType("AES256"),
			KmsKey:         ptr.String("__KmsKey__"),
		},
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidTagParameterException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidTagParameterException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidTagParameterException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_KmsException(t *testing.T) {
	want := &types.KmsException{
		Message:  ptr.String("__Message__"),
		KmsError: ptr.String("__KmsError__"),
	}
	status, header, body, err := serdeRespReadSnapshot("KmsException.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.CompleteLayerUpload(context.Background(), &CompleteLayerUploadInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		UploadId:       ptr.String("__UploadId__"),
		LayerDigests: []string{
			"__Member__",
			"__Member__",
		},
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.KmsException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.KmsException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "KmsException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_LayerAlreadyExistsException(t *testing.T) {
	want := &types.LayerAlreadyExistsException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("LayerAlreadyExistsException.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.CompleteLayerUpload(context.Background(), &CompleteLayerUploadInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		UploadId:       ptr.String("__UploadId__"),
		LayerDigests: []string{
			"__Member__",
			"__Member__",
		},
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.LayerAlreadyExistsException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.LayerAlreadyExistsException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "LayerAlreadyExistsException.error", err)
	}
}

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

func TestCheckResponseSnapshot_Error_LayerPartTooSmallException(t *testing.T) {
	want := &types.LayerPartTooSmallException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("LayerPartTooSmallException.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.CompleteLayerUpload(context.Background(), &CompleteLayerUploadInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		UploadId:       ptr.String("__UploadId__"),
		LayerDigests: []string{
			"__Member__",
			"__Member__",
		},
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.LayerPartTooSmallException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.LayerPartTooSmallException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "LayerPartTooSmallException.error", err)
	}
}

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

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

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

func TestCheckResponseSnapshot_Error_LifecyclePolicyPreviewNotFoundException(t *testing.T) {
	want := &types.LifecyclePolicyPreviewNotFoundException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("LifecyclePolicyPreviewNotFoundException.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.GetLifecyclePolicyPreview(context.Background(), &GetLifecyclePolicyPreviewInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageIds: []types.ImageIdentifier{
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
		Filter: &types.LifecyclePolicyPreviewFilter{
			TagStatus: types.TagStatus("TAGGED"),
		},
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.LifecyclePolicyPreviewNotFoundException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.LifecyclePolicyPreviewNotFoundException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "LifecyclePolicyPreviewNotFoundException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_LimitExceededException(t *testing.T) {
	want := &types.LimitExceededException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("LimitExceededException.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.BatchGetImage(context.Background(), &BatchGetImageInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageIds: []types.ImageIdentifier{
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
		},
		AcceptedMediaTypes: []string{
			"__Member__",
			"__Member__",
		},
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.LimitExceededException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.LimitExceededException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "LimitExceededException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_PullThroughCacheRuleAlreadyExistsException(t *testing.T) {
	want := &types.PullThroughCacheRuleAlreadyExistsException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PullThroughCacheRuleAlreadyExistsException.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.CreatePullThroughCacheRule(context.Background(), &CreatePullThroughCacheRuleInput{
		EcrRepositoryPrefix:      ptr.String("__EcrRepositoryPrefix__"),
		UpstreamRegistryUrl:      ptr.String("__UpstreamRegistryUrl__"),
		RegistryId:               ptr.String("__RegistryId__"),
		UpstreamRegistry:         types.UpstreamRegistry("ecr"),
		CredentialArn:            ptr.String("__CredentialArn__"),
		CustomRoleArn:            ptr.String("__CustomRoleArn__"),
		UpstreamRepositoryPrefix: ptr.String("__UpstreamRepositoryPrefix__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.PullThroughCacheRuleAlreadyExistsException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.PullThroughCacheRuleAlreadyExistsException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "PullThroughCacheRuleAlreadyExistsException.error", err)
	}
}

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

func TestCheckResponseSnapshot_Error_ReferencedImagesNotFoundException(t *testing.T) {
	want := &types.ReferencedImagesNotFoundException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ReferencedImagesNotFoundException.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.PutImage(context.Background(), &PutImageInput{
		RegistryId:             ptr.String("__RegistryId__"),
		RepositoryName:         ptr.String("__RepositoryName__"),
		ImageManifest:          ptr.String("__ImageManifest__"),
		ImageManifestMediaType: ptr.String("__ImageManifestMediaType__"),
		ImageTag:               ptr.String("__ImageTag__"),
		ImageDigest:            ptr.String("__ImageDigest__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ReferencedImagesNotFoundException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ReferencedImagesNotFoundException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ReferencedImagesNotFoundException.error", err)
	}
}

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

func TestCheckResponseSnapshot_Error_RepositoryAlreadyExistsException(t *testing.T) {
	want := &types.RepositoryAlreadyExistsException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("RepositoryAlreadyExistsException.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{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		ImageTagMutability: types.ImageTagMutability("MUTABLE"),
		ImageTagMutabilityExclusionFilters: []types.ImageTagMutabilityExclusionFilter{
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
		},
		ImageScanningConfiguration: &types.ImageScanningConfiguration{
			ScanOnPush: true,
		},
		EncryptionConfiguration: &types.EncryptionConfiguration{
			EncryptionType: types.EncryptionType("AES256"),
			KmsKey:         ptr.String("__KmsKey__"),
		},
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.RepositoryAlreadyExistsException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.RepositoryAlreadyExistsException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "RepositoryAlreadyExistsException.error", err)
	}
}

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

func TestCheckResponseSnapshot_Error_RepositoryNotFoundException(t *testing.T) {
	want := &types.RepositoryNotFoundException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("RepositoryNotFoundException.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.BatchCheckLayerAvailability(context.Background(), &BatchCheckLayerAvailabilityInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		LayerDigests: []string{
			"__Member__",
			"__Member__",
		},
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.RepositoryNotFoundException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.RepositoryNotFoundException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "RepositoryNotFoundException.error", err)
	}
}

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

func TestCheckResponseSnapshot_Error_ScanNotFoundException(t *testing.T) {
	want := &types.ScanNotFoundException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ScanNotFoundException.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.DescribeImageScanFindings(context.Background(), &DescribeImageScanFindingsInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageId: &types.ImageIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
			ImageTag:    ptr.String("__ImageTag__"),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ScanNotFoundException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ScanNotFoundException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ScanNotFoundException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_SecretNotFoundException(t *testing.T) {
	want := &types.SecretNotFoundException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("SecretNotFoundException.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.CreatePullThroughCacheRule(context.Background(), &CreatePullThroughCacheRuleInput{
		EcrRepositoryPrefix:      ptr.String("__EcrRepositoryPrefix__"),
		UpstreamRegistryUrl:      ptr.String("__UpstreamRegistryUrl__"),
		RegistryId:               ptr.String("__RegistryId__"),
		UpstreamRegistry:         types.UpstreamRegistry("ecr"),
		CredentialArn:            ptr.String("__CredentialArn__"),
		CustomRoleArn:            ptr.String("__CustomRoleArn__"),
		UpstreamRepositoryPrefix: ptr.String("__UpstreamRepositoryPrefix__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.SecretNotFoundException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.SecretNotFoundException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "SecretNotFoundException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ServerException(t *testing.T) {
	want := &types.ServerException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ServerException.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.BatchCheckLayerAvailability(context.Background(), &BatchCheckLayerAvailabilityInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		LayerDigests: []string{
			"__Member__",
			"__Member__",
		},
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ServerException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ServerException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ServerException.error", err)
	}
}

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

func TestCheckResponseSnapshot_Error_TemplateAlreadyExistsException(t *testing.T) {
	want := &types.TemplateAlreadyExistsException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("TemplateAlreadyExistsException.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.CreateRepositoryCreationTemplate(context.Background(), &CreateRepositoryCreationTemplateInput{
		Prefix:      ptr.String("__Prefix__"),
		Description: ptr.String("__Description__"),
		EncryptionConfiguration: &types.EncryptionConfigurationForRepositoryCreationTemplate{
			EncryptionType: types.EncryptionType("AES256"),
			KmsKey:         ptr.String("__KmsKey__"),
		},
		ResourceTags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		ImageTagMutability: types.ImageTagMutability("MUTABLE"),
		ImageTagMutabilityExclusionFilters: []types.ImageTagMutabilityExclusionFilter{
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
		},
		RepositoryPolicy: ptr.String("__RepositoryPolicy__"),
		LifecyclePolicy:  ptr.String("__LifecyclePolicy__"),
		AppliedFor: []types.RCTAppliedFor{
			types.RCTAppliedFor("REPLICATION"),
			types.RCTAppliedFor("REPLICATION"),
		},
		CustomRoleArn: ptr.String("__CustomRoleArn__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.TemplateAlreadyExistsException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.TemplateAlreadyExistsException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "TemplateAlreadyExistsException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_TemplateNotFoundException(t *testing.T) {
	want := &types.TemplateNotFoundException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("TemplateNotFoundException.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.DeleteRepositoryCreationTemplate(context.Background(), &DeleteRepositoryCreationTemplateInput{
		Prefix: ptr.String("__Prefix__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.TemplateNotFoundException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.TemplateNotFoundException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "TemplateNotFoundException.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{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		ImageTagMutability: types.ImageTagMutability("MUTABLE"),
		ImageTagMutabilityExclusionFilters: []types.ImageTagMutabilityExclusionFilter{
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
		},
		ImageScanningConfiguration: &types.ImageScanningConfiguration{
			ScanOnPush: true,
		},
		EncryptionConfiguration: &types.EncryptionConfiguration{
			EncryptionType: types.EncryptionType("AES256"),
			KmsKey:         ptr.String("__KmsKey__"),
		},
	})
	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)
	}
}

func TestCheckResponseSnapshot_Error_UnableToAccessSecretException(t *testing.T) {
	want := &types.UnableToAccessSecretException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UnableToAccessSecretException.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.CreatePullThroughCacheRule(context.Background(), &CreatePullThroughCacheRuleInput{
		EcrRepositoryPrefix:      ptr.String("__EcrRepositoryPrefix__"),
		UpstreamRegistryUrl:      ptr.String("__UpstreamRegistryUrl__"),
		RegistryId:               ptr.String("__RegistryId__"),
		UpstreamRegistry:         types.UpstreamRegistry("ecr"),
		CredentialArn:            ptr.String("__CredentialArn__"),
		CustomRoleArn:            ptr.String("__CustomRoleArn__"),
		UpstreamRepositoryPrefix: ptr.String("__UpstreamRepositoryPrefix__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.UnableToAccessSecretException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.UnableToAccessSecretException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "UnableToAccessSecretException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_UnableToDecryptSecretValueException(t *testing.T) {
	want := &types.UnableToDecryptSecretValueException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UnableToDecryptSecretValueException.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.CreatePullThroughCacheRule(context.Background(), &CreatePullThroughCacheRuleInput{
		EcrRepositoryPrefix:      ptr.String("__EcrRepositoryPrefix__"),
		UpstreamRegistryUrl:      ptr.String("__UpstreamRegistryUrl__"),
		RegistryId:               ptr.String("__RegistryId__"),
		UpstreamRegistry:         types.UpstreamRegistry("ecr"),
		CredentialArn:            ptr.String("__CredentialArn__"),
		CustomRoleArn:            ptr.String("__CustomRoleArn__"),
		UpstreamRepositoryPrefix: ptr.String("__UpstreamRepositoryPrefix__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.UnableToDecryptSecretValueException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.UnableToDecryptSecretValueException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "UnableToDecryptSecretValueException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_UnableToGetUpstreamImageException(t *testing.T) {
	want := &types.UnableToGetUpstreamImageException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UnableToGetUpstreamImageException.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.BatchGetImage(context.Background(), &BatchGetImageInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageIds: []types.ImageIdentifier{
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
		},
		AcceptedMediaTypes: []string{
			"__Member__",
			"__Member__",
		},
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.UnableToGetUpstreamImageException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.UnableToGetUpstreamImageException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "UnableToGetUpstreamImageException.error", err)
	}
}

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

func TestCheckResponseSnapshot_Error_UnableToListUpstreamImageReferrersException(t *testing.T) {
	want := &types.UnableToListUpstreamImageReferrersException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UnableToListUpstreamImageReferrersException.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.ListImageReferrers(context.Background(), &ListImageReferrersInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		SubjectId: &types.SubjectIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
		},
		Filter: &types.ListImageReferrersFilter{
			ArtifactTypes: []string{
				"__Member__",
				"__Member__",
			},
			ArtifactStatus: types.ArtifactStatusFilter("ACTIVE"),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.UnableToListUpstreamImageReferrersException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.UnableToListUpstreamImageReferrersException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "UnableToListUpstreamImageReferrersException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_UnsupportedImageTypeException(t *testing.T) {
	want := &types.UnsupportedImageTypeException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UnsupportedImageTypeException.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.StartImageScan(context.Background(), &StartImageScanInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageId: &types.ImageIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
			ImageTag:    ptr.String("__ImageTag__"),
		},
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.UnsupportedImageTypeException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.UnsupportedImageTypeException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "UnsupportedImageTypeException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_UnsupportedUpstreamRegistryException(t *testing.T) {
	want := &types.UnsupportedUpstreamRegistryException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UnsupportedUpstreamRegistryException.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.CreatePullThroughCacheRule(context.Background(), &CreatePullThroughCacheRuleInput{
		EcrRepositoryPrefix:      ptr.String("__EcrRepositoryPrefix__"),
		UpstreamRegistryUrl:      ptr.String("__UpstreamRegistryUrl__"),
		RegistryId:               ptr.String("__RegistryId__"),
		UpstreamRegistry:         types.UpstreamRegistry("ecr"),
		CredentialArn:            ptr.String("__CredentialArn__"),
		CustomRoleArn:            ptr.String("__CustomRoleArn__"),
		UpstreamRepositoryPrefix: ptr.String("__UpstreamRepositoryPrefix__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.UnsupportedUpstreamRegistryException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.UnsupportedUpstreamRegistryException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "UnsupportedUpstreamRegistryException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_UploadNotFoundException(t *testing.T) {
	want := &types.UploadNotFoundException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UploadNotFoundException.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.CompleteLayerUpload(context.Background(), &CompleteLayerUploadInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		UploadId:       ptr.String("__UploadId__"),
		LayerDigests: []string{
			"__Member__",
			"__Member__",
		},
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.UploadNotFoundException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.UploadNotFoundException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "UploadNotFoundException.error", err)
	}
}

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