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

//go:build response_snapshot

package cloudformation

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

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

func TestCheckResponseSnapshot_BatchDescribeTypeConfigurations(t *testing.T) {
	want := &BatchDescribeTypeConfigurationsOutput{
		Errors: []types.BatchDescribeTypeConfigurationsError{
			{
				ErrorCode:    ptr.String("__ErrorCode__"),
				ErrorMessage: ptr.String("__ErrorMessage__"),
				TypeConfigurationIdentifier: &types.TypeConfigurationIdentifier{
					TypeArn:                ptr.String("__TypeArn__"),
					TypeConfigurationAlias: ptr.String("__TypeConfigurationAlias__"),
					TypeConfigurationArn:   ptr.String("__TypeConfigurationArn__"),
					Type:                   types.ThirdPartyType("RESOURCE"),
					TypeName:               ptr.String("__TypeName__"),
				},
			},
			{
				ErrorCode:    ptr.String("__ErrorCode__"),
				ErrorMessage: ptr.String("__ErrorMessage__"),
				TypeConfigurationIdentifier: &types.TypeConfigurationIdentifier{
					TypeArn:                ptr.String("__TypeArn__"),
					TypeConfigurationAlias: ptr.String("__TypeConfigurationAlias__"),
					TypeConfigurationArn:   ptr.String("__TypeConfigurationArn__"),
					Type:                   types.ThirdPartyType("RESOURCE"),
					TypeName:               ptr.String("__TypeName__"),
				},
			},
		},
		UnprocessedTypeConfigurations: []types.TypeConfigurationIdentifier{
			{
				TypeArn:                ptr.String("__TypeArn__"),
				TypeConfigurationAlias: ptr.String("__TypeConfigurationAlias__"),
				TypeConfigurationArn:   ptr.String("__TypeConfigurationArn__"),
				Type:                   types.ThirdPartyType("RESOURCE"),
				TypeName:               ptr.String("__TypeName__"),
			},
			{
				TypeArn:                ptr.String("__TypeArn__"),
				TypeConfigurationAlias: ptr.String("__TypeConfigurationAlias__"),
				TypeConfigurationArn:   ptr.String("__TypeConfigurationArn__"),
				Type:                   types.ThirdPartyType("RESOURCE"),
				TypeName:               ptr.String("__TypeName__"),
			},
		},
		TypeConfigurations: []types.TypeConfigurationDetails{
			{
				Arn:                    ptr.String("__Arn__"),
				Alias:                  ptr.String("__Alias__"),
				Configuration:          ptr.String("__Configuration__"),
				LastUpdated:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				TypeArn:                ptr.String("__TypeArn__"),
				TypeName:               ptr.String("__TypeName__"),
				IsDefaultConfiguration: ptr.Bool(true),
			},
			{
				Arn:                    ptr.String("__Arn__"),
				Alias:                  ptr.String("__Alias__"),
				Configuration:          ptr.String("__Configuration__"),
				LastUpdated:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				TypeArn:                ptr.String("__TypeArn__"),
				TypeName:               ptr.String("__TypeName__"),
				IsDefaultConfiguration: ptr.Bool(true),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("BatchDescribeTypeConfigurations.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.BatchDescribeTypeConfigurations(context.Background(), &BatchDescribeTypeConfigurationsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "BatchDescribeTypeConfigurations.response", err)
	}
}

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

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

func TestCheckResponseSnapshot_CreateChangeSet(t *testing.T) {
	want := &CreateChangeSetOutput{
		Id:      ptr.String("__Id__"),
		StackId: ptr.String("__StackId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateChangeSet.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateChangeSet(context.Background(), &CreateChangeSetInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateChangeSet.response", err)
	}
}

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

func TestCheckResponseSnapshot_CreateStack(t *testing.T) {
	want := &CreateStackOutput{
		StackId:     ptr.String("__StackId__"),
		OperationId: ptr.String("__OperationId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateStack.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateStack(context.Background(), &CreateStackInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateStack.response", err)
	}
}

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

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

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

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

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

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

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

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

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

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

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

func TestCheckResponseSnapshot_DescribeAccountLimits(t *testing.T) {
	want := &DescribeAccountLimitsOutput{
		AccountLimits: []types.AccountLimit{
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.Int32(1),
			},
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.Int32(1),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeAccountLimits.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeAccountLimits(context.Background(), &DescribeAccountLimitsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeAccountLimits.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeChangeSet(t *testing.T) {
	want := &DescribeChangeSetOutput{
		ChangeSetName: ptr.String("__ChangeSetName__"),
		ChangeSetId:   ptr.String("__ChangeSetId__"),
		StackId:       ptr.String("__StackId__"),
		StackName:     ptr.String("__StackName__"),
		Description:   ptr.String("__Description__"),
		Parameters: []types.Parameter{
			{
				ParameterKey:     ptr.String("__ParameterKey__"),
				ParameterValue:   ptr.String("__ParameterValue__"),
				UsePreviousValue: ptr.Bool(true),
				ResolvedValue:    ptr.String("__ResolvedValue__"),
			},
			{
				ParameterKey:     ptr.String("__ParameterKey__"),
				ParameterValue:   ptr.String("__ParameterValue__"),
				UsePreviousValue: ptr.Bool(true),
				ResolvedValue:    ptr.String("__ResolvedValue__"),
			},
		},
		CreationTime:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ExecutionStatus:  types.ExecutionStatus("UNAVAILABLE"),
		Status:           types.ChangeSetStatus("CREATE_PENDING"),
		StatusReason:     ptr.String("__StatusReason__"),
		StackDriftStatus: types.StackDriftStatus("DRIFTED"),
		NotificationARNs: []string{
			"__Member__",
			"__Member__",
		},
		RollbackConfiguration: &types.RollbackConfiguration{
			RollbackTriggers: []types.RollbackTrigger{
				{
					Arn:  ptr.String("__Arn__"),
					Type: ptr.String("__Type__"),
				},
				{
					Arn:  ptr.String("__Arn__"),
					Type: ptr.String("__Type__"),
				},
			},
			MonitoringTimeInMinutes: ptr.Int32(1),
		},
		Capabilities: []types.Capability{
			types.Capability("CAPABILITY_IAM"),
			types.Capability("CAPABILITY_IAM"),
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		Changes: []types.Change{
			{
				Type:                types.ChangeType("Resource"),
				HookInvocationCount: ptr.Int32(1),
				ResourceChange: &types.ResourceChange{
					PolicyAction:       types.PolicyAction("Delete"),
					Action:             types.ChangeAction("Add"),
					LogicalResourceId:  ptr.String("__LogicalResourceId__"),
					PhysicalResourceId: ptr.String("__PhysicalResourceId__"),
					ResourceType:       ptr.String("__ResourceType__"),
					Replacement:        types.Replacement("True"),
					Scope: []types.ResourceAttribute{
						types.ResourceAttribute("Properties"),
						types.ResourceAttribute("Properties"),
					},
					ResourceDriftStatus: types.StackResourceDriftStatus("IN_SYNC"),
					ResourceDriftIgnoredAttributes: []types.ResourceDriftIgnoredAttribute{
						{
							Path:   ptr.String("__Path__"),
							Reason: types.DriftIgnoredReason("MANAGED_BY_AWS"),
						},
						{
							Path:   ptr.String("__Path__"),
							Reason: types.DriftIgnoredReason("MANAGED_BY_AWS"),
						},
					},
					Details: []types.ResourceChangeDetail{
						{
							Target: &types.ResourceTargetDefinition{
								Attribute:          types.ResourceAttribute("Properties"),
								Name:               ptr.String("__Name__"),
								RequiresRecreation: types.RequiresRecreation("Never"),
								Path:               ptr.String("__Path__"),
								BeforeValue:        ptr.String("__BeforeValue__"),
								AfterValue:         ptr.String("__AfterValue__"),
								BeforeValueFrom:    types.BeforeValueFrom("PREVIOUS_DEPLOYMENT_STATE"),
								AfterValueFrom:     types.AfterValueFrom("TEMPLATE"),
								Drift: &types.LiveResourceDrift{
									PreviousValue:           ptr.String("__PreviousValue__"),
									ActualValue:             ptr.String("__ActualValue__"),
									DriftDetectionTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
								},
								AttributeChangeType: types.AttributeChangeType("Add"),
							},
							Evaluation:    types.EvaluationType("Static"),
							ChangeSource:  types.ChangeSource("ResourceReference"),
							CausingEntity: ptr.String("__CausingEntity__"),
						},
						{
							Target: &types.ResourceTargetDefinition{
								Attribute:          types.ResourceAttribute("Properties"),
								Name:               ptr.String("__Name__"),
								RequiresRecreation: types.RequiresRecreation("Never"),
								Path:               ptr.String("__Path__"),
								BeforeValue:        ptr.String("__BeforeValue__"),
								AfterValue:         ptr.String("__AfterValue__"),
								BeforeValueFrom:    types.BeforeValueFrom("PREVIOUS_DEPLOYMENT_STATE"),
								AfterValueFrom:     types.AfterValueFrom("TEMPLATE"),
								Drift: &types.LiveResourceDrift{
									PreviousValue:           ptr.String("__PreviousValue__"),
									ActualValue:             ptr.String("__ActualValue__"),
									DriftDetectionTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
								},
								AttributeChangeType: types.AttributeChangeType("Add"),
							},
							Evaluation:    types.EvaluationType("Static"),
							ChangeSource:  types.ChangeSource("ResourceReference"),
							CausingEntity: ptr.String("__CausingEntity__"),
						},
					},
					ChangeSetId: ptr.String("__ChangeSetId__"),
					ModuleInfo: &types.ModuleInfo{
						TypeHierarchy:      ptr.String("__TypeHierarchy__"),
						LogicalIdHierarchy: ptr.String("__LogicalIdHierarchy__"),
					},
					BeforeContext:             ptr.String("__BeforeContext__"),
					AfterContext:              ptr.String("__AfterContext__"),
					PreviousDeploymentContext: ptr.String("__PreviousDeploymentContext__"),
				},
			},
			{
				Type:                types.ChangeType("Resource"),
				HookInvocationCount: ptr.Int32(1),
				ResourceChange: &types.ResourceChange{
					PolicyAction:       types.PolicyAction("Delete"),
					Action:             types.ChangeAction("Add"),
					LogicalResourceId:  ptr.String("__LogicalResourceId__"),
					PhysicalResourceId: ptr.String("__PhysicalResourceId__"),
					ResourceType:       ptr.String("__ResourceType__"),
					Replacement:        types.Replacement("True"),
					Scope: []types.ResourceAttribute{
						types.ResourceAttribute("Properties"),
						types.ResourceAttribute("Properties"),
					},
					ResourceDriftStatus: types.StackResourceDriftStatus("IN_SYNC"),
					ResourceDriftIgnoredAttributes: []types.ResourceDriftIgnoredAttribute{
						{
							Path:   ptr.String("__Path__"),
							Reason: types.DriftIgnoredReason("MANAGED_BY_AWS"),
						},
						{
							Path:   ptr.String("__Path__"),
							Reason: types.DriftIgnoredReason("MANAGED_BY_AWS"),
						},
					},
					Details: []types.ResourceChangeDetail{
						{
							Target: &types.ResourceTargetDefinition{
								Attribute:          types.ResourceAttribute("Properties"),
								Name:               ptr.String("__Name__"),
								RequiresRecreation: types.RequiresRecreation("Never"),
								Path:               ptr.String("__Path__"),
								BeforeValue:        ptr.String("__BeforeValue__"),
								AfterValue:         ptr.String("__AfterValue__"),
								BeforeValueFrom:    types.BeforeValueFrom("PREVIOUS_DEPLOYMENT_STATE"),
								AfterValueFrom:     types.AfterValueFrom("TEMPLATE"),
								Drift: &types.LiveResourceDrift{
									PreviousValue:           ptr.String("__PreviousValue__"),
									ActualValue:             ptr.String("__ActualValue__"),
									DriftDetectionTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
								},
								AttributeChangeType: types.AttributeChangeType("Add"),
							},
							Evaluation:    types.EvaluationType("Static"),
							ChangeSource:  types.ChangeSource("ResourceReference"),
							CausingEntity: ptr.String("__CausingEntity__"),
						},
						{
							Target: &types.ResourceTargetDefinition{
								Attribute:          types.ResourceAttribute("Properties"),
								Name:               ptr.String("__Name__"),
								RequiresRecreation: types.RequiresRecreation("Never"),
								Path:               ptr.String("__Path__"),
								BeforeValue:        ptr.String("__BeforeValue__"),
								AfterValue:         ptr.String("__AfterValue__"),
								BeforeValueFrom:    types.BeforeValueFrom("PREVIOUS_DEPLOYMENT_STATE"),
								AfterValueFrom:     types.AfterValueFrom("TEMPLATE"),
								Drift: &types.LiveResourceDrift{
									PreviousValue:           ptr.String("__PreviousValue__"),
									ActualValue:             ptr.String("__ActualValue__"),
									DriftDetectionTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
								},
								AttributeChangeType: types.AttributeChangeType("Add"),
							},
							Evaluation:    types.EvaluationType("Static"),
							ChangeSource:  types.ChangeSource("ResourceReference"),
							CausingEntity: ptr.String("__CausingEntity__"),
						},
					},
					ChangeSetId: ptr.String("__ChangeSetId__"),
					ModuleInfo: &types.ModuleInfo{
						TypeHierarchy:      ptr.String("__TypeHierarchy__"),
						LogicalIdHierarchy: ptr.String("__LogicalIdHierarchy__"),
					},
					BeforeContext:             ptr.String("__BeforeContext__"),
					AfterContext:              ptr.String("__AfterContext__"),
					PreviousDeploymentContext: ptr.String("__PreviousDeploymentContext__"),
				},
			},
		},
		NextToken:               ptr.String("__NextToken__"),
		IncludeNestedStacks:     ptr.Bool(true),
		ParentChangeSetId:       ptr.String("__ParentChangeSetId__"),
		RootChangeSetId:         ptr.String("__RootChangeSetId__"),
		OnStackFailure:          types.OnStackFailure("DO_NOTHING"),
		ImportExistingResources: ptr.Bool(true),
		DeploymentMode:          types.DeploymentMode("REVERT_DRIFT"),
		DeploymentConfig: &types.DeploymentConfig{
			Mode:            types.DeploymentConfigMode("STANDARD"),
			DisableRollback: ptr.Bool(true),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeChangeSet.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeChangeSet(context.Background(), &DescribeChangeSetInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeChangeSet.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeChangeSetHooks(t *testing.T) {
	want := &DescribeChangeSetHooksOutput{
		ChangeSetId:   ptr.String("__ChangeSetId__"),
		ChangeSetName: ptr.String("__ChangeSetName__"),
		Hooks: []types.ChangeSetHook{
			{
				InvocationPoint:            types.HookInvocationPoint("PRE_PROVISION"),
				FailureMode:                types.HookFailureMode("FAIL"),
				TypeName:                   ptr.String("__TypeName__"),
				TypeVersionId:              ptr.String("__TypeVersionId__"),
				TypeConfigurationVersionId: ptr.String("__TypeConfigurationVersionId__"),
				TargetDetails: &types.ChangeSetHookTargetDetails{
					TargetType: types.HookTargetType("RESOURCE"),
					ResourceTargetDetails: &types.ChangeSetHookResourceTargetDetails{
						LogicalResourceId: ptr.String("__LogicalResourceId__"),
						ResourceType:      ptr.String("__ResourceType__"),
						ResourceAction:    types.ChangeAction("Add"),
					},
				},
			},
			{
				InvocationPoint:            types.HookInvocationPoint("PRE_PROVISION"),
				FailureMode:                types.HookFailureMode("FAIL"),
				TypeName:                   ptr.String("__TypeName__"),
				TypeVersionId:              ptr.String("__TypeVersionId__"),
				TypeConfigurationVersionId: ptr.String("__TypeConfigurationVersionId__"),
				TargetDetails: &types.ChangeSetHookTargetDetails{
					TargetType: types.HookTargetType("RESOURCE"),
					ResourceTargetDetails: &types.ChangeSetHookResourceTargetDetails{
						LogicalResourceId: ptr.String("__LogicalResourceId__"),
						ResourceType:      ptr.String("__ResourceType__"),
						ResourceAction:    types.ChangeAction("Add"),
					},
				},
			},
		},
		Status:    types.ChangeSetHooksStatus("PLANNING"),
		NextToken: ptr.String("__NextToken__"),
		StackId:   ptr.String("__StackId__"),
		StackName: ptr.String("__StackName__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeChangeSetHooks.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeChangeSetHooks(context.Background(), &DescribeChangeSetHooksInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeChangeSetHooks.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeEvents(t *testing.T) {
	want := &DescribeEventsOutput{
		OperationEvents: []types.OperationEvent{
			{
				EventId:                ptr.String("__EventId__"),
				StackId:                ptr.String("__StackId__"),
				OperationId:            ptr.String("__OperationId__"),
				OperationType:          types.OperationType("CREATE_STACK"),
				OperationStatus:        types.BeaconStackOperationStatus("IN_PROGRESS"),
				EventType:              types.EventType("STACK_EVENT"),
				LogicalResourceId:      ptr.String("__LogicalResourceId__"),
				PhysicalResourceId:     ptr.String("__PhysicalResourceId__"),
				ResourceType:           ptr.String("__ResourceType__"),
				Timestamp:              ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				StartTime:              ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				EndTime:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ResourceStatus:         types.ResourceStatus("CREATE_IN_PROGRESS"),
				ResourceStatusReason:   ptr.String("__ResourceStatusReason__"),
				ResourceProperties:     ptr.String("__ResourceProperties__"),
				ClientRequestToken:     ptr.String("__ClientRequestToken__"),
				HookType:               ptr.String("__HookType__"),
				HookStatus:             types.HookStatus("HOOK_IN_PROGRESS"),
				HookStatusReason:       ptr.String("__HookStatusReason__"),
				HookInvocationPoint:    types.HookInvocationPoint("PRE_PROVISION"),
				HookFailureMode:        types.HookFailureMode("FAIL"),
				DetailedStatus:         types.DetailedStatus("CONFIGURATION_COMPLETE"),
				ValidationFailureMode:  types.HookFailureMode("FAIL"),
				ValidationName:         ptr.String("__ValidationName__"),
				ValidationStatus:       types.ValidationStatus("FAILED"),
				ValidationStatusReason: ptr.String("__ValidationStatusReason__"),
				ValidationPath:         ptr.String("__ValidationPath__"),
			},
			{
				EventId:                ptr.String("__EventId__"),
				StackId:                ptr.String("__StackId__"),
				OperationId:            ptr.String("__OperationId__"),
				OperationType:          types.OperationType("CREATE_STACK"),
				OperationStatus:        types.BeaconStackOperationStatus("IN_PROGRESS"),
				EventType:              types.EventType("STACK_EVENT"),
				LogicalResourceId:      ptr.String("__LogicalResourceId__"),
				PhysicalResourceId:     ptr.String("__PhysicalResourceId__"),
				ResourceType:           ptr.String("__ResourceType__"),
				Timestamp:              ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				StartTime:              ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				EndTime:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ResourceStatus:         types.ResourceStatus("CREATE_IN_PROGRESS"),
				ResourceStatusReason:   ptr.String("__ResourceStatusReason__"),
				ResourceProperties:     ptr.String("__ResourceProperties__"),
				ClientRequestToken:     ptr.String("__ClientRequestToken__"),
				HookType:               ptr.String("__HookType__"),
				HookStatus:             types.HookStatus("HOOK_IN_PROGRESS"),
				HookStatusReason:       ptr.String("__HookStatusReason__"),
				HookInvocationPoint:    types.HookInvocationPoint("PRE_PROVISION"),
				HookFailureMode:        types.HookFailureMode("FAIL"),
				DetailedStatus:         types.DetailedStatus("CONFIGURATION_COMPLETE"),
				ValidationFailureMode:  types.HookFailureMode("FAIL"),
				ValidationName:         ptr.String("__ValidationName__"),
				ValidationStatus:       types.ValidationStatus("FAILED"),
				ValidationStatusReason: ptr.String("__ValidationStatusReason__"),
				ValidationPath:         ptr.String("__ValidationPath__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeEvents.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeEvents(context.Background(), &DescribeEventsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeEvents.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeGeneratedTemplate(t *testing.T) {
	want := &DescribeGeneratedTemplateOutput{
		GeneratedTemplateId:   ptr.String("__GeneratedTemplateId__"),
		GeneratedTemplateName: ptr.String("__GeneratedTemplateName__"),
		Resources: []types.ResourceDetail{
			{
				ResourceType:      ptr.String("__ResourceType__"),
				LogicalResourceId: ptr.String("__LogicalResourceId__"),
				ResourceIdentifier: map[string]string{
					"key0": "__Value__",
				},
				ResourceStatus:       types.GeneratedTemplateResourceStatus("PENDING"),
				ResourceStatusReason: ptr.String("__ResourceStatusReason__"),
				Warnings: []types.WarningDetail{
					{
						Type: types.WarningType("MUTUALLY_EXCLUSIVE_PROPERTIES"),
						Properties: []types.WarningProperty{
							{
								PropertyPath: ptr.String("__PropertyPath__"),
								Required:     ptr.Bool(true),
								Description:  ptr.String("__Description__"),
							},
							{
								PropertyPath: ptr.String("__PropertyPath__"),
								Required:     ptr.Bool(true),
								Description:  ptr.String("__Description__"),
							},
						},
					},
					{
						Type: types.WarningType("MUTUALLY_EXCLUSIVE_PROPERTIES"),
						Properties: []types.WarningProperty{
							{
								PropertyPath: ptr.String("__PropertyPath__"),
								Required:     ptr.Bool(true),
								Description:  ptr.String("__Description__"),
							},
							{
								PropertyPath: ptr.String("__PropertyPath__"),
								Required:     ptr.Bool(true),
								Description:  ptr.String("__Description__"),
							},
						},
					},
				},
			},
			{
				ResourceType:      ptr.String("__ResourceType__"),
				LogicalResourceId: ptr.String("__LogicalResourceId__"),
				ResourceIdentifier: map[string]string{
					"key0": "__Value__",
				},
				ResourceStatus:       types.GeneratedTemplateResourceStatus("PENDING"),
				ResourceStatusReason: ptr.String("__ResourceStatusReason__"),
				Warnings: []types.WarningDetail{
					{
						Type: types.WarningType("MUTUALLY_EXCLUSIVE_PROPERTIES"),
						Properties: []types.WarningProperty{
							{
								PropertyPath: ptr.String("__PropertyPath__"),
								Required:     ptr.Bool(true),
								Description:  ptr.String("__Description__"),
							},
							{
								PropertyPath: ptr.String("__PropertyPath__"),
								Required:     ptr.Bool(true),
								Description:  ptr.String("__Description__"),
							},
						},
					},
					{
						Type: types.WarningType("MUTUALLY_EXCLUSIVE_PROPERTIES"),
						Properties: []types.WarningProperty{
							{
								PropertyPath: ptr.String("__PropertyPath__"),
								Required:     ptr.Bool(true),
								Description:  ptr.String("__Description__"),
							},
							{
								PropertyPath: ptr.String("__PropertyPath__"),
								Required:     ptr.Bool(true),
								Description:  ptr.String("__Description__"),
							},
						},
					},
				},
			},
		},
		Status:          types.GeneratedTemplateStatus("CREATE_PENDING"),
		StatusReason:    ptr.String("__StatusReason__"),
		CreationTime:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		LastUpdatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		Progress: &types.TemplateProgress{
			ResourcesSucceeded:  ptr.Int32(1),
			ResourcesFailed:     ptr.Int32(1),
			ResourcesProcessing: ptr.Int32(1),
			ResourcesPending:    ptr.Int32(1),
		},
		StackId: ptr.String("__StackId__"),
		TemplateConfiguration: &types.TemplateConfiguration{
			DeletionPolicy:      types.GeneratedTemplateDeletionPolicy("DELETE"),
			UpdateReplacePolicy: types.GeneratedTemplateUpdateReplacePolicy("DELETE"),
		},
		TotalWarnings: ptr.Int32(1),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeGeneratedTemplate.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeGeneratedTemplate(context.Background(), &DescribeGeneratedTemplateInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeGeneratedTemplate.response", err)
	}
}

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

func TestCheckResponseSnapshot_DescribePublisher(t *testing.T) {
	want := &DescribePublisherOutput{
		PublisherId:      ptr.String("__PublisherId__"),
		PublisherStatus:  types.PublisherStatus("VERIFIED"),
		IdentityProvider: types.IdentityProvider("AWS_Marketplace"),
		PublisherProfile: ptr.String("__PublisherProfile__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribePublisher.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribePublisher(context.Background(), &DescribePublisherInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribePublisher.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeResourceScan(t *testing.T) {
	want := &DescribeResourceScanOutput{
		ResourceScanId:      ptr.String("__ResourceScanId__"),
		Status:              types.ResourceScanStatus("IN_PROGRESS"),
		StatusReason:        ptr.String("__StatusReason__"),
		StartTime:           ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		EndTime:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		PercentageCompleted: ptr.Float64(1.0),
		ResourceTypes: []string{
			"__Member__",
			"__Member__",
		},
		ResourcesScanned: ptr.Int32(1),
		ResourcesRead:    ptr.Int32(1),
		ScanFilters: []types.ScanFilter{
			{
				Types: []string{
					"__Member__",
					"__Member__",
				},
			},
			{
				Types: []string{
					"__Member__",
					"__Member__",
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeResourceScan.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeResourceScan(context.Background(), &DescribeResourceScanInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeResourceScan.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeStackDriftDetectionStatus(t *testing.T) {
	want := &DescribeStackDriftDetectionStatusOutput{
		StackId:                   ptr.String("__StackId__"),
		StackDriftDetectionId:     ptr.String("__StackDriftDetectionId__"),
		StackDriftStatus:          types.StackDriftStatus("DRIFTED"),
		DetectionStatus:           types.StackDriftDetectionStatus("DETECTION_IN_PROGRESS"),
		DetectionStatusReason:     ptr.String("__DetectionStatusReason__"),
		DriftedStackResourceCount: ptr.Int32(1),
		Timestamp:                 ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeStackDriftDetectionStatus.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeStackDriftDetectionStatus(context.Background(), &DescribeStackDriftDetectionStatusInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeStackDriftDetectionStatus.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeStackEvents(t *testing.T) {
	want := &DescribeStackEventsOutput{
		StackEvents: []types.StackEvent{
			{
				StackId:              ptr.String("__StackId__"),
				EventId:              ptr.String("__EventId__"),
				StackName:            ptr.String("__StackName__"),
				OperationId:          ptr.String("__OperationId__"),
				LogicalResourceId:    ptr.String("__LogicalResourceId__"),
				PhysicalResourceId:   ptr.String("__PhysicalResourceId__"),
				ResourceType:         ptr.String("__ResourceType__"),
				Timestamp:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ResourceStatus:       types.ResourceStatus("CREATE_IN_PROGRESS"),
				ResourceStatusReason: ptr.String("__ResourceStatusReason__"),
				ResourceProperties:   ptr.String("__ResourceProperties__"),
				ClientRequestToken:   ptr.String("__ClientRequestToken__"),
				HookType:             ptr.String("__HookType__"),
				HookStatus:           types.HookStatus("HOOK_IN_PROGRESS"),
				HookStatusReason:     ptr.String("__HookStatusReason__"),
				HookInvocationPoint:  types.HookInvocationPoint("PRE_PROVISION"),
				HookInvocationId:     ptr.String("__HookInvocationId__"),
				HookFailureMode:      types.HookFailureMode("FAIL"),
				DetailedStatus:       types.DetailedStatus("CONFIGURATION_COMPLETE"),
			},
			{
				StackId:              ptr.String("__StackId__"),
				EventId:              ptr.String("__EventId__"),
				StackName:            ptr.String("__StackName__"),
				OperationId:          ptr.String("__OperationId__"),
				LogicalResourceId:    ptr.String("__LogicalResourceId__"),
				PhysicalResourceId:   ptr.String("__PhysicalResourceId__"),
				ResourceType:         ptr.String("__ResourceType__"),
				Timestamp:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ResourceStatus:       types.ResourceStatus("CREATE_IN_PROGRESS"),
				ResourceStatusReason: ptr.String("__ResourceStatusReason__"),
				ResourceProperties:   ptr.String("__ResourceProperties__"),
				ClientRequestToken:   ptr.String("__ClientRequestToken__"),
				HookType:             ptr.String("__HookType__"),
				HookStatus:           types.HookStatus("HOOK_IN_PROGRESS"),
				HookStatusReason:     ptr.String("__HookStatusReason__"),
				HookInvocationPoint:  types.HookInvocationPoint("PRE_PROVISION"),
				HookInvocationId:     ptr.String("__HookInvocationId__"),
				HookFailureMode:      types.HookFailureMode("FAIL"),
				DetailedStatus:       types.DetailedStatus("CONFIGURATION_COMPLETE"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeStackEvents.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeStackEvents(context.Background(), &DescribeStackEventsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeStackEvents.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeStackInstance(t *testing.T) {
	want := &DescribeStackInstanceOutput{
		StackInstance: &types.StackInstance{
			StackSetId: ptr.String("__StackSetId__"),
			Region:     ptr.String("__Region__"),
			Account:    ptr.String("__Account__"),
			StackId:    ptr.String("__StackId__"),
			ParameterOverrides: []types.Parameter{
				{
					ParameterKey:     ptr.String("__ParameterKey__"),
					ParameterValue:   ptr.String("__ParameterValue__"),
					UsePreviousValue: ptr.Bool(true),
					ResolvedValue:    ptr.String("__ResolvedValue__"),
				},
				{
					ParameterKey:     ptr.String("__ParameterKey__"),
					ParameterValue:   ptr.String("__ParameterValue__"),
					UsePreviousValue: ptr.Bool(true),
					ResolvedValue:    ptr.String("__ResolvedValue__"),
				},
			},
			Status: types.StackInstanceStatus("CURRENT"),
			StackInstanceStatus: &types.StackInstanceComprehensiveStatus{
				DetailedStatus: types.StackInstanceDetailedStatus("PENDING"),
			},
			StatusReason:            ptr.String("__StatusReason__"),
			OrganizationalUnitId:    ptr.String("__OrganizationalUnitId__"),
			DriftStatus:             types.StackDriftStatus("DRIFTED"),
			LastDriftCheckTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LastOperationId:         ptr.String("__LastOperationId__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeStackInstance.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeStackInstance(context.Background(), &DescribeStackInstanceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeStackInstance.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeStackRefactor(t *testing.T) {
	want := &DescribeStackRefactorOutput{
		Description:     ptr.String("__Description__"),
		StackRefactorId: ptr.String("__StackRefactorId__"),
		StackIds: []string{
			"__Member__",
			"__Member__",
		},
		ExecutionStatus:       types.StackRefactorExecutionStatus("UNAVAILABLE"),
		ExecutionStatusReason: ptr.String("__ExecutionStatusReason__"),
		Status:                types.StackRefactorStatus("CREATE_IN_PROGRESS"),
		StatusReason:          ptr.String("__StatusReason__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeStackRefactor.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeStackRefactor(context.Background(), &DescribeStackRefactorInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeStackRefactor.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeStackResource(t *testing.T) {
	want := &DescribeStackResourceOutput{
		StackResourceDetail: &types.StackResourceDetail{
			StackName:            ptr.String("__StackName__"),
			StackId:              ptr.String("__StackId__"),
			LogicalResourceId:    ptr.String("__LogicalResourceId__"),
			PhysicalResourceId:   ptr.String("__PhysicalResourceId__"),
			ResourceType:         ptr.String("__ResourceType__"),
			LastUpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			ResourceStatus:       types.ResourceStatus("CREATE_IN_PROGRESS"),
			ResourceStatusReason: ptr.String("__ResourceStatusReason__"),
			Description:          ptr.String("__Description__"),
			Metadata:             ptr.String("__Metadata__"),
			DriftInformation: &types.StackResourceDriftInformation{
				StackResourceDriftStatus: types.StackResourceDriftStatus("IN_SYNC"),
				LastCheckTimestamp:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			ModuleInfo: &types.ModuleInfo{
				TypeHierarchy:      ptr.String("__TypeHierarchy__"),
				LogicalIdHierarchy: ptr.String("__LogicalIdHierarchy__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeStackResource.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeStackResource(context.Background(), &DescribeStackResourceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeStackResource.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeStackResourceDrifts(t *testing.T) {
	want := &DescribeStackResourceDriftsOutput{
		StackResourceDrifts: []types.StackResourceDrift{
			{
				StackId:            ptr.String("__StackId__"),
				LogicalResourceId:  ptr.String("__LogicalResourceId__"),
				PhysicalResourceId: ptr.String("__PhysicalResourceId__"),
				PhysicalResourceIdContext: []types.PhysicalResourceIdContextKeyValuePair{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
				ResourceType:       ptr.String("__ResourceType__"),
				ExpectedProperties: ptr.String("__ExpectedProperties__"),
				ActualProperties:   ptr.String("__ActualProperties__"),
				PropertyDifferences: []types.PropertyDifference{
					{
						PropertyPath:   ptr.String("__PropertyPath__"),
						ExpectedValue:  ptr.String("__ExpectedValue__"),
						ActualValue:    ptr.String("__ActualValue__"),
						DifferenceType: types.DifferenceType("ADD"),
					},
					{
						PropertyPath:   ptr.String("__PropertyPath__"),
						ExpectedValue:  ptr.String("__ExpectedValue__"),
						ActualValue:    ptr.String("__ActualValue__"),
						DifferenceType: types.DifferenceType("ADD"),
					},
				},
				StackResourceDriftStatus: types.StackResourceDriftStatus("IN_SYNC"),
				Timestamp:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ModuleInfo: &types.ModuleInfo{
					TypeHierarchy:      ptr.String("__TypeHierarchy__"),
					LogicalIdHierarchy: ptr.String("__LogicalIdHierarchy__"),
				},
				DriftStatusReason: ptr.String("__DriftStatusReason__"),
			},
			{
				StackId:            ptr.String("__StackId__"),
				LogicalResourceId:  ptr.String("__LogicalResourceId__"),
				PhysicalResourceId: ptr.String("__PhysicalResourceId__"),
				PhysicalResourceIdContext: []types.PhysicalResourceIdContextKeyValuePair{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
				ResourceType:       ptr.String("__ResourceType__"),
				ExpectedProperties: ptr.String("__ExpectedProperties__"),
				ActualProperties:   ptr.String("__ActualProperties__"),
				PropertyDifferences: []types.PropertyDifference{
					{
						PropertyPath:   ptr.String("__PropertyPath__"),
						ExpectedValue:  ptr.String("__ExpectedValue__"),
						ActualValue:    ptr.String("__ActualValue__"),
						DifferenceType: types.DifferenceType("ADD"),
					},
					{
						PropertyPath:   ptr.String("__PropertyPath__"),
						ExpectedValue:  ptr.String("__ExpectedValue__"),
						ActualValue:    ptr.String("__ActualValue__"),
						DifferenceType: types.DifferenceType("ADD"),
					},
				},
				StackResourceDriftStatus: types.StackResourceDriftStatus("IN_SYNC"),
				Timestamp:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ModuleInfo: &types.ModuleInfo{
					TypeHierarchy:      ptr.String("__TypeHierarchy__"),
					LogicalIdHierarchy: ptr.String("__LogicalIdHierarchy__"),
				},
				DriftStatusReason: ptr.String("__DriftStatusReason__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeStackResourceDrifts.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeStackResourceDrifts(context.Background(), &DescribeStackResourceDriftsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeStackResourceDrifts.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeStackResources(t *testing.T) {
	want := &DescribeStackResourcesOutput{
		StackResources: []types.StackResource{
			{
				StackName:            ptr.String("__StackName__"),
				StackId:              ptr.String("__StackId__"),
				LogicalResourceId:    ptr.String("__LogicalResourceId__"),
				PhysicalResourceId:   ptr.String("__PhysicalResourceId__"),
				ResourceType:         ptr.String("__ResourceType__"),
				Timestamp:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ResourceStatus:       types.ResourceStatus("CREATE_IN_PROGRESS"),
				ResourceStatusReason: ptr.String("__ResourceStatusReason__"),
				Description:          ptr.String("__Description__"),
				DriftInformation: &types.StackResourceDriftInformation{
					StackResourceDriftStatus: types.StackResourceDriftStatus("IN_SYNC"),
					LastCheckTimestamp:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				ModuleInfo: &types.ModuleInfo{
					TypeHierarchy:      ptr.String("__TypeHierarchy__"),
					LogicalIdHierarchy: ptr.String("__LogicalIdHierarchy__"),
				},
			},
			{
				StackName:            ptr.String("__StackName__"),
				StackId:              ptr.String("__StackId__"),
				LogicalResourceId:    ptr.String("__LogicalResourceId__"),
				PhysicalResourceId:   ptr.String("__PhysicalResourceId__"),
				ResourceType:         ptr.String("__ResourceType__"),
				Timestamp:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ResourceStatus:       types.ResourceStatus("CREATE_IN_PROGRESS"),
				ResourceStatusReason: ptr.String("__ResourceStatusReason__"),
				Description:          ptr.String("__Description__"),
				DriftInformation: &types.StackResourceDriftInformation{
					StackResourceDriftStatus: types.StackResourceDriftStatus("IN_SYNC"),
					LastCheckTimestamp:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				ModuleInfo: &types.ModuleInfo{
					TypeHierarchy:      ptr.String("__TypeHierarchy__"),
					LogicalIdHierarchy: ptr.String("__LogicalIdHierarchy__"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeStackResources.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeStackResources(context.Background(), &DescribeStackResourcesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeStackResources.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeStackSet(t *testing.T) {
	want := &DescribeStackSetOutput{
		StackSet: &types.StackSet{
			StackSetName: ptr.String("__StackSetName__"),
			StackSetId:   ptr.String("__StackSetId__"),
			Description:  ptr.String("__Description__"),
			Status:       types.StackSetStatus("ACTIVE"),
			TemplateBody: ptr.String("__TemplateBody__"),
			Parameters: []types.Parameter{
				{
					ParameterKey:     ptr.String("__ParameterKey__"),
					ParameterValue:   ptr.String("__ParameterValue__"),
					UsePreviousValue: ptr.Bool(true),
					ResolvedValue:    ptr.String("__ResolvedValue__"),
				},
				{
					ParameterKey:     ptr.String("__ParameterKey__"),
					ParameterValue:   ptr.String("__ParameterValue__"),
					UsePreviousValue: ptr.Bool(true),
					ResolvedValue:    ptr.String("__ResolvedValue__"),
				},
			},
			Capabilities: []types.Capability{
				types.Capability("CAPABILITY_IAM"),
				types.Capability("CAPABILITY_IAM"),
			},
			Tags: []types.Tag{
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
			},
			StackSetARN:           ptr.String("__StackSetARN__"),
			AdministrationRoleARN: ptr.String("__AdministrationRoleARN__"),
			ExecutionRoleName:     ptr.String("__ExecutionRoleName__"),
			StackSetDriftDetectionDetails: &types.StackSetDriftDetectionDetails{
				DriftStatus:                   types.StackSetDriftStatus("DRIFTED"),
				DriftDetectionStatus:          types.StackSetDriftDetectionStatus("COMPLETED"),
				LastDriftCheckTimestamp:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				TotalStackInstancesCount:      ptr.Int32(1),
				DriftedStackInstancesCount:    ptr.Int32(1),
				InSyncStackInstancesCount:     ptr.Int32(1),
				InProgressStackInstancesCount: ptr.Int32(1),
				FailedStackInstancesCount:     ptr.Int32(1),
			},
			AutoDeployment: &types.AutoDeployment{
				Enabled:                      ptr.Bool(true),
				RetainStacksOnAccountRemoval: ptr.Bool(true),
				DependsOn: []string{
					"__Member__",
					"__Member__",
				},
			},
			PermissionModel: types.PermissionModels("SERVICE_MANAGED"),
			OrganizationalUnitIds: []string{
				"__Member__",
				"__Member__",
			},
			ManagedExecution: &types.ManagedExecution{
				Active: ptr.Bool(true),
			},
			Regions: []string{
				"__Member__",
				"__Member__",
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeStackSet.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeStackSet(context.Background(), &DescribeStackSetInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeStackSet.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeStackSetOperation(t *testing.T) {
	want := &DescribeStackSetOperationOutput{
		StackSetOperation: &types.StackSetOperation{
			OperationId: ptr.String("__OperationId__"),
			StackSetId:  ptr.String("__StackSetId__"),
			Action:      types.StackSetOperationAction("CREATE"),
			Status:      types.StackSetOperationStatus("RUNNING"),
			OperationPreferences: &types.StackSetOperationPreferences{
				RegionConcurrencyType: types.RegionConcurrencyType("SEQUENTIAL"),
				RegionOrder: []string{
					"__Member__",
					"__Member__",
				},
				FailureToleranceCount:      ptr.Int32(1),
				FailureTolerancePercentage: ptr.Int32(1),
				MaxConcurrentCount:         ptr.Int32(1),
				MaxConcurrentPercentage:    ptr.Int32(1),
				ConcurrencyMode:            types.ConcurrencyMode("STRICT_FAILURE_TOLERANCE"),
			},
			RetainStacks:          ptr.Bool(true),
			AdministrationRoleARN: ptr.String("__AdministrationRoleARN__"),
			ExecutionRoleName:     ptr.String("__ExecutionRoleName__"),
			CreationTimestamp:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			EndTimestamp:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			DeploymentTargets: &types.DeploymentTargets{
				Accounts: []string{
					"__Member__",
					"__Member__",
				},
				AccountsUrl: ptr.String("__AccountsUrl__"),
				OrganizationalUnitIds: []string{
					"__Member__",
					"__Member__",
				},
				AccountFilterType: types.AccountFilterType("NONE"),
			},
			StackSetDriftDetectionDetails: &types.StackSetDriftDetectionDetails{
				DriftStatus:                   types.StackSetDriftStatus("DRIFTED"),
				DriftDetectionStatus:          types.StackSetDriftDetectionStatus("COMPLETED"),
				LastDriftCheckTimestamp:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				TotalStackInstancesCount:      ptr.Int32(1),
				DriftedStackInstancesCount:    ptr.Int32(1),
				InSyncStackInstancesCount:     ptr.Int32(1),
				InProgressStackInstancesCount: ptr.Int32(1),
				FailedStackInstancesCount:     ptr.Int32(1),
			},
			StatusReason: ptr.String("__StatusReason__"),
			StatusDetails: &types.StackSetOperationStatusDetails{
				FailedStackInstancesCount: ptr.Int32(1),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeStackSetOperation.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeStackSetOperation(context.Background(), &DescribeStackSetOperationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeStackSetOperation.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeStacks(t *testing.T) {
	want := &DescribeStacksOutput{
		Stacks: []types.Stack{
			{
				StackId:     ptr.String("__StackId__"),
				StackName:   ptr.String("__StackName__"),
				ChangeSetId: ptr.String("__ChangeSetId__"),
				Description: ptr.String("__Description__"),
				Parameters: []types.Parameter{
					{
						ParameterKey:     ptr.String("__ParameterKey__"),
						ParameterValue:   ptr.String("__ParameterValue__"),
						UsePreviousValue: ptr.Bool(true),
						ResolvedValue:    ptr.String("__ResolvedValue__"),
					},
					{
						ParameterKey:     ptr.String("__ParameterKey__"),
						ParameterValue:   ptr.String("__ParameterValue__"),
						UsePreviousValue: ptr.Bool(true),
						ResolvedValue:    ptr.String("__ResolvedValue__"),
					},
				},
				CreationTime:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				DeletionTime:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastUpdatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				RollbackConfiguration: &types.RollbackConfiguration{
					RollbackTriggers: []types.RollbackTrigger{
						{
							Arn:  ptr.String("__Arn__"),
							Type: ptr.String("__Type__"),
						},
						{
							Arn:  ptr.String("__Arn__"),
							Type: ptr.String("__Type__"),
						},
					},
					MonitoringTimeInMinutes: ptr.Int32(1),
				},
				StackStatus:       types.StackStatus("CREATE_IN_PROGRESS"),
				StackStatusReason: ptr.String("__StackStatusReason__"),
				DisableRollback:   ptr.Bool(true),
				DeploymentConfig: &types.DeploymentConfig{
					Mode:            types.DeploymentConfigMode("STANDARD"),
					DisableRollback: ptr.Bool(true),
				},
				NotificationARNs: []string{
					"__Member__",
					"__Member__",
				},
				TimeoutInMinutes: ptr.Int32(1),
				Capabilities: []types.Capability{
					types.Capability("CAPABILITY_IAM"),
					types.Capability("CAPABILITY_IAM"),
				},
				Outputs: []types.Output{
					{
						OutputKey:   ptr.String("__OutputKey__"),
						OutputValue: ptr.String("__OutputValue__"),
						Description: ptr.String("__Description__"),
						ExportName:  ptr.String("__ExportName__"),
					},
					{
						OutputKey:   ptr.String("__OutputKey__"),
						OutputValue: ptr.String("__OutputValue__"),
						Description: ptr.String("__Description__"),
						ExportName:  ptr.String("__ExportName__"),
					},
				},
				RoleARN: ptr.String("__RoleARN__"),
				Tags: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
				EnableTerminationProtection: ptr.Bool(true),
				ParentId:                    ptr.String("__ParentId__"),
				RootId:                      ptr.String("__RootId__"),
				DriftInformation: &types.StackDriftInformation{
					StackDriftStatus:   types.StackDriftStatus("DRIFTED"),
					LastCheckTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				RetainExceptOnCreate: ptr.Bool(true),
				DeletionMode:         types.DeletionMode("STANDARD"),
				DetailedStatus:       types.DetailedStatus("CONFIGURATION_COMPLETE"),
				LastOperations: []types.OperationEntry{
					{
						OperationType: types.OperationType("CREATE_STACK"),
						OperationId:   ptr.String("__OperationId__"),
					},
					{
						OperationType: types.OperationType("CREATE_STACK"),
						OperationId:   ptr.String("__OperationId__"),
					},
				},
			},
			{
				StackId:     ptr.String("__StackId__"),
				StackName:   ptr.String("__StackName__"),
				ChangeSetId: ptr.String("__ChangeSetId__"),
				Description: ptr.String("__Description__"),
				Parameters: []types.Parameter{
					{
						ParameterKey:     ptr.String("__ParameterKey__"),
						ParameterValue:   ptr.String("__ParameterValue__"),
						UsePreviousValue: ptr.Bool(true),
						ResolvedValue:    ptr.String("__ResolvedValue__"),
					},
					{
						ParameterKey:     ptr.String("__ParameterKey__"),
						ParameterValue:   ptr.String("__ParameterValue__"),
						UsePreviousValue: ptr.Bool(true),
						ResolvedValue:    ptr.String("__ResolvedValue__"),
					},
				},
				CreationTime:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				DeletionTime:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastUpdatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				RollbackConfiguration: &types.RollbackConfiguration{
					RollbackTriggers: []types.RollbackTrigger{
						{
							Arn:  ptr.String("__Arn__"),
							Type: ptr.String("__Type__"),
						},
						{
							Arn:  ptr.String("__Arn__"),
							Type: ptr.String("__Type__"),
						},
					},
					MonitoringTimeInMinutes: ptr.Int32(1),
				},
				StackStatus:       types.StackStatus("CREATE_IN_PROGRESS"),
				StackStatusReason: ptr.String("__StackStatusReason__"),
				DisableRollback:   ptr.Bool(true),
				DeploymentConfig: &types.DeploymentConfig{
					Mode:            types.DeploymentConfigMode("STANDARD"),
					DisableRollback: ptr.Bool(true),
				},
				NotificationARNs: []string{
					"__Member__",
					"__Member__",
				},
				TimeoutInMinutes: ptr.Int32(1),
				Capabilities: []types.Capability{
					types.Capability("CAPABILITY_IAM"),
					types.Capability("CAPABILITY_IAM"),
				},
				Outputs: []types.Output{
					{
						OutputKey:   ptr.String("__OutputKey__"),
						OutputValue: ptr.String("__OutputValue__"),
						Description: ptr.String("__Description__"),
						ExportName:  ptr.String("__ExportName__"),
					},
					{
						OutputKey:   ptr.String("__OutputKey__"),
						OutputValue: ptr.String("__OutputValue__"),
						Description: ptr.String("__Description__"),
						ExportName:  ptr.String("__ExportName__"),
					},
				},
				RoleARN: ptr.String("__RoleARN__"),
				Tags: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
				EnableTerminationProtection: ptr.Bool(true),
				ParentId:                    ptr.String("__ParentId__"),
				RootId:                      ptr.String("__RootId__"),
				DriftInformation: &types.StackDriftInformation{
					StackDriftStatus:   types.StackDriftStatus("DRIFTED"),
					LastCheckTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				RetainExceptOnCreate: ptr.Bool(true),
				DeletionMode:         types.DeletionMode("STANDARD"),
				DetailedStatus:       types.DetailedStatus("CONFIGURATION_COMPLETE"),
				LastOperations: []types.OperationEntry{
					{
						OperationType: types.OperationType("CREATE_STACK"),
						OperationId:   ptr.String("__OperationId__"),
					},
					{
						OperationType: types.OperationType("CREATE_STACK"),
						OperationId:   ptr.String("__OperationId__"),
					},
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeStacks.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeStacks(context.Background(), &DescribeStacksInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeStacks.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeType(t *testing.T) {
	want := &DescribeTypeOutput{
		Arn:                        ptr.String("__Arn__"),
		Type:                       types.RegistryType("RESOURCE"),
		TypeName:                   ptr.String("__TypeName__"),
		DefaultVersionId:           ptr.String("__DefaultVersionId__"),
		IsDefaultVersion:           ptr.Bool(true),
		TypeTestsStatus:            types.TypeTestsStatus("PASSED"),
		TypeTestsStatusDescription: ptr.String("__TypeTestsStatusDescription__"),
		Description:                ptr.String("__Description__"),
		Schema:                     ptr.String("__Schema__"),
		ProvisioningType:           types.ProvisioningType("NON_PROVISIONABLE"),
		DeprecatedStatus:           types.DeprecatedStatus("LIVE"),
		LoggingConfig: &types.LoggingConfig{
			LogRoleArn:   ptr.String("__LogRoleArn__"),
			LogGroupName: ptr.String("__LogGroupName__"),
		},
		RequiredActivatedTypes: []types.RequiredActivatedType{
			{
				TypeNameAlias:    ptr.String("__TypeNameAlias__"),
				OriginalTypeName: ptr.String("__OriginalTypeName__"),
				PublisherId:      ptr.String("__PublisherId__"),
				SupportedMajorVersions: []int32{
					1,
					1,
				},
			},
			{
				TypeNameAlias:    ptr.String("__TypeNameAlias__"),
				OriginalTypeName: ptr.String("__OriginalTypeName__"),
				PublisherId:      ptr.String("__PublisherId__"),
				SupportedMajorVersions: []int32{
					1,
					1,
				},
			},
		},
		ExecutionRoleArn:    ptr.String("__ExecutionRoleArn__"),
		Visibility:          types.Visibility("PUBLIC"),
		SourceUrl:           ptr.String("__SourceUrl__"),
		DocumentationUrl:    ptr.String("__DocumentationUrl__"),
		LastUpdated:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		TimeCreated:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ConfigurationSchema: ptr.String("__ConfigurationSchema__"),
		PublisherId:         ptr.String("__PublisherId__"),
		OriginalTypeName:    ptr.String("__OriginalTypeName__"),
		OriginalTypeArn:     ptr.String("__OriginalTypeArn__"),
		PublicVersionNumber: ptr.String("__PublicVersionNumber__"),
		LatestPublicVersion: ptr.String("__LatestPublicVersion__"),
		IsActivated:         ptr.Bool(true),
		AutoUpdate:          ptr.Bool(true),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeType.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeType(context.Background(), &DescribeTypeInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeType.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeTypeRegistration(t *testing.T) {
	want := &DescribeTypeRegistrationOutput{
		ProgressStatus: types.RegistrationStatus("COMPLETE"),
		Description:    ptr.String("__Description__"),
		TypeArn:        ptr.String("__TypeArn__"),
		TypeVersionArn: ptr.String("__TypeVersionArn__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeTypeRegistration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeTypeRegistration(context.Background(), &DescribeTypeRegistrationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeTypeRegistration.response", err)
	}
}

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

func TestCheckResponseSnapshot_DetectStackResourceDrift(t *testing.T) {
	want := &DetectStackResourceDriftOutput{
		StackResourceDrift: &types.StackResourceDrift{
			StackId:            ptr.String("__StackId__"),
			LogicalResourceId:  ptr.String("__LogicalResourceId__"),
			PhysicalResourceId: ptr.String("__PhysicalResourceId__"),
			PhysicalResourceIdContext: []types.PhysicalResourceIdContextKeyValuePair{
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
			},
			ResourceType:       ptr.String("__ResourceType__"),
			ExpectedProperties: ptr.String("__ExpectedProperties__"),
			ActualProperties:   ptr.String("__ActualProperties__"),
			PropertyDifferences: []types.PropertyDifference{
				{
					PropertyPath:   ptr.String("__PropertyPath__"),
					ExpectedValue:  ptr.String("__ExpectedValue__"),
					ActualValue:    ptr.String("__ActualValue__"),
					DifferenceType: types.DifferenceType("ADD"),
				},
				{
					PropertyPath:   ptr.String("__PropertyPath__"),
					ExpectedValue:  ptr.String("__ExpectedValue__"),
					ActualValue:    ptr.String("__ActualValue__"),
					DifferenceType: types.DifferenceType("ADD"),
				},
			},
			StackResourceDriftStatus: types.StackResourceDriftStatus("IN_SYNC"),
			Timestamp:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			ModuleInfo: &types.ModuleInfo{
				TypeHierarchy:      ptr.String("__TypeHierarchy__"),
				LogicalIdHierarchy: ptr.String("__LogicalIdHierarchy__"),
			},
			DriftStatusReason: ptr.String("__DriftStatusReason__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DetectStackResourceDrift.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DetectStackResourceDrift(context.Background(), &DetectStackResourceDriftInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DetectStackResourceDrift.response", err)
	}
}

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

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

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

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

func TestCheckResponseSnapshot_GetGeneratedTemplate(t *testing.T) {
	want := &GetGeneratedTemplateOutput{
		Status:       types.GeneratedTemplateStatus("CREATE_PENDING"),
		TemplateBody: ptr.String("__TemplateBody__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetGeneratedTemplate.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetGeneratedTemplate(context.Background(), &GetGeneratedTemplateInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetGeneratedTemplate.response", err)
	}
}

func TestCheckResponseSnapshot_GetHookResult(t *testing.T) {
	want := &GetHookResultOutput{
		HookResultId:               ptr.String("__HookResultId__"),
		InvocationPoint:            types.HookInvocationPoint("PRE_PROVISION"),
		FailureMode:                types.HookFailureMode("FAIL"),
		TypeName:                   ptr.String("__TypeName__"),
		OriginalTypeName:           ptr.String("__OriginalTypeName__"),
		TypeVersionId:              ptr.String("__TypeVersionId__"),
		TypeConfigurationVersionId: ptr.String("__TypeConfigurationVersionId__"),
		TypeArn:                    ptr.String("__TypeArn__"),
		Status:                     types.HookStatus("HOOK_IN_PROGRESS"),
		HookStatusReason:           ptr.String("__HookStatusReason__"),
		InvokedAt:                  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		Target: &types.HookTarget{
			TargetType:     types.HookTargetType("RESOURCE"),
			TargetTypeName: ptr.String("__TargetTypeName__"),
			TargetId:       ptr.String("__TargetId__"),
			Action:         types.HookTargetAction("CREATE"),
		},
		Annotations: []types.Annotation{
			{
				AnnotationName:     ptr.String("__AnnotationName__"),
				Status:             types.AnnotationStatus("PASSED"),
				StatusMessage:      ptr.String("__StatusMessage__"),
				RemediationMessage: ptr.String("__RemediationMessage__"),
				RemediationLink:    ptr.String("__RemediationLink__"),
				SeverityLevel:      types.AnnotationSeverityLevel("INFORMATIONAL"),
			},
			{
				AnnotationName:     ptr.String("__AnnotationName__"),
				Status:             types.AnnotationStatus("PASSED"),
				StatusMessage:      ptr.String("__StatusMessage__"),
				RemediationMessage: ptr.String("__RemediationMessage__"),
				RemediationLink:    ptr.String("__RemediationLink__"),
				SeverityLevel:      types.AnnotationSeverityLevel("INFORMATIONAL"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetHookResult.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetHookResult(context.Background(), &GetHookResultInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetHookResult.response", err)
	}
}

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

func TestCheckResponseSnapshot_GetTemplate(t *testing.T) {
	want := &GetTemplateOutput{
		TemplateBody: ptr.String("__TemplateBody__"),
		StagesAvailable: []types.TemplateStage{
			types.TemplateStage("Original"),
			types.TemplateStage("Original"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetTemplate.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetTemplate(context.Background(), &GetTemplateInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetTemplate.response", err)
	}
}

func TestCheckResponseSnapshot_GetTemplateSummary(t *testing.T) {
	want := &GetTemplateSummaryOutput{
		Parameters: []types.ParameterDeclaration{
			{
				ParameterKey:  ptr.String("__ParameterKey__"),
				DefaultValue:  ptr.String("__DefaultValue__"),
				ParameterType: ptr.String("__ParameterType__"),
				NoEcho:        ptr.Bool(true),
				Description:   ptr.String("__Description__"),
				ParameterConstraints: &types.ParameterConstraints{
					AllowedValues: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
			{
				ParameterKey:  ptr.String("__ParameterKey__"),
				DefaultValue:  ptr.String("__DefaultValue__"),
				ParameterType: ptr.String("__ParameterType__"),
				NoEcho:        ptr.Bool(true),
				Description:   ptr.String("__Description__"),
				ParameterConstraints: &types.ParameterConstraints{
					AllowedValues: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
		},
		Description: ptr.String("__Description__"),
		Capabilities: []types.Capability{
			types.Capability("CAPABILITY_IAM"),
			types.Capability("CAPABILITY_IAM"),
		},
		CapabilitiesReason: ptr.String("__CapabilitiesReason__"),
		ResourceTypes: []string{
			"__Member__",
			"__Member__",
		},
		Version:  ptr.String("__Version__"),
		Metadata: ptr.String("__Metadata__"),
		DeclaredTransforms: []string{
			"__Member__",
			"__Member__",
		},
		ResourceIdentifierSummaries: []types.ResourceIdentifierSummary{
			{
				ResourceType: ptr.String("__ResourceType__"),
				LogicalResourceIds: []string{
					"__Member__",
					"__Member__",
				},
				ResourceIdentifiers: []string{
					"__Member__",
					"__Member__",
				},
			},
			{
				ResourceType: ptr.String("__ResourceType__"),
				LogicalResourceIds: []string{
					"__Member__",
					"__Member__",
				},
				ResourceIdentifiers: []string{
					"__Member__",
					"__Member__",
				},
			},
		},
		Warnings: &types.Warnings{
			UnrecognizedResourceTypes: []string{
				"__Member__",
				"__Member__",
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetTemplateSummary.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetTemplateSummary(context.Background(), &GetTemplateSummaryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetTemplateSummary.response", err)
	}
}

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

func TestCheckResponseSnapshot_ListChangeSets(t *testing.T) {
	want := &ListChangeSetsOutput{
		Summaries: []types.ChangeSetSummary{
			{
				StackId:                 ptr.String("__StackId__"),
				StackName:               ptr.String("__StackName__"),
				ChangeSetId:             ptr.String("__ChangeSetId__"),
				ChangeSetName:           ptr.String("__ChangeSetName__"),
				ExecutionStatus:         types.ExecutionStatus("UNAVAILABLE"),
				Status:                  types.ChangeSetStatus("CREATE_PENDING"),
				StatusReason:            ptr.String("__StatusReason__"),
				CreationTime:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Description:             ptr.String("__Description__"),
				IncludeNestedStacks:     ptr.Bool(true),
				ParentChangeSetId:       ptr.String("__ParentChangeSetId__"),
				RootChangeSetId:         ptr.String("__RootChangeSetId__"),
				ImportExistingResources: ptr.Bool(true),
			},
			{
				StackId:                 ptr.String("__StackId__"),
				StackName:               ptr.String("__StackName__"),
				ChangeSetId:             ptr.String("__ChangeSetId__"),
				ChangeSetName:           ptr.String("__ChangeSetName__"),
				ExecutionStatus:         types.ExecutionStatus("UNAVAILABLE"),
				Status:                  types.ChangeSetStatus("CREATE_PENDING"),
				StatusReason:            ptr.String("__StatusReason__"),
				CreationTime:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Description:             ptr.String("__Description__"),
				IncludeNestedStacks:     ptr.Bool(true),
				ParentChangeSetId:       ptr.String("__ParentChangeSetId__"),
				RootChangeSetId:         ptr.String("__RootChangeSetId__"),
				ImportExistingResources: ptr.Bool(true),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListChangeSets.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListChangeSets(context.Background(), &ListChangeSetsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListChangeSets.response", err)
	}
}

func TestCheckResponseSnapshot_ListExports(t *testing.T) {
	want := &ListExportsOutput{
		Exports: []types.Export{
			{
				ExportingStackId: ptr.String("__ExportingStackId__"),
				Name:             ptr.String("__Name__"),
				Value:            ptr.String("__Value__"),
			},
			{
				ExportingStackId: ptr.String("__ExportingStackId__"),
				Name:             ptr.String("__Name__"),
				Value:            ptr.String("__Value__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListExports.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListExports(context.Background(), &ListExportsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListExports.response", err)
	}
}

func TestCheckResponseSnapshot_ListGeneratedTemplates(t *testing.T) {
	want := &ListGeneratedTemplatesOutput{
		Summaries: []types.TemplateSummary{
			{
				GeneratedTemplateId:   ptr.String("__GeneratedTemplateId__"),
				GeneratedTemplateName: ptr.String("__GeneratedTemplateName__"),
				Status:                types.GeneratedTemplateStatus("CREATE_PENDING"),
				StatusReason:          ptr.String("__StatusReason__"),
				CreationTime:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastUpdatedTime:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				NumberOfResources:     ptr.Int32(1),
			},
			{
				GeneratedTemplateId:   ptr.String("__GeneratedTemplateId__"),
				GeneratedTemplateName: ptr.String("__GeneratedTemplateName__"),
				Status:                types.GeneratedTemplateStatus("CREATE_PENDING"),
				StatusReason:          ptr.String("__StatusReason__"),
				CreationTime:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastUpdatedTime:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				NumberOfResources:     ptr.Int32(1),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListGeneratedTemplates.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListGeneratedTemplates(context.Background(), &ListGeneratedTemplatesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListGeneratedTemplates.response", err)
	}
}

func TestCheckResponseSnapshot_ListHookResults(t *testing.T) {
	want := &ListHookResultsOutput{
		TargetType: types.ListHookResultsTargetType("CHANGE_SET"),
		TargetId:   ptr.String("__TargetId__"),
		HookResults: []types.HookResultSummary{
			{
				HookResultId:               ptr.String("__HookResultId__"),
				InvocationPoint:            types.HookInvocationPoint("PRE_PROVISION"),
				FailureMode:                types.HookFailureMode("FAIL"),
				TypeName:                   ptr.String("__TypeName__"),
				TypeVersionId:              ptr.String("__TypeVersionId__"),
				TypeConfigurationVersionId: ptr.String("__TypeConfigurationVersionId__"),
				Status:                     types.HookStatus("HOOK_IN_PROGRESS"),
				HookStatusReason:           ptr.String("__HookStatusReason__"),
				InvokedAt:                  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				TargetType:                 types.ListHookResultsTargetType("CHANGE_SET"),
				TargetId:                   ptr.String("__TargetId__"),
				TypeArn:                    ptr.String("__TypeArn__"),
				HookExecutionTarget:        ptr.String("__HookExecutionTarget__"),
			},
			{
				HookResultId:               ptr.String("__HookResultId__"),
				InvocationPoint:            types.HookInvocationPoint("PRE_PROVISION"),
				FailureMode:                types.HookFailureMode("FAIL"),
				TypeName:                   ptr.String("__TypeName__"),
				TypeVersionId:              ptr.String("__TypeVersionId__"),
				TypeConfigurationVersionId: ptr.String("__TypeConfigurationVersionId__"),
				Status:                     types.HookStatus("HOOK_IN_PROGRESS"),
				HookStatusReason:           ptr.String("__HookStatusReason__"),
				InvokedAt:                  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				TargetType:                 types.ListHookResultsTargetType("CHANGE_SET"),
				TargetId:                   ptr.String("__TargetId__"),
				TypeArn:                    ptr.String("__TypeArn__"),
				HookExecutionTarget:        ptr.String("__HookExecutionTarget__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListHookResults.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListHookResults(context.Background(), &ListHookResultsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListHookResults.response", err)
	}
}

func TestCheckResponseSnapshot_ListImports(t *testing.T) {
	want := &ListImportsOutput{
		Imports: []string{
			"__Member__",
			"__Member__",
		},
		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_ListResourceScanRelatedResources(t *testing.T) {
	want := &ListResourceScanRelatedResourcesOutput{
		RelatedResources: []types.ScannedResource{
			{
				ResourceType: ptr.String("__ResourceType__"),
				ResourceIdentifier: map[string]string{
					"key0": "__Value__",
				},
				ManagedByStack: ptr.Bool(true),
			},
			{
				ResourceType: ptr.String("__ResourceType__"),
				ResourceIdentifier: map[string]string{
					"key0": "__Value__",
				},
				ManagedByStack: ptr.Bool(true),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListResourceScanRelatedResources.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListResourceScanRelatedResources(context.Background(), &ListResourceScanRelatedResourcesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListResourceScanRelatedResources.response", err)
	}
}

func TestCheckResponseSnapshot_ListResourceScanResources(t *testing.T) {
	want := &ListResourceScanResourcesOutput{
		Resources: []types.ScannedResource{
			{
				ResourceType: ptr.String("__ResourceType__"),
				ResourceIdentifier: map[string]string{
					"key0": "__Value__",
				},
				ManagedByStack: ptr.Bool(true),
			},
			{
				ResourceType: ptr.String("__ResourceType__"),
				ResourceIdentifier: map[string]string{
					"key0": "__Value__",
				},
				ManagedByStack: ptr.Bool(true),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListResourceScanResources.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListResourceScanResources(context.Background(), &ListResourceScanResourcesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListResourceScanResources.response", err)
	}
}

func TestCheckResponseSnapshot_ListResourceScans(t *testing.T) {
	want := &ListResourceScansOutput{
		ResourceScanSummaries: []types.ResourceScanSummary{
			{
				ResourceScanId:      ptr.String("__ResourceScanId__"),
				Status:              types.ResourceScanStatus("IN_PROGRESS"),
				StatusReason:        ptr.String("__StatusReason__"),
				StartTime:           ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				EndTime:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PercentageCompleted: ptr.Float64(1.0),
				ScanType:            types.ScanType("FULL"),
			},
			{
				ResourceScanId:      ptr.String("__ResourceScanId__"),
				Status:              types.ResourceScanStatus("IN_PROGRESS"),
				StatusReason:        ptr.String("__StatusReason__"),
				StartTime:           ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				EndTime:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PercentageCompleted: ptr.Float64(1.0),
				ScanType:            types.ScanType("FULL"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListResourceScans.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListResourceScans(context.Background(), &ListResourceScansInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListResourceScans.response", err)
	}
}

func TestCheckResponseSnapshot_ListStackInstanceResourceDrifts(t *testing.T) {
	want := &ListStackInstanceResourceDriftsOutput{
		Summaries: []types.StackInstanceResourceDriftsSummary{
			{
				StackId:            ptr.String("__StackId__"),
				LogicalResourceId:  ptr.String("__LogicalResourceId__"),
				PhysicalResourceId: ptr.String("__PhysicalResourceId__"),
				PhysicalResourceIdContext: []types.PhysicalResourceIdContextKeyValuePair{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
				ResourceType: ptr.String("__ResourceType__"),
				PropertyDifferences: []types.PropertyDifference{
					{
						PropertyPath:   ptr.String("__PropertyPath__"),
						ExpectedValue:  ptr.String("__ExpectedValue__"),
						ActualValue:    ptr.String("__ActualValue__"),
						DifferenceType: types.DifferenceType("ADD"),
					},
					{
						PropertyPath:   ptr.String("__PropertyPath__"),
						ExpectedValue:  ptr.String("__ExpectedValue__"),
						ActualValue:    ptr.String("__ActualValue__"),
						DifferenceType: types.DifferenceType("ADD"),
					},
				},
				StackResourceDriftStatus: types.StackResourceDriftStatus("IN_SYNC"),
				Timestamp:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				StackId:            ptr.String("__StackId__"),
				LogicalResourceId:  ptr.String("__LogicalResourceId__"),
				PhysicalResourceId: ptr.String("__PhysicalResourceId__"),
				PhysicalResourceIdContext: []types.PhysicalResourceIdContextKeyValuePair{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
				ResourceType: ptr.String("__ResourceType__"),
				PropertyDifferences: []types.PropertyDifference{
					{
						PropertyPath:   ptr.String("__PropertyPath__"),
						ExpectedValue:  ptr.String("__ExpectedValue__"),
						ActualValue:    ptr.String("__ActualValue__"),
						DifferenceType: types.DifferenceType("ADD"),
					},
					{
						PropertyPath:   ptr.String("__PropertyPath__"),
						ExpectedValue:  ptr.String("__ExpectedValue__"),
						ActualValue:    ptr.String("__ActualValue__"),
						DifferenceType: types.DifferenceType("ADD"),
					},
				},
				StackResourceDriftStatus: types.StackResourceDriftStatus("IN_SYNC"),
				Timestamp:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListStackInstanceResourceDrifts.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListStackInstanceResourceDrifts(context.Background(), &ListStackInstanceResourceDriftsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListStackInstanceResourceDrifts.response", err)
	}
}

func TestCheckResponseSnapshot_ListStackInstances(t *testing.T) {
	want := &ListStackInstancesOutput{
		Summaries: []types.StackInstanceSummary{
			{
				StackSetId:   ptr.String("__StackSetId__"),
				Region:       ptr.String("__Region__"),
				Account:      ptr.String("__Account__"),
				StackId:      ptr.String("__StackId__"),
				Status:       types.StackInstanceStatus("CURRENT"),
				StatusReason: ptr.String("__StatusReason__"),
				StackInstanceStatus: &types.StackInstanceComprehensiveStatus{
					DetailedStatus: types.StackInstanceDetailedStatus("PENDING"),
				},
				OrganizationalUnitId:    ptr.String("__OrganizationalUnitId__"),
				DriftStatus:             types.StackDriftStatus("DRIFTED"),
				LastDriftCheckTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastOperationId:         ptr.String("__LastOperationId__"),
			},
			{
				StackSetId:   ptr.String("__StackSetId__"),
				Region:       ptr.String("__Region__"),
				Account:      ptr.String("__Account__"),
				StackId:      ptr.String("__StackId__"),
				Status:       types.StackInstanceStatus("CURRENT"),
				StatusReason: ptr.String("__StatusReason__"),
				StackInstanceStatus: &types.StackInstanceComprehensiveStatus{
					DetailedStatus: types.StackInstanceDetailedStatus("PENDING"),
				},
				OrganizationalUnitId:    ptr.String("__OrganizationalUnitId__"),
				DriftStatus:             types.StackDriftStatus("DRIFTED"),
				LastDriftCheckTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastOperationId:         ptr.String("__LastOperationId__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListStackInstances.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListStackInstances(context.Background(), &ListStackInstancesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListStackInstances.response", err)
	}
}

func TestCheckResponseSnapshot_ListStackRefactorActions(t *testing.T) {
	want := &ListStackRefactorActionsOutput{
		StackRefactorActions: []types.StackRefactorAction{
			{
				Action:             types.StackRefactorActionType("MOVE"),
				Entity:             types.StackRefactorActionEntity("RESOURCE"),
				PhysicalResourceId: ptr.String("__PhysicalResourceId__"),
				ResourceIdentifier: ptr.String("__ResourceIdentifier__"),
				Description:        ptr.String("__Description__"),
				Detection:          types.StackRefactorDetection("AUTO"),
				DetectionReason:    ptr.String("__DetectionReason__"),
				TagResources: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
				UntagResources: []string{
					"__Member__",
					"__Member__",
				},
				ResourceMapping: &types.ResourceMapping{
					Source: &types.ResourceLocation{
						StackName:         ptr.String("__StackName__"),
						LogicalResourceId: ptr.String("__LogicalResourceId__"),
					},
					Destination: &types.ResourceLocation{
						StackName:         ptr.String("__StackName__"),
						LogicalResourceId: ptr.String("__LogicalResourceId__"),
					},
				},
			},
			{
				Action:             types.StackRefactorActionType("MOVE"),
				Entity:             types.StackRefactorActionEntity("RESOURCE"),
				PhysicalResourceId: ptr.String("__PhysicalResourceId__"),
				ResourceIdentifier: ptr.String("__ResourceIdentifier__"),
				Description:        ptr.String("__Description__"),
				Detection:          types.StackRefactorDetection("AUTO"),
				DetectionReason:    ptr.String("__DetectionReason__"),
				TagResources: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
				UntagResources: []string{
					"__Member__",
					"__Member__",
				},
				ResourceMapping: &types.ResourceMapping{
					Source: &types.ResourceLocation{
						StackName:         ptr.String("__StackName__"),
						LogicalResourceId: ptr.String("__LogicalResourceId__"),
					},
					Destination: &types.ResourceLocation{
						StackName:         ptr.String("__StackName__"),
						LogicalResourceId: ptr.String("__LogicalResourceId__"),
					},
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListStackRefactorActions.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListStackRefactorActions(context.Background(), &ListStackRefactorActionsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListStackRefactorActions.response", err)
	}
}

func TestCheckResponseSnapshot_ListStackRefactors(t *testing.T) {
	want := &ListStackRefactorsOutput{
		StackRefactorSummaries: []types.StackRefactorSummary{
			{
				StackRefactorId:       ptr.String("__StackRefactorId__"),
				Description:           ptr.String("__Description__"),
				ExecutionStatus:       types.StackRefactorExecutionStatus("UNAVAILABLE"),
				ExecutionStatusReason: ptr.String("__ExecutionStatusReason__"),
				Status:                types.StackRefactorStatus("CREATE_IN_PROGRESS"),
				StatusReason:          ptr.String("__StatusReason__"),
			},
			{
				StackRefactorId:       ptr.String("__StackRefactorId__"),
				Description:           ptr.String("__Description__"),
				ExecutionStatus:       types.StackRefactorExecutionStatus("UNAVAILABLE"),
				ExecutionStatusReason: ptr.String("__ExecutionStatusReason__"),
				Status:                types.StackRefactorStatus("CREATE_IN_PROGRESS"),
				StatusReason:          ptr.String("__StatusReason__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListStackRefactors.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListStackRefactors(context.Background(), &ListStackRefactorsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListStackRefactors.response", err)
	}
}

func TestCheckResponseSnapshot_ListStackResources(t *testing.T) {
	want := &ListStackResourcesOutput{
		StackResourceSummaries: []types.StackResourceSummary{
			{
				LogicalResourceId:    ptr.String("__LogicalResourceId__"),
				PhysicalResourceId:   ptr.String("__PhysicalResourceId__"),
				ResourceType:         ptr.String("__ResourceType__"),
				LastUpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ResourceStatus:       types.ResourceStatus("CREATE_IN_PROGRESS"),
				ResourceStatusReason: ptr.String("__ResourceStatusReason__"),
				DriftInformation: &types.StackResourceDriftInformationSummary{
					StackResourceDriftStatus: types.StackResourceDriftStatus("IN_SYNC"),
					LastCheckTimestamp:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				ModuleInfo: &types.ModuleInfo{
					TypeHierarchy:      ptr.String("__TypeHierarchy__"),
					LogicalIdHierarchy: ptr.String("__LogicalIdHierarchy__"),
				},
			},
			{
				LogicalResourceId:    ptr.String("__LogicalResourceId__"),
				PhysicalResourceId:   ptr.String("__PhysicalResourceId__"),
				ResourceType:         ptr.String("__ResourceType__"),
				LastUpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ResourceStatus:       types.ResourceStatus("CREATE_IN_PROGRESS"),
				ResourceStatusReason: ptr.String("__ResourceStatusReason__"),
				DriftInformation: &types.StackResourceDriftInformationSummary{
					StackResourceDriftStatus: types.StackResourceDriftStatus("IN_SYNC"),
					LastCheckTimestamp:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				ModuleInfo: &types.ModuleInfo{
					TypeHierarchy:      ptr.String("__TypeHierarchy__"),
					LogicalIdHierarchy: ptr.String("__LogicalIdHierarchy__"),
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListStackResources.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListStackResources(context.Background(), &ListStackResourcesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListStackResources.response", err)
	}
}

func TestCheckResponseSnapshot_ListStackSetAutoDeploymentTargets(t *testing.T) {
	want := &ListStackSetAutoDeploymentTargetsOutput{
		Summaries: []types.StackSetAutoDeploymentTargetSummary{
			{
				OrganizationalUnitId: ptr.String("__OrganizationalUnitId__"),
				Regions: []string{
					"__Member__",
					"__Member__",
				},
			},
			{
				OrganizationalUnitId: ptr.String("__OrganizationalUnitId__"),
				Regions: []string{
					"__Member__",
					"__Member__",
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListStackSetAutoDeploymentTargets.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListStackSetAutoDeploymentTargets(context.Background(), &ListStackSetAutoDeploymentTargetsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListStackSetAutoDeploymentTargets.response", err)
	}
}

func TestCheckResponseSnapshot_ListStackSetOperationResults(t *testing.T) {
	want := &ListStackSetOperationResultsOutput{
		Summaries: []types.StackSetOperationResultSummary{
			{
				Account:      ptr.String("__Account__"),
				Region:       ptr.String("__Region__"),
				Status:       types.StackSetOperationResultStatus("PENDING"),
				StatusReason: ptr.String("__StatusReason__"),
				AccountGateResult: &types.AccountGateResult{
					Status:       types.AccountGateStatus("SUCCEEDED"),
					StatusReason: ptr.String("__StatusReason__"),
				},
				OrganizationalUnitId: ptr.String("__OrganizationalUnitId__"),
			},
			{
				Account:      ptr.String("__Account__"),
				Region:       ptr.String("__Region__"),
				Status:       types.StackSetOperationResultStatus("PENDING"),
				StatusReason: ptr.String("__StatusReason__"),
				AccountGateResult: &types.AccountGateResult{
					Status:       types.AccountGateStatus("SUCCEEDED"),
					StatusReason: ptr.String("__StatusReason__"),
				},
				OrganizationalUnitId: ptr.String("__OrganizationalUnitId__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListStackSetOperationResults.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListStackSetOperationResults(context.Background(), &ListStackSetOperationResultsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListStackSetOperationResults.response", err)
	}
}

func TestCheckResponseSnapshot_ListStackSetOperations(t *testing.T) {
	want := &ListStackSetOperationsOutput{
		Summaries: []types.StackSetOperationSummary{
			{
				OperationId:       ptr.String("__OperationId__"),
				Action:            types.StackSetOperationAction("CREATE"),
				Status:            types.StackSetOperationStatus("RUNNING"),
				CreationTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				EndTimestamp:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				StatusReason:      ptr.String("__StatusReason__"),
				StatusDetails: &types.StackSetOperationStatusDetails{
					FailedStackInstancesCount: ptr.Int32(1),
				},
				OperationPreferences: &types.StackSetOperationPreferences{
					RegionConcurrencyType: types.RegionConcurrencyType("SEQUENTIAL"),
					RegionOrder: []string{
						"__Member__",
						"__Member__",
					},
					FailureToleranceCount:      ptr.Int32(1),
					FailureTolerancePercentage: ptr.Int32(1),
					MaxConcurrentCount:         ptr.Int32(1),
					MaxConcurrentPercentage:    ptr.Int32(1),
					ConcurrencyMode:            types.ConcurrencyMode("STRICT_FAILURE_TOLERANCE"),
				},
			},
			{
				OperationId:       ptr.String("__OperationId__"),
				Action:            types.StackSetOperationAction("CREATE"),
				Status:            types.StackSetOperationStatus("RUNNING"),
				CreationTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				EndTimestamp:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				StatusReason:      ptr.String("__StatusReason__"),
				StatusDetails: &types.StackSetOperationStatusDetails{
					FailedStackInstancesCount: ptr.Int32(1),
				},
				OperationPreferences: &types.StackSetOperationPreferences{
					RegionConcurrencyType: types.RegionConcurrencyType("SEQUENTIAL"),
					RegionOrder: []string{
						"__Member__",
						"__Member__",
					},
					FailureToleranceCount:      ptr.Int32(1),
					FailureTolerancePercentage: ptr.Int32(1),
					MaxConcurrentCount:         ptr.Int32(1),
					MaxConcurrentPercentage:    ptr.Int32(1),
					ConcurrencyMode:            types.ConcurrencyMode("STRICT_FAILURE_TOLERANCE"),
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListStackSetOperations.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListStackSetOperations(context.Background(), &ListStackSetOperationsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListStackSetOperations.response", err)
	}
}

func TestCheckResponseSnapshot_ListStackSets(t *testing.T) {
	want := &ListStackSetsOutput{
		Summaries: []types.StackSetSummary{
			{
				StackSetName: ptr.String("__StackSetName__"),
				StackSetId:   ptr.String("__StackSetId__"),
				Description:  ptr.String("__Description__"),
				Status:       types.StackSetStatus("ACTIVE"),
				AutoDeployment: &types.AutoDeployment{
					Enabled:                      ptr.Bool(true),
					RetainStacksOnAccountRemoval: ptr.Bool(true),
					DependsOn: []string{
						"__Member__",
						"__Member__",
					},
				},
				PermissionModel:         types.PermissionModels("SERVICE_MANAGED"),
				DriftStatus:             types.StackDriftStatus("DRIFTED"),
				LastDriftCheckTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ManagedExecution: &types.ManagedExecution{
					Active: ptr.Bool(true),
				},
			},
			{
				StackSetName: ptr.String("__StackSetName__"),
				StackSetId:   ptr.String("__StackSetId__"),
				Description:  ptr.String("__Description__"),
				Status:       types.StackSetStatus("ACTIVE"),
				AutoDeployment: &types.AutoDeployment{
					Enabled:                      ptr.Bool(true),
					RetainStacksOnAccountRemoval: ptr.Bool(true),
					DependsOn: []string{
						"__Member__",
						"__Member__",
					},
				},
				PermissionModel:         types.PermissionModels("SERVICE_MANAGED"),
				DriftStatus:             types.StackDriftStatus("DRIFTED"),
				LastDriftCheckTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ManagedExecution: &types.ManagedExecution{
					Active: ptr.Bool(true),
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListStackSets.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListStackSets(context.Background(), &ListStackSetsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListStackSets.response", err)
	}
}

func TestCheckResponseSnapshot_ListStacks(t *testing.T) {
	want := &ListStacksOutput{
		StackSummaries: []types.StackSummary{
			{
				StackId:             ptr.String("__StackId__"),
				StackName:           ptr.String("__StackName__"),
				TemplateDescription: ptr.String("__TemplateDescription__"),
				CreationTime:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastUpdatedTime:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				DeletionTime:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				StackStatus:         types.StackStatus("CREATE_IN_PROGRESS"),
				StackStatusReason:   ptr.String("__StackStatusReason__"),
				ParentId:            ptr.String("__ParentId__"),
				RootId:              ptr.String("__RootId__"),
				DriftInformation: &types.StackDriftInformationSummary{
					StackDriftStatus:   types.StackDriftStatus("DRIFTED"),
					LastCheckTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				LastOperations: []types.OperationEntry{
					{
						OperationType: types.OperationType("CREATE_STACK"),
						OperationId:   ptr.String("__OperationId__"),
					},
					{
						OperationType: types.OperationType("CREATE_STACK"),
						OperationId:   ptr.String("__OperationId__"),
					},
				},
			},
			{
				StackId:             ptr.String("__StackId__"),
				StackName:           ptr.String("__StackName__"),
				TemplateDescription: ptr.String("__TemplateDescription__"),
				CreationTime:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastUpdatedTime:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				DeletionTime:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				StackStatus:         types.StackStatus("CREATE_IN_PROGRESS"),
				StackStatusReason:   ptr.String("__StackStatusReason__"),
				ParentId:            ptr.String("__ParentId__"),
				RootId:              ptr.String("__RootId__"),
				DriftInformation: &types.StackDriftInformationSummary{
					StackDriftStatus:   types.StackDriftStatus("DRIFTED"),
					LastCheckTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				LastOperations: []types.OperationEntry{
					{
						OperationType: types.OperationType("CREATE_STACK"),
						OperationId:   ptr.String("__OperationId__"),
					},
					{
						OperationType: types.OperationType("CREATE_STACK"),
						OperationId:   ptr.String("__OperationId__"),
					},
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListStacks.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListStacks(context.Background(), &ListStacksInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListStacks.response", err)
	}
}

func TestCheckResponseSnapshot_ListTypeRegistrations(t *testing.T) {
	want := &ListTypeRegistrationsOutput{
		RegistrationTokenList: []string{
			"__Member__",
			"__Member__",
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListTypeRegistrations.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListTypeRegistrations(context.Background(), &ListTypeRegistrationsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListTypeRegistrations.response", err)
	}
}

func TestCheckResponseSnapshot_ListTypeVersions(t *testing.T) {
	want := &ListTypeVersionsOutput{
		TypeVersionSummaries: []types.TypeVersionSummary{
			{
				Type:                types.RegistryType("RESOURCE"),
				TypeName:            ptr.String("__TypeName__"),
				VersionId:           ptr.String("__VersionId__"),
				IsDefaultVersion:    ptr.Bool(true),
				Arn:                 ptr.String("__Arn__"),
				TimeCreated:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Description:         ptr.String("__Description__"),
				PublicVersionNumber: ptr.String("__PublicVersionNumber__"),
			},
			{
				Type:                types.RegistryType("RESOURCE"),
				TypeName:            ptr.String("__TypeName__"),
				VersionId:           ptr.String("__VersionId__"),
				IsDefaultVersion:    ptr.Bool(true),
				Arn:                 ptr.String("__Arn__"),
				TimeCreated:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Description:         ptr.String("__Description__"),
				PublicVersionNumber: ptr.String("__PublicVersionNumber__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListTypeVersions.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListTypeVersions(context.Background(), &ListTypeVersionsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListTypeVersions.response", err)
	}
}

func TestCheckResponseSnapshot_ListTypes(t *testing.T) {
	want := &ListTypesOutput{
		TypeSummaries: []types.TypeSummary{
			{
				Type:                types.RegistryType("RESOURCE"),
				TypeName:            ptr.String("__TypeName__"),
				DefaultVersionId:    ptr.String("__DefaultVersionId__"),
				TypeArn:             ptr.String("__TypeArn__"),
				LastUpdated:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Description:         ptr.String("__Description__"),
				PublisherId:         ptr.String("__PublisherId__"),
				OriginalTypeName:    ptr.String("__OriginalTypeName__"),
				PublicVersionNumber: ptr.String("__PublicVersionNumber__"),
				LatestPublicVersion: ptr.String("__LatestPublicVersion__"),
				PublisherIdentity:   types.IdentityProvider("AWS_Marketplace"),
				PublisherName:       ptr.String("__PublisherName__"),
				IsActivated:         ptr.Bool(true),
			},
			{
				Type:                types.RegistryType("RESOURCE"),
				TypeName:            ptr.String("__TypeName__"),
				DefaultVersionId:    ptr.String("__DefaultVersionId__"),
				TypeArn:             ptr.String("__TypeArn__"),
				LastUpdated:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Description:         ptr.String("__Description__"),
				PublisherId:         ptr.String("__PublisherId__"),
				OriginalTypeName:    ptr.String("__OriginalTypeName__"),
				PublicVersionNumber: ptr.String("__PublicVersionNumber__"),
				LatestPublicVersion: ptr.String("__LatestPublicVersion__"),
				PublisherIdentity:   types.IdentityProvider("AWS_Marketplace"),
				PublisherName:       ptr.String("__PublisherName__"),
				IsActivated:         ptr.Bool(true),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListTypes.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListTypes(context.Background(), &ListTypesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListTypes.response", err)
	}
}

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

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

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

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

func TestCheckResponseSnapshot_RollbackStack(t *testing.T) {
	want := &RollbackStackOutput{
		StackId:     ptr.String("__StackId__"),
		OperationId: ptr.String("__OperationId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("RollbackStack.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.RollbackStack(context.Background(), &RollbackStackInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "RollbackStack.response", err)
	}
}

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

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

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

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

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

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

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

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

func TestCheckResponseSnapshot_UpdateStack(t *testing.T) {
	want := &UpdateStackOutput{
		StackId:     ptr.String("__StackId__"),
		OperationId: ptr.String("__OperationId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateStack.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateStack(context.Background(), &UpdateStackInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateStack.response", err)
	}
}

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

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

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

func TestCheckResponseSnapshot_ValidateTemplate(t *testing.T) {
	want := &ValidateTemplateOutput{
		Parameters: []types.TemplateParameter{
			{
				ParameterKey: ptr.String("__ParameterKey__"),
				DefaultValue: ptr.String("__DefaultValue__"),
				NoEcho:       ptr.Bool(true),
				Description:  ptr.String("__Description__"),
			},
			{
				ParameterKey: ptr.String("__ParameterKey__"),
				DefaultValue: ptr.String("__DefaultValue__"),
				NoEcho:       ptr.Bool(true),
				Description:  ptr.String("__Description__"),
			},
		},
		Description: ptr.String("__Description__"),
		Capabilities: []types.Capability{
			types.Capability("CAPABILITY_IAM"),
			types.Capability("CAPABILITY_IAM"),
		},
		CapabilitiesReason: ptr.String("__CapabilitiesReason__"),
		DeclaredTransforms: []string{
			"__Member__",
			"__Member__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ValidateTemplate.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ValidateTemplate(context.Background(), &ValidateTemplateInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ValidateTemplate.response", err)
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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