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

//go:build response_snapshot

package appstream

import (
	"bufio"
	"bytes"
	"context"
	"errors"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/appstream/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_AssociateAppBlockBuilderAppBlock(t *testing.T) {
	want := &AssociateAppBlockBuilderAppBlockOutput{
		AppBlockBuilderAppBlockAssociation: &types.AppBlockBuilderAppBlockAssociation{
			AppBlockArn:         ptr.String("__AppBlockArn__"),
			AppBlockBuilderName: ptr.String("__AppBlockBuilderName__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("AssociateAppBlockBuilderAppBlock.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.AssociateAppBlockBuilderAppBlock(context.Background(), &AssociateAppBlockBuilderAppBlockInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "AssociateAppBlockBuilderAppBlock.response", err)
	}
}

func TestCheckResponseSnapshot_AssociateApplicationFleet(t *testing.T) {
	want := &AssociateApplicationFleetOutput{
		ApplicationFleetAssociation: &types.ApplicationFleetAssociation{
			FleetName:      ptr.String("__FleetName__"),
			ApplicationArn: ptr.String("__ApplicationArn__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("AssociateApplicationFleet.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.AssociateApplicationFleet(context.Background(), &AssociateApplicationFleetInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "AssociateApplicationFleet.response", err)
	}
}

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

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

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

func TestCheckResponseSnapshot_BatchAssociateUserStack(t *testing.T) {
	want := &BatchAssociateUserStackOutput{
		Errors: []types.UserStackAssociationError{
			{
				UserStackAssociation: &types.UserStackAssociation{
					StackName:             ptr.String("__StackName__"),
					UserName:              ptr.String("__UserName__"),
					AuthenticationType:    types.AuthenticationType("API"),
					SendEmailNotification: ptr.Bool(true),
				},
				ErrorCode:    types.UserStackAssociationErrorCode("STACK_NOT_FOUND"),
				ErrorMessage: ptr.String("__ErrorMessage__"),
			},
			{
				UserStackAssociation: &types.UserStackAssociation{
					StackName:             ptr.String("__StackName__"),
					UserName:              ptr.String("__UserName__"),
					AuthenticationType:    types.AuthenticationType("API"),
					SendEmailNotification: ptr.Bool(true),
				},
				ErrorCode:    types.UserStackAssociationErrorCode("STACK_NOT_FOUND"),
				ErrorMessage: ptr.String("__ErrorMessage__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("BatchAssociateUserStack.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.BatchAssociateUserStack(context.Background(), &BatchAssociateUserStackInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "BatchAssociateUserStack.response", err)
	}
}

func TestCheckResponseSnapshot_BatchDisassociateUserStack(t *testing.T) {
	want := &BatchDisassociateUserStackOutput{
		Errors: []types.UserStackAssociationError{
			{
				UserStackAssociation: &types.UserStackAssociation{
					StackName:             ptr.String("__StackName__"),
					UserName:              ptr.String("__UserName__"),
					AuthenticationType:    types.AuthenticationType("API"),
					SendEmailNotification: ptr.Bool(true),
				},
				ErrorCode:    types.UserStackAssociationErrorCode("STACK_NOT_FOUND"),
				ErrorMessage: ptr.String("__ErrorMessage__"),
			},
			{
				UserStackAssociation: &types.UserStackAssociation{
					StackName:             ptr.String("__StackName__"),
					UserName:              ptr.String("__UserName__"),
					AuthenticationType:    types.AuthenticationType("API"),
					SendEmailNotification: ptr.Bool(true),
				},
				ErrorCode:    types.UserStackAssociationErrorCode("STACK_NOT_FOUND"),
				ErrorMessage: ptr.String("__ErrorMessage__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("BatchDisassociateUserStack.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.BatchDisassociateUserStack(context.Background(), &BatchDisassociateUserStackInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "BatchDisassociateUserStack.response", err)
	}
}

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

func TestCheckResponseSnapshot_CreateAppBlock(t *testing.T) {
	want := &CreateAppBlockOutput{
		AppBlock: &types.AppBlock{
			Name:        ptr.String("__Name__"),
			Arn:         ptr.String("__Arn__"),
			Description: ptr.String("__Description__"),
			DisplayName: ptr.String("__DisplayName__"),
			SourceS3Location: &types.S3Location{
				S3Bucket: ptr.String("__S3Bucket__"),
				S3Key:    ptr.String("__S3Key__"),
			},
			SetupScriptDetails: &types.ScriptDetails{
				ScriptS3Location: &types.S3Location{
					S3Bucket: ptr.String("__S3Bucket__"),
					S3Key:    ptr.String("__S3Key__"),
				},
				ExecutablePath:       ptr.String("__ExecutablePath__"),
				ExecutableParameters: ptr.String("__ExecutableParameters__"),
				TimeoutInSeconds:     ptr.Int32(1),
			},
			CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			PostSetupScriptDetails: &types.ScriptDetails{
				ScriptS3Location: &types.S3Location{
					S3Bucket: ptr.String("__S3Bucket__"),
					S3Key:    ptr.String("__S3Key__"),
				},
				ExecutablePath:       ptr.String("__ExecutablePath__"),
				ExecutableParameters: ptr.String("__ExecutableParameters__"),
				TimeoutInSeconds:     ptr.Int32(1),
			},
			PackagingType: types.PackagingType("CUSTOM"),
			State:         types.AppBlockState("INACTIVE"),
			AppBlockErrors: []types.ErrorDetails{
				{
					ErrorCode:    ptr.String("__ErrorCode__"),
					ErrorMessage: ptr.String("__ErrorMessage__"),
				},
				{
					ErrorCode:    ptr.String("__ErrorCode__"),
					ErrorMessage: ptr.String("__ErrorMessage__"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateAppBlock.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateAppBlock(context.Background(), &CreateAppBlockInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateAppBlock.response", err)
	}
}

func TestCheckResponseSnapshot_CreateAppBlockBuilder(t *testing.T) {
	want := &CreateAppBlockBuilderOutput{
		AppBlockBuilder: &types.AppBlockBuilder{
			Arn:                         ptr.String("__Arn__"),
			Name:                        ptr.String("__Name__"),
			DisplayName:                 ptr.String("__DisplayName__"),
			Description:                 ptr.String("__Description__"),
			Platform:                    types.AppBlockBuilderPlatformType("WINDOWS_SERVER_2019"),
			InstanceType:                ptr.String("__InstanceType__"),
			EnableDefaultInternetAccess: ptr.Bool(true),
			IamRoleArn:                  ptr.String("__IamRoleArn__"),
			VpcConfig: &types.VpcConfig{
				SubnetIds: []string{
					"__Member__",
					"__Member__",
				},
				SecurityGroupIds: []string{
					"__Member__",
					"__Member__",
				},
			},
			State:       types.AppBlockBuilderState("STARTING"),
			CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			AppBlockBuilderErrors: []types.ResourceError{
				{
					ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
					ErrorMessage:   ptr.String("__ErrorMessage__"),
					ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				{
					ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
					ErrorMessage:   ptr.String("__ErrorMessage__"),
					ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
			StateChangeReason: &types.AppBlockBuilderStateChangeReason{
				Code:    types.AppBlockBuilderStateChangeReasonCode("INTERNAL_ERROR"),
				Message: ptr.String("__Message__"),
			},
			AccessEndpoints: []types.AccessEndpoint{
				{
					EndpointType: types.AccessEndpointType("STREAMING"),
					VpceId:       ptr.String("__VpceId__"),
				},
				{
					EndpointType: types.AccessEndpointType("STREAMING"),
					VpceId:       ptr.String("__VpceId__"),
				},
			},
			DisableIMDSV1: ptr.Bool(true),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateAppBlockBuilder.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateAppBlockBuilder(context.Background(), &CreateAppBlockBuilderInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateAppBlockBuilder.response", err)
	}
}

func TestCheckResponseSnapshot_CreateAppBlockBuilderStreamingURL(t *testing.T) {
	want := &CreateAppBlockBuilderStreamingURLOutput{
		StreamingURL: ptr.String("__StreamingURL__"),
		Expires:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateAppBlockBuilderStreamingURL.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateAppBlockBuilderStreamingURL(context.Background(), &CreateAppBlockBuilderStreamingURLInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateAppBlockBuilderStreamingURL.response", err)
	}
}

func TestCheckResponseSnapshot_CreateApplication(t *testing.T) {
	want := &CreateApplicationOutput{
		Application: &types.Application{
			Name:             ptr.String("__Name__"),
			DisplayName:      ptr.String("__DisplayName__"),
			IconURL:          ptr.String("__IconURL__"),
			LaunchPath:       ptr.String("__LaunchPath__"),
			LaunchParameters: ptr.String("__LaunchParameters__"),
			Enabled:          ptr.Bool(true),
			Metadata: map[string]string{
				"key0": "__Value__",
			},
			WorkingDirectory: ptr.String("__WorkingDirectory__"),
			Description:      ptr.String("__Description__"),
			Arn:              ptr.String("__Arn__"),
			AppBlockArn:      ptr.String("__AppBlockArn__"),
			IconS3Location: &types.S3Location{
				S3Bucket: ptr.String("__S3Bucket__"),
				S3Key:    ptr.String("__S3Key__"),
			},
			Platforms: []types.PlatformType{
				types.PlatformType("WINDOWS"),
				types.PlatformType("WINDOWS"),
			},
			InstanceFamilies: []string{
				"__Member__",
				"__Member__",
			},
			CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateApplication.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateApplication(context.Background(), &CreateApplicationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateApplication.response", err)
	}
}

func TestCheckResponseSnapshot_CreateDirectoryConfig(t *testing.T) {
	want := &CreateDirectoryConfigOutput{
		DirectoryConfig: &types.DirectoryConfig{
			DirectoryName: ptr.String("__DirectoryName__"),
			OrganizationalUnitDistinguishedNames: []string{
				"__Member__",
				"__Member__",
			},
			ServiceAccountCredentials: &types.ServiceAccountCredentials{
				AccountName:     ptr.String("__AccountName__"),
				AccountPassword: ptr.String("__AccountPassword__"),
			},
			CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CertificateBasedAuthProperties: &types.CertificateBasedAuthProperties{
				Status:                  types.CertificateBasedAuthStatus("DISABLED"),
				CertificateAuthorityArn: ptr.String("__CertificateAuthorityArn__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateDirectoryConfig.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateDirectoryConfig(context.Background(), &CreateDirectoryConfigInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateDirectoryConfig.response", err)
	}
}

func TestCheckResponseSnapshot_CreateEntitlement(t *testing.T) {
	want := &CreateEntitlementOutput{
		Entitlement: &types.Entitlement{
			Name:          ptr.String("__Name__"),
			StackName:     ptr.String("__StackName__"),
			Description:   ptr.String("__Description__"),
			AppVisibility: types.AppVisibility("ALL"),
			Attributes: []types.EntitlementAttribute{
				{
					Name:  ptr.String("__Name__"),
					Value: ptr.String("__Value__"),
				},
				{
					Name:  ptr.String("__Name__"),
					Value: ptr.String("__Value__"),
				},
			},
			CreatedTime:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LastModifiedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateEntitlement.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateEntitlement(context.Background(), &CreateEntitlementInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateEntitlement.response", err)
	}
}

func TestCheckResponseSnapshot_CreateExportImageTask(t *testing.T) {
	want := &CreateExportImageTaskOutput{
		ExportImageTask: &types.ExportImageTask{
			TaskId:         ptr.String("__TaskId__"),
			ImageArn:       ptr.String("__ImageArn__"),
			AmiName:        ptr.String("__AmiName__"),
			CreatedDate:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			AmiDescription: ptr.String("__AmiDescription__"),
			State:          types.ExportImageTaskState("EXPORTING"),
			AmiId:          ptr.String("__AmiId__"),
			TagSpecifications: map[string]string{
				"key0": "__Value__",
			},
			ErrorDetails: []types.ErrorDetails{
				{
					ErrorCode:    ptr.String("__ErrorCode__"),
					ErrorMessage: ptr.String("__ErrorMessage__"),
				},
				{
					ErrorCode:    ptr.String("__ErrorCode__"),
					ErrorMessage: ptr.String("__ErrorMessage__"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateExportImageTask.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateExportImageTask(context.Background(), &CreateExportImageTaskInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateExportImageTask.response", err)
	}
}

func TestCheckResponseSnapshot_CreateFleet(t *testing.T) {
	want := &CreateFleetOutput{
		Fleet: &types.Fleet{
			Arn:          ptr.String("__Arn__"),
			Name:         ptr.String("__Name__"),
			DisplayName:  ptr.String("__DisplayName__"),
			Description:  ptr.String("__Description__"),
			ImageName:    ptr.String("__ImageName__"),
			ImageArn:     ptr.String("__ImageArn__"),
			InstanceType: ptr.String("__InstanceType__"),
			FleetType:    types.FleetType("ALWAYS_ON"),
			ComputeCapacityStatus: &types.ComputeCapacityStatus{
				Desired:                     ptr.Int32(1),
				Running:                     ptr.Int32(1),
				InUse:                       ptr.Int32(1),
				Available:                   ptr.Int32(1),
				DesiredUserSessions:         ptr.Int32(1),
				AvailableUserSessions:       ptr.Int32(1),
				ActiveUserSessions:          ptr.Int32(1),
				ActualUserSessions:          ptr.Int32(1),
				Draining:                    ptr.Int32(1),
				DrainModeActiveUserSessions: ptr.Int32(1),
				DrainModeUnusedUserSessions: ptr.Int32(1),
			},
			MaxUserDurationInSeconds:   ptr.Int32(1),
			DisconnectTimeoutInSeconds: ptr.Int32(1),
			State:                      types.FleetState("STARTING"),
			VpcConfig: &types.VpcConfig{
				SubnetIds: []string{
					"__Member__",
					"__Member__",
				},
				SecurityGroupIds: []string{
					"__Member__",
					"__Member__",
				},
			},
			CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			FleetErrors: []types.FleetError{
				{
					ErrorCode:    types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
					ErrorMessage: ptr.String("__ErrorMessage__"),
				},
				{
					ErrorCode:    types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
					ErrorMessage: ptr.String("__ErrorMessage__"),
				},
			},
			EnableDefaultInternetAccess: ptr.Bool(true),
			DomainJoinInfo: &types.DomainJoinInfo{
				DirectoryName:                       ptr.String("__DirectoryName__"),
				OrganizationalUnitDistinguishedName: ptr.String("__OrganizationalUnitDistinguishedName__"),
			},
			IdleDisconnectTimeoutInSeconds: ptr.Int32(1),
			IamRoleArn:                     ptr.String("__IamRoleArn__"),
			StreamView:                     types.StreamView("APP"),
			Platform:                       types.PlatformType("WINDOWS"),
			MaxConcurrentSessions:          ptr.Int32(1),
			UsbDeviceFilterStrings: []string{
				"__Member__",
				"__Member__",
			},
			SessionScriptS3Location: &types.S3Location{
				S3Bucket: ptr.String("__S3Bucket__"),
				S3Key:    ptr.String("__S3Key__"),
			},
			MaxSessionsPerInstance: ptr.Int32(1),
			RootVolumeConfig: &types.VolumeConfig{
				VolumeSizeInGb: ptr.Int32(1),
			},
			DisableIMDSV1: ptr.Bool(true),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateFleet.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateFleet(context.Background(), &CreateFleetInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateFleet.response", err)
	}
}

func TestCheckResponseSnapshot_CreateImageBuilder(t *testing.T) {
	want := &CreateImageBuilderOutput{
		ImageBuilder: &types.ImageBuilder{
			Name:        ptr.String("__Name__"),
			Arn:         ptr.String("__Arn__"),
			ImageArn:    ptr.String("__ImageArn__"),
			Description: ptr.String("__Description__"),
			DisplayName: ptr.String("__DisplayName__"),
			VpcConfig: &types.VpcConfig{
				SubnetIds: []string{
					"__Member__",
					"__Member__",
				},
				SecurityGroupIds: []string{
					"__Member__",
					"__Member__",
				},
			},
			InstanceType: ptr.String("__InstanceType__"),
			Platform:     types.PlatformType("WINDOWS"),
			IamRoleArn:   ptr.String("__IamRoleArn__"),
			State:        types.ImageBuilderState("PENDING"),
			StateChangeReason: &types.ImageBuilderStateChangeReason{
				Code:    types.ImageBuilderStateChangeReasonCode("INTERNAL_ERROR"),
				Message: ptr.String("__Message__"),
			},
			CreatedTime:                 ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			EnableDefaultInternetAccess: ptr.Bool(true),
			DomainJoinInfo: &types.DomainJoinInfo{
				DirectoryName:                       ptr.String("__DirectoryName__"),
				OrganizationalUnitDistinguishedName: ptr.String("__OrganizationalUnitDistinguishedName__"),
			},
			NetworkAccessConfiguration: &types.NetworkAccessConfiguration{
				EniPrivateIpAddress: ptr.String("__EniPrivateIpAddress__"),
				EniIpv6Addresses: []string{
					"__Member__",
					"__Member__",
				},
				EniId: ptr.String("__EniId__"),
			},
			ImageBuilderErrors: []types.ResourceError{
				{
					ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
					ErrorMessage:   ptr.String("__ErrorMessage__"),
					ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				{
					ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
					ErrorMessage:   ptr.String("__ErrorMessage__"),
					ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
			AppstreamAgentVersion: ptr.String("__AppstreamAgentVersion__"),
			AccessEndpoints: []types.AccessEndpoint{
				{
					EndpointType: types.AccessEndpointType("STREAMING"),
					VpceId:       ptr.String("__VpceId__"),
				},
				{
					EndpointType: types.AccessEndpointType("STREAMING"),
					VpceId:       ptr.String("__VpceId__"),
				},
			},
			RootVolumeConfig: &types.VolumeConfig{
				VolumeSizeInGb: ptr.Int32(1),
			},
			LatestAppstreamAgentVersion: types.LatestAppstreamAgentVersion("TRUE"),
			DisableIMDSV1:               ptr.Bool(true),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateImageBuilder.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateImageBuilder(context.Background(), &CreateImageBuilderInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateImageBuilder.response", err)
	}
}

func TestCheckResponseSnapshot_CreateImageBuilderStreamingURL(t *testing.T) {
	want := &CreateImageBuilderStreamingURLOutput{
		StreamingURL: ptr.String("__StreamingURL__"),
		Expires:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateImageBuilderStreamingURL.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateImageBuilderStreamingURL(context.Background(), &CreateImageBuilderStreamingURLInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateImageBuilderStreamingURL.response", err)
	}
}

func TestCheckResponseSnapshot_CreateImportedImage(t *testing.T) {
	want := &CreateImportedImageOutput{
		Image: &types.Image{
			Name:                  ptr.String("__Name__"),
			Arn:                   ptr.String("__Arn__"),
			BaseImageArn:          ptr.String("__BaseImageArn__"),
			DisplayName:           ptr.String("__DisplayName__"),
			State:                 types.ImageState("PENDING"),
			Visibility:            types.VisibilityType("PUBLIC"),
			ImageBuilderSupported: ptr.Bool(true),
			ImageBuilderName:      ptr.String("__ImageBuilderName__"),
			Platform:              types.PlatformType("WINDOWS"),
			Description:           ptr.String("__Description__"),
			StateChangeReason: &types.ImageStateChangeReason{
				Code:    types.ImageStateChangeReasonCode("INTERNAL_ERROR"),
				Message: ptr.String("__Message__"),
			},
			Applications: []types.Application{
				{
					Name:             ptr.String("__Name__"),
					DisplayName:      ptr.String("__DisplayName__"),
					IconURL:          ptr.String("__IconURL__"),
					LaunchPath:       ptr.String("__LaunchPath__"),
					LaunchParameters: ptr.String("__LaunchParameters__"),
					Enabled:          ptr.Bool(true),
					Metadata: map[string]string{
						"key0": "__Value__",
					},
					WorkingDirectory: ptr.String("__WorkingDirectory__"),
					Description:      ptr.String("__Description__"),
					Arn:              ptr.String("__Arn__"),
					AppBlockArn:      ptr.String("__AppBlockArn__"),
					IconS3Location: &types.S3Location{
						S3Bucket: ptr.String("__S3Bucket__"),
						S3Key:    ptr.String("__S3Key__"),
					},
					Platforms: []types.PlatformType{
						types.PlatformType("WINDOWS"),
						types.PlatformType("WINDOWS"),
					},
					InstanceFamilies: []string{
						"__Member__",
						"__Member__",
					},
					CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				{
					Name:             ptr.String("__Name__"),
					DisplayName:      ptr.String("__DisplayName__"),
					IconURL:          ptr.String("__IconURL__"),
					LaunchPath:       ptr.String("__LaunchPath__"),
					LaunchParameters: ptr.String("__LaunchParameters__"),
					Enabled:          ptr.Bool(true),
					Metadata: map[string]string{
						"key0": "__Value__",
					},
					WorkingDirectory: ptr.String("__WorkingDirectory__"),
					Description:      ptr.String("__Description__"),
					Arn:              ptr.String("__Arn__"),
					AppBlockArn:      ptr.String("__AppBlockArn__"),
					IconS3Location: &types.S3Location{
						S3Bucket: ptr.String("__S3Bucket__"),
						S3Key:    ptr.String("__S3Key__"),
					},
					Platforms: []types.PlatformType{
						types.PlatformType("WINDOWS"),
						types.PlatformType("WINDOWS"),
					},
					InstanceFamilies: []string{
						"__Member__",
						"__Member__",
					},
					CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
			CreatedTime:                 ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			PublicBaseImageReleasedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			AppstreamAgentVersion:       ptr.String("__AppstreamAgentVersion__"),
			ImagePermissions: &types.ImagePermissions{
				AllowFleet:        ptr.Bool(true),
				AllowImageBuilder: ptr.Bool(true),
			},
			ImageErrors: []types.ResourceError{
				{
					ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
					ErrorMessage:   ptr.String("__ErrorMessage__"),
					ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				{
					ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
					ErrorMessage:   ptr.String("__ErrorMessage__"),
					ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
			LatestAppstreamAgentVersion: types.LatestAppstreamAgentVersion("TRUE"),
			SupportedInstanceFamilies: []string{
				"__Member__",
				"__Member__",
			},
			DynamicAppProvidersEnabled: types.DynamicAppProvidersEnabled("ENABLED"),
			ImageSharedWithOthers:      types.ImageSharedWithOthers("TRUE"),
			ManagedSoftwareIncluded:    ptr.Bool(true),
			ImageType:                  types.ImageType("CUSTOM"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateImportedImage.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateImportedImage(context.Background(), &CreateImportedImageInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateImportedImage.response", err)
	}
}

func TestCheckResponseSnapshot_CreateStack(t *testing.T) {
	want := &CreateStackOutput{
		Stack: &types.Stack{
			Arn:         ptr.String("__Arn__"),
			Name:        ptr.String("__Name__"),
			Description: ptr.String("__Description__"),
			DisplayName: ptr.String("__DisplayName__"),
			CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			StorageConnectors: []types.StorageConnector{
				{
					ConnectorType:      types.StorageConnectorType("HOMEFOLDERS"),
					ResourceIdentifier: ptr.String("__ResourceIdentifier__"),
					Domains: []string{
						"__Member__",
						"__Member__",
					},
					DomainsRequireAdminConsent: []string{
						"__Member__",
						"__Member__",
					},
				},
				{
					ConnectorType:      types.StorageConnectorType("HOMEFOLDERS"),
					ResourceIdentifier: ptr.String("__ResourceIdentifier__"),
					Domains: []string{
						"__Member__",
						"__Member__",
					},
					DomainsRequireAdminConsent: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
			RedirectURL: ptr.String("__RedirectURL__"),
			FeedbackURL: ptr.String("__FeedbackURL__"),
			StackErrors: []types.StackError{
				{
					ErrorCode:    types.StackErrorCode("STORAGE_CONNECTOR_ERROR"),
					ErrorMessage: ptr.String("__ErrorMessage__"),
				},
				{
					ErrorCode:    types.StackErrorCode("STORAGE_CONNECTOR_ERROR"),
					ErrorMessage: ptr.String("__ErrorMessage__"),
				},
			},
			UserSettings: []types.UserSetting{
				{
					Action:        types.Action("CLIPBOARD_COPY_FROM_LOCAL_DEVICE"),
					Permission:    types.Permission("ENABLED"),
					MaximumLength: ptr.Int32(1),
				},
				{
					Action:        types.Action("CLIPBOARD_COPY_FROM_LOCAL_DEVICE"),
					Permission:    types.Permission("ENABLED"),
					MaximumLength: ptr.Int32(1),
				},
			},
			ApplicationSettings: &types.ApplicationSettingsResponse{
				Enabled:       ptr.Bool(true),
				SettingsGroup: ptr.String("__SettingsGroup__"),
				S3BucketName:  ptr.String("__S3BucketName__"),
			},
			AccessEndpoints: []types.AccessEndpoint{
				{
					EndpointType: types.AccessEndpointType("STREAMING"),
					VpceId:       ptr.String("__VpceId__"),
				},
				{
					EndpointType: types.AccessEndpointType("STREAMING"),
					VpceId:       ptr.String("__VpceId__"),
				},
			},
			EmbedHostDomains: []string{
				"__Member__",
				"__Member__",
			},
			StreamingExperienceSettings: &types.StreamingExperienceSettings{
				PreferredProtocol: types.PreferredProtocol("TCP"),
			},
			ContentRedirection: &types.ContentRedirection{
				HostToClient: &types.UrlRedirectionConfig{
					Enabled: ptr.Bool(true),
					AllowedUrls: []string{
						"__Member__",
						"__Member__",
					},
					DeniedUrls: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
			AgentAccessConfig: &types.AgentAccessConfig{
				Settings: []types.AgentAccessSetting{
					{
						AgentAction: types.AgentAction("COMPUTER_VISION"),
						Permission:  types.Permission("ENABLED"),
					},
					{
						AgentAction: types.AgentAction("COMPUTER_VISION"),
						Permission:  types.Permission("ENABLED"),
					},
				},
				S3BucketArn:              ptr.String("__S3BucketArn__"),
				ScreenshotsUploadEnabled: ptr.Bool(true),
				ScreenResolution:         types.ScreenResolution("W_1280xH_720"),
				ScreenImageFormat:        types.ScreenImageFormat("PNG"),
				UserControlMode:          types.UserControlMode("VIEW_ONLY"),
			},
		},
	}
	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_CreateStreamingURL(t *testing.T) {
	want := &CreateStreamingURLOutput{
		StreamingURL: ptr.String("__StreamingURL__"),
		Expires:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateStreamingURL.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateStreamingURL(context.Background(), &CreateStreamingURLInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateStreamingURL.response", err)
	}
}

func TestCheckResponseSnapshot_CreateThemeForStack(t *testing.T) {
	want := &CreateThemeForStackOutput{
		Theme: &types.Theme{
			StackName:      ptr.String("__StackName__"),
			State:          types.ThemeState("ENABLED"),
			ThemeTitleText: ptr.String("__ThemeTitleText__"),
			ThemeStyling:   types.ThemeStyling("LIGHT_BLUE"),
			ThemeFooterLinks: []types.ThemeFooterLink{
				{
					DisplayName:   ptr.String("__DisplayName__"),
					FooterLinkURL: ptr.String("__FooterLinkURL__"),
				},
				{
					DisplayName:   ptr.String("__DisplayName__"),
					FooterLinkURL: ptr.String("__FooterLinkURL__"),
				},
			},
			ThemeOrganizationLogoURL: ptr.String("__ThemeOrganizationLogoURL__"),
			ThemeFaviconURL:          ptr.String("__ThemeFaviconURL__"),
			CreatedTime:              ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateThemeForStack.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateThemeForStack(context.Background(), &CreateThemeForStackInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateThemeForStack.response", err)
	}
}

func TestCheckResponseSnapshot_CreateUpdatedImage(t *testing.T) {
	want := &CreateUpdatedImageOutput{
		Image: &types.Image{
			Name:                  ptr.String("__Name__"),
			Arn:                   ptr.String("__Arn__"),
			BaseImageArn:          ptr.String("__BaseImageArn__"),
			DisplayName:           ptr.String("__DisplayName__"),
			State:                 types.ImageState("PENDING"),
			Visibility:            types.VisibilityType("PUBLIC"),
			ImageBuilderSupported: ptr.Bool(true),
			ImageBuilderName:      ptr.String("__ImageBuilderName__"),
			Platform:              types.PlatformType("WINDOWS"),
			Description:           ptr.String("__Description__"),
			StateChangeReason: &types.ImageStateChangeReason{
				Code:    types.ImageStateChangeReasonCode("INTERNAL_ERROR"),
				Message: ptr.String("__Message__"),
			},
			Applications: []types.Application{
				{
					Name:             ptr.String("__Name__"),
					DisplayName:      ptr.String("__DisplayName__"),
					IconURL:          ptr.String("__IconURL__"),
					LaunchPath:       ptr.String("__LaunchPath__"),
					LaunchParameters: ptr.String("__LaunchParameters__"),
					Enabled:          ptr.Bool(true),
					Metadata: map[string]string{
						"key0": "__Value__",
					},
					WorkingDirectory: ptr.String("__WorkingDirectory__"),
					Description:      ptr.String("__Description__"),
					Arn:              ptr.String("__Arn__"),
					AppBlockArn:      ptr.String("__AppBlockArn__"),
					IconS3Location: &types.S3Location{
						S3Bucket: ptr.String("__S3Bucket__"),
						S3Key:    ptr.String("__S3Key__"),
					},
					Platforms: []types.PlatformType{
						types.PlatformType("WINDOWS"),
						types.PlatformType("WINDOWS"),
					},
					InstanceFamilies: []string{
						"__Member__",
						"__Member__",
					},
					CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				{
					Name:             ptr.String("__Name__"),
					DisplayName:      ptr.String("__DisplayName__"),
					IconURL:          ptr.String("__IconURL__"),
					LaunchPath:       ptr.String("__LaunchPath__"),
					LaunchParameters: ptr.String("__LaunchParameters__"),
					Enabled:          ptr.Bool(true),
					Metadata: map[string]string{
						"key0": "__Value__",
					},
					WorkingDirectory: ptr.String("__WorkingDirectory__"),
					Description:      ptr.String("__Description__"),
					Arn:              ptr.String("__Arn__"),
					AppBlockArn:      ptr.String("__AppBlockArn__"),
					IconS3Location: &types.S3Location{
						S3Bucket: ptr.String("__S3Bucket__"),
						S3Key:    ptr.String("__S3Key__"),
					},
					Platforms: []types.PlatformType{
						types.PlatformType("WINDOWS"),
						types.PlatformType("WINDOWS"),
					},
					InstanceFamilies: []string{
						"__Member__",
						"__Member__",
					},
					CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
			CreatedTime:                 ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			PublicBaseImageReleasedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			AppstreamAgentVersion:       ptr.String("__AppstreamAgentVersion__"),
			ImagePermissions: &types.ImagePermissions{
				AllowFleet:        ptr.Bool(true),
				AllowImageBuilder: ptr.Bool(true),
			},
			ImageErrors: []types.ResourceError{
				{
					ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
					ErrorMessage:   ptr.String("__ErrorMessage__"),
					ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				{
					ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
					ErrorMessage:   ptr.String("__ErrorMessage__"),
					ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
			LatestAppstreamAgentVersion: types.LatestAppstreamAgentVersion("TRUE"),
			SupportedInstanceFamilies: []string{
				"__Member__",
				"__Member__",
			},
			DynamicAppProvidersEnabled: types.DynamicAppProvidersEnabled("ENABLED"),
			ImageSharedWithOthers:      types.ImageSharedWithOthers("TRUE"),
			ManagedSoftwareIncluded:    ptr.Bool(true),
			ImageType:                  types.ImageType("CUSTOM"),
		},
		CanUpdateImage: ptr.Bool(true),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateUpdatedImage.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateUpdatedImage(context.Background(), &CreateUpdatedImageInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateUpdatedImage.response", err)
	}
}

func TestCheckResponseSnapshot_CreateUsageReportSubscription(t *testing.T) {
	want := &CreateUsageReportSubscriptionOutput{
		S3BucketName: ptr.String("__S3BucketName__"),
		Schedule:     types.UsageReportSchedule("DAILY"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateUsageReportSubscription.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateUsageReportSubscription(context.Background(), &CreateUsageReportSubscriptionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateUsageReportSubscription.response", err)
	}
}

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

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

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

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

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

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

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

func TestCheckResponseSnapshot_DeleteImage(t *testing.T) {
	want := &DeleteImageOutput{
		Image: &types.Image{
			Name:                  ptr.String("__Name__"),
			Arn:                   ptr.String("__Arn__"),
			BaseImageArn:          ptr.String("__BaseImageArn__"),
			DisplayName:           ptr.String("__DisplayName__"),
			State:                 types.ImageState("PENDING"),
			Visibility:            types.VisibilityType("PUBLIC"),
			ImageBuilderSupported: ptr.Bool(true),
			ImageBuilderName:      ptr.String("__ImageBuilderName__"),
			Platform:              types.PlatformType("WINDOWS"),
			Description:           ptr.String("__Description__"),
			StateChangeReason: &types.ImageStateChangeReason{
				Code:    types.ImageStateChangeReasonCode("INTERNAL_ERROR"),
				Message: ptr.String("__Message__"),
			},
			Applications: []types.Application{
				{
					Name:             ptr.String("__Name__"),
					DisplayName:      ptr.String("__DisplayName__"),
					IconURL:          ptr.String("__IconURL__"),
					LaunchPath:       ptr.String("__LaunchPath__"),
					LaunchParameters: ptr.String("__LaunchParameters__"),
					Enabled:          ptr.Bool(true),
					Metadata: map[string]string{
						"key0": "__Value__",
					},
					WorkingDirectory: ptr.String("__WorkingDirectory__"),
					Description:      ptr.String("__Description__"),
					Arn:              ptr.String("__Arn__"),
					AppBlockArn:      ptr.String("__AppBlockArn__"),
					IconS3Location: &types.S3Location{
						S3Bucket: ptr.String("__S3Bucket__"),
						S3Key:    ptr.String("__S3Key__"),
					},
					Platforms: []types.PlatformType{
						types.PlatformType("WINDOWS"),
						types.PlatformType("WINDOWS"),
					},
					InstanceFamilies: []string{
						"__Member__",
						"__Member__",
					},
					CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				{
					Name:             ptr.String("__Name__"),
					DisplayName:      ptr.String("__DisplayName__"),
					IconURL:          ptr.String("__IconURL__"),
					LaunchPath:       ptr.String("__LaunchPath__"),
					LaunchParameters: ptr.String("__LaunchParameters__"),
					Enabled:          ptr.Bool(true),
					Metadata: map[string]string{
						"key0": "__Value__",
					},
					WorkingDirectory: ptr.String("__WorkingDirectory__"),
					Description:      ptr.String("__Description__"),
					Arn:              ptr.String("__Arn__"),
					AppBlockArn:      ptr.String("__AppBlockArn__"),
					IconS3Location: &types.S3Location{
						S3Bucket: ptr.String("__S3Bucket__"),
						S3Key:    ptr.String("__S3Key__"),
					},
					Platforms: []types.PlatformType{
						types.PlatformType("WINDOWS"),
						types.PlatformType("WINDOWS"),
					},
					InstanceFamilies: []string{
						"__Member__",
						"__Member__",
					},
					CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
			CreatedTime:                 ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			PublicBaseImageReleasedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			AppstreamAgentVersion:       ptr.String("__AppstreamAgentVersion__"),
			ImagePermissions: &types.ImagePermissions{
				AllowFleet:        ptr.Bool(true),
				AllowImageBuilder: ptr.Bool(true),
			},
			ImageErrors: []types.ResourceError{
				{
					ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
					ErrorMessage:   ptr.String("__ErrorMessage__"),
					ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				{
					ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
					ErrorMessage:   ptr.String("__ErrorMessage__"),
					ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
			LatestAppstreamAgentVersion: types.LatestAppstreamAgentVersion("TRUE"),
			SupportedInstanceFamilies: []string{
				"__Member__",
				"__Member__",
			},
			DynamicAppProvidersEnabled: types.DynamicAppProvidersEnabled("ENABLED"),
			ImageSharedWithOthers:      types.ImageSharedWithOthers("TRUE"),
			ManagedSoftwareIncluded:    ptr.Bool(true),
			ImageType:                  types.ImageType("CUSTOM"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DeleteImage.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteImage(context.Background(), &DeleteImageInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteImage.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteImageBuilder(t *testing.T) {
	want := &DeleteImageBuilderOutput{
		ImageBuilder: &types.ImageBuilder{
			Name:        ptr.String("__Name__"),
			Arn:         ptr.String("__Arn__"),
			ImageArn:    ptr.String("__ImageArn__"),
			Description: ptr.String("__Description__"),
			DisplayName: ptr.String("__DisplayName__"),
			VpcConfig: &types.VpcConfig{
				SubnetIds: []string{
					"__Member__",
					"__Member__",
				},
				SecurityGroupIds: []string{
					"__Member__",
					"__Member__",
				},
			},
			InstanceType: ptr.String("__InstanceType__"),
			Platform:     types.PlatformType("WINDOWS"),
			IamRoleArn:   ptr.String("__IamRoleArn__"),
			State:        types.ImageBuilderState("PENDING"),
			StateChangeReason: &types.ImageBuilderStateChangeReason{
				Code:    types.ImageBuilderStateChangeReasonCode("INTERNAL_ERROR"),
				Message: ptr.String("__Message__"),
			},
			CreatedTime:                 ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			EnableDefaultInternetAccess: ptr.Bool(true),
			DomainJoinInfo: &types.DomainJoinInfo{
				DirectoryName:                       ptr.String("__DirectoryName__"),
				OrganizationalUnitDistinguishedName: ptr.String("__OrganizationalUnitDistinguishedName__"),
			},
			NetworkAccessConfiguration: &types.NetworkAccessConfiguration{
				EniPrivateIpAddress: ptr.String("__EniPrivateIpAddress__"),
				EniIpv6Addresses: []string{
					"__Member__",
					"__Member__",
				},
				EniId: ptr.String("__EniId__"),
			},
			ImageBuilderErrors: []types.ResourceError{
				{
					ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
					ErrorMessage:   ptr.String("__ErrorMessage__"),
					ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				{
					ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
					ErrorMessage:   ptr.String("__ErrorMessage__"),
					ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
			AppstreamAgentVersion: ptr.String("__AppstreamAgentVersion__"),
			AccessEndpoints: []types.AccessEndpoint{
				{
					EndpointType: types.AccessEndpointType("STREAMING"),
					VpceId:       ptr.String("__VpceId__"),
				},
				{
					EndpointType: types.AccessEndpointType("STREAMING"),
					VpceId:       ptr.String("__VpceId__"),
				},
			},
			RootVolumeConfig: &types.VolumeConfig{
				VolumeSizeInGb: ptr.Int32(1),
			},
			LatestAppstreamAgentVersion: types.LatestAppstreamAgentVersion("TRUE"),
			DisableIMDSV1:               ptr.Bool(true),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DeleteImageBuilder.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteImageBuilder(context.Background(), &DeleteImageBuilderInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteImageBuilder.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteImagePermissions(t *testing.T) {
	want := &DeleteImagePermissionsOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteImagePermissions.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteImagePermissions(context.Background(), &DeleteImagePermissionsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteImagePermissions.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_DeleteThemeForStack(t *testing.T) {
	want := &DeleteThemeForStackOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteThemeForStack.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteThemeForStack(context.Background(), &DeleteThemeForStackInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteThemeForStack.response", err)
	}
}

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

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

func TestCheckResponseSnapshot_DescribeAppBlockBuilderAppBlockAssociations(t *testing.T) {
	want := &DescribeAppBlockBuilderAppBlockAssociationsOutput{
		AppBlockBuilderAppBlockAssociations: []types.AppBlockBuilderAppBlockAssociation{
			{
				AppBlockArn:         ptr.String("__AppBlockArn__"),
				AppBlockBuilderName: ptr.String("__AppBlockBuilderName__"),
			},
			{
				AppBlockArn:         ptr.String("__AppBlockArn__"),
				AppBlockBuilderName: ptr.String("__AppBlockBuilderName__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeAppBlockBuilderAppBlockAssociations.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeAppBlockBuilderAppBlockAssociations(context.Background(), &DescribeAppBlockBuilderAppBlockAssociationsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeAppBlockBuilderAppBlockAssociations.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeAppBlockBuilders(t *testing.T) {
	want := &DescribeAppBlockBuildersOutput{
		AppBlockBuilders: []types.AppBlockBuilder{
			{
				Arn:                         ptr.String("__Arn__"),
				Name:                        ptr.String("__Name__"),
				DisplayName:                 ptr.String("__DisplayName__"),
				Description:                 ptr.String("__Description__"),
				Platform:                    types.AppBlockBuilderPlatformType("WINDOWS_SERVER_2019"),
				InstanceType:                ptr.String("__InstanceType__"),
				EnableDefaultInternetAccess: ptr.Bool(true),
				IamRoleArn:                  ptr.String("__IamRoleArn__"),
				VpcConfig: &types.VpcConfig{
					SubnetIds: []string{
						"__Member__",
						"__Member__",
					},
					SecurityGroupIds: []string{
						"__Member__",
						"__Member__",
					},
				},
				State:       types.AppBlockBuilderState("STARTING"),
				CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				AppBlockBuilderErrors: []types.ResourceError{
					{
						ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
						ErrorMessage:   ptr.String("__ErrorMessage__"),
						ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
					{
						ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
						ErrorMessage:   ptr.String("__ErrorMessage__"),
						ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
				},
				StateChangeReason: &types.AppBlockBuilderStateChangeReason{
					Code:    types.AppBlockBuilderStateChangeReasonCode("INTERNAL_ERROR"),
					Message: ptr.String("__Message__"),
				},
				AccessEndpoints: []types.AccessEndpoint{
					{
						EndpointType: types.AccessEndpointType("STREAMING"),
						VpceId:       ptr.String("__VpceId__"),
					},
					{
						EndpointType: types.AccessEndpointType("STREAMING"),
						VpceId:       ptr.String("__VpceId__"),
					},
				},
				DisableIMDSV1: ptr.Bool(true),
			},
			{
				Arn:                         ptr.String("__Arn__"),
				Name:                        ptr.String("__Name__"),
				DisplayName:                 ptr.String("__DisplayName__"),
				Description:                 ptr.String("__Description__"),
				Platform:                    types.AppBlockBuilderPlatformType("WINDOWS_SERVER_2019"),
				InstanceType:                ptr.String("__InstanceType__"),
				EnableDefaultInternetAccess: ptr.Bool(true),
				IamRoleArn:                  ptr.String("__IamRoleArn__"),
				VpcConfig: &types.VpcConfig{
					SubnetIds: []string{
						"__Member__",
						"__Member__",
					},
					SecurityGroupIds: []string{
						"__Member__",
						"__Member__",
					},
				},
				State:       types.AppBlockBuilderState("STARTING"),
				CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				AppBlockBuilderErrors: []types.ResourceError{
					{
						ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
						ErrorMessage:   ptr.String("__ErrorMessage__"),
						ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
					{
						ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
						ErrorMessage:   ptr.String("__ErrorMessage__"),
						ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
				},
				StateChangeReason: &types.AppBlockBuilderStateChangeReason{
					Code:    types.AppBlockBuilderStateChangeReasonCode("INTERNAL_ERROR"),
					Message: ptr.String("__Message__"),
				},
				AccessEndpoints: []types.AccessEndpoint{
					{
						EndpointType: types.AccessEndpointType("STREAMING"),
						VpceId:       ptr.String("__VpceId__"),
					},
					{
						EndpointType: types.AccessEndpointType("STREAMING"),
						VpceId:       ptr.String("__VpceId__"),
					},
				},
				DisableIMDSV1: ptr.Bool(true),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeAppBlockBuilders.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeAppBlockBuilders(context.Background(), &DescribeAppBlockBuildersInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeAppBlockBuilders.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeAppBlocks(t *testing.T) {
	want := &DescribeAppBlocksOutput{
		AppBlocks: []types.AppBlock{
			{
				Name:        ptr.String("__Name__"),
				Arn:         ptr.String("__Arn__"),
				Description: ptr.String("__Description__"),
				DisplayName: ptr.String("__DisplayName__"),
				SourceS3Location: &types.S3Location{
					S3Bucket: ptr.String("__S3Bucket__"),
					S3Key:    ptr.String("__S3Key__"),
				},
				SetupScriptDetails: &types.ScriptDetails{
					ScriptS3Location: &types.S3Location{
						S3Bucket: ptr.String("__S3Bucket__"),
						S3Key:    ptr.String("__S3Key__"),
					},
					ExecutablePath:       ptr.String("__ExecutablePath__"),
					ExecutableParameters: ptr.String("__ExecutableParameters__"),
					TimeoutInSeconds:     ptr.Int32(1),
				},
				CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PostSetupScriptDetails: &types.ScriptDetails{
					ScriptS3Location: &types.S3Location{
						S3Bucket: ptr.String("__S3Bucket__"),
						S3Key:    ptr.String("__S3Key__"),
					},
					ExecutablePath:       ptr.String("__ExecutablePath__"),
					ExecutableParameters: ptr.String("__ExecutableParameters__"),
					TimeoutInSeconds:     ptr.Int32(1),
				},
				PackagingType: types.PackagingType("CUSTOM"),
				State:         types.AppBlockState("INACTIVE"),
				AppBlockErrors: []types.ErrorDetails{
					{
						ErrorCode:    ptr.String("__ErrorCode__"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
					{
						ErrorCode:    ptr.String("__ErrorCode__"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
				},
			},
			{
				Name:        ptr.String("__Name__"),
				Arn:         ptr.String("__Arn__"),
				Description: ptr.String("__Description__"),
				DisplayName: ptr.String("__DisplayName__"),
				SourceS3Location: &types.S3Location{
					S3Bucket: ptr.String("__S3Bucket__"),
					S3Key:    ptr.String("__S3Key__"),
				},
				SetupScriptDetails: &types.ScriptDetails{
					ScriptS3Location: &types.S3Location{
						S3Bucket: ptr.String("__S3Bucket__"),
						S3Key:    ptr.String("__S3Key__"),
					},
					ExecutablePath:       ptr.String("__ExecutablePath__"),
					ExecutableParameters: ptr.String("__ExecutableParameters__"),
					TimeoutInSeconds:     ptr.Int32(1),
				},
				CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PostSetupScriptDetails: &types.ScriptDetails{
					ScriptS3Location: &types.S3Location{
						S3Bucket: ptr.String("__S3Bucket__"),
						S3Key:    ptr.String("__S3Key__"),
					},
					ExecutablePath:       ptr.String("__ExecutablePath__"),
					ExecutableParameters: ptr.String("__ExecutableParameters__"),
					TimeoutInSeconds:     ptr.Int32(1),
				},
				PackagingType: types.PackagingType("CUSTOM"),
				State:         types.AppBlockState("INACTIVE"),
				AppBlockErrors: []types.ErrorDetails{
					{
						ErrorCode:    ptr.String("__ErrorCode__"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
					{
						ErrorCode:    ptr.String("__ErrorCode__"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeAppBlocks.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeAppBlocks(context.Background(), &DescribeAppBlocksInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeAppBlocks.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeAppLicenseUsage(t *testing.T) {
	want := &DescribeAppLicenseUsageOutput{
		AppLicenseUsages: []types.AdminAppLicenseUsageRecord{
			{
				UserArn:                   ptr.String("__UserArn__"),
				BillingPeriod:             ptr.String("__BillingPeriod__"),
				OwnerAWSAccountId:         ptr.String("__OwnerAWSAccountId__"),
				SubscriptionFirstUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				SubscriptionLastUsedDate:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LicenseType:               ptr.String("__LicenseType__"),
				UserId:                    ptr.String("__UserId__"),
			},
			{
				UserArn:                   ptr.String("__UserArn__"),
				BillingPeriod:             ptr.String("__BillingPeriod__"),
				OwnerAWSAccountId:         ptr.String("__OwnerAWSAccountId__"),
				SubscriptionFirstUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				SubscriptionLastUsedDate:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LicenseType:               ptr.String("__LicenseType__"),
				UserId:                    ptr.String("__UserId__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeAppLicenseUsage.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeAppLicenseUsage(context.Background(), &DescribeAppLicenseUsageInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeAppLicenseUsage.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeApplicationFleetAssociations(t *testing.T) {
	want := &DescribeApplicationFleetAssociationsOutput{
		ApplicationFleetAssociations: []types.ApplicationFleetAssociation{
			{
				FleetName:      ptr.String("__FleetName__"),
				ApplicationArn: ptr.String("__ApplicationArn__"),
			},
			{
				FleetName:      ptr.String("__FleetName__"),
				ApplicationArn: ptr.String("__ApplicationArn__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeApplicationFleetAssociations.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeApplicationFleetAssociations(context.Background(), &DescribeApplicationFleetAssociationsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeApplicationFleetAssociations.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeApplications(t *testing.T) {
	want := &DescribeApplicationsOutput{
		Applications: []types.Application{
			{
				Name:             ptr.String("__Name__"),
				DisplayName:      ptr.String("__DisplayName__"),
				IconURL:          ptr.String("__IconURL__"),
				LaunchPath:       ptr.String("__LaunchPath__"),
				LaunchParameters: ptr.String("__LaunchParameters__"),
				Enabled:          ptr.Bool(true),
				Metadata: map[string]string{
					"key0": "__Value__",
				},
				WorkingDirectory: ptr.String("__WorkingDirectory__"),
				Description:      ptr.String("__Description__"),
				Arn:              ptr.String("__Arn__"),
				AppBlockArn:      ptr.String("__AppBlockArn__"),
				IconS3Location: &types.S3Location{
					S3Bucket: ptr.String("__S3Bucket__"),
					S3Key:    ptr.String("__S3Key__"),
				},
				Platforms: []types.PlatformType{
					types.PlatformType("WINDOWS"),
					types.PlatformType("WINDOWS"),
				},
				InstanceFamilies: []string{
					"__Member__",
					"__Member__",
				},
				CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				Name:             ptr.String("__Name__"),
				DisplayName:      ptr.String("__DisplayName__"),
				IconURL:          ptr.String("__IconURL__"),
				LaunchPath:       ptr.String("__LaunchPath__"),
				LaunchParameters: ptr.String("__LaunchParameters__"),
				Enabled:          ptr.Bool(true),
				Metadata: map[string]string{
					"key0": "__Value__",
				},
				WorkingDirectory: ptr.String("__WorkingDirectory__"),
				Description:      ptr.String("__Description__"),
				Arn:              ptr.String("__Arn__"),
				AppBlockArn:      ptr.String("__AppBlockArn__"),
				IconS3Location: &types.S3Location{
					S3Bucket: ptr.String("__S3Bucket__"),
					S3Key:    ptr.String("__S3Key__"),
				},
				Platforms: []types.PlatformType{
					types.PlatformType("WINDOWS"),
					types.PlatformType("WINDOWS"),
				},
				InstanceFamilies: []string{
					"__Member__",
					"__Member__",
				},
				CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeApplications.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeApplications(context.Background(), &DescribeApplicationsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeApplications.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeDirectoryConfigs(t *testing.T) {
	want := &DescribeDirectoryConfigsOutput{
		DirectoryConfigs: []types.DirectoryConfig{
			{
				DirectoryName: ptr.String("__DirectoryName__"),
				OrganizationalUnitDistinguishedNames: []string{
					"__Member__",
					"__Member__",
				},
				ServiceAccountCredentials: &types.ServiceAccountCredentials{
					AccountName:     ptr.String("__AccountName__"),
					AccountPassword: ptr.String("__AccountPassword__"),
				},
				CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CertificateBasedAuthProperties: &types.CertificateBasedAuthProperties{
					Status:                  types.CertificateBasedAuthStatus("DISABLED"),
					CertificateAuthorityArn: ptr.String("__CertificateAuthorityArn__"),
				},
			},
			{
				DirectoryName: ptr.String("__DirectoryName__"),
				OrganizationalUnitDistinguishedNames: []string{
					"__Member__",
					"__Member__",
				},
				ServiceAccountCredentials: &types.ServiceAccountCredentials{
					AccountName:     ptr.String("__AccountName__"),
					AccountPassword: ptr.String("__AccountPassword__"),
				},
				CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CertificateBasedAuthProperties: &types.CertificateBasedAuthProperties{
					Status:                  types.CertificateBasedAuthStatus("DISABLED"),
					CertificateAuthorityArn: ptr.String("__CertificateAuthorityArn__"),
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeDirectoryConfigs.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeDirectoryConfigs(context.Background(), &DescribeDirectoryConfigsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeDirectoryConfigs.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeEntitlements(t *testing.T) {
	want := &DescribeEntitlementsOutput{
		Entitlements: []types.Entitlement{
			{
				Name:          ptr.String("__Name__"),
				StackName:     ptr.String("__StackName__"),
				Description:   ptr.String("__Description__"),
				AppVisibility: types.AppVisibility("ALL"),
				Attributes: []types.EntitlementAttribute{
					{
						Name:  ptr.String("__Name__"),
						Value: ptr.String("__Value__"),
					},
					{
						Name:  ptr.String("__Name__"),
						Value: ptr.String("__Value__"),
					},
				},
				CreatedTime:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastModifiedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				Name:          ptr.String("__Name__"),
				StackName:     ptr.String("__StackName__"),
				Description:   ptr.String("__Description__"),
				AppVisibility: types.AppVisibility("ALL"),
				Attributes: []types.EntitlementAttribute{
					{
						Name:  ptr.String("__Name__"),
						Value: ptr.String("__Value__"),
					},
					{
						Name:  ptr.String("__Name__"),
						Value: ptr.String("__Value__"),
					},
				},
				CreatedTime:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastModifiedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeEntitlements.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeEntitlements(context.Background(), &DescribeEntitlementsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeEntitlements.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeFleets(t *testing.T) {
	want := &DescribeFleetsOutput{
		Fleets: []types.Fleet{
			{
				Arn:          ptr.String("__Arn__"),
				Name:         ptr.String("__Name__"),
				DisplayName:  ptr.String("__DisplayName__"),
				Description:  ptr.String("__Description__"),
				ImageName:    ptr.String("__ImageName__"),
				ImageArn:     ptr.String("__ImageArn__"),
				InstanceType: ptr.String("__InstanceType__"),
				FleetType:    types.FleetType("ALWAYS_ON"),
				ComputeCapacityStatus: &types.ComputeCapacityStatus{
					Desired:                     ptr.Int32(1),
					Running:                     ptr.Int32(1),
					InUse:                       ptr.Int32(1),
					Available:                   ptr.Int32(1),
					DesiredUserSessions:         ptr.Int32(1),
					AvailableUserSessions:       ptr.Int32(1),
					ActiveUserSessions:          ptr.Int32(1),
					ActualUserSessions:          ptr.Int32(1),
					Draining:                    ptr.Int32(1),
					DrainModeActiveUserSessions: ptr.Int32(1),
					DrainModeUnusedUserSessions: ptr.Int32(1),
				},
				MaxUserDurationInSeconds:   ptr.Int32(1),
				DisconnectTimeoutInSeconds: ptr.Int32(1),
				State:                      types.FleetState("STARTING"),
				VpcConfig: &types.VpcConfig{
					SubnetIds: []string{
						"__Member__",
						"__Member__",
					},
					SecurityGroupIds: []string{
						"__Member__",
						"__Member__",
					},
				},
				CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				FleetErrors: []types.FleetError{
					{
						ErrorCode:    types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
					{
						ErrorCode:    types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
				},
				EnableDefaultInternetAccess: ptr.Bool(true),
				DomainJoinInfo: &types.DomainJoinInfo{
					DirectoryName:                       ptr.String("__DirectoryName__"),
					OrganizationalUnitDistinguishedName: ptr.String("__OrganizationalUnitDistinguishedName__"),
				},
				IdleDisconnectTimeoutInSeconds: ptr.Int32(1),
				IamRoleArn:                     ptr.String("__IamRoleArn__"),
				StreamView:                     types.StreamView("APP"),
				Platform:                       types.PlatformType("WINDOWS"),
				MaxConcurrentSessions:          ptr.Int32(1),
				UsbDeviceFilterStrings: []string{
					"__Member__",
					"__Member__",
				},
				SessionScriptS3Location: &types.S3Location{
					S3Bucket: ptr.String("__S3Bucket__"),
					S3Key:    ptr.String("__S3Key__"),
				},
				MaxSessionsPerInstance: ptr.Int32(1),
				RootVolumeConfig: &types.VolumeConfig{
					VolumeSizeInGb: ptr.Int32(1),
				},
				DisableIMDSV1: ptr.Bool(true),
			},
			{
				Arn:          ptr.String("__Arn__"),
				Name:         ptr.String("__Name__"),
				DisplayName:  ptr.String("__DisplayName__"),
				Description:  ptr.String("__Description__"),
				ImageName:    ptr.String("__ImageName__"),
				ImageArn:     ptr.String("__ImageArn__"),
				InstanceType: ptr.String("__InstanceType__"),
				FleetType:    types.FleetType("ALWAYS_ON"),
				ComputeCapacityStatus: &types.ComputeCapacityStatus{
					Desired:                     ptr.Int32(1),
					Running:                     ptr.Int32(1),
					InUse:                       ptr.Int32(1),
					Available:                   ptr.Int32(1),
					DesiredUserSessions:         ptr.Int32(1),
					AvailableUserSessions:       ptr.Int32(1),
					ActiveUserSessions:          ptr.Int32(1),
					ActualUserSessions:          ptr.Int32(1),
					Draining:                    ptr.Int32(1),
					DrainModeActiveUserSessions: ptr.Int32(1),
					DrainModeUnusedUserSessions: ptr.Int32(1),
				},
				MaxUserDurationInSeconds:   ptr.Int32(1),
				DisconnectTimeoutInSeconds: ptr.Int32(1),
				State:                      types.FleetState("STARTING"),
				VpcConfig: &types.VpcConfig{
					SubnetIds: []string{
						"__Member__",
						"__Member__",
					},
					SecurityGroupIds: []string{
						"__Member__",
						"__Member__",
					},
				},
				CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				FleetErrors: []types.FleetError{
					{
						ErrorCode:    types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
					{
						ErrorCode:    types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
				},
				EnableDefaultInternetAccess: ptr.Bool(true),
				DomainJoinInfo: &types.DomainJoinInfo{
					DirectoryName:                       ptr.String("__DirectoryName__"),
					OrganizationalUnitDistinguishedName: ptr.String("__OrganizationalUnitDistinguishedName__"),
				},
				IdleDisconnectTimeoutInSeconds: ptr.Int32(1),
				IamRoleArn:                     ptr.String("__IamRoleArn__"),
				StreamView:                     types.StreamView("APP"),
				Platform:                       types.PlatformType("WINDOWS"),
				MaxConcurrentSessions:          ptr.Int32(1),
				UsbDeviceFilterStrings: []string{
					"__Member__",
					"__Member__",
				},
				SessionScriptS3Location: &types.S3Location{
					S3Bucket: ptr.String("__S3Bucket__"),
					S3Key:    ptr.String("__S3Key__"),
				},
				MaxSessionsPerInstance: ptr.Int32(1),
				RootVolumeConfig: &types.VolumeConfig{
					VolumeSizeInGb: ptr.Int32(1),
				},
				DisableIMDSV1: ptr.Bool(true),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeFleets.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeFleets(context.Background(), &DescribeFleetsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeFleets.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeImageBuilders(t *testing.T) {
	want := &DescribeImageBuildersOutput{
		ImageBuilders: []types.ImageBuilder{
			{
				Name:        ptr.String("__Name__"),
				Arn:         ptr.String("__Arn__"),
				ImageArn:    ptr.String("__ImageArn__"),
				Description: ptr.String("__Description__"),
				DisplayName: ptr.String("__DisplayName__"),
				VpcConfig: &types.VpcConfig{
					SubnetIds: []string{
						"__Member__",
						"__Member__",
					},
					SecurityGroupIds: []string{
						"__Member__",
						"__Member__",
					},
				},
				InstanceType: ptr.String("__InstanceType__"),
				Platform:     types.PlatformType("WINDOWS"),
				IamRoleArn:   ptr.String("__IamRoleArn__"),
				State:        types.ImageBuilderState("PENDING"),
				StateChangeReason: &types.ImageBuilderStateChangeReason{
					Code:    types.ImageBuilderStateChangeReasonCode("INTERNAL_ERROR"),
					Message: ptr.String("__Message__"),
				},
				CreatedTime:                 ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				EnableDefaultInternetAccess: ptr.Bool(true),
				DomainJoinInfo: &types.DomainJoinInfo{
					DirectoryName:                       ptr.String("__DirectoryName__"),
					OrganizationalUnitDistinguishedName: ptr.String("__OrganizationalUnitDistinguishedName__"),
				},
				NetworkAccessConfiguration: &types.NetworkAccessConfiguration{
					EniPrivateIpAddress: ptr.String("__EniPrivateIpAddress__"),
					EniIpv6Addresses: []string{
						"__Member__",
						"__Member__",
					},
					EniId: ptr.String("__EniId__"),
				},
				ImageBuilderErrors: []types.ResourceError{
					{
						ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
						ErrorMessage:   ptr.String("__ErrorMessage__"),
						ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
					{
						ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
						ErrorMessage:   ptr.String("__ErrorMessage__"),
						ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
				},
				AppstreamAgentVersion: ptr.String("__AppstreamAgentVersion__"),
				AccessEndpoints: []types.AccessEndpoint{
					{
						EndpointType: types.AccessEndpointType("STREAMING"),
						VpceId:       ptr.String("__VpceId__"),
					},
					{
						EndpointType: types.AccessEndpointType("STREAMING"),
						VpceId:       ptr.String("__VpceId__"),
					},
				},
				RootVolumeConfig: &types.VolumeConfig{
					VolumeSizeInGb: ptr.Int32(1),
				},
				LatestAppstreamAgentVersion: types.LatestAppstreamAgentVersion("TRUE"),
				DisableIMDSV1:               ptr.Bool(true),
			},
			{
				Name:        ptr.String("__Name__"),
				Arn:         ptr.String("__Arn__"),
				ImageArn:    ptr.String("__ImageArn__"),
				Description: ptr.String("__Description__"),
				DisplayName: ptr.String("__DisplayName__"),
				VpcConfig: &types.VpcConfig{
					SubnetIds: []string{
						"__Member__",
						"__Member__",
					},
					SecurityGroupIds: []string{
						"__Member__",
						"__Member__",
					},
				},
				InstanceType: ptr.String("__InstanceType__"),
				Platform:     types.PlatformType("WINDOWS"),
				IamRoleArn:   ptr.String("__IamRoleArn__"),
				State:        types.ImageBuilderState("PENDING"),
				StateChangeReason: &types.ImageBuilderStateChangeReason{
					Code:    types.ImageBuilderStateChangeReasonCode("INTERNAL_ERROR"),
					Message: ptr.String("__Message__"),
				},
				CreatedTime:                 ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				EnableDefaultInternetAccess: ptr.Bool(true),
				DomainJoinInfo: &types.DomainJoinInfo{
					DirectoryName:                       ptr.String("__DirectoryName__"),
					OrganizationalUnitDistinguishedName: ptr.String("__OrganizationalUnitDistinguishedName__"),
				},
				NetworkAccessConfiguration: &types.NetworkAccessConfiguration{
					EniPrivateIpAddress: ptr.String("__EniPrivateIpAddress__"),
					EniIpv6Addresses: []string{
						"__Member__",
						"__Member__",
					},
					EniId: ptr.String("__EniId__"),
				},
				ImageBuilderErrors: []types.ResourceError{
					{
						ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
						ErrorMessage:   ptr.String("__ErrorMessage__"),
						ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
					{
						ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
						ErrorMessage:   ptr.String("__ErrorMessage__"),
						ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
				},
				AppstreamAgentVersion: ptr.String("__AppstreamAgentVersion__"),
				AccessEndpoints: []types.AccessEndpoint{
					{
						EndpointType: types.AccessEndpointType("STREAMING"),
						VpceId:       ptr.String("__VpceId__"),
					},
					{
						EndpointType: types.AccessEndpointType("STREAMING"),
						VpceId:       ptr.String("__VpceId__"),
					},
				},
				RootVolumeConfig: &types.VolumeConfig{
					VolumeSizeInGb: ptr.Int32(1),
				},
				LatestAppstreamAgentVersion: types.LatestAppstreamAgentVersion("TRUE"),
				DisableIMDSV1:               ptr.Bool(true),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeImageBuilders.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeImageBuilders(context.Background(), &DescribeImageBuildersInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeImageBuilders.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeImagePermissions(t *testing.T) {
	want := &DescribeImagePermissionsOutput{
		Name: ptr.String("__Name__"),
		SharedImagePermissionsList: []types.SharedImagePermissions{
			{
				SharedAccountId: ptr.String("__SharedAccountId__"),
				ImagePermissions: &types.ImagePermissions{
					AllowFleet:        ptr.Bool(true),
					AllowImageBuilder: ptr.Bool(true),
				},
			},
			{
				SharedAccountId: ptr.String("__SharedAccountId__"),
				ImagePermissions: &types.ImagePermissions{
					AllowFleet:        ptr.Bool(true),
					AllowImageBuilder: ptr.Bool(true),
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeImagePermissions.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeImagePermissions(context.Background(), &DescribeImagePermissionsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeImagePermissions.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeImages(t *testing.T) {
	want := &DescribeImagesOutput{
		Images: []types.Image{
			{
				Name:                  ptr.String("__Name__"),
				Arn:                   ptr.String("__Arn__"),
				BaseImageArn:          ptr.String("__BaseImageArn__"),
				DisplayName:           ptr.String("__DisplayName__"),
				State:                 types.ImageState("PENDING"),
				Visibility:            types.VisibilityType("PUBLIC"),
				ImageBuilderSupported: ptr.Bool(true),
				ImageBuilderName:      ptr.String("__ImageBuilderName__"),
				Platform:              types.PlatformType("WINDOWS"),
				Description:           ptr.String("__Description__"),
				StateChangeReason: &types.ImageStateChangeReason{
					Code:    types.ImageStateChangeReasonCode("INTERNAL_ERROR"),
					Message: ptr.String("__Message__"),
				},
				Applications: []types.Application{
					{
						Name:             ptr.String("__Name__"),
						DisplayName:      ptr.String("__DisplayName__"),
						IconURL:          ptr.String("__IconURL__"),
						LaunchPath:       ptr.String("__LaunchPath__"),
						LaunchParameters: ptr.String("__LaunchParameters__"),
						Enabled:          ptr.Bool(true),
						Metadata: map[string]string{
							"key0": "__Value__",
						},
						WorkingDirectory: ptr.String("__WorkingDirectory__"),
						Description:      ptr.String("__Description__"),
						Arn:              ptr.String("__Arn__"),
						AppBlockArn:      ptr.String("__AppBlockArn__"),
						IconS3Location: &types.S3Location{
							S3Bucket: ptr.String("__S3Bucket__"),
							S3Key:    ptr.String("__S3Key__"),
						},
						Platforms: []types.PlatformType{
							types.PlatformType("WINDOWS"),
							types.PlatformType("WINDOWS"),
						},
						InstanceFamilies: []string{
							"__Member__",
							"__Member__",
						},
						CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
					{
						Name:             ptr.String("__Name__"),
						DisplayName:      ptr.String("__DisplayName__"),
						IconURL:          ptr.String("__IconURL__"),
						LaunchPath:       ptr.String("__LaunchPath__"),
						LaunchParameters: ptr.String("__LaunchParameters__"),
						Enabled:          ptr.Bool(true),
						Metadata: map[string]string{
							"key0": "__Value__",
						},
						WorkingDirectory: ptr.String("__WorkingDirectory__"),
						Description:      ptr.String("__Description__"),
						Arn:              ptr.String("__Arn__"),
						AppBlockArn:      ptr.String("__AppBlockArn__"),
						IconS3Location: &types.S3Location{
							S3Bucket: ptr.String("__S3Bucket__"),
							S3Key:    ptr.String("__S3Key__"),
						},
						Platforms: []types.PlatformType{
							types.PlatformType("WINDOWS"),
							types.PlatformType("WINDOWS"),
						},
						InstanceFamilies: []string{
							"__Member__",
							"__Member__",
						},
						CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
				},
				CreatedTime:                 ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PublicBaseImageReleasedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				AppstreamAgentVersion:       ptr.String("__AppstreamAgentVersion__"),
				ImagePermissions: &types.ImagePermissions{
					AllowFleet:        ptr.Bool(true),
					AllowImageBuilder: ptr.Bool(true),
				},
				ImageErrors: []types.ResourceError{
					{
						ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
						ErrorMessage:   ptr.String("__ErrorMessage__"),
						ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
					{
						ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
						ErrorMessage:   ptr.String("__ErrorMessage__"),
						ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
				},
				LatestAppstreamAgentVersion: types.LatestAppstreamAgentVersion("TRUE"),
				SupportedInstanceFamilies: []string{
					"__Member__",
					"__Member__",
				},
				DynamicAppProvidersEnabled: types.DynamicAppProvidersEnabled("ENABLED"),
				ImageSharedWithOthers:      types.ImageSharedWithOthers("TRUE"),
				ManagedSoftwareIncluded:    ptr.Bool(true),
				ImageType:                  types.ImageType("CUSTOM"),
			},
			{
				Name:                  ptr.String("__Name__"),
				Arn:                   ptr.String("__Arn__"),
				BaseImageArn:          ptr.String("__BaseImageArn__"),
				DisplayName:           ptr.String("__DisplayName__"),
				State:                 types.ImageState("PENDING"),
				Visibility:            types.VisibilityType("PUBLIC"),
				ImageBuilderSupported: ptr.Bool(true),
				ImageBuilderName:      ptr.String("__ImageBuilderName__"),
				Platform:              types.PlatformType("WINDOWS"),
				Description:           ptr.String("__Description__"),
				StateChangeReason: &types.ImageStateChangeReason{
					Code:    types.ImageStateChangeReasonCode("INTERNAL_ERROR"),
					Message: ptr.String("__Message__"),
				},
				Applications: []types.Application{
					{
						Name:             ptr.String("__Name__"),
						DisplayName:      ptr.String("__DisplayName__"),
						IconURL:          ptr.String("__IconURL__"),
						LaunchPath:       ptr.String("__LaunchPath__"),
						LaunchParameters: ptr.String("__LaunchParameters__"),
						Enabled:          ptr.Bool(true),
						Metadata: map[string]string{
							"key0": "__Value__",
						},
						WorkingDirectory: ptr.String("__WorkingDirectory__"),
						Description:      ptr.String("__Description__"),
						Arn:              ptr.String("__Arn__"),
						AppBlockArn:      ptr.String("__AppBlockArn__"),
						IconS3Location: &types.S3Location{
							S3Bucket: ptr.String("__S3Bucket__"),
							S3Key:    ptr.String("__S3Key__"),
						},
						Platforms: []types.PlatformType{
							types.PlatformType("WINDOWS"),
							types.PlatformType("WINDOWS"),
						},
						InstanceFamilies: []string{
							"__Member__",
							"__Member__",
						},
						CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
					{
						Name:             ptr.String("__Name__"),
						DisplayName:      ptr.String("__DisplayName__"),
						IconURL:          ptr.String("__IconURL__"),
						LaunchPath:       ptr.String("__LaunchPath__"),
						LaunchParameters: ptr.String("__LaunchParameters__"),
						Enabled:          ptr.Bool(true),
						Metadata: map[string]string{
							"key0": "__Value__",
						},
						WorkingDirectory: ptr.String("__WorkingDirectory__"),
						Description:      ptr.String("__Description__"),
						Arn:              ptr.String("__Arn__"),
						AppBlockArn:      ptr.String("__AppBlockArn__"),
						IconS3Location: &types.S3Location{
							S3Bucket: ptr.String("__S3Bucket__"),
							S3Key:    ptr.String("__S3Key__"),
						},
						Platforms: []types.PlatformType{
							types.PlatformType("WINDOWS"),
							types.PlatformType("WINDOWS"),
						},
						InstanceFamilies: []string{
							"__Member__",
							"__Member__",
						},
						CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
				},
				CreatedTime:                 ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PublicBaseImageReleasedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				AppstreamAgentVersion:       ptr.String("__AppstreamAgentVersion__"),
				ImagePermissions: &types.ImagePermissions{
					AllowFleet:        ptr.Bool(true),
					AllowImageBuilder: ptr.Bool(true),
				},
				ImageErrors: []types.ResourceError{
					{
						ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
						ErrorMessage:   ptr.String("__ErrorMessage__"),
						ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
					{
						ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
						ErrorMessage:   ptr.String("__ErrorMessage__"),
						ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
				},
				LatestAppstreamAgentVersion: types.LatestAppstreamAgentVersion("TRUE"),
				SupportedInstanceFamilies: []string{
					"__Member__",
					"__Member__",
				},
				DynamicAppProvidersEnabled: types.DynamicAppProvidersEnabled("ENABLED"),
				ImageSharedWithOthers:      types.ImageSharedWithOthers("TRUE"),
				ManagedSoftwareIncluded:    ptr.Bool(true),
				ImageType:                  types.ImageType("CUSTOM"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeImages.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeImages(context.Background(), &DescribeImagesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeImages.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeSessions(t *testing.T) {
	want := &DescribeSessionsOutput{
		Sessions: []types.Session{
			{
				Id:                 ptr.String("__Id__"),
				UserId:             ptr.String("__UserId__"),
				StackName:          ptr.String("__StackName__"),
				FleetName:          ptr.String("__FleetName__"),
				State:              types.SessionState("ACTIVE"),
				ConnectionState:    types.SessionConnectionState("CONNECTED"),
				StartTime:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				MaxExpirationTime:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				AuthenticationType: types.AuthenticationType("API"),
				NetworkAccessConfiguration: &types.NetworkAccessConfiguration{
					EniPrivateIpAddress: ptr.String("__EniPrivateIpAddress__"),
					EniIpv6Addresses: []string{
						"__Member__",
						"__Member__",
					},
					EniId: ptr.String("__EniId__"),
				},
				InstanceId:          ptr.String("__InstanceId__"),
				InstanceDrainStatus: types.InstanceDrainStatus("ACTIVE"),
			},
			{
				Id:                 ptr.String("__Id__"),
				UserId:             ptr.String("__UserId__"),
				StackName:          ptr.String("__StackName__"),
				FleetName:          ptr.String("__FleetName__"),
				State:              types.SessionState("ACTIVE"),
				ConnectionState:    types.SessionConnectionState("CONNECTED"),
				StartTime:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				MaxExpirationTime:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				AuthenticationType: types.AuthenticationType("API"),
				NetworkAccessConfiguration: &types.NetworkAccessConfiguration{
					EniPrivateIpAddress: ptr.String("__EniPrivateIpAddress__"),
					EniIpv6Addresses: []string{
						"__Member__",
						"__Member__",
					},
					EniId: ptr.String("__EniId__"),
				},
				InstanceId:          ptr.String("__InstanceId__"),
				InstanceDrainStatus: types.InstanceDrainStatus("ACTIVE"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeSessions.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeSessions(context.Background(), &DescribeSessionsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeSessions.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeSoftwareAssociations(t *testing.T) {
	want := &DescribeSoftwareAssociationsOutput{
		AssociatedResource: ptr.String("__AssociatedResource__"),
		SoftwareAssociations: []types.SoftwareAssociations{
			{
				SoftwareName: ptr.String("__SoftwareName__"),
				Status:       types.SoftwareDeploymentStatus("STAGED_FOR_INSTALLATION"),
				DeploymentError: []types.ErrorDetails{
					{
						ErrorCode:    ptr.String("__ErrorCode__"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
					{
						ErrorCode:    ptr.String("__ErrorCode__"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
				},
			},
			{
				SoftwareName: ptr.String("__SoftwareName__"),
				Status:       types.SoftwareDeploymentStatus("STAGED_FOR_INSTALLATION"),
				DeploymentError: []types.ErrorDetails{
					{
						ErrorCode:    ptr.String("__ErrorCode__"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
					{
						ErrorCode:    ptr.String("__ErrorCode__"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeSoftwareAssociations.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeSoftwareAssociations(context.Background(), &DescribeSoftwareAssociationsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeSoftwareAssociations.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeStacks(t *testing.T) {
	want := &DescribeStacksOutput{
		Stacks: []types.Stack{
			{
				Arn:         ptr.String("__Arn__"),
				Name:        ptr.String("__Name__"),
				Description: ptr.String("__Description__"),
				DisplayName: ptr.String("__DisplayName__"),
				CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				StorageConnectors: []types.StorageConnector{
					{
						ConnectorType:      types.StorageConnectorType("HOMEFOLDERS"),
						ResourceIdentifier: ptr.String("__ResourceIdentifier__"),
						Domains: []string{
							"__Member__",
							"__Member__",
						},
						DomainsRequireAdminConsent: []string{
							"__Member__",
							"__Member__",
						},
					},
					{
						ConnectorType:      types.StorageConnectorType("HOMEFOLDERS"),
						ResourceIdentifier: ptr.String("__ResourceIdentifier__"),
						Domains: []string{
							"__Member__",
							"__Member__",
						},
						DomainsRequireAdminConsent: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
				RedirectURL: ptr.String("__RedirectURL__"),
				FeedbackURL: ptr.String("__FeedbackURL__"),
				StackErrors: []types.StackError{
					{
						ErrorCode:    types.StackErrorCode("STORAGE_CONNECTOR_ERROR"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
					{
						ErrorCode:    types.StackErrorCode("STORAGE_CONNECTOR_ERROR"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
				},
				UserSettings: []types.UserSetting{
					{
						Action:        types.Action("CLIPBOARD_COPY_FROM_LOCAL_DEVICE"),
						Permission:    types.Permission("ENABLED"),
						MaximumLength: ptr.Int32(1),
					},
					{
						Action:        types.Action("CLIPBOARD_COPY_FROM_LOCAL_DEVICE"),
						Permission:    types.Permission("ENABLED"),
						MaximumLength: ptr.Int32(1),
					},
				},
				ApplicationSettings: &types.ApplicationSettingsResponse{
					Enabled:       ptr.Bool(true),
					SettingsGroup: ptr.String("__SettingsGroup__"),
					S3BucketName:  ptr.String("__S3BucketName__"),
				},
				AccessEndpoints: []types.AccessEndpoint{
					{
						EndpointType: types.AccessEndpointType("STREAMING"),
						VpceId:       ptr.String("__VpceId__"),
					},
					{
						EndpointType: types.AccessEndpointType("STREAMING"),
						VpceId:       ptr.String("__VpceId__"),
					},
				},
				EmbedHostDomains: []string{
					"__Member__",
					"__Member__",
				},
				StreamingExperienceSettings: &types.StreamingExperienceSettings{
					PreferredProtocol: types.PreferredProtocol("TCP"),
				},
				ContentRedirection: &types.ContentRedirection{
					HostToClient: &types.UrlRedirectionConfig{
						Enabled: ptr.Bool(true),
						AllowedUrls: []string{
							"__Member__",
							"__Member__",
						},
						DeniedUrls: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
				AgentAccessConfig: &types.AgentAccessConfig{
					Settings: []types.AgentAccessSetting{
						{
							AgentAction: types.AgentAction("COMPUTER_VISION"),
							Permission:  types.Permission("ENABLED"),
						},
						{
							AgentAction: types.AgentAction("COMPUTER_VISION"),
							Permission:  types.Permission("ENABLED"),
						},
					},
					S3BucketArn:              ptr.String("__S3BucketArn__"),
					ScreenshotsUploadEnabled: ptr.Bool(true),
					ScreenResolution:         types.ScreenResolution("W_1280xH_720"),
					ScreenImageFormat:        types.ScreenImageFormat("PNG"),
					UserControlMode:          types.UserControlMode("VIEW_ONLY"),
				},
			},
			{
				Arn:         ptr.String("__Arn__"),
				Name:        ptr.String("__Name__"),
				Description: ptr.String("__Description__"),
				DisplayName: ptr.String("__DisplayName__"),
				CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				StorageConnectors: []types.StorageConnector{
					{
						ConnectorType:      types.StorageConnectorType("HOMEFOLDERS"),
						ResourceIdentifier: ptr.String("__ResourceIdentifier__"),
						Domains: []string{
							"__Member__",
							"__Member__",
						},
						DomainsRequireAdminConsent: []string{
							"__Member__",
							"__Member__",
						},
					},
					{
						ConnectorType:      types.StorageConnectorType("HOMEFOLDERS"),
						ResourceIdentifier: ptr.String("__ResourceIdentifier__"),
						Domains: []string{
							"__Member__",
							"__Member__",
						},
						DomainsRequireAdminConsent: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
				RedirectURL: ptr.String("__RedirectURL__"),
				FeedbackURL: ptr.String("__FeedbackURL__"),
				StackErrors: []types.StackError{
					{
						ErrorCode:    types.StackErrorCode("STORAGE_CONNECTOR_ERROR"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
					{
						ErrorCode:    types.StackErrorCode("STORAGE_CONNECTOR_ERROR"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
				},
				UserSettings: []types.UserSetting{
					{
						Action:        types.Action("CLIPBOARD_COPY_FROM_LOCAL_DEVICE"),
						Permission:    types.Permission("ENABLED"),
						MaximumLength: ptr.Int32(1),
					},
					{
						Action:        types.Action("CLIPBOARD_COPY_FROM_LOCAL_DEVICE"),
						Permission:    types.Permission("ENABLED"),
						MaximumLength: ptr.Int32(1),
					},
				},
				ApplicationSettings: &types.ApplicationSettingsResponse{
					Enabled:       ptr.Bool(true),
					SettingsGroup: ptr.String("__SettingsGroup__"),
					S3BucketName:  ptr.String("__S3BucketName__"),
				},
				AccessEndpoints: []types.AccessEndpoint{
					{
						EndpointType: types.AccessEndpointType("STREAMING"),
						VpceId:       ptr.String("__VpceId__"),
					},
					{
						EndpointType: types.AccessEndpointType("STREAMING"),
						VpceId:       ptr.String("__VpceId__"),
					},
				},
				EmbedHostDomains: []string{
					"__Member__",
					"__Member__",
				},
				StreamingExperienceSettings: &types.StreamingExperienceSettings{
					PreferredProtocol: types.PreferredProtocol("TCP"),
				},
				ContentRedirection: &types.ContentRedirection{
					HostToClient: &types.UrlRedirectionConfig{
						Enabled: ptr.Bool(true),
						AllowedUrls: []string{
							"__Member__",
							"__Member__",
						},
						DeniedUrls: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
				AgentAccessConfig: &types.AgentAccessConfig{
					Settings: []types.AgentAccessSetting{
						{
							AgentAction: types.AgentAction("COMPUTER_VISION"),
							Permission:  types.Permission("ENABLED"),
						},
						{
							AgentAction: types.AgentAction("COMPUTER_VISION"),
							Permission:  types.Permission("ENABLED"),
						},
					},
					S3BucketArn:              ptr.String("__S3BucketArn__"),
					ScreenshotsUploadEnabled: ptr.Bool(true),
					ScreenResolution:         types.ScreenResolution("W_1280xH_720"),
					ScreenImageFormat:        types.ScreenImageFormat("PNG"),
					UserControlMode:          types.UserControlMode("VIEW_ONLY"),
				},
			},
		},
		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_DescribeThemeForStack(t *testing.T) {
	want := &DescribeThemeForStackOutput{
		Theme: &types.Theme{
			StackName:      ptr.String("__StackName__"),
			State:          types.ThemeState("ENABLED"),
			ThemeTitleText: ptr.String("__ThemeTitleText__"),
			ThemeStyling:   types.ThemeStyling("LIGHT_BLUE"),
			ThemeFooterLinks: []types.ThemeFooterLink{
				{
					DisplayName:   ptr.String("__DisplayName__"),
					FooterLinkURL: ptr.String("__FooterLinkURL__"),
				},
				{
					DisplayName:   ptr.String("__DisplayName__"),
					FooterLinkURL: ptr.String("__FooterLinkURL__"),
				},
			},
			ThemeOrganizationLogoURL: ptr.String("__ThemeOrganizationLogoURL__"),
			ThemeFaviconURL:          ptr.String("__ThemeFaviconURL__"),
			CreatedTime:              ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeThemeForStack.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeThemeForStack(context.Background(), &DescribeThemeForStackInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeThemeForStack.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeUsageReportSubscriptions(t *testing.T) {
	want := &DescribeUsageReportSubscriptionsOutput{
		UsageReportSubscriptions: []types.UsageReportSubscription{
			{
				S3BucketName:            ptr.String("__S3BucketName__"),
				Schedule:                types.UsageReportSchedule("DAILY"),
				LastGeneratedReportDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				SubscriptionErrors: []types.LastReportGenerationExecutionError{
					{
						ErrorCode:    types.UsageReportExecutionErrorCode("RESOURCE_NOT_FOUND"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
					{
						ErrorCode:    types.UsageReportExecutionErrorCode("RESOURCE_NOT_FOUND"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
				},
			},
			{
				S3BucketName:            ptr.String("__S3BucketName__"),
				Schedule:                types.UsageReportSchedule("DAILY"),
				LastGeneratedReportDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				SubscriptionErrors: []types.LastReportGenerationExecutionError{
					{
						ErrorCode:    types.UsageReportExecutionErrorCode("RESOURCE_NOT_FOUND"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
					{
						ErrorCode:    types.UsageReportExecutionErrorCode("RESOURCE_NOT_FOUND"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeUsageReportSubscriptions.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeUsageReportSubscriptions(context.Background(), &DescribeUsageReportSubscriptionsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeUsageReportSubscriptions.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeUserStackAssociations(t *testing.T) {
	want := &DescribeUserStackAssociationsOutput{
		UserStackAssociations: []types.UserStackAssociation{
			{
				StackName:             ptr.String("__StackName__"),
				UserName:              ptr.String("__UserName__"),
				AuthenticationType:    types.AuthenticationType("API"),
				SendEmailNotification: ptr.Bool(true),
			},
			{
				StackName:             ptr.String("__StackName__"),
				UserName:              ptr.String("__UserName__"),
				AuthenticationType:    types.AuthenticationType("API"),
				SendEmailNotification: ptr.Bool(true),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeUserStackAssociations.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeUserStackAssociations(context.Background(), &DescribeUserStackAssociationsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeUserStackAssociations.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeUsers(t *testing.T) {
	want := &DescribeUsersOutput{
		Users: []types.User{
			{
				Arn:                ptr.String("__Arn__"),
				UserName:           ptr.String("__UserName__"),
				Enabled:            ptr.Bool(true),
				Status:             ptr.String("__Status__"),
				FirstName:          ptr.String("__FirstName__"),
				LastName:           ptr.String("__LastName__"),
				CreatedTime:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				AuthenticationType: types.AuthenticationType("API"),
			},
			{
				Arn:                ptr.String("__Arn__"),
				UserName:           ptr.String("__UserName__"),
				Enabled:            ptr.Bool(true),
				Status:             ptr.String("__Status__"),
				FirstName:          ptr.String("__FirstName__"),
				LastName:           ptr.String("__LastName__"),
				CreatedTime:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				AuthenticationType: types.AuthenticationType("API"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeUsers.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DescribeUsers(context.Background(), &DescribeUsersInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeUsers.response", err)
	}
}

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

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

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

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

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

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

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

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

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

func TestCheckResponseSnapshot_GetExportImageTask(t *testing.T) {
	want := &GetExportImageTaskOutput{
		ExportImageTask: &types.ExportImageTask{
			TaskId:         ptr.String("__TaskId__"),
			ImageArn:       ptr.String("__ImageArn__"),
			AmiName:        ptr.String("__AmiName__"),
			CreatedDate:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			AmiDescription: ptr.String("__AmiDescription__"),
			State:          types.ExportImageTaskState("EXPORTING"),
			AmiId:          ptr.String("__AmiId__"),
			TagSpecifications: map[string]string{
				"key0": "__Value__",
			},
			ErrorDetails: []types.ErrorDetails{
				{
					ErrorCode:    ptr.String("__ErrorCode__"),
					ErrorMessage: ptr.String("__ErrorMessage__"),
				},
				{
					ErrorCode:    ptr.String("__ErrorCode__"),
					ErrorMessage: ptr.String("__ErrorMessage__"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetExportImageTask.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetExportImageTask(context.Background(), &GetExportImageTaskInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetExportImageTask.response", err)
	}
}

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

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

func TestCheckResponseSnapshot_ListEntitledApplications(t *testing.T) {
	want := &ListEntitledApplicationsOutput{
		EntitledApplications: []types.EntitledApplication{
			{
				ApplicationIdentifier: ptr.String("__ApplicationIdentifier__"),
			},
			{
				ApplicationIdentifier: ptr.String("__ApplicationIdentifier__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListEntitledApplications.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListEntitledApplications(context.Background(), &ListEntitledApplicationsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListEntitledApplications.response", err)
	}
}

func TestCheckResponseSnapshot_ListExportImageTasks(t *testing.T) {
	want := &ListExportImageTasksOutput{
		ExportImageTasks: []types.ExportImageTask{
			{
				TaskId:         ptr.String("__TaskId__"),
				ImageArn:       ptr.String("__ImageArn__"),
				AmiName:        ptr.String("__AmiName__"),
				CreatedDate:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				AmiDescription: ptr.String("__AmiDescription__"),
				State:          types.ExportImageTaskState("EXPORTING"),
				AmiId:          ptr.String("__AmiId__"),
				TagSpecifications: map[string]string{
					"key0": "__Value__",
				},
				ErrorDetails: []types.ErrorDetails{
					{
						ErrorCode:    ptr.String("__ErrorCode__"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
					{
						ErrorCode:    ptr.String("__ErrorCode__"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
				},
			},
			{
				TaskId:         ptr.String("__TaskId__"),
				ImageArn:       ptr.String("__ImageArn__"),
				AmiName:        ptr.String("__AmiName__"),
				CreatedDate:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				AmiDescription: ptr.String("__AmiDescription__"),
				State:          types.ExportImageTaskState("EXPORTING"),
				AmiId:          ptr.String("__AmiId__"),
				TagSpecifications: map[string]string{
					"key0": "__Value__",
				},
				ErrorDetails: []types.ErrorDetails{
					{
						ErrorCode:    ptr.String("__ErrorCode__"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
					{
						ErrorCode:    ptr.String("__ErrorCode__"),
						ErrorMessage: ptr.String("__ErrorMessage__"),
					},
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListExportImageTasks.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListExportImageTasks(context.Background(), &ListExportImageTasksInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListExportImageTasks.response", err)
	}
}

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

func TestCheckResponseSnapshot_StartAppBlockBuilder(t *testing.T) {
	want := &StartAppBlockBuilderOutput{
		AppBlockBuilder: &types.AppBlockBuilder{
			Arn:                         ptr.String("__Arn__"),
			Name:                        ptr.String("__Name__"),
			DisplayName:                 ptr.String("__DisplayName__"),
			Description:                 ptr.String("__Description__"),
			Platform:                    types.AppBlockBuilderPlatformType("WINDOWS_SERVER_2019"),
			InstanceType:                ptr.String("__InstanceType__"),
			EnableDefaultInternetAccess: ptr.Bool(true),
			IamRoleArn:                  ptr.String("__IamRoleArn__"),
			VpcConfig: &types.VpcConfig{
				SubnetIds: []string{
					"__Member__",
					"__Member__",
				},
				SecurityGroupIds: []string{
					"__Member__",
					"__Member__",
				},
			},
			State:       types.AppBlockBuilderState("STARTING"),
			CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			AppBlockBuilderErrors: []types.ResourceError{
				{
					ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
					ErrorMessage:   ptr.String("__ErrorMessage__"),
					ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				{
					ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
					ErrorMessage:   ptr.String("__ErrorMessage__"),
					ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
			StateChangeReason: &types.AppBlockBuilderStateChangeReason{
				Code:    types.AppBlockBuilderStateChangeReasonCode("INTERNAL_ERROR"),
				Message: ptr.String("__Message__"),
			},
			AccessEndpoints: []types.AccessEndpoint{
				{
					EndpointType: types.AccessEndpointType("STREAMING"),
					VpceId:       ptr.String("__VpceId__"),
				},
				{
					EndpointType: types.AccessEndpointType("STREAMING"),
					VpceId:       ptr.String("__VpceId__"),
				},
			},
			DisableIMDSV1: ptr.Bool(true),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("StartAppBlockBuilder.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.StartAppBlockBuilder(context.Background(), &StartAppBlockBuilderInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StartAppBlockBuilder.response", err)
	}
}

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

func TestCheckResponseSnapshot_StartImageBuilder(t *testing.T) {
	want := &StartImageBuilderOutput{
		ImageBuilder: &types.ImageBuilder{
			Name:        ptr.String("__Name__"),
			Arn:         ptr.String("__Arn__"),
			ImageArn:    ptr.String("__ImageArn__"),
			Description: ptr.String("__Description__"),
			DisplayName: ptr.String("__DisplayName__"),
			VpcConfig: &types.VpcConfig{
				SubnetIds: []string{
					"__Member__",
					"__Member__",
				},
				SecurityGroupIds: []string{
					"__Member__",
					"__Member__",
				},
			},
			InstanceType: ptr.String("__InstanceType__"),
			Platform:     types.PlatformType("WINDOWS"),
			IamRoleArn:   ptr.String("__IamRoleArn__"),
			State:        types.ImageBuilderState("PENDING"),
			StateChangeReason: &types.ImageBuilderStateChangeReason{
				Code:    types.ImageBuilderStateChangeReasonCode("INTERNAL_ERROR"),
				Message: ptr.String("__Message__"),
			},
			CreatedTime:                 ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			EnableDefaultInternetAccess: ptr.Bool(true),
			DomainJoinInfo: &types.DomainJoinInfo{
				DirectoryName:                       ptr.String("__DirectoryName__"),
				OrganizationalUnitDistinguishedName: ptr.String("__OrganizationalUnitDistinguishedName__"),
			},
			NetworkAccessConfiguration: &types.NetworkAccessConfiguration{
				EniPrivateIpAddress: ptr.String("__EniPrivateIpAddress__"),
				EniIpv6Addresses: []string{
					"__Member__",
					"__Member__",
				},
				EniId: ptr.String("__EniId__"),
			},
			ImageBuilderErrors: []types.ResourceError{
				{
					ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
					ErrorMessage:   ptr.String("__ErrorMessage__"),
					ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				{
					ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
					ErrorMessage:   ptr.String("__ErrorMessage__"),
					ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
			AppstreamAgentVersion: ptr.String("__AppstreamAgentVersion__"),
			AccessEndpoints: []types.AccessEndpoint{
				{
					EndpointType: types.AccessEndpointType("STREAMING"),
					VpceId:       ptr.String("__VpceId__"),
				},
				{
					EndpointType: types.AccessEndpointType("STREAMING"),
					VpceId:       ptr.String("__VpceId__"),
				},
			},
			RootVolumeConfig: &types.VolumeConfig{
				VolumeSizeInGb: ptr.Int32(1),
			},
			LatestAppstreamAgentVersion: types.LatestAppstreamAgentVersion("TRUE"),
			DisableIMDSV1:               ptr.Bool(true),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("StartImageBuilder.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.StartImageBuilder(context.Background(), &StartImageBuilderInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StartImageBuilder.response", err)
	}
}

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

func TestCheckResponseSnapshot_StopAppBlockBuilder(t *testing.T) {
	want := &StopAppBlockBuilderOutput{
		AppBlockBuilder: &types.AppBlockBuilder{
			Arn:                         ptr.String("__Arn__"),
			Name:                        ptr.String("__Name__"),
			DisplayName:                 ptr.String("__DisplayName__"),
			Description:                 ptr.String("__Description__"),
			Platform:                    types.AppBlockBuilderPlatformType("WINDOWS_SERVER_2019"),
			InstanceType:                ptr.String("__InstanceType__"),
			EnableDefaultInternetAccess: ptr.Bool(true),
			IamRoleArn:                  ptr.String("__IamRoleArn__"),
			VpcConfig: &types.VpcConfig{
				SubnetIds: []string{
					"__Member__",
					"__Member__",
				},
				SecurityGroupIds: []string{
					"__Member__",
					"__Member__",
				},
			},
			State:       types.AppBlockBuilderState("STARTING"),
			CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			AppBlockBuilderErrors: []types.ResourceError{
				{
					ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
					ErrorMessage:   ptr.String("__ErrorMessage__"),
					ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				{
					ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
					ErrorMessage:   ptr.String("__ErrorMessage__"),
					ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
			StateChangeReason: &types.AppBlockBuilderStateChangeReason{
				Code:    types.AppBlockBuilderStateChangeReasonCode("INTERNAL_ERROR"),
				Message: ptr.String("__Message__"),
			},
			AccessEndpoints: []types.AccessEndpoint{
				{
					EndpointType: types.AccessEndpointType("STREAMING"),
					VpceId:       ptr.String("__VpceId__"),
				},
				{
					EndpointType: types.AccessEndpointType("STREAMING"),
					VpceId:       ptr.String("__VpceId__"),
				},
			},
			DisableIMDSV1: ptr.Bool(true),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("StopAppBlockBuilder.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.StopAppBlockBuilder(context.Background(), &StopAppBlockBuilderInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StopAppBlockBuilder.response", err)
	}
}

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

func TestCheckResponseSnapshot_StopImageBuilder(t *testing.T) {
	want := &StopImageBuilderOutput{
		ImageBuilder: &types.ImageBuilder{
			Name:        ptr.String("__Name__"),
			Arn:         ptr.String("__Arn__"),
			ImageArn:    ptr.String("__ImageArn__"),
			Description: ptr.String("__Description__"),
			DisplayName: ptr.String("__DisplayName__"),
			VpcConfig: &types.VpcConfig{
				SubnetIds: []string{
					"__Member__",
					"__Member__",
				},
				SecurityGroupIds: []string{
					"__Member__",
					"__Member__",
				},
			},
			InstanceType: ptr.String("__InstanceType__"),
			Platform:     types.PlatformType("WINDOWS"),
			IamRoleArn:   ptr.String("__IamRoleArn__"),
			State:        types.ImageBuilderState("PENDING"),
			StateChangeReason: &types.ImageBuilderStateChangeReason{
				Code:    types.ImageBuilderStateChangeReasonCode("INTERNAL_ERROR"),
				Message: ptr.String("__Message__"),
			},
			CreatedTime:                 ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			EnableDefaultInternetAccess: ptr.Bool(true),
			DomainJoinInfo: &types.DomainJoinInfo{
				DirectoryName:                       ptr.String("__DirectoryName__"),
				OrganizationalUnitDistinguishedName: ptr.String("__OrganizationalUnitDistinguishedName__"),
			},
			NetworkAccessConfiguration: &types.NetworkAccessConfiguration{
				EniPrivateIpAddress: ptr.String("__EniPrivateIpAddress__"),
				EniIpv6Addresses: []string{
					"__Member__",
					"__Member__",
				},
				EniId: ptr.String("__EniId__"),
			},
			ImageBuilderErrors: []types.ResourceError{
				{
					ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
					ErrorMessage:   ptr.String("__ErrorMessage__"),
					ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				{
					ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
					ErrorMessage:   ptr.String("__ErrorMessage__"),
					ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
			AppstreamAgentVersion: ptr.String("__AppstreamAgentVersion__"),
			AccessEndpoints: []types.AccessEndpoint{
				{
					EndpointType: types.AccessEndpointType("STREAMING"),
					VpceId:       ptr.String("__VpceId__"),
				},
				{
					EndpointType: types.AccessEndpointType("STREAMING"),
					VpceId:       ptr.String("__VpceId__"),
				},
			},
			RootVolumeConfig: &types.VolumeConfig{
				VolumeSizeInGb: ptr.Int32(1),
			},
			LatestAppstreamAgentVersion: types.LatestAppstreamAgentVersion("TRUE"),
			DisableIMDSV1:               ptr.Bool(true),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("StopImageBuilder.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.StopImageBuilder(context.Background(), &StopImageBuilderInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StopImageBuilder.response", err)
	}
}

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

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

func TestCheckResponseSnapshot_UpdateAppBlockBuilder(t *testing.T) {
	want := &UpdateAppBlockBuilderOutput{
		AppBlockBuilder: &types.AppBlockBuilder{
			Arn:                         ptr.String("__Arn__"),
			Name:                        ptr.String("__Name__"),
			DisplayName:                 ptr.String("__DisplayName__"),
			Description:                 ptr.String("__Description__"),
			Platform:                    types.AppBlockBuilderPlatformType("WINDOWS_SERVER_2019"),
			InstanceType:                ptr.String("__InstanceType__"),
			EnableDefaultInternetAccess: ptr.Bool(true),
			IamRoleArn:                  ptr.String("__IamRoleArn__"),
			VpcConfig: &types.VpcConfig{
				SubnetIds: []string{
					"__Member__",
					"__Member__",
				},
				SecurityGroupIds: []string{
					"__Member__",
					"__Member__",
				},
			},
			State:       types.AppBlockBuilderState("STARTING"),
			CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			AppBlockBuilderErrors: []types.ResourceError{
				{
					ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
					ErrorMessage:   ptr.String("__ErrorMessage__"),
					ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				{
					ErrorCode:      types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
					ErrorMessage:   ptr.String("__ErrorMessage__"),
					ErrorTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
			StateChangeReason: &types.AppBlockBuilderStateChangeReason{
				Code:    types.AppBlockBuilderStateChangeReasonCode("INTERNAL_ERROR"),
				Message: ptr.String("__Message__"),
			},
			AccessEndpoints: []types.AccessEndpoint{
				{
					EndpointType: types.AccessEndpointType("STREAMING"),
					VpceId:       ptr.String("__VpceId__"),
				},
				{
					EndpointType: types.AccessEndpointType("STREAMING"),
					VpceId:       ptr.String("__VpceId__"),
				},
			},
			DisableIMDSV1: ptr.Bool(true),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateAppBlockBuilder.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateAppBlockBuilder(context.Background(), &UpdateAppBlockBuilderInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateAppBlockBuilder.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateApplication(t *testing.T) {
	want := &UpdateApplicationOutput{
		Application: &types.Application{
			Name:             ptr.String("__Name__"),
			DisplayName:      ptr.String("__DisplayName__"),
			IconURL:          ptr.String("__IconURL__"),
			LaunchPath:       ptr.String("__LaunchPath__"),
			LaunchParameters: ptr.String("__LaunchParameters__"),
			Enabled:          ptr.Bool(true),
			Metadata: map[string]string{
				"key0": "__Value__",
			},
			WorkingDirectory: ptr.String("__WorkingDirectory__"),
			Description:      ptr.String("__Description__"),
			Arn:              ptr.String("__Arn__"),
			AppBlockArn:      ptr.String("__AppBlockArn__"),
			IconS3Location: &types.S3Location{
				S3Bucket: ptr.String("__S3Bucket__"),
				S3Key:    ptr.String("__S3Key__"),
			},
			Platforms: []types.PlatformType{
				types.PlatformType("WINDOWS"),
				types.PlatformType("WINDOWS"),
			},
			InstanceFamilies: []string{
				"__Member__",
				"__Member__",
			},
			CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateApplication.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateApplication(context.Background(), &UpdateApplicationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateApplication.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateDirectoryConfig(t *testing.T) {
	want := &UpdateDirectoryConfigOutput{
		DirectoryConfig: &types.DirectoryConfig{
			DirectoryName: ptr.String("__DirectoryName__"),
			OrganizationalUnitDistinguishedNames: []string{
				"__Member__",
				"__Member__",
			},
			ServiceAccountCredentials: &types.ServiceAccountCredentials{
				AccountName:     ptr.String("__AccountName__"),
				AccountPassword: ptr.String("__AccountPassword__"),
			},
			CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CertificateBasedAuthProperties: &types.CertificateBasedAuthProperties{
				Status:                  types.CertificateBasedAuthStatus("DISABLED"),
				CertificateAuthorityArn: ptr.String("__CertificateAuthorityArn__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateDirectoryConfig.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateDirectoryConfig(context.Background(), &UpdateDirectoryConfigInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateDirectoryConfig.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateEntitlement(t *testing.T) {
	want := &UpdateEntitlementOutput{
		Entitlement: &types.Entitlement{
			Name:          ptr.String("__Name__"),
			StackName:     ptr.String("__StackName__"),
			Description:   ptr.String("__Description__"),
			AppVisibility: types.AppVisibility("ALL"),
			Attributes: []types.EntitlementAttribute{
				{
					Name:  ptr.String("__Name__"),
					Value: ptr.String("__Value__"),
				},
				{
					Name:  ptr.String("__Name__"),
					Value: ptr.String("__Value__"),
				},
			},
			CreatedTime:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LastModifiedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateEntitlement.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateEntitlement(context.Background(), &UpdateEntitlementInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateEntitlement.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateFleet(t *testing.T) {
	want := &UpdateFleetOutput{
		Fleet: &types.Fleet{
			Arn:          ptr.String("__Arn__"),
			Name:         ptr.String("__Name__"),
			DisplayName:  ptr.String("__DisplayName__"),
			Description:  ptr.String("__Description__"),
			ImageName:    ptr.String("__ImageName__"),
			ImageArn:     ptr.String("__ImageArn__"),
			InstanceType: ptr.String("__InstanceType__"),
			FleetType:    types.FleetType("ALWAYS_ON"),
			ComputeCapacityStatus: &types.ComputeCapacityStatus{
				Desired:                     ptr.Int32(1),
				Running:                     ptr.Int32(1),
				InUse:                       ptr.Int32(1),
				Available:                   ptr.Int32(1),
				DesiredUserSessions:         ptr.Int32(1),
				AvailableUserSessions:       ptr.Int32(1),
				ActiveUserSessions:          ptr.Int32(1),
				ActualUserSessions:          ptr.Int32(1),
				Draining:                    ptr.Int32(1),
				DrainModeActiveUserSessions: ptr.Int32(1),
				DrainModeUnusedUserSessions: ptr.Int32(1),
			},
			MaxUserDurationInSeconds:   ptr.Int32(1),
			DisconnectTimeoutInSeconds: ptr.Int32(1),
			State:                      types.FleetState("STARTING"),
			VpcConfig: &types.VpcConfig{
				SubnetIds: []string{
					"__Member__",
					"__Member__",
				},
				SecurityGroupIds: []string{
					"__Member__",
					"__Member__",
				},
			},
			CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			FleetErrors: []types.FleetError{
				{
					ErrorCode:    types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
					ErrorMessage: ptr.String("__ErrorMessage__"),
				},
				{
					ErrorCode:    types.FleetErrorCode("IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"),
					ErrorMessage: ptr.String("__ErrorMessage__"),
				},
			},
			EnableDefaultInternetAccess: ptr.Bool(true),
			DomainJoinInfo: &types.DomainJoinInfo{
				DirectoryName:                       ptr.String("__DirectoryName__"),
				OrganizationalUnitDistinguishedName: ptr.String("__OrganizationalUnitDistinguishedName__"),
			},
			IdleDisconnectTimeoutInSeconds: ptr.Int32(1),
			IamRoleArn:                     ptr.String("__IamRoleArn__"),
			StreamView:                     types.StreamView("APP"),
			Platform:                       types.PlatformType("WINDOWS"),
			MaxConcurrentSessions:          ptr.Int32(1),
			UsbDeviceFilterStrings: []string{
				"__Member__",
				"__Member__",
			},
			SessionScriptS3Location: &types.S3Location{
				S3Bucket: ptr.String("__S3Bucket__"),
				S3Key:    ptr.String("__S3Key__"),
			},
			MaxSessionsPerInstance: ptr.Int32(1),
			RootVolumeConfig: &types.VolumeConfig{
				VolumeSizeInGb: ptr.Int32(1),
			},
			DisableIMDSV1: ptr.Bool(true),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateFleet.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateFleet(context.Background(), &UpdateFleetInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateFleet.response", err)
	}
}

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

func TestCheckResponseSnapshot_UpdateStack(t *testing.T) {
	want := &UpdateStackOutput{
		Stack: &types.Stack{
			Arn:         ptr.String("__Arn__"),
			Name:        ptr.String("__Name__"),
			Description: ptr.String("__Description__"),
			DisplayName: ptr.String("__DisplayName__"),
			CreatedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			StorageConnectors: []types.StorageConnector{
				{
					ConnectorType:      types.StorageConnectorType("HOMEFOLDERS"),
					ResourceIdentifier: ptr.String("__ResourceIdentifier__"),
					Domains: []string{
						"__Member__",
						"__Member__",
					},
					DomainsRequireAdminConsent: []string{
						"__Member__",
						"__Member__",
					},
				},
				{
					ConnectorType:      types.StorageConnectorType("HOMEFOLDERS"),
					ResourceIdentifier: ptr.String("__ResourceIdentifier__"),
					Domains: []string{
						"__Member__",
						"__Member__",
					},
					DomainsRequireAdminConsent: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
			RedirectURL: ptr.String("__RedirectURL__"),
			FeedbackURL: ptr.String("__FeedbackURL__"),
			StackErrors: []types.StackError{
				{
					ErrorCode:    types.StackErrorCode("STORAGE_CONNECTOR_ERROR"),
					ErrorMessage: ptr.String("__ErrorMessage__"),
				},
				{
					ErrorCode:    types.StackErrorCode("STORAGE_CONNECTOR_ERROR"),
					ErrorMessage: ptr.String("__ErrorMessage__"),
				},
			},
			UserSettings: []types.UserSetting{
				{
					Action:        types.Action("CLIPBOARD_COPY_FROM_LOCAL_DEVICE"),
					Permission:    types.Permission("ENABLED"),
					MaximumLength: ptr.Int32(1),
				},
				{
					Action:        types.Action("CLIPBOARD_COPY_FROM_LOCAL_DEVICE"),
					Permission:    types.Permission("ENABLED"),
					MaximumLength: ptr.Int32(1),
				},
			},
			ApplicationSettings: &types.ApplicationSettingsResponse{
				Enabled:       ptr.Bool(true),
				SettingsGroup: ptr.String("__SettingsGroup__"),
				S3BucketName:  ptr.String("__S3BucketName__"),
			},
			AccessEndpoints: []types.AccessEndpoint{
				{
					EndpointType: types.AccessEndpointType("STREAMING"),
					VpceId:       ptr.String("__VpceId__"),
				},
				{
					EndpointType: types.AccessEndpointType("STREAMING"),
					VpceId:       ptr.String("__VpceId__"),
				},
			},
			EmbedHostDomains: []string{
				"__Member__",
				"__Member__",
			},
			StreamingExperienceSettings: &types.StreamingExperienceSettings{
				PreferredProtocol: types.PreferredProtocol("TCP"),
			},
			ContentRedirection: &types.ContentRedirection{
				HostToClient: &types.UrlRedirectionConfig{
					Enabled: ptr.Bool(true),
					AllowedUrls: []string{
						"__Member__",
						"__Member__",
					},
					DeniedUrls: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
			AgentAccessConfig: &types.AgentAccessConfig{
				Settings: []types.AgentAccessSetting{
					{
						AgentAction: types.AgentAction("COMPUTER_VISION"),
						Permission:  types.Permission("ENABLED"),
					},
					{
						AgentAction: types.AgentAction("COMPUTER_VISION"),
						Permission:  types.Permission("ENABLED"),
					},
				},
				S3BucketArn:              ptr.String("__S3BucketArn__"),
				ScreenshotsUploadEnabled: ptr.Bool(true),
				ScreenResolution:         types.ScreenResolution("W_1280xH_720"),
				ScreenImageFormat:        types.ScreenImageFormat("PNG"),
				UserControlMode:          types.UserControlMode("VIEW_ONLY"),
			},
		},
	}
	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_UpdateThemeForStack(t *testing.T) {
	want := &UpdateThemeForStackOutput{
		Theme: &types.Theme{
			StackName:      ptr.String("__StackName__"),
			State:          types.ThemeState("ENABLED"),
			ThemeTitleText: ptr.String("__ThemeTitleText__"),
			ThemeStyling:   types.ThemeStyling("LIGHT_BLUE"),
			ThemeFooterLinks: []types.ThemeFooterLink{
				{
					DisplayName:   ptr.String("__DisplayName__"),
					FooterLinkURL: ptr.String("__FooterLinkURL__"),
				},
				{
					DisplayName:   ptr.String("__DisplayName__"),
					FooterLinkURL: ptr.String("__FooterLinkURL__"),
				},
			},
			ThemeOrganizationLogoURL: ptr.String("__ThemeOrganizationLogoURL__"),
			ThemeFaviconURL:          ptr.String("__ThemeFaviconURL__"),
			CreatedTime:              ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateThemeForStack.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateThemeForStack(context.Background(), &UpdateThemeForStackInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateThemeForStack.response", err)
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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