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

//go:build response_snapshot

package cloudtrail

import (
	"bufio"
	"bytes"
	"context"
	"errors"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/cloudtrail/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_AddTags(t *testing.T) {
	want := &AddTagsOutput{}
	status, header, body, err := serdeRespReadSnapshot("AddTags.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.AddTags(context.Background(), &AddTagsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "AddTags.response", err)
	}
}

func TestCheckResponseSnapshot_CancelQuery(t *testing.T) {
	want := &CancelQueryOutput{
		QueryId:                      ptr.String("__QueryId__"),
		QueryStatus:                  types.QueryStatus("QUEUED"),
		EventDataStoreOwnerAccountId: ptr.String("__EventDataStoreOwnerAccountId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CancelQuery.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CancelQuery(context.Background(), &CancelQueryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CancelQuery.response", err)
	}
}

func TestCheckResponseSnapshot_CreateChannel(t *testing.T) {
	want := &CreateChannelOutput{
		ChannelArn: ptr.String("__ChannelArn__"),
		Name:       ptr.String("__Name__"),
		Source:     ptr.String("__Source__"),
		Destinations: []types.Destination{
			{
				Type:     types.DestinationType("EVENT_DATA_STORE"),
				Location: ptr.String("__Location__"),
			},
			{
				Type:     types.DestinationType("EVENT_DATA_STORE"),
				Location: ptr.String("__Location__"),
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateChannel.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateChannel(context.Background(), &CreateChannelInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateChannel.response", err)
	}
}

func TestCheckResponseSnapshot_CreateDashboard(t *testing.T) {
	want := &CreateDashboardOutput{
		DashboardArn: ptr.String("__DashboardArn__"),
		Name:         ptr.String("__Name__"),
		Type:         types.DashboardType("MANAGED"),
		Widgets: []types.Widget{
			{
				QueryAlias:     ptr.String("__QueryAlias__"),
				QueryStatement: ptr.String("__QueryStatement__"),
				QueryParameters: []string{
					"__Member__",
					"__Member__",
				},
				ViewProperties: map[string]string{
					"key0": "__Value__",
				},
			},
			{
				QueryAlias:     ptr.String("__QueryAlias__"),
				QueryStatement: ptr.String("__QueryStatement__"),
				QueryParameters: []string{
					"__Member__",
					"__Member__",
				},
				ViewProperties: map[string]string{
					"key0": "__Value__",
				},
			},
		},
		TagsList: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		RefreshSchedule: &types.RefreshSchedule{
			Frequency: &types.RefreshScheduleFrequency{
				Unit:  types.RefreshScheduleFrequencyUnit("HOURS"),
				Value: ptr.Int32(1),
			},
			Status:    types.RefreshScheduleStatus("ENABLED"),
			TimeOfDay: ptr.String("__TimeOfDay__"),
		},
		TerminationProtectionEnabled: ptr.Bool(true),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateDashboard.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateDashboard(context.Background(), &CreateDashboardInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateDashboard.response", err)
	}
}

func TestCheckResponseSnapshot_CreateEventDataStore(t *testing.T) {
	want := &CreateEventDataStoreOutput{
		EventDataStoreArn: ptr.String("__EventDataStoreArn__"),
		Name:              ptr.String("__Name__"),
		Status:            types.EventDataStoreStatus("CREATED"),
		AdvancedEventSelectors: []types.AdvancedEventSelector{
			{
				Name: ptr.String("__Name__"),
				FieldSelectors: []types.AdvancedFieldSelector{
					{
						Field: ptr.String("__Field__"),
						Equals: []string{
							"__Member__",
							"__Member__",
						},
						StartsWith: []string{
							"__Member__",
							"__Member__",
						},
						EndsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEquals: []string{
							"__Member__",
							"__Member__",
						},
						NotStartsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEndsWith: []string{
							"__Member__",
							"__Member__",
						},
					},
					{
						Field: ptr.String("__Field__"),
						Equals: []string{
							"__Member__",
							"__Member__",
						},
						StartsWith: []string{
							"__Member__",
							"__Member__",
						},
						EndsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEquals: []string{
							"__Member__",
							"__Member__",
						},
						NotStartsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEndsWith: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
			},
			{
				Name: ptr.String("__Name__"),
				FieldSelectors: []types.AdvancedFieldSelector{
					{
						Field: ptr.String("__Field__"),
						Equals: []string{
							"__Member__",
							"__Member__",
						},
						StartsWith: []string{
							"__Member__",
							"__Member__",
						},
						EndsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEquals: []string{
							"__Member__",
							"__Member__",
						},
						NotStartsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEndsWith: []string{
							"__Member__",
							"__Member__",
						},
					},
					{
						Field: ptr.String("__Field__"),
						Equals: []string{
							"__Member__",
							"__Member__",
						},
						StartsWith: []string{
							"__Member__",
							"__Member__",
						},
						EndsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEquals: []string{
							"__Member__",
							"__Member__",
						},
						NotStartsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEndsWith: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
			},
		},
		MultiRegionEnabled:           ptr.Bool(true),
		OrganizationEnabled:          ptr.Bool(true),
		RetentionPeriod:              ptr.Int32(1),
		TerminationProtectionEnabled: ptr.Bool(true),
		TagsList: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		CreatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		UpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		KmsKeyId:         ptr.String("__KmsKeyId__"),
		BillingMode:      types.BillingMode("EXTENDABLE_RETENTION_PRICING"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateEventDataStore.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateEventDataStore(context.Background(), &CreateEventDataStoreInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateEventDataStore.response", err)
	}
}

func TestCheckResponseSnapshot_CreateTrail(t *testing.T) {
	want := &CreateTrailOutput{
		Name:                       ptr.String("__Name__"),
		S3BucketName:               ptr.String("__S3BucketName__"),
		S3KeyPrefix:                ptr.String("__S3KeyPrefix__"),
		SnsTopicName:               ptr.String("__SnsTopicName__"),
		SnsTopicARN:                ptr.String("__SnsTopicARN__"),
		IncludeGlobalServiceEvents: ptr.Bool(true),
		IsMultiRegionTrail:         ptr.Bool(true),
		TrailARN:                   ptr.String("__TrailARN__"),
		LogFileValidationEnabled:   ptr.Bool(true),
		CloudWatchLogsLogGroupArn:  ptr.String("__CloudWatchLogsLogGroupArn__"),
		CloudWatchLogsRoleArn:      ptr.String("__CloudWatchLogsRoleArn__"),
		KmsKeyId:                   ptr.String("__KmsKeyId__"),
		IsOrganizationTrail:        ptr.Bool(true),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateTrail.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateTrail(context.Background(), &CreateTrailInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateTrail.response", err)
	}
}

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

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

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

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

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

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

func TestCheckResponseSnapshot_DescribeQuery(t *testing.T) {
	want := &DescribeQueryOutput{
		QueryId:     ptr.String("__QueryId__"),
		QueryString: ptr.String("__QueryString__"),
		QueryStatus: types.QueryStatus("QUEUED"),
		QueryStatistics: &types.QueryStatisticsForDescribeQuery{
			EventsMatched:         ptr.Int64(1),
			EventsScanned:         ptr.Int64(1),
			BytesScanned:          ptr.Int64(1),
			ExecutionTimeInMillis: ptr.Int32(1),
			CreationTime:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		ErrorMessage:                 ptr.String("__ErrorMessage__"),
		DeliveryS3Uri:                ptr.String("__DeliveryS3Uri__"),
		DeliveryStatus:               types.DeliveryStatus("SUCCESS"),
		Prompt:                       ptr.String("__Prompt__"),
		EventDataStoreOwnerAccountId: ptr.String("__EventDataStoreOwnerAccountId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeQuery.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeQuery(context.Background(), &DescribeQueryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeQuery.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeTrails(t *testing.T) {
	want := &DescribeTrailsOutput{
		TrailList: []types.Trail{
			{
				Name:                       ptr.String("__Name__"),
				S3BucketName:               ptr.String("__S3BucketName__"),
				S3KeyPrefix:                ptr.String("__S3KeyPrefix__"),
				SnsTopicName:               ptr.String("__SnsTopicName__"),
				SnsTopicARN:                ptr.String("__SnsTopicARN__"),
				IncludeGlobalServiceEvents: ptr.Bool(true),
				IsMultiRegionTrail:         ptr.Bool(true),
				HomeRegion:                 ptr.String("__HomeRegion__"),
				TrailARN:                   ptr.String("__TrailARN__"),
				LogFileValidationEnabled:   ptr.Bool(true),
				CloudWatchLogsLogGroupArn:  ptr.String("__CloudWatchLogsLogGroupArn__"),
				CloudWatchLogsRoleArn:      ptr.String("__CloudWatchLogsRoleArn__"),
				KmsKeyId:                   ptr.String("__KmsKeyId__"),
				HasCustomEventSelectors:    ptr.Bool(true),
				HasInsightSelectors:        ptr.Bool(true),
				IsOrganizationTrail:        ptr.Bool(true),
			},
			{
				Name:                       ptr.String("__Name__"),
				S3BucketName:               ptr.String("__S3BucketName__"),
				S3KeyPrefix:                ptr.String("__S3KeyPrefix__"),
				SnsTopicName:               ptr.String("__SnsTopicName__"),
				SnsTopicARN:                ptr.String("__SnsTopicARN__"),
				IncludeGlobalServiceEvents: ptr.Bool(true),
				IsMultiRegionTrail:         ptr.Bool(true),
				HomeRegion:                 ptr.String("__HomeRegion__"),
				TrailARN:                   ptr.String("__TrailARN__"),
				LogFileValidationEnabled:   ptr.Bool(true),
				CloudWatchLogsLogGroupArn:  ptr.String("__CloudWatchLogsLogGroupArn__"),
				CloudWatchLogsRoleArn:      ptr.String("__CloudWatchLogsRoleArn__"),
				KmsKeyId:                   ptr.String("__KmsKeyId__"),
				HasCustomEventSelectors:    ptr.Bool(true),
				HasInsightSelectors:        ptr.Bool(true),
				IsOrganizationTrail:        ptr.Bool(true),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeTrails.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeTrails(context.Background(), &DescribeTrailsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeTrails.response", err)
	}
}

func TestCheckResponseSnapshot_DisableFederation(t *testing.T) {
	want := &DisableFederationOutput{
		EventDataStoreArn: ptr.String("__EventDataStoreArn__"),
		FederationStatus:  types.FederationStatus("ENABLING"),
	}
	status, header, body, err := serdeRespReadSnapshot("DisableFederation.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DisableFederation(context.Background(), &DisableFederationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DisableFederation.response", err)
	}
}

func TestCheckResponseSnapshot_EnableFederation(t *testing.T) {
	want := &EnableFederationOutput{
		EventDataStoreArn: ptr.String("__EventDataStoreArn__"),
		FederationStatus:  types.FederationStatus("ENABLING"),
		FederationRoleArn: ptr.String("__FederationRoleArn__"),
	}
	status, header, body, err := serdeRespReadSnapshot("EnableFederation.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.EnableFederation(context.Background(), &EnableFederationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "EnableFederation.response", err)
	}
}

func TestCheckResponseSnapshot_GenerateQuery(t *testing.T) {
	want := &GenerateQueryOutput{
		QueryStatement:               ptr.String("__QueryStatement__"),
		QueryAlias:                   ptr.String("__QueryAlias__"),
		EventDataStoreOwnerAccountId: ptr.String("__EventDataStoreOwnerAccountId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GenerateQuery.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GenerateQuery(context.Background(), &GenerateQueryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GenerateQuery.response", err)
	}
}

func TestCheckResponseSnapshot_GetChannel(t *testing.T) {
	want := &GetChannelOutput{
		ChannelArn: ptr.String("__ChannelArn__"),
		Name:       ptr.String("__Name__"),
		Source:     ptr.String("__Source__"),
		SourceConfig: &types.SourceConfig{
			ApplyToAllRegions: ptr.Bool(true),
			AdvancedEventSelectors: []types.AdvancedEventSelector{
				{
					Name: ptr.String("__Name__"),
					FieldSelectors: []types.AdvancedFieldSelector{
						{
							Field: ptr.String("__Field__"),
							Equals: []string{
								"__Member__",
								"__Member__",
							},
							StartsWith: []string{
								"__Member__",
								"__Member__",
							},
							EndsWith: []string{
								"__Member__",
								"__Member__",
							},
							NotEquals: []string{
								"__Member__",
								"__Member__",
							},
							NotStartsWith: []string{
								"__Member__",
								"__Member__",
							},
							NotEndsWith: []string{
								"__Member__",
								"__Member__",
							},
						},
						{
							Field: ptr.String("__Field__"),
							Equals: []string{
								"__Member__",
								"__Member__",
							},
							StartsWith: []string{
								"__Member__",
								"__Member__",
							},
							EndsWith: []string{
								"__Member__",
								"__Member__",
							},
							NotEquals: []string{
								"__Member__",
								"__Member__",
							},
							NotStartsWith: []string{
								"__Member__",
								"__Member__",
							},
							NotEndsWith: []string{
								"__Member__",
								"__Member__",
							},
						},
					},
				},
				{
					Name: ptr.String("__Name__"),
					FieldSelectors: []types.AdvancedFieldSelector{
						{
							Field: ptr.String("__Field__"),
							Equals: []string{
								"__Member__",
								"__Member__",
							},
							StartsWith: []string{
								"__Member__",
								"__Member__",
							},
							EndsWith: []string{
								"__Member__",
								"__Member__",
							},
							NotEquals: []string{
								"__Member__",
								"__Member__",
							},
							NotStartsWith: []string{
								"__Member__",
								"__Member__",
							},
							NotEndsWith: []string{
								"__Member__",
								"__Member__",
							},
						},
						{
							Field: ptr.String("__Field__"),
							Equals: []string{
								"__Member__",
								"__Member__",
							},
							StartsWith: []string{
								"__Member__",
								"__Member__",
							},
							EndsWith: []string{
								"__Member__",
								"__Member__",
							},
							NotEquals: []string{
								"__Member__",
								"__Member__",
							},
							NotStartsWith: []string{
								"__Member__",
								"__Member__",
							},
							NotEndsWith: []string{
								"__Member__",
								"__Member__",
							},
						},
					},
				},
			},
		},
		Destinations: []types.Destination{
			{
				Type:     types.DestinationType("EVENT_DATA_STORE"),
				Location: ptr.String("__Location__"),
			},
			{
				Type:     types.DestinationType("EVENT_DATA_STORE"),
				Location: ptr.String("__Location__"),
			},
		},
		IngestionStatus: &types.IngestionStatus{
			LatestIngestionSuccessTime:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LatestIngestionSuccessEventID: ptr.String("__LatestIngestionSuccessEventID__"),
			LatestIngestionErrorCode:      ptr.String("__LatestIngestionErrorCode__"),
			LatestIngestionAttemptTime:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LatestIngestionAttemptEventID: ptr.String("__LatestIngestionAttemptEventID__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetChannel.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetChannel(context.Background(), &GetChannelInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetChannel.response", err)
	}
}

func TestCheckResponseSnapshot_GetDashboard(t *testing.T) {
	want := &GetDashboardOutput{
		DashboardArn: ptr.String("__DashboardArn__"),
		Type:         types.DashboardType("MANAGED"),
		Status:       types.DashboardStatus("CREATING"),
		Widgets: []types.Widget{
			{
				QueryAlias:     ptr.String("__QueryAlias__"),
				QueryStatement: ptr.String("__QueryStatement__"),
				QueryParameters: []string{
					"__Member__",
					"__Member__",
				},
				ViewProperties: map[string]string{
					"key0": "__Value__",
				},
			},
			{
				QueryAlias:     ptr.String("__QueryAlias__"),
				QueryStatement: ptr.String("__QueryStatement__"),
				QueryParameters: []string{
					"__Member__",
					"__Member__",
				},
				ViewProperties: map[string]string{
					"key0": "__Value__",
				},
			},
		},
		RefreshSchedule: &types.RefreshSchedule{
			Frequency: &types.RefreshScheduleFrequency{
				Unit:  types.RefreshScheduleFrequencyUnit("HOURS"),
				Value: ptr.Int32(1),
			},
			Status:    types.RefreshScheduleStatus("ENABLED"),
			TimeOfDay: ptr.String("__TimeOfDay__"),
		},
		CreatedTimestamp:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		UpdatedTimestamp:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		LastRefreshId:                ptr.String("__LastRefreshId__"),
		LastRefreshFailureReason:     ptr.String("__LastRefreshFailureReason__"),
		TerminationProtectionEnabled: ptr.Bool(true),
	}
	status, header, body, err := serdeRespReadSnapshot("GetDashboard.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetDashboard(context.Background(), &GetDashboardInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetDashboard.response", err)
	}
}

func TestCheckResponseSnapshot_GetEventConfiguration(t *testing.T) {
	want := &GetEventConfigurationOutput{
		TrailARN:          ptr.String("__TrailARN__"),
		EventDataStoreArn: ptr.String("__EventDataStoreArn__"),
		MaxEventSize:      types.MaxEventSize("Standard"),
		ContextKeySelectors: []types.ContextKeySelector{
			{
				Type: types.Type("TagContext"),
				Equals: []string{
					"__Member__",
					"__Member__",
				},
			},
			{
				Type: types.Type("TagContext"),
				Equals: []string{
					"__Member__",
					"__Member__",
				},
			},
		},
		AggregationConfigurations: []types.AggregationConfiguration{
			{
				Templates: []types.Template{
					types.Template("API_ACTIVITY"),
					types.Template("API_ACTIVITY"),
				},
				EventCategory: types.EventCategoryAggregation("Data"),
			},
			{
				Templates: []types.Template{
					types.Template("API_ACTIVITY"),
					types.Template("API_ACTIVITY"),
				},
				EventCategory: types.EventCategoryAggregation("Data"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetEventConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetEventConfiguration(context.Background(), &GetEventConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetEventConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_GetEventDataStore(t *testing.T) {
	want := &GetEventDataStoreOutput{
		EventDataStoreArn: ptr.String("__EventDataStoreArn__"),
		Name:              ptr.String("__Name__"),
		Status:            types.EventDataStoreStatus("CREATED"),
		AdvancedEventSelectors: []types.AdvancedEventSelector{
			{
				Name: ptr.String("__Name__"),
				FieldSelectors: []types.AdvancedFieldSelector{
					{
						Field: ptr.String("__Field__"),
						Equals: []string{
							"__Member__",
							"__Member__",
						},
						StartsWith: []string{
							"__Member__",
							"__Member__",
						},
						EndsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEquals: []string{
							"__Member__",
							"__Member__",
						},
						NotStartsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEndsWith: []string{
							"__Member__",
							"__Member__",
						},
					},
					{
						Field: ptr.String("__Field__"),
						Equals: []string{
							"__Member__",
							"__Member__",
						},
						StartsWith: []string{
							"__Member__",
							"__Member__",
						},
						EndsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEquals: []string{
							"__Member__",
							"__Member__",
						},
						NotStartsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEndsWith: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
			},
			{
				Name: ptr.String("__Name__"),
				FieldSelectors: []types.AdvancedFieldSelector{
					{
						Field: ptr.String("__Field__"),
						Equals: []string{
							"__Member__",
							"__Member__",
						},
						StartsWith: []string{
							"__Member__",
							"__Member__",
						},
						EndsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEquals: []string{
							"__Member__",
							"__Member__",
						},
						NotStartsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEndsWith: []string{
							"__Member__",
							"__Member__",
						},
					},
					{
						Field: ptr.String("__Field__"),
						Equals: []string{
							"__Member__",
							"__Member__",
						},
						StartsWith: []string{
							"__Member__",
							"__Member__",
						},
						EndsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEquals: []string{
							"__Member__",
							"__Member__",
						},
						NotStartsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEndsWith: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
			},
		},
		MultiRegionEnabled:           ptr.Bool(true),
		OrganizationEnabled:          ptr.Bool(true),
		RetentionPeriod:              ptr.Int32(1),
		TerminationProtectionEnabled: ptr.Bool(true),
		CreatedTimestamp:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		UpdatedTimestamp:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		KmsKeyId:                     ptr.String("__KmsKeyId__"),
		BillingMode:                  types.BillingMode("EXTENDABLE_RETENTION_PRICING"),
		FederationStatus:             types.FederationStatus("ENABLING"),
		FederationRoleArn:            ptr.String("__FederationRoleArn__"),
		PartitionKeys: []types.PartitionKey{
			{
				Name: ptr.String("__Name__"),
				Type: ptr.String("__Type__"),
			},
			{
				Name: ptr.String("__Name__"),
				Type: ptr.String("__Type__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetEventDataStore.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetEventDataStore(context.Background(), &GetEventDataStoreInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetEventDataStore.response", err)
	}
}

func TestCheckResponseSnapshot_GetEventSelectors(t *testing.T) {
	want := &GetEventSelectorsOutput{
		TrailARN: ptr.String("__TrailARN__"),
		EventSelectors: []types.EventSelector{
			{
				ReadWriteType:           types.ReadWriteType("ReadOnly"),
				IncludeManagementEvents: ptr.Bool(true),
				DataResources: []types.DataResource{
					{
						Type: ptr.String("__Type__"),
						Values: []string{
							"__Member__",
							"__Member__",
						},
					},
					{
						Type: ptr.String("__Type__"),
						Values: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
				ExcludeManagementEventSources: []string{
					"__Member__",
					"__Member__",
				},
			},
			{
				ReadWriteType:           types.ReadWriteType("ReadOnly"),
				IncludeManagementEvents: ptr.Bool(true),
				DataResources: []types.DataResource{
					{
						Type: ptr.String("__Type__"),
						Values: []string{
							"__Member__",
							"__Member__",
						},
					},
					{
						Type: ptr.String("__Type__"),
						Values: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
				ExcludeManagementEventSources: []string{
					"__Member__",
					"__Member__",
				},
			},
		},
		AdvancedEventSelectors: []types.AdvancedEventSelector{
			{
				Name: ptr.String("__Name__"),
				FieldSelectors: []types.AdvancedFieldSelector{
					{
						Field: ptr.String("__Field__"),
						Equals: []string{
							"__Member__",
							"__Member__",
						},
						StartsWith: []string{
							"__Member__",
							"__Member__",
						},
						EndsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEquals: []string{
							"__Member__",
							"__Member__",
						},
						NotStartsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEndsWith: []string{
							"__Member__",
							"__Member__",
						},
					},
					{
						Field: ptr.String("__Field__"),
						Equals: []string{
							"__Member__",
							"__Member__",
						},
						StartsWith: []string{
							"__Member__",
							"__Member__",
						},
						EndsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEquals: []string{
							"__Member__",
							"__Member__",
						},
						NotStartsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEndsWith: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
			},
			{
				Name: ptr.String("__Name__"),
				FieldSelectors: []types.AdvancedFieldSelector{
					{
						Field: ptr.String("__Field__"),
						Equals: []string{
							"__Member__",
							"__Member__",
						},
						StartsWith: []string{
							"__Member__",
							"__Member__",
						},
						EndsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEquals: []string{
							"__Member__",
							"__Member__",
						},
						NotStartsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEndsWith: []string{
							"__Member__",
							"__Member__",
						},
					},
					{
						Field: ptr.String("__Field__"),
						Equals: []string{
							"__Member__",
							"__Member__",
						},
						StartsWith: []string{
							"__Member__",
							"__Member__",
						},
						EndsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEquals: []string{
							"__Member__",
							"__Member__",
						},
						NotStartsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEndsWith: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetEventSelectors.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetEventSelectors(context.Background(), &GetEventSelectorsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetEventSelectors.response", err)
	}
}

func TestCheckResponseSnapshot_GetImport(t *testing.T) {
	want := &GetImportOutput{
		ImportId: ptr.String("__ImportId__"),
		Destinations: []string{
			"__Member__",
			"__Member__",
		},
		ImportSource: &types.ImportSource{
			S3: &types.S3ImportSource{
				S3LocationUri:         ptr.String("__S3LocationUri__"),
				S3BucketRegion:        ptr.String("__S3BucketRegion__"),
				S3BucketAccessRoleArn: ptr.String("__S3BucketAccessRoleArn__"),
			},
		},
		StartEventTime:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		EndEventTime:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ImportStatus:     types.ImportStatus("INITIALIZING"),
		CreatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		UpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ImportStatistics: &types.ImportStatistics{
			PrefixesFound:     ptr.Int64(1),
			PrefixesCompleted: ptr.Int64(1),
			FilesCompleted:    ptr.Int64(1),
			EventsCompleted:   ptr.Int64(1),
			FailedEntries:     ptr.Int64(1),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetImport.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetImport(context.Background(), &GetImportInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetImport.response", err)
	}
}

func TestCheckResponseSnapshot_GetInsightSelectors(t *testing.T) {
	want := &GetInsightSelectorsOutput{
		TrailARN: ptr.String("__TrailARN__"),
		InsightSelectors: []types.InsightSelector{
			{
				InsightType: types.InsightType("ApiCallRateInsight"),
				EventCategories: []types.SourceEventCategory{
					types.SourceEventCategory("Management"),
					types.SourceEventCategory("Management"),
				},
			},
			{
				InsightType: types.InsightType("ApiCallRateInsight"),
				EventCategories: []types.SourceEventCategory{
					types.SourceEventCategory("Management"),
					types.SourceEventCategory("Management"),
				},
			},
		},
		EventDataStoreArn:   ptr.String("__EventDataStoreArn__"),
		InsightsDestination: ptr.String("__InsightsDestination__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetInsightSelectors.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetInsightSelectors(context.Background(), &GetInsightSelectorsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetInsightSelectors.response", err)
	}
}

func TestCheckResponseSnapshot_GetQueryResults(t *testing.T) {
	want := &GetQueryResultsOutput{
		QueryStatus: types.QueryStatus("QUEUED"),
		QueryStatistics: &types.QueryStatistics{
			ResultsCount:      ptr.Int32(1),
			TotalResultsCount: ptr.Int32(1),
			BytesScanned:      ptr.Int64(1),
		},
		QueryResultRows: [][]map[string]string{
			{
				{
					"key0": "__Value__",
				},
				{
					"key0": "__Value__",
				},
			},
			{
				{
					"key0": "__Value__",
				},
				{
					"key0": "__Value__",
				},
			},
		},
		NextToken:    ptr.String("__NextToken__"),
		ErrorMessage: ptr.String("__ErrorMessage__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetQueryResults.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetQueryResults(context.Background(), &GetQueryResultsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetQueryResults.response", err)
	}
}

func TestCheckResponseSnapshot_GetResourcePolicy(t *testing.T) {
	want := &GetResourcePolicyOutput{
		ResourceArn:                  ptr.String("__ResourceArn__"),
		ResourcePolicy:               ptr.String("__ResourcePolicy__"),
		DelegatedAdminResourcePolicy: ptr.String("__DelegatedAdminResourcePolicy__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetResourcePolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetResourcePolicy(context.Background(), &GetResourcePolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetResourcePolicy.response", err)
	}
}

func TestCheckResponseSnapshot_GetTrail(t *testing.T) {
	want := &GetTrailOutput{
		Trail: &types.Trail{
			Name:                       ptr.String("__Name__"),
			S3BucketName:               ptr.String("__S3BucketName__"),
			S3KeyPrefix:                ptr.String("__S3KeyPrefix__"),
			SnsTopicName:               ptr.String("__SnsTopicName__"),
			SnsTopicARN:                ptr.String("__SnsTopicARN__"),
			IncludeGlobalServiceEvents: ptr.Bool(true),
			IsMultiRegionTrail:         ptr.Bool(true),
			HomeRegion:                 ptr.String("__HomeRegion__"),
			TrailARN:                   ptr.String("__TrailARN__"),
			LogFileValidationEnabled:   ptr.Bool(true),
			CloudWatchLogsLogGroupArn:  ptr.String("__CloudWatchLogsLogGroupArn__"),
			CloudWatchLogsRoleArn:      ptr.String("__CloudWatchLogsRoleArn__"),
			KmsKeyId:                   ptr.String("__KmsKeyId__"),
			HasCustomEventSelectors:    ptr.Bool(true),
			HasInsightSelectors:        ptr.Bool(true),
			IsOrganizationTrail:        ptr.Bool(true),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetTrail.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetTrail(context.Background(), &GetTrailInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetTrail.response", err)
	}
}

func TestCheckResponseSnapshot_GetTrailStatus(t *testing.T) {
	want := &GetTrailStatusOutput{
		IsLogging:                          ptr.Bool(true),
		LatestDeliveryError:                ptr.String("__LatestDeliveryError__"),
		LatestNotificationError:            ptr.String("__LatestNotificationError__"),
		LatestDeliveryTime:                 ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		LatestNotificationTime:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		StartLoggingTime:                   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		StopLoggingTime:                    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		LatestCloudWatchLogsDeliveryError:  ptr.String("__LatestCloudWatchLogsDeliveryError__"),
		LatestCloudWatchLogsDeliveryTime:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		LatestDigestDeliveryTime:           ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		LatestDigestDeliveryError:          ptr.String("__LatestDigestDeliveryError__"),
		LatestDeliveryAttemptTime:          ptr.String("__LatestDeliveryAttemptTime__"),
		LatestNotificationAttemptTime:      ptr.String("__LatestNotificationAttemptTime__"),
		LatestNotificationAttemptSucceeded: ptr.String("__LatestNotificationAttemptSucceeded__"),
		LatestDeliveryAttemptSucceeded:     ptr.String("__LatestDeliveryAttemptSucceeded__"),
		TimeLoggingStarted:                 ptr.String("__TimeLoggingStarted__"),
		TimeLoggingStopped:                 ptr.String("__TimeLoggingStopped__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetTrailStatus.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetTrailStatus(context.Background(), &GetTrailStatusInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetTrailStatus.response", err)
	}
}

func TestCheckResponseSnapshot_ListChannels(t *testing.T) {
	want := &ListChannelsOutput{
		Channels: []types.Channel{
			{
				ChannelArn: ptr.String("__ChannelArn__"),
				Name:       ptr.String("__Name__"),
			},
			{
				ChannelArn: ptr.String("__ChannelArn__"),
				Name:       ptr.String("__Name__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListChannels.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListChannels(context.Background(), &ListChannelsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListChannels.response", err)
	}
}

func TestCheckResponseSnapshot_ListDashboards(t *testing.T) {
	want := &ListDashboardsOutput{
		Dashboards: []types.DashboardDetail{
			{
				DashboardArn: ptr.String("__DashboardArn__"),
				Type:         types.DashboardType("MANAGED"),
			},
			{
				DashboardArn: ptr.String("__DashboardArn__"),
				Type:         types.DashboardType("MANAGED"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListDashboards.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListDashboards(context.Background(), &ListDashboardsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListDashboards.response", err)
	}
}

func TestCheckResponseSnapshot_ListEventDataStores(t *testing.T) {
	want := &ListEventDataStoresOutput{
		EventDataStores: []types.EventDataStore{
			{
				EventDataStoreArn:            ptr.String("__EventDataStoreArn__"),
				Name:                         ptr.String("__Name__"),
				TerminationProtectionEnabled: ptr.Bool(true),
				Status:                       types.EventDataStoreStatus("CREATED"),
				AdvancedEventSelectors: []types.AdvancedEventSelector{
					{
						Name: ptr.String("__Name__"),
						FieldSelectors: []types.AdvancedFieldSelector{
							{
								Field: ptr.String("__Field__"),
								Equals: []string{
									"__Member__",
									"__Member__",
								},
								StartsWith: []string{
									"__Member__",
									"__Member__",
								},
								EndsWith: []string{
									"__Member__",
									"__Member__",
								},
								NotEquals: []string{
									"__Member__",
									"__Member__",
								},
								NotStartsWith: []string{
									"__Member__",
									"__Member__",
								},
								NotEndsWith: []string{
									"__Member__",
									"__Member__",
								},
							},
							{
								Field: ptr.String("__Field__"),
								Equals: []string{
									"__Member__",
									"__Member__",
								},
								StartsWith: []string{
									"__Member__",
									"__Member__",
								},
								EndsWith: []string{
									"__Member__",
									"__Member__",
								},
								NotEquals: []string{
									"__Member__",
									"__Member__",
								},
								NotStartsWith: []string{
									"__Member__",
									"__Member__",
								},
								NotEndsWith: []string{
									"__Member__",
									"__Member__",
								},
							},
						},
					},
					{
						Name: ptr.String("__Name__"),
						FieldSelectors: []types.AdvancedFieldSelector{
							{
								Field: ptr.String("__Field__"),
								Equals: []string{
									"__Member__",
									"__Member__",
								},
								StartsWith: []string{
									"__Member__",
									"__Member__",
								},
								EndsWith: []string{
									"__Member__",
									"__Member__",
								},
								NotEquals: []string{
									"__Member__",
									"__Member__",
								},
								NotStartsWith: []string{
									"__Member__",
									"__Member__",
								},
								NotEndsWith: []string{
									"__Member__",
									"__Member__",
								},
							},
							{
								Field: ptr.String("__Field__"),
								Equals: []string{
									"__Member__",
									"__Member__",
								},
								StartsWith: []string{
									"__Member__",
									"__Member__",
								},
								EndsWith: []string{
									"__Member__",
									"__Member__",
								},
								NotEquals: []string{
									"__Member__",
									"__Member__",
								},
								NotStartsWith: []string{
									"__Member__",
									"__Member__",
								},
								NotEndsWith: []string{
									"__Member__",
									"__Member__",
								},
							},
						},
					},
				},
				MultiRegionEnabled:  ptr.Bool(true),
				OrganizationEnabled: ptr.Bool(true),
				RetentionPeriod:     ptr.Int32(1),
				CreatedTimestamp:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedTimestamp:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				EventDataStoreArn:            ptr.String("__EventDataStoreArn__"),
				Name:                         ptr.String("__Name__"),
				TerminationProtectionEnabled: ptr.Bool(true),
				Status:                       types.EventDataStoreStatus("CREATED"),
				AdvancedEventSelectors: []types.AdvancedEventSelector{
					{
						Name: ptr.String("__Name__"),
						FieldSelectors: []types.AdvancedFieldSelector{
							{
								Field: ptr.String("__Field__"),
								Equals: []string{
									"__Member__",
									"__Member__",
								},
								StartsWith: []string{
									"__Member__",
									"__Member__",
								},
								EndsWith: []string{
									"__Member__",
									"__Member__",
								},
								NotEquals: []string{
									"__Member__",
									"__Member__",
								},
								NotStartsWith: []string{
									"__Member__",
									"__Member__",
								},
								NotEndsWith: []string{
									"__Member__",
									"__Member__",
								},
							},
							{
								Field: ptr.String("__Field__"),
								Equals: []string{
									"__Member__",
									"__Member__",
								},
								StartsWith: []string{
									"__Member__",
									"__Member__",
								},
								EndsWith: []string{
									"__Member__",
									"__Member__",
								},
								NotEquals: []string{
									"__Member__",
									"__Member__",
								},
								NotStartsWith: []string{
									"__Member__",
									"__Member__",
								},
								NotEndsWith: []string{
									"__Member__",
									"__Member__",
								},
							},
						},
					},
					{
						Name: ptr.String("__Name__"),
						FieldSelectors: []types.AdvancedFieldSelector{
							{
								Field: ptr.String("__Field__"),
								Equals: []string{
									"__Member__",
									"__Member__",
								},
								StartsWith: []string{
									"__Member__",
									"__Member__",
								},
								EndsWith: []string{
									"__Member__",
									"__Member__",
								},
								NotEquals: []string{
									"__Member__",
									"__Member__",
								},
								NotStartsWith: []string{
									"__Member__",
									"__Member__",
								},
								NotEndsWith: []string{
									"__Member__",
									"__Member__",
								},
							},
							{
								Field: ptr.String("__Field__"),
								Equals: []string{
									"__Member__",
									"__Member__",
								},
								StartsWith: []string{
									"__Member__",
									"__Member__",
								},
								EndsWith: []string{
									"__Member__",
									"__Member__",
								},
								NotEquals: []string{
									"__Member__",
									"__Member__",
								},
								NotStartsWith: []string{
									"__Member__",
									"__Member__",
								},
								NotEndsWith: []string{
									"__Member__",
									"__Member__",
								},
							},
						},
					},
				},
				MultiRegionEnabled:  ptr.Bool(true),
				OrganizationEnabled: ptr.Bool(true),
				RetentionPeriod:     ptr.Int32(1),
				CreatedTimestamp:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedTimestamp:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListEventDataStores.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListEventDataStores(context.Background(), &ListEventDataStoresInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListEventDataStores.response", err)
	}
}

func TestCheckResponseSnapshot_ListImportFailures(t *testing.T) {
	want := &ListImportFailuresOutput{
		Failures: []types.ImportFailureListItem{
			{
				Location:        ptr.String("__Location__"),
				Status:          types.ImportFailureStatus("FAILED"),
				ErrorType:       ptr.String("__ErrorType__"),
				ErrorMessage:    ptr.String("__ErrorMessage__"),
				LastUpdatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				Location:        ptr.String("__Location__"),
				Status:          types.ImportFailureStatus("FAILED"),
				ErrorType:       ptr.String("__ErrorType__"),
				ErrorMessage:    ptr.String("__ErrorMessage__"),
				LastUpdatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListImportFailures.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListImportFailures(context.Background(), &ListImportFailuresInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListImportFailures.response", err)
	}
}

func TestCheckResponseSnapshot_ListImports(t *testing.T) {
	want := &ListImportsOutput{
		Imports: []types.ImportsListItem{
			{
				ImportId:     ptr.String("__ImportId__"),
				ImportStatus: types.ImportStatus("INITIALIZING"),
				Destinations: []string{
					"__Member__",
					"__Member__",
				},
				CreatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				ImportId:     ptr.String("__ImportId__"),
				ImportStatus: types.ImportStatus("INITIALIZING"),
				Destinations: []string{
					"__Member__",
					"__Member__",
				},
				CreatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListImports.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListImports(context.Background(), &ListImportsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListImports.response", err)
	}
}

func TestCheckResponseSnapshot_ListInsightsData(t *testing.T) {
	want := &ListInsightsDataOutput{
		Events: []types.Event{
			{
				EventId:     ptr.String("__EventId__"),
				EventName:   ptr.String("__EventName__"),
				ReadOnly:    ptr.String("__ReadOnly__"),
				AccessKeyId: ptr.String("__AccessKeyId__"),
				EventTime:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				EventSource: ptr.String("__EventSource__"),
				Username:    ptr.String("__Username__"),
				Resources: []types.Resource{
					{
						ResourceType: ptr.String("__ResourceType__"),
						ResourceName: ptr.String("__ResourceName__"),
					},
					{
						ResourceType: ptr.String("__ResourceType__"),
						ResourceName: ptr.String("__ResourceName__"),
					},
				},
				CloudTrailEvent: ptr.String("__CloudTrailEvent__"),
			},
			{
				EventId:     ptr.String("__EventId__"),
				EventName:   ptr.String("__EventName__"),
				ReadOnly:    ptr.String("__ReadOnly__"),
				AccessKeyId: ptr.String("__AccessKeyId__"),
				EventTime:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				EventSource: ptr.String("__EventSource__"),
				Username:    ptr.String("__Username__"),
				Resources: []types.Resource{
					{
						ResourceType: ptr.String("__ResourceType__"),
						ResourceName: ptr.String("__ResourceName__"),
					},
					{
						ResourceType: ptr.String("__ResourceType__"),
						ResourceName: ptr.String("__ResourceName__"),
					},
				},
				CloudTrailEvent: ptr.String("__CloudTrailEvent__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListInsightsData.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListInsightsData(context.Background(), &ListInsightsDataInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListInsightsData.response", err)
	}
}

func TestCheckResponseSnapshot_ListInsightsMetricData(t *testing.T) {
	want := &ListInsightsMetricDataOutput{
		TrailARN:    ptr.String("__TrailARN__"),
		EventSource: ptr.String("__EventSource__"),
		EventName:   ptr.String("__EventName__"),
		InsightType: types.InsightType("ApiCallRateInsight"),
		ErrorCode:   ptr.String("__ErrorCode__"),
		Timestamps: []time.Time{
			time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC),
			time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC),
		},
		Values: []float64{
			1.0,
			1.0,
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListInsightsMetricData.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListInsightsMetricData(context.Background(), &ListInsightsMetricDataInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListInsightsMetricData.response", err)
	}
}

func TestCheckResponseSnapshot_ListPublicKeys(t *testing.T) {
	want := &ListPublicKeysOutput{
		PublicKeyList: []types.PublicKey{
			{
				Value:             []byte("blob"),
				ValidityStartTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ValidityEndTime:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Fingerprint:       ptr.String("__Fingerprint__"),
			},
			{
				Value:             []byte("blob"),
				ValidityStartTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ValidityEndTime:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Fingerprint:       ptr.String("__Fingerprint__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListPublicKeys.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListPublicKeys(context.Background(), &ListPublicKeysInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListPublicKeys.response", err)
	}
}

func TestCheckResponseSnapshot_ListQueries(t *testing.T) {
	want := &ListQueriesOutput{
		Queries: []types.Query{
			{
				QueryId:      ptr.String("__QueryId__"),
				QueryStatus:  types.QueryStatus("QUEUED"),
				CreationTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				QueryId:      ptr.String("__QueryId__"),
				QueryStatus:  types.QueryStatus("QUEUED"),
				CreationTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListQueries.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListQueries(context.Background(), &ListQueriesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListQueries.response", err)
	}
}

func TestCheckResponseSnapshot_ListTags(t *testing.T) {
	want := &ListTagsOutput{
		ResourceTagList: []types.ResourceTag{
			{
				ResourceId: ptr.String("__ResourceId__"),
				TagsList: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
			},
			{
				ResourceId: ptr.String("__ResourceId__"),
				TagsList: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListTags.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListTags(context.Background(), &ListTagsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListTags.response", err)
	}
}

func TestCheckResponseSnapshot_ListTrails(t *testing.T) {
	want := &ListTrailsOutput{
		Trails: []types.TrailInfo{
			{
				TrailARN:   ptr.String("__TrailARN__"),
				Name:       ptr.String("__Name__"),
				HomeRegion: ptr.String("__HomeRegion__"),
			},
			{
				TrailARN:   ptr.String("__TrailARN__"),
				Name:       ptr.String("__Name__"),
				HomeRegion: ptr.String("__HomeRegion__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListTrails.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListTrails(context.Background(), &ListTrailsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListTrails.response", err)
	}
}

func TestCheckResponseSnapshot_LookupEvents(t *testing.T) {
	want := &LookupEventsOutput{
		Events: []types.Event{
			{
				EventId:     ptr.String("__EventId__"),
				EventName:   ptr.String("__EventName__"),
				ReadOnly:    ptr.String("__ReadOnly__"),
				AccessKeyId: ptr.String("__AccessKeyId__"),
				EventTime:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				EventSource: ptr.String("__EventSource__"),
				Username:    ptr.String("__Username__"),
				Resources: []types.Resource{
					{
						ResourceType: ptr.String("__ResourceType__"),
						ResourceName: ptr.String("__ResourceName__"),
					},
					{
						ResourceType: ptr.String("__ResourceType__"),
						ResourceName: ptr.String("__ResourceName__"),
					},
				},
				CloudTrailEvent: ptr.String("__CloudTrailEvent__"),
			},
			{
				EventId:     ptr.String("__EventId__"),
				EventName:   ptr.String("__EventName__"),
				ReadOnly:    ptr.String("__ReadOnly__"),
				AccessKeyId: ptr.String("__AccessKeyId__"),
				EventTime:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				EventSource: ptr.String("__EventSource__"),
				Username:    ptr.String("__Username__"),
				Resources: []types.Resource{
					{
						ResourceType: ptr.String("__ResourceType__"),
						ResourceName: ptr.String("__ResourceName__"),
					},
					{
						ResourceType: ptr.String("__ResourceType__"),
						ResourceName: ptr.String("__ResourceName__"),
					},
				},
				CloudTrailEvent: ptr.String("__CloudTrailEvent__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("LookupEvents.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.LookupEvents(context.Background(), &LookupEventsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "LookupEvents.response", err)
	}
}

func TestCheckResponseSnapshot_PutEventConfiguration(t *testing.T) {
	want := &PutEventConfigurationOutput{
		TrailARN:          ptr.String("__TrailARN__"),
		EventDataStoreArn: ptr.String("__EventDataStoreArn__"),
		MaxEventSize:      types.MaxEventSize("Standard"),
		ContextKeySelectors: []types.ContextKeySelector{
			{
				Type: types.Type("TagContext"),
				Equals: []string{
					"__Member__",
					"__Member__",
				},
			},
			{
				Type: types.Type("TagContext"),
				Equals: []string{
					"__Member__",
					"__Member__",
				},
			},
		},
		AggregationConfigurations: []types.AggregationConfiguration{
			{
				Templates: []types.Template{
					types.Template("API_ACTIVITY"),
					types.Template("API_ACTIVITY"),
				},
				EventCategory: types.EventCategoryAggregation("Data"),
			},
			{
				Templates: []types.Template{
					types.Template("API_ACTIVITY"),
					types.Template("API_ACTIVITY"),
				},
				EventCategory: types.EventCategoryAggregation("Data"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("PutEventConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutEventConfiguration(context.Background(), &PutEventConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutEventConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_PutEventSelectors(t *testing.T) {
	want := &PutEventSelectorsOutput{
		TrailARN: ptr.String("__TrailARN__"),
		EventSelectors: []types.EventSelector{
			{
				ReadWriteType:           types.ReadWriteType("ReadOnly"),
				IncludeManagementEvents: ptr.Bool(true),
				DataResources: []types.DataResource{
					{
						Type: ptr.String("__Type__"),
						Values: []string{
							"__Member__",
							"__Member__",
						},
					},
					{
						Type: ptr.String("__Type__"),
						Values: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
				ExcludeManagementEventSources: []string{
					"__Member__",
					"__Member__",
				},
			},
			{
				ReadWriteType:           types.ReadWriteType("ReadOnly"),
				IncludeManagementEvents: ptr.Bool(true),
				DataResources: []types.DataResource{
					{
						Type: ptr.String("__Type__"),
						Values: []string{
							"__Member__",
							"__Member__",
						},
					},
					{
						Type: ptr.String("__Type__"),
						Values: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
				ExcludeManagementEventSources: []string{
					"__Member__",
					"__Member__",
				},
			},
		},
		AdvancedEventSelectors: []types.AdvancedEventSelector{
			{
				Name: ptr.String("__Name__"),
				FieldSelectors: []types.AdvancedFieldSelector{
					{
						Field: ptr.String("__Field__"),
						Equals: []string{
							"__Member__",
							"__Member__",
						},
						StartsWith: []string{
							"__Member__",
							"__Member__",
						},
						EndsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEquals: []string{
							"__Member__",
							"__Member__",
						},
						NotStartsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEndsWith: []string{
							"__Member__",
							"__Member__",
						},
					},
					{
						Field: ptr.String("__Field__"),
						Equals: []string{
							"__Member__",
							"__Member__",
						},
						StartsWith: []string{
							"__Member__",
							"__Member__",
						},
						EndsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEquals: []string{
							"__Member__",
							"__Member__",
						},
						NotStartsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEndsWith: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
			},
			{
				Name: ptr.String("__Name__"),
				FieldSelectors: []types.AdvancedFieldSelector{
					{
						Field: ptr.String("__Field__"),
						Equals: []string{
							"__Member__",
							"__Member__",
						},
						StartsWith: []string{
							"__Member__",
							"__Member__",
						},
						EndsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEquals: []string{
							"__Member__",
							"__Member__",
						},
						NotStartsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEndsWith: []string{
							"__Member__",
							"__Member__",
						},
					},
					{
						Field: ptr.String("__Field__"),
						Equals: []string{
							"__Member__",
							"__Member__",
						},
						StartsWith: []string{
							"__Member__",
							"__Member__",
						},
						EndsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEquals: []string{
							"__Member__",
							"__Member__",
						},
						NotStartsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEndsWith: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("PutEventSelectors.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutEventSelectors(context.Background(), &PutEventSelectorsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutEventSelectors.response", err)
	}
}

func TestCheckResponseSnapshot_PutInsightSelectors(t *testing.T) {
	want := &PutInsightSelectorsOutput{
		TrailARN: ptr.String("__TrailARN__"),
		InsightSelectors: []types.InsightSelector{
			{
				InsightType: types.InsightType("ApiCallRateInsight"),
				EventCategories: []types.SourceEventCategory{
					types.SourceEventCategory("Management"),
					types.SourceEventCategory("Management"),
				},
			},
			{
				InsightType: types.InsightType("ApiCallRateInsight"),
				EventCategories: []types.SourceEventCategory{
					types.SourceEventCategory("Management"),
					types.SourceEventCategory("Management"),
				},
			},
		},
		EventDataStoreArn:   ptr.String("__EventDataStoreArn__"),
		InsightsDestination: ptr.String("__InsightsDestination__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PutInsightSelectors.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutInsightSelectors(context.Background(), &PutInsightSelectorsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutInsightSelectors.response", err)
	}
}

func TestCheckResponseSnapshot_PutResourcePolicy(t *testing.T) {
	want := &PutResourcePolicyOutput{
		ResourceArn:                  ptr.String("__ResourceArn__"),
		ResourcePolicy:               ptr.String("__ResourcePolicy__"),
		DelegatedAdminResourcePolicy: ptr.String("__DelegatedAdminResourcePolicy__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PutResourcePolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutResourcePolicy(context.Background(), &PutResourcePolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutResourcePolicy.response", err)
	}
}

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

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

func TestCheckResponseSnapshot_RestoreEventDataStore(t *testing.T) {
	want := &RestoreEventDataStoreOutput{
		EventDataStoreArn: ptr.String("__EventDataStoreArn__"),
		Name:              ptr.String("__Name__"),
		Status:            types.EventDataStoreStatus("CREATED"),
		AdvancedEventSelectors: []types.AdvancedEventSelector{
			{
				Name: ptr.String("__Name__"),
				FieldSelectors: []types.AdvancedFieldSelector{
					{
						Field: ptr.String("__Field__"),
						Equals: []string{
							"__Member__",
							"__Member__",
						},
						StartsWith: []string{
							"__Member__",
							"__Member__",
						},
						EndsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEquals: []string{
							"__Member__",
							"__Member__",
						},
						NotStartsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEndsWith: []string{
							"__Member__",
							"__Member__",
						},
					},
					{
						Field: ptr.String("__Field__"),
						Equals: []string{
							"__Member__",
							"__Member__",
						},
						StartsWith: []string{
							"__Member__",
							"__Member__",
						},
						EndsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEquals: []string{
							"__Member__",
							"__Member__",
						},
						NotStartsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEndsWith: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
			},
			{
				Name: ptr.String("__Name__"),
				FieldSelectors: []types.AdvancedFieldSelector{
					{
						Field: ptr.String("__Field__"),
						Equals: []string{
							"__Member__",
							"__Member__",
						},
						StartsWith: []string{
							"__Member__",
							"__Member__",
						},
						EndsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEquals: []string{
							"__Member__",
							"__Member__",
						},
						NotStartsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEndsWith: []string{
							"__Member__",
							"__Member__",
						},
					},
					{
						Field: ptr.String("__Field__"),
						Equals: []string{
							"__Member__",
							"__Member__",
						},
						StartsWith: []string{
							"__Member__",
							"__Member__",
						},
						EndsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEquals: []string{
							"__Member__",
							"__Member__",
						},
						NotStartsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEndsWith: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
			},
		},
		MultiRegionEnabled:           ptr.Bool(true),
		OrganizationEnabled:          ptr.Bool(true),
		RetentionPeriod:              ptr.Int32(1),
		TerminationProtectionEnabled: ptr.Bool(true),
		CreatedTimestamp:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		UpdatedTimestamp:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		KmsKeyId:                     ptr.String("__KmsKeyId__"),
		BillingMode:                  types.BillingMode("EXTENDABLE_RETENTION_PRICING"),
	}
	status, header, body, err := serdeRespReadSnapshot("RestoreEventDataStore.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.RestoreEventDataStore(context.Background(), &RestoreEventDataStoreInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "RestoreEventDataStore.response", err)
	}
}

func TestCheckResponseSnapshot_SearchSampleQueries(t *testing.T) {
	want := &SearchSampleQueriesOutput{
		SearchResults: []types.SearchSampleQueriesSearchResult{
			{
				Name:        ptr.String("__Name__"),
				Description: ptr.String("__Description__"),
				SQL:         ptr.String("__SQL__"),
				Relevance:   1.0,
			},
			{
				Name:        ptr.String("__Name__"),
				Description: ptr.String("__Description__"),
				SQL:         ptr.String("__SQL__"),
				Relevance:   1.0,
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("SearchSampleQueries.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.SearchSampleQueries(context.Background(), &SearchSampleQueriesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "SearchSampleQueries.response", err)
	}
}

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

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

func TestCheckResponseSnapshot_StartImport(t *testing.T) {
	want := &StartImportOutput{
		ImportId: ptr.String("__ImportId__"),
		Destinations: []string{
			"__Member__",
			"__Member__",
		},
		ImportSource: &types.ImportSource{
			S3: &types.S3ImportSource{
				S3LocationUri:         ptr.String("__S3LocationUri__"),
				S3BucketRegion:        ptr.String("__S3BucketRegion__"),
				S3BucketAccessRoleArn: ptr.String("__S3BucketAccessRoleArn__"),
			},
		},
		StartEventTime:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		EndEventTime:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ImportStatus:     types.ImportStatus("INITIALIZING"),
		CreatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		UpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("StartImport.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.StartImport(context.Background(), &StartImportInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StartImport.response", err)
	}
}

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

func TestCheckResponseSnapshot_StartQuery(t *testing.T) {
	want := &StartQueryOutput{
		QueryId:                      ptr.String("__QueryId__"),
		EventDataStoreOwnerAccountId: ptr.String("__EventDataStoreOwnerAccountId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("StartQuery.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.StartQuery(context.Background(), &StartQueryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StartQuery.response", err)
	}
}

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

func TestCheckResponseSnapshot_StopImport(t *testing.T) {
	want := &StopImportOutput{
		ImportId: ptr.String("__ImportId__"),
		ImportSource: &types.ImportSource{
			S3: &types.S3ImportSource{
				S3LocationUri:         ptr.String("__S3LocationUri__"),
				S3BucketRegion:        ptr.String("__S3BucketRegion__"),
				S3BucketAccessRoleArn: ptr.String("__S3BucketAccessRoleArn__"),
			},
		},
		Destinations: []string{
			"__Member__",
			"__Member__",
		},
		ImportStatus:     types.ImportStatus("INITIALIZING"),
		CreatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		UpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		StartEventTime:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		EndEventTime:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ImportStatistics: &types.ImportStatistics{
			PrefixesFound:     ptr.Int64(1),
			PrefixesCompleted: ptr.Int64(1),
			FilesCompleted:    ptr.Int64(1),
			EventsCompleted:   ptr.Int64(1),
			FailedEntries:     ptr.Int64(1),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("StopImport.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.StopImport(context.Background(), &StopImportInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StopImport.response", err)
	}
}

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

func TestCheckResponseSnapshot_UpdateChannel(t *testing.T) {
	want := &UpdateChannelOutput{
		ChannelArn: ptr.String("__ChannelArn__"),
		Name:       ptr.String("__Name__"),
		Source:     ptr.String("__Source__"),
		Destinations: []types.Destination{
			{
				Type:     types.DestinationType("EVENT_DATA_STORE"),
				Location: ptr.String("__Location__"),
			},
			{
				Type:     types.DestinationType("EVENT_DATA_STORE"),
				Location: ptr.String("__Location__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateChannel.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateChannel(context.Background(), &UpdateChannelInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateChannel.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateDashboard(t *testing.T) {
	want := &UpdateDashboardOutput{
		DashboardArn: ptr.String("__DashboardArn__"),
		Name:         ptr.String("__Name__"),
		Type:         types.DashboardType("MANAGED"),
		Widgets: []types.Widget{
			{
				QueryAlias:     ptr.String("__QueryAlias__"),
				QueryStatement: ptr.String("__QueryStatement__"),
				QueryParameters: []string{
					"__Member__",
					"__Member__",
				},
				ViewProperties: map[string]string{
					"key0": "__Value__",
				},
			},
			{
				QueryAlias:     ptr.String("__QueryAlias__"),
				QueryStatement: ptr.String("__QueryStatement__"),
				QueryParameters: []string{
					"__Member__",
					"__Member__",
				},
				ViewProperties: map[string]string{
					"key0": "__Value__",
				},
			},
		},
		RefreshSchedule: &types.RefreshSchedule{
			Frequency: &types.RefreshScheduleFrequency{
				Unit:  types.RefreshScheduleFrequencyUnit("HOURS"),
				Value: ptr.Int32(1),
			},
			Status:    types.RefreshScheduleStatus("ENABLED"),
			TimeOfDay: ptr.String("__TimeOfDay__"),
		},
		TerminationProtectionEnabled: ptr.Bool(true),
		CreatedTimestamp:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		UpdatedTimestamp:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateDashboard.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateDashboard(context.Background(), &UpdateDashboardInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateDashboard.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateEventDataStore(t *testing.T) {
	want := &UpdateEventDataStoreOutput{
		EventDataStoreArn: ptr.String("__EventDataStoreArn__"),
		Name:              ptr.String("__Name__"),
		Status:            types.EventDataStoreStatus("CREATED"),
		AdvancedEventSelectors: []types.AdvancedEventSelector{
			{
				Name: ptr.String("__Name__"),
				FieldSelectors: []types.AdvancedFieldSelector{
					{
						Field: ptr.String("__Field__"),
						Equals: []string{
							"__Member__",
							"__Member__",
						},
						StartsWith: []string{
							"__Member__",
							"__Member__",
						},
						EndsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEquals: []string{
							"__Member__",
							"__Member__",
						},
						NotStartsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEndsWith: []string{
							"__Member__",
							"__Member__",
						},
					},
					{
						Field: ptr.String("__Field__"),
						Equals: []string{
							"__Member__",
							"__Member__",
						},
						StartsWith: []string{
							"__Member__",
							"__Member__",
						},
						EndsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEquals: []string{
							"__Member__",
							"__Member__",
						},
						NotStartsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEndsWith: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
			},
			{
				Name: ptr.String("__Name__"),
				FieldSelectors: []types.AdvancedFieldSelector{
					{
						Field: ptr.String("__Field__"),
						Equals: []string{
							"__Member__",
							"__Member__",
						},
						StartsWith: []string{
							"__Member__",
							"__Member__",
						},
						EndsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEquals: []string{
							"__Member__",
							"__Member__",
						},
						NotStartsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEndsWith: []string{
							"__Member__",
							"__Member__",
						},
					},
					{
						Field: ptr.String("__Field__"),
						Equals: []string{
							"__Member__",
							"__Member__",
						},
						StartsWith: []string{
							"__Member__",
							"__Member__",
						},
						EndsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEquals: []string{
							"__Member__",
							"__Member__",
						},
						NotStartsWith: []string{
							"__Member__",
							"__Member__",
						},
						NotEndsWith: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
			},
		},
		MultiRegionEnabled:           ptr.Bool(true),
		OrganizationEnabled:          ptr.Bool(true),
		RetentionPeriod:              ptr.Int32(1),
		TerminationProtectionEnabled: ptr.Bool(true),
		CreatedTimestamp:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		UpdatedTimestamp:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		KmsKeyId:                     ptr.String("__KmsKeyId__"),
		BillingMode:                  types.BillingMode("EXTENDABLE_RETENTION_PRICING"),
		FederationStatus:             types.FederationStatus("ENABLING"),
		FederationRoleArn:            ptr.String("__FederationRoleArn__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateEventDataStore.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateEventDataStore(context.Background(), &UpdateEventDataStoreInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateEventDataStore.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateTrail(t *testing.T) {
	want := &UpdateTrailOutput{
		Name:                       ptr.String("__Name__"),
		S3BucketName:               ptr.String("__S3BucketName__"),
		S3KeyPrefix:                ptr.String("__S3KeyPrefix__"),
		SnsTopicName:               ptr.String("__SnsTopicName__"),
		SnsTopicARN:                ptr.String("__SnsTopicARN__"),
		IncludeGlobalServiceEvents: ptr.Bool(true),
		IsMultiRegionTrail:         ptr.Bool(true),
		TrailARN:                   ptr.String("__TrailARN__"),
		LogFileValidationEnabled:   ptr.Bool(true),
		CloudWatchLogsLogGroupArn:  ptr.String("__CloudWatchLogsLogGroupArn__"),
		CloudWatchLogsRoleArn:      ptr.String("__CloudWatchLogsRoleArn__"),
		KmsKeyId:                   ptr.String("__KmsKeyId__"),
		IsOrganizationTrail:        ptr.Bool(true),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateTrail.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateTrail(context.Background(), &UpdateTrailInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateTrail.response", err)
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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