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

//go:build response_snapshot

package kms

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

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

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

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

func TestCheckResponseSnapshot_CreateGrant(t *testing.T) {
	want := &CreateGrantOutput{
		GrantToken: ptr.String("__GrantToken__"),
		GrantId:    ptr.String("__GrantId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateGrant.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.CreateGrant(context.Background(), &CreateGrantInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateGrant.response", err)
	}
}

func TestCheckResponseSnapshot_CreateKey(t *testing.T) {
	want := &CreateKeyOutput{
		KeyMetadata: &types.KeyMetadata{
			AWSAccountId:          ptr.String("__AWSAccountId__"),
			KeyId:                 ptr.String("__KeyId__"),
			Arn:                   ptr.String("__Arn__"),
			CreationDate:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			Enabled:               true,
			Description:           ptr.String("__Description__"),
			KeyUsage:              types.KeyUsageType("SIGN_VERIFY"),
			KeyState:              types.KeyState("Creating"),
			DeletionDate:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			ValidTo:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			Origin:                types.OriginType("AWS_KMS"),
			CustomKeyStoreId:      ptr.String("__CustomKeyStoreId__"),
			CloudHsmClusterId:     ptr.String("__CloudHsmClusterId__"),
			ExpirationModel:       types.ExpirationModelType("KEY_MATERIAL_EXPIRES"),
			KeyManager:            types.KeyManagerType("AWS"),
			CustomerMasterKeySpec: types.CustomerMasterKeySpec("RSA_2048"),
			KeySpec:               types.KeySpec("RSA_2048"),
			EncryptionAlgorithms: []types.EncryptionAlgorithmSpec{
				types.EncryptionAlgorithmSpec("SYMMETRIC_DEFAULT"),
				types.EncryptionAlgorithmSpec("SYMMETRIC_DEFAULT"),
			},
			SigningAlgorithms: []types.SigningAlgorithmSpec{
				types.SigningAlgorithmSpec("RSASSA_PSS_SHA_256"),
				types.SigningAlgorithmSpec("RSASSA_PSS_SHA_256"),
			},
			KeyAgreementAlgorithms: []types.KeyAgreementAlgorithmSpec{
				types.KeyAgreementAlgorithmSpec("ECDH"),
				types.KeyAgreementAlgorithmSpec("ECDH"),
			},
			MultiRegion: ptr.Bool(true),
			MultiRegionConfiguration: &types.MultiRegionConfiguration{
				MultiRegionKeyType: types.MultiRegionKeyType("PRIMARY"),
				PrimaryKey: &types.MultiRegionKey{
					Arn:    ptr.String("__Arn__"),
					Region: ptr.String("__Region__"),
				},
				ReplicaKeys: []types.MultiRegionKey{
					{
						Arn:    ptr.String("__Arn__"),
						Region: ptr.String("__Region__"),
					},
					{
						Arn:    ptr.String("__Arn__"),
						Region: ptr.String("__Region__"),
					},
				},
			},
			PendingDeletionWindowInDays: ptr.Int32(1),
			MacAlgorithms: []types.MacAlgorithmSpec{
				types.MacAlgorithmSpec("HMAC_SHA_224"),
				types.MacAlgorithmSpec("HMAC_SHA_224"),
			},
			XksKeyConfiguration: &types.XksKeyConfigurationType{
				Id: ptr.String("__Id__"),
			},
			CurrentKeyMaterialId: ptr.String("__CurrentKeyMaterialId__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateKey.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.CreateKey(context.Background(), &CreateKeyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateKey.response", err)
	}
}

func TestCheckResponseSnapshot_Decrypt(t *testing.T) {
	want := &DecryptOutput{
		KeyId:                  ptr.String("__KeyId__"),
		Plaintext:              []byte("blob"),
		EncryptionAlgorithm:    types.EncryptionAlgorithmSpec("SYMMETRIC_DEFAULT"),
		CiphertextForRecipient: []byte("blob"),
		KeyMaterialId:          ptr.String("__KeyMaterialId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("Decrypt.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.Decrypt(context.Background(), &DecryptInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "Decrypt.response", err)
	}
}

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

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

func TestCheckResponseSnapshot_DeleteImportedKeyMaterial(t *testing.T) {
	want := &DeleteImportedKeyMaterialOutput{
		KeyId:         ptr.String("__KeyId__"),
		KeyMaterialId: ptr.String("__KeyMaterialId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DeleteImportedKeyMaterial.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.DeleteImportedKeyMaterial(context.Background(), &DeleteImportedKeyMaterialInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteImportedKeyMaterial.response", err)
	}
}

func TestCheckResponseSnapshot_DeriveSharedSecret(t *testing.T) {
	want := &DeriveSharedSecretOutput{
		KeyId:                  ptr.String("__KeyId__"),
		SharedSecret:           []byte("blob"),
		CiphertextForRecipient: []byte("blob"),
		KeyAgreementAlgorithm:  types.KeyAgreementAlgorithmSpec("ECDH"),
		KeyOrigin:              types.OriginType("AWS_KMS"),
	}
	status, header, body, err := serdeRespReadSnapshot("DeriveSharedSecret.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.DeriveSharedSecret(context.Background(), &DeriveSharedSecretInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeriveSharedSecret.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeCustomKeyStores(t *testing.T) {
	want := &DescribeCustomKeyStoresOutput{
		CustomKeyStores: []types.CustomKeyStoresListEntry{
			{
				CustomKeyStoreId:       ptr.String("__CustomKeyStoreId__"),
				CustomKeyStoreName:     ptr.String("__CustomKeyStoreName__"),
				CloudHsmClusterId:      ptr.String("__CloudHsmClusterId__"),
				TrustAnchorCertificate: ptr.String("__TrustAnchorCertificate__"),
				ConnectionState:        types.ConnectionStateType("CONNECTED"),
				ConnectionErrorCode:    types.ConnectionErrorCodeType("INVALID_CREDENTIALS"),
				CreationDate:           ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CustomKeyStoreType:     types.CustomKeyStoreType("AWS_CLOUDHSM"),
				XksProxyConfiguration: &types.XksProxyConfigurationType{
					Connectivity:            types.XksProxyConnectivityType("PUBLIC_ENDPOINT"),
					AccessKeyId:             ptr.String("__AccessKeyId__"),
					UriEndpoint:             ptr.String("__UriEndpoint__"),
					UriPath:                 ptr.String("__UriPath__"),
					VpcEndpointServiceName:  ptr.String("__VpcEndpointServiceName__"),
					VpcEndpointServiceOwner: ptr.String("__VpcEndpointServiceOwner__"),
				},
			},
			{
				CustomKeyStoreId:       ptr.String("__CustomKeyStoreId__"),
				CustomKeyStoreName:     ptr.String("__CustomKeyStoreName__"),
				CloudHsmClusterId:      ptr.String("__CloudHsmClusterId__"),
				TrustAnchorCertificate: ptr.String("__TrustAnchorCertificate__"),
				ConnectionState:        types.ConnectionStateType("CONNECTED"),
				ConnectionErrorCode:    types.ConnectionErrorCodeType("INVALID_CREDENTIALS"),
				CreationDate:           ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CustomKeyStoreType:     types.CustomKeyStoreType("AWS_CLOUDHSM"),
				XksProxyConfiguration: &types.XksProxyConfigurationType{
					Connectivity:            types.XksProxyConnectivityType("PUBLIC_ENDPOINT"),
					AccessKeyId:             ptr.String("__AccessKeyId__"),
					UriEndpoint:             ptr.String("__UriEndpoint__"),
					UriPath:                 ptr.String("__UriPath__"),
					VpcEndpointServiceName:  ptr.String("__VpcEndpointServiceName__"),
					VpcEndpointServiceOwner: ptr.String("__VpcEndpointServiceOwner__"),
				},
			},
		},
		NextMarker: ptr.String("__NextMarker__"),
		Truncated:  true,
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeCustomKeyStores.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.DescribeCustomKeyStores(context.Background(), &DescribeCustomKeyStoresInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeCustomKeyStores.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeKey(t *testing.T) {
	want := &DescribeKeyOutput{
		KeyMetadata: &types.KeyMetadata{
			AWSAccountId:          ptr.String("__AWSAccountId__"),
			KeyId:                 ptr.String("__KeyId__"),
			Arn:                   ptr.String("__Arn__"),
			CreationDate:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			Enabled:               true,
			Description:           ptr.String("__Description__"),
			KeyUsage:              types.KeyUsageType("SIGN_VERIFY"),
			KeyState:              types.KeyState("Creating"),
			DeletionDate:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			ValidTo:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			Origin:                types.OriginType("AWS_KMS"),
			CustomKeyStoreId:      ptr.String("__CustomKeyStoreId__"),
			CloudHsmClusterId:     ptr.String("__CloudHsmClusterId__"),
			ExpirationModel:       types.ExpirationModelType("KEY_MATERIAL_EXPIRES"),
			KeyManager:            types.KeyManagerType("AWS"),
			CustomerMasterKeySpec: types.CustomerMasterKeySpec("RSA_2048"),
			KeySpec:               types.KeySpec("RSA_2048"),
			EncryptionAlgorithms: []types.EncryptionAlgorithmSpec{
				types.EncryptionAlgorithmSpec("SYMMETRIC_DEFAULT"),
				types.EncryptionAlgorithmSpec("SYMMETRIC_DEFAULT"),
			},
			SigningAlgorithms: []types.SigningAlgorithmSpec{
				types.SigningAlgorithmSpec("RSASSA_PSS_SHA_256"),
				types.SigningAlgorithmSpec("RSASSA_PSS_SHA_256"),
			},
			KeyAgreementAlgorithms: []types.KeyAgreementAlgorithmSpec{
				types.KeyAgreementAlgorithmSpec("ECDH"),
				types.KeyAgreementAlgorithmSpec("ECDH"),
			},
			MultiRegion: ptr.Bool(true),
			MultiRegionConfiguration: &types.MultiRegionConfiguration{
				MultiRegionKeyType: types.MultiRegionKeyType("PRIMARY"),
				PrimaryKey: &types.MultiRegionKey{
					Arn:    ptr.String("__Arn__"),
					Region: ptr.String("__Region__"),
				},
				ReplicaKeys: []types.MultiRegionKey{
					{
						Arn:    ptr.String("__Arn__"),
						Region: ptr.String("__Region__"),
					},
					{
						Arn:    ptr.String("__Arn__"),
						Region: ptr.String("__Region__"),
					},
				},
			},
			PendingDeletionWindowInDays: ptr.Int32(1),
			MacAlgorithms: []types.MacAlgorithmSpec{
				types.MacAlgorithmSpec("HMAC_SHA_224"),
				types.MacAlgorithmSpec("HMAC_SHA_224"),
			},
			XksKeyConfiguration: &types.XksKeyConfigurationType{
				Id: ptr.String("__Id__"),
			},
			CurrentKeyMaterialId: ptr.String("__CurrentKeyMaterialId__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeKey.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.DescribeKey(context.Background(), &DescribeKeyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeKey.response", err)
	}
}

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

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

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

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

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

func TestCheckResponseSnapshot_Encrypt(t *testing.T) {
	want := &EncryptOutput{
		CiphertextBlob:      []byte("blob"),
		KeyId:               ptr.String("__KeyId__"),
		EncryptionAlgorithm: types.EncryptionAlgorithmSpec("SYMMETRIC_DEFAULT"),
	}
	status, header, body, err := serdeRespReadSnapshot("Encrypt.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.Encrypt(context.Background(), &EncryptInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "Encrypt.response", err)
	}
}

func TestCheckResponseSnapshot_GenerateDataKey(t *testing.T) {
	want := &GenerateDataKeyOutput{
		CiphertextBlob:         []byte("blob"),
		Plaintext:              []byte("blob"),
		KeyId:                  ptr.String("__KeyId__"),
		CiphertextForRecipient: []byte("blob"),
		KeyMaterialId:          ptr.String("__KeyMaterialId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GenerateDataKey.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.GenerateDataKey(context.Background(), &GenerateDataKeyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GenerateDataKey.response", err)
	}
}

func TestCheckResponseSnapshot_GenerateDataKeyPair(t *testing.T) {
	want := &GenerateDataKeyPairOutput{
		PrivateKeyCiphertextBlob: []byte("blob"),
		PrivateKeyPlaintext:      []byte("blob"),
		PublicKey:                []byte("blob"),
		KeyId:                    ptr.String("__KeyId__"),
		KeyPairSpec:              types.DataKeyPairSpec("RSA_2048"),
		CiphertextForRecipient:   []byte("blob"),
		KeyMaterialId:            ptr.String("__KeyMaterialId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GenerateDataKeyPair.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.GenerateDataKeyPair(context.Background(), &GenerateDataKeyPairInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GenerateDataKeyPair.response", err)
	}
}

func TestCheckResponseSnapshot_GenerateDataKeyPairWithoutPlaintext(t *testing.T) {
	want := &GenerateDataKeyPairWithoutPlaintextOutput{
		PrivateKeyCiphertextBlob: []byte("blob"),
		PublicKey:                []byte("blob"),
		KeyId:                    ptr.String("__KeyId__"),
		KeyPairSpec:              types.DataKeyPairSpec("RSA_2048"),
		KeyMaterialId:            ptr.String("__KeyMaterialId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GenerateDataKeyPairWithoutPlaintext.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.GenerateDataKeyPairWithoutPlaintext(context.Background(), &GenerateDataKeyPairWithoutPlaintextInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GenerateDataKeyPairWithoutPlaintext.response", err)
	}
}

func TestCheckResponseSnapshot_GenerateDataKeyWithoutPlaintext(t *testing.T) {
	want := &GenerateDataKeyWithoutPlaintextOutput{
		CiphertextBlob: []byte("blob"),
		KeyId:          ptr.String("__KeyId__"),
		KeyMaterialId:  ptr.String("__KeyMaterialId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GenerateDataKeyWithoutPlaintext.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.GenerateDataKeyWithoutPlaintext(context.Background(), &GenerateDataKeyWithoutPlaintextInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GenerateDataKeyWithoutPlaintext.response", err)
	}
}

func TestCheckResponseSnapshot_GenerateMac(t *testing.T) {
	want := &GenerateMacOutput{
		Mac:          []byte("blob"),
		MacAlgorithm: types.MacAlgorithmSpec("HMAC_SHA_224"),
		KeyId:        ptr.String("__KeyId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GenerateMac.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.GenerateMac(context.Background(), &GenerateMacInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GenerateMac.response", err)
	}
}

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

func TestCheckResponseSnapshot_GetKeyLastUsage(t *testing.T) {
	want := &GetKeyLastUsageOutput{
		KeyId: ptr.String("__KeyId__"),
		KeyLastUsage: &types.KeyLastUsageData{
			Operation:         types.KeyLastUsageTrackingOperation("Decrypt"),
			Timestamp:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CloudTrailEventId: ptr.String("__CloudTrailEventId__"),
			KmsRequestId:      ptr.String("__KmsRequestId__"),
		},
		TrackingStartDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		KeyCreationDate:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("GetKeyLastUsage.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.GetKeyLastUsage(context.Background(), &GetKeyLastUsageInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetKeyLastUsage.response", err)
	}
}

func TestCheckResponseSnapshot_GetKeyPolicy(t *testing.T) {
	want := &GetKeyPolicyOutput{
		Policy:     ptr.String("__Policy__"),
		PolicyName: ptr.String("__PolicyName__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetKeyPolicy.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.GetKeyPolicy(context.Background(), &GetKeyPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetKeyPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_GetKeyRotationStatus(t *testing.T) {
	want := &GetKeyRotationStatusOutput{
		KeyRotationEnabled:        true,
		KeyId:                     ptr.String("__KeyId__"),
		RotationPeriodInDays:      ptr.Int32(1),
		NextRotationDate:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		OnDemandRotationStartDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("GetKeyRotationStatus.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.GetKeyRotationStatus(context.Background(), &GetKeyRotationStatusInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetKeyRotationStatus.response", err)
	}
}

func TestCheckResponseSnapshot_GetParametersForImport(t *testing.T) {
	want := &GetParametersForImportOutput{
		KeyId:             ptr.String("__KeyId__"),
		ImportToken:       []byte("blob"),
		PublicKey:         []byte("blob"),
		ParametersValidTo: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("GetParametersForImport.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.GetParametersForImport(context.Background(), &GetParametersForImportInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetParametersForImport.response", err)
	}
}

func TestCheckResponseSnapshot_GetPublicKey(t *testing.T) {
	want := &GetPublicKeyOutput{
		KeyId:                 ptr.String("__KeyId__"),
		PublicKey:             []byte("blob"),
		CustomerMasterKeySpec: types.CustomerMasterKeySpec("RSA_2048"),
		KeySpec:               types.KeySpec("RSA_2048"),
		KeyUsage:              types.KeyUsageType("SIGN_VERIFY"),
		EncryptionAlgorithms: []types.EncryptionAlgorithmSpec{
			types.EncryptionAlgorithmSpec("SYMMETRIC_DEFAULT"),
			types.EncryptionAlgorithmSpec("SYMMETRIC_DEFAULT"),
		},
		SigningAlgorithms: []types.SigningAlgorithmSpec{
			types.SigningAlgorithmSpec("RSASSA_PSS_SHA_256"),
			types.SigningAlgorithmSpec("RSASSA_PSS_SHA_256"),
		},
		KeyAgreementAlgorithms: []types.KeyAgreementAlgorithmSpec{
			types.KeyAgreementAlgorithmSpec("ECDH"),
			types.KeyAgreementAlgorithmSpec("ECDH"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetPublicKey.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.GetPublicKey(context.Background(), &GetPublicKeyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetPublicKey.response", err)
	}
}

func TestCheckResponseSnapshot_ImportKeyMaterial(t *testing.T) {
	want := &ImportKeyMaterialOutput{
		KeyId:         ptr.String("__KeyId__"),
		KeyMaterialId: ptr.String("__KeyMaterialId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ImportKeyMaterial.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.ImportKeyMaterial(context.Background(), &ImportKeyMaterialInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ImportKeyMaterial.response", err)
	}
}

func TestCheckResponseSnapshot_ListAliases(t *testing.T) {
	want := &ListAliasesOutput{
		Aliases: []types.AliasListEntry{
			{
				AliasName:       ptr.String("__AliasName__"),
				AliasArn:        ptr.String("__AliasArn__"),
				TargetKeyId:     ptr.String("__TargetKeyId__"),
				CreationDate:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastUpdatedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				AliasName:       ptr.String("__AliasName__"),
				AliasArn:        ptr.String("__AliasArn__"),
				TargetKeyId:     ptr.String("__TargetKeyId__"),
				CreationDate:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastUpdatedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		NextMarker: ptr.String("__NextMarker__"),
		Truncated:  true,
	}
	status, header, body, err := serdeRespReadSnapshot("ListAliases.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.ListAliases(context.Background(), &ListAliasesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListAliases.response", err)
	}
}

func TestCheckResponseSnapshot_ListGrants(t *testing.T) {
	want := &ListGrantsOutput{
		Grants: []types.GrantListEntry{
			{
				KeyId:             ptr.String("__KeyId__"),
				GrantId:           ptr.String("__GrantId__"),
				Name:              ptr.String("__Name__"),
				CreationDate:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				GranteePrincipal:  ptr.String("__GranteePrincipal__"),
				RetiringPrincipal: ptr.String("__RetiringPrincipal__"),
				IssuingAccount:    ptr.String("__IssuingAccount__"),
				Operations: []types.GrantOperation{
					types.GrantOperation("Decrypt"),
					types.GrantOperation("Decrypt"),
				},
				Constraints: &types.GrantConstraints{
					EncryptionContextSubset: map[string]string{
						"key0": "__Value__",
					},
					EncryptionContextEquals: map[string]string{
						"key0": "__Value__",
					},
					SourceArn: ptr.String("__SourceArn__"),
				},
				GranteeServicePrincipal:  ptr.String("__GranteeServicePrincipal__"),
				RetiringServicePrincipal: ptr.String("__RetiringServicePrincipal__"),
			},
			{
				KeyId:             ptr.String("__KeyId__"),
				GrantId:           ptr.String("__GrantId__"),
				Name:              ptr.String("__Name__"),
				CreationDate:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				GranteePrincipal:  ptr.String("__GranteePrincipal__"),
				RetiringPrincipal: ptr.String("__RetiringPrincipal__"),
				IssuingAccount:    ptr.String("__IssuingAccount__"),
				Operations: []types.GrantOperation{
					types.GrantOperation("Decrypt"),
					types.GrantOperation("Decrypt"),
				},
				Constraints: &types.GrantConstraints{
					EncryptionContextSubset: map[string]string{
						"key0": "__Value__",
					},
					EncryptionContextEquals: map[string]string{
						"key0": "__Value__",
					},
					SourceArn: ptr.String("__SourceArn__"),
				},
				GranteeServicePrincipal:  ptr.String("__GranteeServicePrincipal__"),
				RetiringServicePrincipal: ptr.String("__RetiringServicePrincipal__"),
			},
		},
		NextMarker: ptr.String("__NextMarker__"),
		Truncated:  true,
	}
	status, header, body, err := serdeRespReadSnapshot("ListGrants.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.ListGrants(context.Background(), &ListGrantsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListGrants.response", err)
	}
}

func TestCheckResponseSnapshot_ListKeyPolicies(t *testing.T) {
	want := &ListKeyPoliciesOutput{
		PolicyNames: []string{
			"__Member__",
			"__Member__",
		},
		NextMarker: ptr.String("__NextMarker__"),
		Truncated:  true,
	}
	status, header, body, err := serdeRespReadSnapshot("ListKeyPolicies.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.ListKeyPolicies(context.Background(), &ListKeyPoliciesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListKeyPolicies.response", err)
	}
}

func TestCheckResponseSnapshot_ListKeyRotations(t *testing.T) {
	want := &ListKeyRotationsOutput{
		Rotations: []types.RotationsListEntry{
			{
				KeyId:                  ptr.String("__KeyId__"),
				KeyMaterialId:          ptr.String("__KeyMaterialId__"),
				KeyMaterialDescription: ptr.String("__KeyMaterialDescription__"),
				ImportState:            types.ImportState("IMPORTED"),
				KeyMaterialState:       types.KeyMaterialState("NON_CURRENT"),
				ExpirationModel:        types.ExpirationModelType("KEY_MATERIAL_EXPIRES"),
				ValidTo:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				RotationDate:           ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				RotationType:           types.RotationType("AUTOMATIC"),
			},
			{
				KeyId:                  ptr.String("__KeyId__"),
				KeyMaterialId:          ptr.String("__KeyMaterialId__"),
				KeyMaterialDescription: ptr.String("__KeyMaterialDescription__"),
				ImportState:            types.ImportState("IMPORTED"),
				KeyMaterialState:       types.KeyMaterialState("NON_CURRENT"),
				ExpirationModel:        types.ExpirationModelType("KEY_MATERIAL_EXPIRES"),
				ValidTo:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				RotationDate:           ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				RotationType:           types.RotationType("AUTOMATIC"),
			},
		},
		NextMarker: ptr.String("__NextMarker__"),
		Truncated:  true,
	}
	status, header, body, err := serdeRespReadSnapshot("ListKeyRotations.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.ListKeyRotations(context.Background(), &ListKeyRotationsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListKeyRotations.response", err)
	}
}

func TestCheckResponseSnapshot_ListKeys(t *testing.T) {
	want := &ListKeysOutput{
		Keys: []types.KeyListEntry{
			{
				KeyId:  ptr.String("__KeyId__"),
				KeyArn: ptr.String("__KeyArn__"),
			},
			{
				KeyId:  ptr.String("__KeyId__"),
				KeyArn: ptr.String("__KeyArn__"),
			},
		},
		NextMarker: ptr.String("__NextMarker__"),
		Truncated:  true,
	}
	status, header, body, err := serdeRespReadSnapshot("ListKeys.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.ListKeys(context.Background(), &ListKeysInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListKeys.response", err)
	}
}

func TestCheckResponseSnapshot_ListResourceTags(t *testing.T) {
	want := &ListResourceTagsOutput{
		Tags: []types.Tag{
			{
				TagKey:   ptr.String("__TagKey__"),
				TagValue: ptr.String("__TagValue__"),
			},
			{
				TagKey:   ptr.String("__TagKey__"),
				TagValue: ptr.String("__TagValue__"),
			},
		},
		NextMarker: ptr.String("__NextMarker__"),
		Truncated:  true,
	}
	status, header, body, err := serdeRespReadSnapshot("ListResourceTags.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.ListResourceTags(context.Background(), &ListResourceTagsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListResourceTags.response", err)
	}
}

func TestCheckResponseSnapshot_ListRetirableGrants(t *testing.T) {
	want := &ListRetirableGrantsOutput{
		Grants: []types.GrantListEntry{
			{
				KeyId:             ptr.String("__KeyId__"),
				GrantId:           ptr.String("__GrantId__"),
				Name:              ptr.String("__Name__"),
				CreationDate:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				GranteePrincipal:  ptr.String("__GranteePrincipal__"),
				RetiringPrincipal: ptr.String("__RetiringPrincipal__"),
				IssuingAccount:    ptr.String("__IssuingAccount__"),
				Operations: []types.GrantOperation{
					types.GrantOperation("Decrypt"),
					types.GrantOperation("Decrypt"),
				},
				Constraints: &types.GrantConstraints{
					EncryptionContextSubset: map[string]string{
						"key0": "__Value__",
					},
					EncryptionContextEquals: map[string]string{
						"key0": "__Value__",
					},
					SourceArn: ptr.String("__SourceArn__"),
				},
				GranteeServicePrincipal:  ptr.String("__GranteeServicePrincipal__"),
				RetiringServicePrincipal: ptr.String("__RetiringServicePrincipal__"),
			},
			{
				KeyId:             ptr.String("__KeyId__"),
				GrantId:           ptr.String("__GrantId__"),
				Name:              ptr.String("__Name__"),
				CreationDate:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				GranteePrincipal:  ptr.String("__GranteePrincipal__"),
				RetiringPrincipal: ptr.String("__RetiringPrincipal__"),
				IssuingAccount:    ptr.String("__IssuingAccount__"),
				Operations: []types.GrantOperation{
					types.GrantOperation("Decrypt"),
					types.GrantOperation("Decrypt"),
				},
				Constraints: &types.GrantConstraints{
					EncryptionContextSubset: map[string]string{
						"key0": "__Value__",
					},
					EncryptionContextEquals: map[string]string{
						"key0": "__Value__",
					},
					SourceArn: ptr.String("__SourceArn__"),
				},
				GranteeServicePrincipal:  ptr.String("__GranteeServicePrincipal__"),
				RetiringServicePrincipal: ptr.String("__RetiringServicePrincipal__"),
			},
		},
		NextMarker: ptr.String("__NextMarker__"),
		Truncated:  true,
	}
	status, header, body, err := serdeRespReadSnapshot("ListRetirableGrants.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.ListRetirableGrants(context.Background(), &ListRetirableGrantsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListRetirableGrants.response", err)
	}
}

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

func TestCheckResponseSnapshot_ReEncrypt(t *testing.T) {
	want := &ReEncryptOutput{
		CiphertextBlob:                 []byte("blob"),
		SourceKeyId:                    ptr.String("__SourceKeyId__"),
		KeyId:                          ptr.String("__KeyId__"),
		SourceEncryptionAlgorithm:      types.EncryptionAlgorithmSpec("SYMMETRIC_DEFAULT"),
		DestinationEncryptionAlgorithm: types.EncryptionAlgorithmSpec("SYMMETRIC_DEFAULT"),
		SourceKeyMaterialId:            ptr.String("__SourceKeyMaterialId__"),
		DestinationKeyMaterialId:       ptr.String("__DestinationKeyMaterialId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ReEncrypt.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.ReEncrypt(context.Background(), &ReEncryptInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ReEncrypt.response", err)
	}
}

func TestCheckResponseSnapshot_ReplicateKey(t *testing.T) {
	want := &ReplicateKeyOutput{
		ReplicaKeyMetadata: &types.KeyMetadata{
			AWSAccountId:          ptr.String("__AWSAccountId__"),
			KeyId:                 ptr.String("__KeyId__"),
			Arn:                   ptr.String("__Arn__"),
			CreationDate:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			Enabled:               true,
			Description:           ptr.String("__Description__"),
			KeyUsage:              types.KeyUsageType("SIGN_VERIFY"),
			KeyState:              types.KeyState("Creating"),
			DeletionDate:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			ValidTo:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			Origin:                types.OriginType("AWS_KMS"),
			CustomKeyStoreId:      ptr.String("__CustomKeyStoreId__"),
			CloudHsmClusterId:     ptr.String("__CloudHsmClusterId__"),
			ExpirationModel:       types.ExpirationModelType("KEY_MATERIAL_EXPIRES"),
			KeyManager:            types.KeyManagerType("AWS"),
			CustomerMasterKeySpec: types.CustomerMasterKeySpec("RSA_2048"),
			KeySpec:               types.KeySpec("RSA_2048"),
			EncryptionAlgorithms: []types.EncryptionAlgorithmSpec{
				types.EncryptionAlgorithmSpec("SYMMETRIC_DEFAULT"),
				types.EncryptionAlgorithmSpec("SYMMETRIC_DEFAULT"),
			},
			SigningAlgorithms: []types.SigningAlgorithmSpec{
				types.SigningAlgorithmSpec("RSASSA_PSS_SHA_256"),
				types.SigningAlgorithmSpec("RSASSA_PSS_SHA_256"),
			},
			KeyAgreementAlgorithms: []types.KeyAgreementAlgorithmSpec{
				types.KeyAgreementAlgorithmSpec("ECDH"),
				types.KeyAgreementAlgorithmSpec("ECDH"),
			},
			MultiRegion: ptr.Bool(true),
			MultiRegionConfiguration: &types.MultiRegionConfiguration{
				MultiRegionKeyType: types.MultiRegionKeyType("PRIMARY"),
				PrimaryKey: &types.MultiRegionKey{
					Arn:    ptr.String("__Arn__"),
					Region: ptr.String("__Region__"),
				},
				ReplicaKeys: []types.MultiRegionKey{
					{
						Arn:    ptr.String("__Arn__"),
						Region: ptr.String("__Region__"),
					},
					{
						Arn:    ptr.String("__Arn__"),
						Region: ptr.String("__Region__"),
					},
				},
			},
			PendingDeletionWindowInDays: ptr.Int32(1),
			MacAlgorithms: []types.MacAlgorithmSpec{
				types.MacAlgorithmSpec("HMAC_SHA_224"),
				types.MacAlgorithmSpec("HMAC_SHA_224"),
			},
			XksKeyConfiguration: &types.XksKeyConfigurationType{
				Id: ptr.String("__Id__"),
			},
			CurrentKeyMaterialId: ptr.String("__CurrentKeyMaterialId__"),
		},
		ReplicaPolicy: ptr.String("__ReplicaPolicy__"),
		ReplicaTags: []types.Tag{
			{
				TagKey:   ptr.String("__TagKey__"),
				TagValue: ptr.String("__TagValue__"),
			},
			{
				TagKey:   ptr.String("__TagKey__"),
				TagValue: ptr.String("__TagValue__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ReplicateKey.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.ReplicateKey(context.Background(), &ReplicateKeyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ReplicateKey.response", err)
	}
}

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

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

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

func TestCheckResponseSnapshot_ScheduleKeyDeletion(t *testing.T) {
	want := &ScheduleKeyDeletionOutput{
		KeyId:               ptr.String("__KeyId__"),
		DeletionDate:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		KeyState:            types.KeyState("Creating"),
		PendingWindowInDays: ptr.Int32(1),
	}
	status, header, body, err := serdeRespReadSnapshot("ScheduleKeyDeletion.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.ScheduleKeyDeletion(context.Background(), &ScheduleKeyDeletionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ScheduleKeyDeletion.response", err)
	}
}

func TestCheckResponseSnapshot_Sign(t *testing.T) {
	want := &SignOutput{
		KeyId:            ptr.String("__KeyId__"),
		Signature:        []byte("blob"),
		SigningAlgorithm: types.SigningAlgorithmSpec("RSASSA_PSS_SHA_256"),
	}
	status, header, body, err := serdeRespReadSnapshot("Sign.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.Sign(context.Background(), &SignInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "Sign.response", err)
	}
}

func TestCheckResponseSnapshot_TagResource(t *testing.T) {
	want := &TagResourceOutput{}
	status, header, body, err := serdeRespReadSnapshot("TagResource.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.TagResource(context.Background(), &TagResourceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "TagResource.response", err)
	}
}

func TestCheckResponseSnapshot_UntagResource(t *testing.T) {
	want := &UntagResourceOutput{}
	status, header, body, err := serdeRespReadSnapshot("UntagResource.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UntagResource(context.Background(), &UntagResourceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UntagResource.response", err)
	}
}

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

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

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

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

func TestCheckResponseSnapshot_Verify(t *testing.T) {
	want := &VerifyOutput{
		KeyId:            ptr.String("__KeyId__"),
		SignatureValid:   true,
		SigningAlgorithm: types.SigningAlgorithmSpec("RSASSA_PSS_SHA_256"),
	}
	status, header, body, err := serdeRespReadSnapshot("Verify.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.Verify(context.Background(), &VerifyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "Verify.response", err)
	}
}

func TestCheckResponseSnapshot_VerifyMac(t *testing.T) {
	want := &VerifyMacOutput{
		KeyId:        ptr.String("__KeyId__"),
		MacValid:     true,
		MacAlgorithm: types.MacAlgorithmSpec("HMAC_SHA_224"),
	}
	status, header, body, err := serdeRespReadSnapshot("VerifyMac.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.VerifyMac(context.Background(), &VerifyMacInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "VerifyMac.response", err)
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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