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

//go:build response_snapshot

package amp

import (
	"bufio"
	"bytes"
	"context"
	"errors"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/amp/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_CreateAlertManagerDefinition(t *testing.T) {
	want := &CreateAlertManagerDefinitionOutput{
		Status: &types.AlertManagerDefinitionStatus{
			StatusCode:   types.AlertManagerDefinitionStatusCode("CREATING"),
			StatusReason: ptr.String("__StatusReason__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateAlertManagerDefinition.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateAlertManagerDefinition(context.Background(), &CreateAlertManagerDefinitionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateAlertManagerDefinition.response", err)
	}
}

func TestCheckResponseSnapshot_CreateAnomalyDetector(t *testing.T) {
	want := &CreateAnomalyDetectorOutput{
		AnomalyDetectorId: ptr.String("__AnomalyDetectorId__"),
		Arn:               ptr.String("__Arn__"),
		Status: &types.AnomalyDetectorStatus{
			StatusCode:   types.AnomalyDetectorStatusCode("CREATING"),
			StatusReason: ptr.String("__StatusReason__"),
		},
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateAnomalyDetector.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateAnomalyDetector(context.Background(), &CreateAnomalyDetectorInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateAnomalyDetector.response", err)
	}
}

func TestCheckResponseSnapshot_CreateLoggingConfiguration(t *testing.T) {
	want := &CreateLoggingConfigurationOutput{
		Status: &types.LoggingConfigurationStatus{
			StatusCode:   types.LoggingConfigurationStatusCode("CREATING"),
			StatusReason: ptr.String("__StatusReason__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateLoggingConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateLoggingConfiguration(context.Background(), &CreateLoggingConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateLoggingConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_CreateQueryLoggingConfiguration(t *testing.T) {
	want := &CreateQueryLoggingConfigurationOutput{
		Status: &types.QueryLoggingConfigurationStatus{
			StatusCode:   types.QueryLoggingConfigurationStatusCode("CREATING"),
			StatusReason: ptr.String("__StatusReason__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateQueryLoggingConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateQueryLoggingConfiguration(context.Background(), &CreateQueryLoggingConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateQueryLoggingConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_CreateRuleGroupsNamespace(t *testing.T) {
	want := &CreateRuleGroupsNamespaceOutput{
		Name: ptr.String("__Name__"),
		Arn:  ptr.String("__Arn__"),
		Status: &types.RuleGroupsNamespaceStatus{
			StatusCode:   types.RuleGroupsNamespaceStatusCode("CREATING"),
			StatusReason: ptr.String("__StatusReason__"),
		},
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateRuleGroupsNamespace.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateRuleGroupsNamespace(context.Background(), &CreateRuleGroupsNamespaceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateRuleGroupsNamespace.response", err)
	}
}

func TestCheckResponseSnapshot_CreateScraper(t *testing.T) {
	want := &CreateScraperOutput{
		ScraperId: ptr.String("__ScraperId__"),
		Arn:       ptr.String("__Arn__"),
		Status: &types.ScraperStatus{
			StatusCode: types.ScraperStatusCode("CREATING"),
		},
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateScraper.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateScraper(context.Background(), &CreateScraperInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateScraper.response", err)
	}
}

func TestCheckResponseSnapshot_CreateWorkspace(t *testing.T) {
	want := &CreateWorkspaceOutput{
		WorkspaceId: ptr.String("__WorkspaceId__"),
		Arn:         ptr.String("__Arn__"),
		Status: &types.WorkspaceStatus{
			StatusCode: types.WorkspaceStatusCode("CREATING"),
		},
		Tags: map[string]string{
			"key0": "__Value__",
		},
		KmsKeyArn: ptr.String("__KmsKeyArn__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateWorkspace.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateWorkspace(context.Background(), &CreateWorkspaceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateWorkspace.response", err)
	}
}

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

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

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

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

func TestCheckResponseSnapshot_DeleteScraper(t *testing.T) {
	want := &DeleteScraperOutput{
		ScraperId: ptr.String("__ScraperId__"),
		Status: &types.ScraperStatus{
			StatusCode: types.ScraperStatusCode("CREATING"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DeleteScraper.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteScraper(context.Background(), &DeleteScraperInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteScraper.response", err)
	}
}

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

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

func TestCheckResponseSnapshot_DescribeAlertManagerDefinition(t *testing.T) {
	want := &DescribeAlertManagerDefinitionOutput{
		AlertManagerDefinition: &types.AlertManagerDefinitionDescription{
			Status: &types.AlertManagerDefinitionStatus{
				StatusCode:   types.AlertManagerDefinitionStatusCode("CREATING"),
				StatusReason: ptr.String("__StatusReason__"),
			},
			Data:       []byte("blob"),
			CreatedAt:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			ModifiedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeAlertManagerDefinition.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeAlertManagerDefinition(context.Background(), &DescribeAlertManagerDefinitionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeAlertManagerDefinition.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeAnomalyDetector(t *testing.T) {
	want := &DescribeAnomalyDetectorOutput{
		AnomalyDetector: &types.AnomalyDetectorDescription{
			Arn:                         ptr.String("__Arn__"),
			AnomalyDetectorId:           ptr.String("__AnomalyDetectorId__"),
			Alias:                       ptr.String("__Alias__"),
			EvaluationIntervalInSeconds: ptr.Int32(1),
			MissingDataAction: &types.AnomalyDetectorMissingDataActionMemberMarkAsAnomaly{
				Value: true,
			},
			Configuration: &types.AnomalyDetectorConfigurationMemberRandomCutForest{
				Value: types.RandomCutForestConfiguration{
					Query:       ptr.String("__Query__"),
					ShingleSize: ptr.Int32(1),
					SampleSize:  ptr.Int32(1),
					IgnoreNearExpectedFromAbove: &types.IgnoreNearExpectedMemberAmount{
						Value: 1.0,
					},
					IgnoreNearExpectedFromBelow: &types.IgnoreNearExpectedMemberAmount{
						Value: 1.0,
					},
				},
			},
			Labels: map[string]string{
				"key0": "__Value__",
			},
			Status: &types.AnomalyDetectorStatus{
				StatusCode:   types.AnomalyDetectorStatusCode("CREATING"),
				StatusReason: ptr.String("__StatusReason__"),
			},
			CreatedAt:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			ModifiedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			Tags: map[string]string{
				"key0": "__Value__",
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeAnomalyDetector.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeAnomalyDetector(context.Background(), &DescribeAnomalyDetectorInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeAnomalyDetector.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeLoggingConfiguration(t *testing.T) {
	want := &DescribeLoggingConfigurationOutput{
		LoggingConfiguration: &types.LoggingConfigurationMetadata{
			Status: &types.LoggingConfigurationStatus{
				StatusCode:   types.LoggingConfigurationStatusCode("CREATING"),
				StatusReason: ptr.String("__StatusReason__"),
			},
			Workspace:   ptr.String("__Workspace__"),
			LogGroupArn: ptr.String("__LogGroupArn__"),
			CreatedAt:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			ModifiedAt:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeLoggingConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeLoggingConfiguration(context.Background(), &DescribeLoggingConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeLoggingConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeQueryLoggingConfiguration(t *testing.T) {
	want := &DescribeQueryLoggingConfigurationOutput{
		QueryLoggingConfiguration: &types.QueryLoggingConfigurationMetadata{
			Status: &types.QueryLoggingConfigurationStatus{
				StatusCode:   types.QueryLoggingConfigurationStatusCode("CREATING"),
				StatusReason: ptr.String("__StatusReason__"),
			},
			Workspace: ptr.String("__Workspace__"),
			Destinations: []types.LoggingDestination{
				{
					CloudWatchLogs: &types.CloudWatchLogDestination{
						LogGroupArn: ptr.String("__LogGroupArn__"),
					},
					Filters: &types.LoggingFilter{
						QspThreshold: ptr.Int64(1),
					},
				},
				{
					CloudWatchLogs: &types.CloudWatchLogDestination{
						LogGroupArn: ptr.String("__LogGroupArn__"),
					},
					Filters: &types.LoggingFilter{
						QspThreshold: ptr.Int64(1),
					},
				},
			},
			CreatedAt:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			ModifiedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeQueryLoggingConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeQueryLoggingConfiguration(context.Background(), &DescribeQueryLoggingConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeQueryLoggingConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeResourcePolicy(t *testing.T) {
	want := &DescribeResourcePolicyOutput{
		PolicyDocument: ptr.String("__PolicyDocument__"),
		PolicyStatus:   types.WorkspacePolicyStatusCode("CREATING"),
		RevisionId:     ptr.String("__RevisionId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeResourcePolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeResourcePolicy(context.Background(), &DescribeResourcePolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeResourcePolicy.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeRuleGroupsNamespace(t *testing.T) {
	want := &DescribeRuleGroupsNamespaceOutput{
		RuleGroupsNamespace: &types.RuleGroupsNamespaceDescription{
			Arn:  ptr.String("__Arn__"),
			Name: ptr.String("__Name__"),
			Status: &types.RuleGroupsNamespaceStatus{
				StatusCode:   types.RuleGroupsNamespaceStatusCode("CREATING"),
				StatusReason: ptr.String("__StatusReason__"),
			},
			Data:       []byte("blob"),
			CreatedAt:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			ModifiedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			Tags: map[string]string{
				"key0": "__Value__",
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeRuleGroupsNamespace.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeRuleGroupsNamespace(context.Background(), &DescribeRuleGroupsNamespaceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeRuleGroupsNamespace.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeScraper(t *testing.T) {
	want := &DescribeScraperOutput{
		Scraper: &types.ScraperDescription{
			Alias:     ptr.String("__Alias__"),
			ScraperId: ptr.String("__ScraperId__"),
			Arn:       ptr.String("__Arn__"),
			RoleArn:   ptr.String("__RoleArn__"),
			Status: &types.ScraperStatus{
				StatusCode: types.ScraperStatusCode("CREATING"),
			},
			CreatedAt:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LastModifiedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			Tags: map[string]string{
				"key0": "__Value__",
			},
			StatusReason: ptr.String("__StatusReason__"),
			ScrapeConfiguration: &types.ScrapeConfigurationMemberConfigurationBlob{
				Value: []byte("blob"),
			},
			Source: &types.SourceMemberEksConfiguration{
				Value: types.EksConfiguration{
					ClusterArn: ptr.String("__ClusterArn__"),
					SecurityGroupIds: []string{
						"__Member__",
						"__Member__",
					},
					SubnetIds: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
			Destination: &types.DestinationMemberAmpConfiguration{
				Value: types.AmpConfiguration{
					WorkspaceArn: ptr.String("__WorkspaceArn__"),
				},
			},
			RoleConfiguration: &types.RoleConfiguration{
				SourceRoleArn: ptr.String("__SourceRoleArn__"),
				TargetRoleArn: ptr.String("__TargetRoleArn__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeScraper.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeScraper(context.Background(), &DescribeScraperInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeScraper.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeScraperLoggingConfiguration(t *testing.T) {
	want := &DescribeScraperLoggingConfigurationOutput{
		Status: &types.ScraperLoggingConfigurationStatus{
			StatusCode:   types.ScraperLoggingConfigurationStatusCode("CREATING"),
			StatusReason: ptr.String("__StatusReason__"),
		},
		ScraperId: ptr.String("__ScraperId__"),
		LoggingDestination: &types.ScraperLoggingDestinationMemberCloudWatchLogs{
			Value: types.CloudWatchLogDestination{
				LogGroupArn: ptr.String("__LogGroupArn__"),
			},
		},
		ScraperComponents: []types.ScraperComponent{
			{
				Type: types.ScraperComponentType("SERVICE_DISCOVERY"),
				Config: &types.ComponentConfig{
					Options: map[string]string{
						"key0": "__Value__",
					},
				},
			},
			{
				Type: types.ScraperComponentType("SERVICE_DISCOVERY"),
				Config: &types.ComponentConfig{
					Options: map[string]string{
						"key0": "__Value__",
					},
				},
			},
		},
		ModifiedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeScraperLoggingConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeScraperLoggingConfiguration(context.Background(), &DescribeScraperLoggingConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeScraperLoggingConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeWorkspace(t *testing.T) {
	want := &DescribeWorkspaceOutput{
		Workspace: &types.WorkspaceDescription{
			WorkspaceId: ptr.String("__WorkspaceId__"),
			Alias:       ptr.String("__Alias__"),
			Arn:         ptr.String("__Arn__"),
			Status: &types.WorkspaceStatus{
				StatusCode: types.WorkspaceStatusCode("CREATING"),
			},
			PrometheusEndpoint: ptr.String("__PrometheusEndpoint__"),
			CreatedAt:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			Tags: map[string]string{
				"key0": "__Value__",
			},
			KmsKeyArn: ptr.String("__KmsKeyArn__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeWorkspace.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeWorkspace(context.Background(), &DescribeWorkspaceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeWorkspace.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeWorkspaceConfiguration(t *testing.T) {
	want := &DescribeWorkspaceConfigurationOutput{
		WorkspaceConfiguration: &types.WorkspaceConfigurationDescription{
			Status: &types.WorkspaceConfigurationStatus{
				StatusCode:   types.WorkspaceConfigurationStatusCode("ACTIVE"),
				StatusReason: ptr.String("__StatusReason__"),
			},
			LimitsPerLabelSet: []types.LimitsPerLabelSet{
				{
					Limits: &types.LimitsPerLabelSetEntry{
						MaxSeries: ptr.Int64(1),
					},
					LabelSet: map[string]string{
						"key0": "__Value__",
					},
				},
				{
					Limits: &types.LimitsPerLabelSetEntry{
						MaxSeries: ptr.Int64(1),
					},
					LabelSet: map[string]string{
						"key0": "__Value__",
					},
				},
			},
			RetentionPeriodInDays:         ptr.Int32(1),
			OutOfOrderTimeWindowInSeconds: ptr.Int32(1),
			RuleQueryOffsetInSeconds:      ptr.Int32(1),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeWorkspaceConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeWorkspaceConfiguration(context.Background(), &DescribeWorkspaceConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeWorkspaceConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_GetDefaultScraperConfiguration(t *testing.T) {
	want := &GetDefaultScraperConfigurationOutput{
		Configuration: []byte("blob"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetDefaultScraperConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetDefaultScraperConfiguration(context.Background(), &GetDefaultScraperConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetDefaultScraperConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_ListAnomalyDetectors(t *testing.T) {
	want := &ListAnomalyDetectorsOutput{
		AnomalyDetectors: []types.AnomalyDetectorSummary{
			{
				Arn:               ptr.String("__Arn__"),
				AnomalyDetectorId: ptr.String("__AnomalyDetectorId__"),
				Alias:             ptr.String("__Alias__"),
				Status: &types.AnomalyDetectorStatus{
					StatusCode:   types.AnomalyDetectorStatusCode("CREATING"),
					StatusReason: ptr.String("__StatusReason__"),
				},
				CreatedAt:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ModifiedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Tags: map[string]string{
					"key0": "__Value__",
				},
			},
			{
				Arn:               ptr.String("__Arn__"),
				AnomalyDetectorId: ptr.String("__AnomalyDetectorId__"),
				Alias:             ptr.String("__Alias__"),
				Status: &types.AnomalyDetectorStatus{
					StatusCode:   types.AnomalyDetectorStatusCode("CREATING"),
					StatusReason: ptr.String("__StatusReason__"),
				},
				CreatedAt:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ModifiedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Tags: map[string]string{
					"key0": "__Value__",
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListAnomalyDetectors.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListAnomalyDetectors(context.Background(), &ListAnomalyDetectorsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListAnomalyDetectors.response", err)
	}
}

func TestCheckResponseSnapshot_ListRuleGroupsNamespaces(t *testing.T) {
	want := &ListRuleGroupsNamespacesOutput{
		RuleGroupsNamespaces: []types.RuleGroupsNamespaceSummary{
			{
				Arn:  ptr.String("__Arn__"),
				Name: ptr.String("__Name__"),
				Status: &types.RuleGroupsNamespaceStatus{
					StatusCode:   types.RuleGroupsNamespaceStatusCode("CREATING"),
					StatusReason: ptr.String("__StatusReason__"),
				},
				CreatedAt:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ModifiedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Tags: map[string]string{
					"key0": "__Value__",
				},
			},
			{
				Arn:  ptr.String("__Arn__"),
				Name: ptr.String("__Name__"),
				Status: &types.RuleGroupsNamespaceStatus{
					StatusCode:   types.RuleGroupsNamespaceStatusCode("CREATING"),
					StatusReason: ptr.String("__StatusReason__"),
				},
				CreatedAt:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ModifiedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Tags: map[string]string{
					"key0": "__Value__",
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListRuleGroupsNamespaces.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListRuleGroupsNamespaces(context.Background(), &ListRuleGroupsNamespacesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListRuleGroupsNamespaces.response", err)
	}
}

func TestCheckResponseSnapshot_ListScrapers(t *testing.T) {
	want := &ListScrapersOutput{
		Scrapers: []types.ScraperSummary{
			{
				Alias:     ptr.String("__Alias__"),
				ScraperId: ptr.String("__ScraperId__"),
				Arn:       ptr.String("__Arn__"),
				RoleArn:   ptr.String("__RoleArn__"),
				Status: &types.ScraperStatus{
					StatusCode: types.ScraperStatusCode("CREATING"),
				},
				CreatedAt:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastModifiedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Tags: map[string]string{
					"key0": "__Value__",
				},
				StatusReason: ptr.String("__StatusReason__"),
				Source: &types.SourceMemberEksConfiguration{
					Value: types.EksConfiguration{
						ClusterArn: ptr.String("__ClusterArn__"),
						SecurityGroupIds: []string{
							"__Member__",
							"__Member__",
						},
						SubnetIds: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
				Destination: &types.DestinationMemberAmpConfiguration{
					Value: types.AmpConfiguration{
						WorkspaceArn: ptr.String("__WorkspaceArn__"),
					},
				},
				RoleConfiguration: &types.RoleConfiguration{
					SourceRoleArn: ptr.String("__SourceRoleArn__"),
					TargetRoleArn: ptr.String("__TargetRoleArn__"),
				},
			},
			{
				Alias:     ptr.String("__Alias__"),
				ScraperId: ptr.String("__ScraperId__"),
				Arn:       ptr.String("__Arn__"),
				RoleArn:   ptr.String("__RoleArn__"),
				Status: &types.ScraperStatus{
					StatusCode: types.ScraperStatusCode("CREATING"),
				},
				CreatedAt:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastModifiedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Tags: map[string]string{
					"key0": "__Value__",
				},
				StatusReason: ptr.String("__StatusReason__"),
				Source: &types.SourceMemberEksConfiguration{
					Value: types.EksConfiguration{
						ClusterArn: ptr.String("__ClusterArn__"),
						SecurityGroupIds: []string{
							"__Member__",
							"__Member__",
						},
						SubnetIds: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
				Destination: &types.DestinationMemberAmpConfiguration{
					Value: types.AmpConfiguration{
						WorkspaceArn: ptr.String("__WorkspaceArn__"),
					},
				},
				RoleConfiguration: &types.RoleConfiguration{
					SourceRoleArn: ptr.String("__SourceRoleArn__"),
					TargetRoleArn: ptr.String("__TargetRoleArn__"),
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListScrapers.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListScrapers(context.Background(), &ListScrapersInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListScrapers.response", err)
	}
}

func TestCheckResponseSnapshot_ListTagsForResource(t *testing.T) {
	want := &ListTagsForResourceOutput{
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListTagsForResource.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListTagsForResource(context.Background(), &ListTagsForResourceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListTagsForResource.response", err)
	}
}

func TestCheckResponseSnapshot_ListWorkspaces(t *testing.T) {
	want := &ListWorkspacesOutput{
		Workspaces: []types.WorkspaceSummary{
			{
				WorkspaceId: ptr.String("__WorkspaceId__"),
				Alias:       ptr.String("__Alias__"),
				Arn:         ptr.String("__Arn__"),
				Status: &types.WorkspaceStatus{
					StatusCode: types.WorkspaceStatusCode("CREATING"),
				},
				CreatedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Tags: map[string]string{
					"key0": "__Value__",
				},
				KmsKeyArn: ptr.String("__KmsKeyArn__"),
			},
			{
				WorkspaceId: ptr.String("__WorkspaceId__"),
				Alias:       ptr.String("__Alias__"),
				Arn:         ptr.String("__Arn__"),
				Status: &types.WorkspaceStatus{
					StatusCode: types.WorkspaceStatusCode("CREATING"),
				},
				CreatedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Tags: map[string]string{
					"key0": "__Value__",
				},
				KmsKeyArn: ptr.String("__KmsKeyArn__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListWorkspaces.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListWorkspaces(context.Background(), &ListWorkspacesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListWorkspaces.response", err)
	}
}

func TestCheckResponseSnapshot_PutAlertManagerDefinition(t *testing.T) {
	want := &PutAlertManagerDefinitionOutput{
		Status: &types.AlertManagerDefinitionStatus{
			StatusCode:   types.AlertManagerDefinitionStatusCode("CREATING"),
			StatusReason: ptr.String("__StatusReason__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("PutAlertManagerDefinition.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutAlertManagerDefinition(context.Background(), &PutAlertManagerDefinitionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutAlertManagerDefinition.response", err)
	}
}

func TestCheckResponseSnapshot_PutAnomalyDetector(t *testing.T) {
	want := &PutAnomalyDetectorOutput{
		AnomalyDetectorId: ptr.String("__AnomalyDetectorId__"),
		Arn:               ptr.String("__Arn__"),
		Status: &types.AnomalyDetectorStatus{
			StatusCode:   types.AnomalyDetectorStatusCode("CREATING"),
			StatusReason: ptr.String("__StatusReason__"),
		},
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("PutAnomalyDetector.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutAnomalyDetector(context.Background(), &PutAnomalyDetectorInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutAnomalyDetector.response", err)
	}
}

func TestCheckResponseSnapshot_PutResourcePolicy(t *testing.T) {
	want := &PutResourcePolicyOutput{
		PolicyStatus: types.WorkspacePolicyStatusCode("CREATING"),
		RevisionId:   ptr.String("__RevisionId__"),
	}
	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_PutRuleGroupsNamespace(t *testing.T) {
	want := &PutRuleGroupsNamespaceOutput{
		Name: ptr.String("__Name__"),
		Arn:  ptr.String("__Arn__"),
		Status: &types.RuleGroupsNamespaceStatus{
			StatusCode:   types.RuleGroupsNamespaceStatusCode("CREATING"),
			StatusReason: ptr.String("__StatusReason__"),
		},
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("PutRuleGroupsNamespace.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutRuleGroupsNamespace(context.Background(), &PutRuleGroupsNamespaceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutRuleGroupsNamespace.response", err)
	}
}

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

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

func TestCheckResponseSnapshot_UpdateLoggingConfiguration(t *testing.T) {
	want := &UpdateLoggingConfigurationOutput{
		Status: &types.LoggingConfigurationStatus{
			StatusCode:   types.LoggingConfigurationStatusCode("CREATING"),
			StatusReason: ptr.String("__StatusReason__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateLoggingConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateLoggingConfiguration(context.Background(), &UpdateLoggingConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateLoggingConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateQueryLoggingConfiguration(t *testing.T) {
	want := &UpdateQueryLoggingConfigurationOutput{
		Status: &types.QueryLoggingConfigurationStatus{
			StatusCode:   types.QueryLoggingConfigurationStatusCode("CREATING"),
			StatusReason: ptr.String("__StatusReason__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateQueryLoggingConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateQueryLoggingConfiguration(context.Background(), &UpdateQueryLoggingConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateQueryLoggingConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateScraper(t *testing.T) {
	want := &UpdateScraperOutput{
		ScraperId: ptr.String("__ScraperId__"),
		Arn:       ptr.String("__Arn__"),
		Status: &types.ScraperStatus{
			StatusCode: types.ScraperStatusCode("CREATING"),
		},
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateScraper.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateScraper(context.Background(), &UpdateScraperInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateScraper.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateScraperLoggingConfiguration(t *testing.T) {
	want := &UpdateScraperLoggingConfigurationOutput{
		Status: &types.ScraperLoggingConfigurationStatus{
			StatusCode:   types.ScraperLoggingConfigurationStatusCode("CREATING"),
			StatusReason: ptr.String("__StatusReason__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateScraperLoggingConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateScraperLoggingConfiguration(context.Background(), &UpdateScraperLoggingConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateScraperLoggingConfiguration.response", err)
	}
}

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

func TestCheckResponseSnapshot_UpdateWorkspaceConfiguration(t *testing.T) {
	want := &UpdateWorkspaceConfigurationOutput{
		Status: &types.WorkspaceConfigurationStatus{
			StatusCode:   types.WorkspaceConfigurationStatusCode("ACTIVE"),
			StatusReason: ptr.String("__StatusReason__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateWorkspaceConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateWorkspaceConfiguration(context.Background(), &UpdateWorkspaceConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateWorkspaceConfiguration.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.CreateAlertManagerDefinition(context.Background(), &CreateAlertManagerDefinitionInput{})
	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_ConflictException(t *testing.T) {
	want := &types.ConflictException{
		Message:      ptr.String("__Message__"),
		ResourceId:   ptr.String("__ResourceId__"),
		ResourceType: ptr.String("__ResourceType__"),
	}
	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.CreateAlertManagerDefinition(context.Background(), &CreateAlertManagerDefinitionInput{})
	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_InternalServerException(t *testing.T) {
	want := &types.InternalServerException{
		Message:           ptr.String("__Message__"),
		RetryAfterSeconds: ptr.Int32(1),
	}
	status, header, body, err := serdeRespReadSnapshot("InternalServerException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.CreateAlertManagerDefinition(context.Background(), &CreateAlertManagerDefinitionInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InternalServerException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InternalServerException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InternalServerException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ResourceNotFoundException(t *testing.T) {
	want := &types.ResourceNotFoundException{
		Message:      ptr.String("__Message__"),
		ResourceId:   ptr.String("__ResourceId__"),
		ResourceType: ptr.String("__ResourceType__"),
	}
	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.CreateAlertManagerDefinition(context.Background(), &CreateAlertManagerDefinitionInput{})
	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_ServiceQuotaExceededException(t *testing.T) {
	want := &types.ServiceQuotaExceededException{
		Message:      ptr.String("__Message__"),
		ResourceId:   ptr.String("__ResourceId__"),
		ResourceType: ptr.String("__ResourceType__"),
		ServiceCode:  ptr.String("__ServiceCode__"),
		QuotaCode:    ptr.String("__QuotaCode__"),
	}
	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.CreateAlertManagerDefinition(context.Background(), &CreateAlertManagerDefinitionInput{})
	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_ThrottlingException(t *testing.T) {
	want := &types.ThrottlingException{
		Message:           ptr.String("__Message__"),
		ServiceCode:       ptr.String("__ServiceCode__"),
		QuotaCode:         ptr.String("__QuotaCode__"),
		RetryAfterSeconds: ptr.Int32(1),
	}
	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.CreateAlertManagerDefinition(context.Background(), &CreateAlertManagerDefinitionInput{})
	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_ValidationException(t *testing.T) {
	want := &types.ValidationException{
		Message: ptr.String("__Message__"),
		Reason:  types.ValidationExceptionReason("UNKNOWN_OPERATION"),
		FieldList: []types.ValidationExceptionField{
			{
				Name:    ptr.String("__Name__"),
				Message: ptr.String("__Message__"),
			},
			{
				Name:    ptr.String("__Name__"),
				Message: ptr.String("__Message__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ValidationException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.CreateAlertManagerDefinition(context.Background(), &CreateAlertManagerDefinitionInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ValidationException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ValidationException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ValidationException.error", err)
	}
}
