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

//go:build response_snapshot

package chime

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

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

func TestCheckResponseSnapshot_BatchCreateRoomMembership(t *testing.T) {
	want := &BatchCreateRoomMembershipOutput{
		Errors: []types.MemberError{
			{
				MemberId:     ptr.String("__MemberId__"),
				ErrorCode:    types.ErrorCode("BadRequest"),
				ErrorMessage: ptr.String("__ErrorMessage__"),
			},
			{
				MemberId:     ptr.String("__MemberId__"),
				ErrorCode:    types.ErrorCode("BadRequest"),
				ErrorMessage: ptr.String("__ErrorMessage__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("BatchCreateRoomMembership.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.BatchCreateRoomMembership(context.Background(), &BatchCreateRoomMembershipInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "BatchCreateRoomMembership.response", err)
	}
}

func TestCheckResponseSnapshot_BatchDeletePhoneNumber(t *testing.T) {
	want := &BatchDeletePhoneNumberOutput{
		PhoneNumberErrors: []types.PhoneNumberError{
			{
				PhoneNumberId: ptr.String("__PhoneNumberId__"),
				ErrorCode:     types.ErrorCode("BadRequest"),
				ErrorMessage:  ptr.String("__ErrorMessage__"),
			},
			{
				PhoneNumberId: ptr.String("__PhoneNumberId__"),
				ErrorCode:     types.ErrorCode("BadRequest"),
				ErrorMessage:  ptr.String("__ErrorMessage__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("BatchDeletePhoneNumber.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.BatchDeletePhoneNumber(context.Background(), &BatchDeletePhoneNumberInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "BatchDeletePhoneNumber.response", err)
	}
}

func TestCheckResponseSnapshot_BatchSuspendUser(t *testing.T) {
	want := &BatchSuspendUserOutput{
		UserErrors: []types.UserError{
			{
				UserId:       ptr.String("__UserId__"),
				ErrorCode:    types.ErrorCode("BadRequest"),
				ErrorMessage: ptr.String("__ErrorMessage__"),
			},
			{
				UserId:       ptr.String("__UserId__"),
				ErrorCode:    types.ErrorCode("BadRequest"),
				ErrorMessage: ptr.String("__ErrorMessage__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("BatchSuspendUser.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.BatchSuspendUser(context.Background(), &BatchSuspendUserInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "BatchSuspendUser.response", err)
	}
}

func TestCheckResponseSnapshot_BatchUnsuspendUser(t *testing.T) {
	want := &BatchUnsuspendUserOutput{
		UserErrors: []types.UserError{
			{
				UserId:       ptr.String("__UserId__"),
				ErrorCode:    types.ErrorCode("BadRequest"),
				ErrorMessage: ptr.String("__ErrorMessage__"),
			},
			{
				UserId:       ptr.String("__UserId__"),
				ErrorCode:    types.ErrorCode("BadRequest"),
				ErrorMessage: ptr.String("__ErrorMessage__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("BatchUnsuspendUser.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.BatchUnsuspendUser(context.Background(), &BatchUnsuspendUserInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "BatchUnsuspendUser.response", err)
	}
}

func TestCheckResponseSnapshot_BatchUpdatePhoneNumber(t *testing.T) {
	want := &BatchUpdatePhoneNumberOutput{
		PhoneNumberErrors: []types.PhoneNumberError{
			{
				PhoneNumberId: ptr.String("__PhoneNumberId__"),
				ErrorCode:     types.ErrorCode("BadRequest"),
				ErrorMessage:  ptr.String("__ErrorMessage__"),
			},
			{
				PhoneNumberId: ptr.String("__PhoneNumberId__"),
				ErrorCode:     types.ErrorCode("BadRequest"),
				ErrorMessage:  ptr.String("__ErrorMessage__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("BatchUpdatePhoneNumber.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.BatchUpdatePhoneNumber(context.Background(), &BatchUpdatePhoneNumberInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "BatchUpdatePhoneNumber.response", err)
	}
}

func TestCheckResponseSnapshot_BatchUpdateUser(t *testing.T) {
	want := &BatchUpdateUserOutput{
		UserErrors: []types.UserError{
			{
				UserId:       ptr.String("__UserId__"),
				ErrorCode:    types.ErrorCode("BadRequest"),
				ErrorMessage: ptr.String("__ErrorMessage__"),
			},
			{
				UserId:       ptr.String("__UserId__"),
				ErrorCode:    types.ErrorCode("BadRequest"),
				ErrorMessage: ptr.String("__ErrorMessage__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("BatchUpdateUser.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.BatchUpdateUser(context.Background(), &BatchUpdateUserInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "BatchUpdateUser.response", err)
	}
}

func TestCheckResponseSnapshot_CreateAccount(t *testing.T) {
	want := &CreateAccountOutput{
		Account: &types.Account{
			AwsAccountId:     ptr.String("__AwsAccountId__"),
			AccountId:        ptr.String("__AccountId__"),
			Name:             ptr.String("__Name__"),
			AccountType:      types.AccountType("Team"),
			CreatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			DefaultLicense:   types.License("Basic"),
			SupportedLicenses: []types.License{
				types.License("Basic"),
				types.License("Basic"),
			},
			AccountStatus: types.AccountStatus("Suspended"),
			SigninDelegateGroups: []types.SigninDelegateGroup{
				{
					GroupName: ptr.String("__GroupName__"),
				},
				{
					GroupName: ptr.String("__GroupName__"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateAccount.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateAccount(context.Background(), &CreateAccountInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateAccount.response", err)
	}
}

func TestCheckResponseSnapshot_CreateBot(t *testing.T) {
	want := &CreateBotOutput{
		Bot: &types.Bot{
			BotId:            ptr.String("__BotId__"),
			UserId:           ptr.String("__UserId__"),
			DisplayName:      ptr.String("__DisplayName__"),
			BotType:          types.BotType("ChatBot"),
			Disabled:         ptr.Bool(true),
			CreatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			UpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			BotEmail:         ptr.String("__BotEmail__"),
			SecurityToken:    ptr.String("__SecurityToken__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateBot.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateBot(context.Background(), &CreateBotInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateBot.response", err)
	}
}

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

func TestCheckResponseSnapshot_CreatePhoneNumberOrder(t *testing.T) {
	want := &CreatePhoneNumberOrderOutput{
		PhoneNumberOrder: &types.PhoneNumberOrder{
			PhoneNumberOrderId: ptr.String("__PhoneNumberOrderId__"),
			ProductType:        types.PhoneNumberProductType("BusinessCalling"),
			Status:             types.PhoneNumberOrderStatus("Processing"),
			OrderedPhoneNumbers: []types.OrderedPhoneNumber{
				{
					E164PhoneNumber: ptr.String("__E164PhoneNumber__"),
					Status:          types.OrderedPhoneNumberStatus("Processing"),
				},
				{
					E164PhoneNumber: ptr.String("__E164PhoneNumber__"),
					Status:          types.OrderedPhoneNumberStatus("Processing"),
				},
			},
			CreatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			UpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreatePhoneNumberOrder.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreatePhoneNumberOrder(context.Background(), &CreatePhoneNumberOrderInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreatePhoneNumberOrder.response", err)
	}
}

func TestCheckResponseSnapshot_CreateRoom(t *testing.T) {
	want := &CreateRoomOutput{
		Room: &types.Room{
			RoomId:           ptr.String("__RoomId__"),
			Name:             ptr.String("__Name__"),
			AccountId:        ptr.String("__AccountId__"),
			CreatedBy:        ptr.String("__CreatedBy__"),
			CreatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			UpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateRoom.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateRoom(context.Background(), &CreateRoomInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateRoom.response", err)
	}
}

func TestCheckResponseSnapshot_CreateRoomMembership(t *testing.T) {
	want := &CreateRoomMembershipOutput{
		RoomMembership: &types.RoomMembership{
			RoomId: ptr.String("__RoomId__"),
			Member: &types.Member{
				MemberId:   ptr.String("__MemberId__"),
				MemberType: types.MemberType("User"),
				Email:      ptr.String("__Email__"),
				FullName:   ptr.String("__FullName__"),
				AccountId:  ptr.String("__AccountId__"),
			},
			Role:             types.RoomMembershipRole("Administrator"),
			InvitedBy:        ptr.String("__InvitedBy__"),
			UpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateRoomMembership.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateRoomMembership(context.Background(), &CreateRoomMembershipInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateRoomMembership.response", err)
	}
}

func TestCheckResponseSnapshot_CreateUser(t *testing.T) {
	want := &CreateUserOutput{
		User: &types.User{
			UserId:                   ptr.String("__UserId__"),
			AccountId:                ptr.String("__AccountId__"),
			PrimaryEmail:             ptr.String("__PrimaryEmail__"),
			PrimaryProvisionedNumber: ptr.String("__PrimaryProvisionedNumber__"),
			DisplayName:              ptr.String("__DisplayName__"),
			LicenseType:              types.License("Basic"),
			UserType:                 types.UserType("PrivateUser"),
			UserRegistrationStatus:   types.RegistrationStatus("Unregistered"),
			UserInvitationStatus:     types.InviteStatus("Pending"),
			RegisteredOn:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			InvitedOn:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			AlexaForBusinessMetadata: &types.AlexaForBusinessMetadata{
				IsAlexaForBusinessEnabled: ptr.Bool(true),
				AlexaForBusinessRoomArn:   ptr.String("__AlexaForBusinessRoomArn__"),
			},
			PersonalPIN: ptr.String("__PersonalPIN__"),
		},
	}
	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_DeleteAccount(t *testing.T) {
	want := &DeleteAccountOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteAccount.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteAccount(context.Background(), &DeleteAccountInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteAccount.response", err)
	}
}

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

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

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

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

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

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

func TestCheckResponseSnapshot_GetAccount(t *testing.T) {
	want := &GetAccountOutput{
		Account: &types.Account{
			AwsAccountId:     ptr.String("__AwsAccountId__"),
			AccountId:        ptr.String("__AccountId__"),
			Name:             ptr.String("__Name__"),
			AccountType:      types.AccountType("Team"),
			CreatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			DefaultLicense:   types.License("Basic"),
			SupportedLicenses: []types.License{
				types.License("Basic"),
				types.License("Basic"),
			},
			AccountStatus: types.AccountStatus("Suspended"),
			SigninDelegateGroups: []types.SigninDelegateGroup{
				{
					GroupName: ptr.String("__GroupName__"),
				},
				{
					GroupName: ptr.String("__GroupName__"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetAccount.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetAccount(context.Background(), &GetAccountInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetAccount.response", err)
	}
}

func TestCheckResponseSnapshot_GetAccountSettings(t *testing.T) {
	want := &GetAccountSettingsOutput{
		AccountSettings: &types.AccountSettings{
			DisableRemoteControl: ptr.Bool(true),
			EnableDialOut:        ptr.Bool(true),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetAccountSettings.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetAccountSettings(context.Background(), &GetAccountSettingsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetAccountSettings.response", err)
	}
}

func TestCheckResponseSnapshot_GetBot(t *testing.T) {
	want := &GetBotOutput{
		Bot: &types.Bot{
			BotId:            ptr.String("__BotId__"),
			UserId:           ptr.String("__UserId__"),
			DisplayName:      ptr.String("__DisplayName__"),
			BotType:          types.BotType("ChatBot"),
			Disabled:         ptr.Bool(true),
			CreatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			UpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			BotEmail:         ptr.String("__BotEmail__"),
			SecurityToken:    ptr.String("__SecurityToken__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetBot.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetBot(context.Background(), &GetBotInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBot.response", err)
	}
}

func TestCheckResponseSnapshot_GetEventsConfiguration(t *testing.T) {
	want := &GetEventsConfigurationOutput{
		EventsConfiguration: &types.EventsConfiguration{
			BotId:                       ptr.String("__BotId__"),
			OutboundEventsHTTPSEndpoint: ptr.String("__OutboundEventsHTTPSEndpoint__"),
			LambdaFunctionArn:           ptr.String("__LambdaFunctionArn__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetEventsConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetEventsConfiguration(context.Background(), &GetEventsConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetEventsConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_GetGlobalSettings(t *testing.T) {
	want := &GetGlobalSettingsOutput{
		BusinessCalling: &types.BusinessCallingSettings{
			CdrBucket: ptr.String("__CdrBucket__"),
		},
		VoiceConnector: &types.VoiceConnectorSettings{
			CdrBucket: ptr.String("__CdrBucket__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetGlobalSettings.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetGlobalSettings(context.Background(), &GetGlobalSettingsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetGlobalSettings.response", err)
	}
}

func TestCheckResponseSnapshot_GetPhoneNumber(t *testing.T) {
	want := &GetPhoneNumberOutput{
		PhoneNumber: &types.PhoneNumber{
			PhoneNumberId:   ptr.String("__PhoneNumberId__"),
			E164PhoneNumber: ptr.String("__E164PhoneNumber__"),
			Country:         ptr.String("__Country__"),
			Type:            types.PhoneNumberType("Local"),
			ProductType:     types.PhoneNumberProductType("BusinessCalling"),
			Status:          types.PhoneNumberStatus("AcquireInProgress"),
			Capabilities: &types.PhoneNumberCapabilities{
				InboundCall:  ptr.Bool(true),
				OutboundCall: ptr.Bool(true),
				InboundSMS:   ptr.Bool(true),
				OutboundSMS:  ptr.Bool(true),
				InboundMMS:   ptr.Bool(true),
				OutboundMMS:  ptr.Bool(true),
			},
			Associations: []types.PhoneNumberAssociation{
				{
					Value:               ptr.String("__Value__"),
					Name:                types.PhoneNumberAssociationName("AccountId"),
					AssociatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				{
					Value:               ptr.String("__Value__"),
					Name:                types.PhoneNumberAssociationName("AccountId"),
					AssociatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
			CallingName:       ptr.String("__CallingName__"),
			CallingNameStatus: types.CallingNameStatus("Unassigned"),
			CreatedTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			UpdatedTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			DeletionTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetPhoneNumber.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetPhoneNumber(context.Background(), &GetPhoneNumberInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetPhoneNumber.response", err)
	}
}

func TestCheckResponseSnapshot_GetPhoneNumberOrder(t *testing.T) {
	want := &GetPhoneNumberOrderOutput{
		PhoneNumberOrder: &types.PhoneNumberOrder{
			PhoneNumberOrderId: ptr.String("__PhoneNumberOrderId__"),
			ProductType:        types.PhoneNumberProductType("BusinessCalling"),
			Status:             types.PhoneNumberOrderStatus("Processing"),
			OrderedPhoneNumbers: []types.OrderedPhoneNumber{
				{
					E164PhoneNumber: ptr.String("__E164PhoneNumber__"),
					Status:          types.OrderedPhoneNumberStatus("Processing"),
				},
				{
					E164PhoneNumber: ptr.String("__E164PhoneNumber__"),
					Status:          types.OrderedPhoneNumberStatus("Processing"),
				},
			},
			CreatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			UpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetPhoneNumberOrder.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetPhoneNumberOrder(context.Background(), &GetPhoneNumberOrderInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetPhoneNumberOrder.response", err)
	}
}

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

func TestCheckResponseSnapshot_GetRetentionSettings(t *testing.T) {
	want := &GetRetentionSettingsOutput{
		RetentionSettings: &types.RetentionSettings{
			RoomRetentionSettings: &types.RoomRetentionSettings{
				RetentionDays: ptr.Int32(1),
			},
			ConversationRetentionSettings: &types.ConversationRetentionSettings{
				RetentionDays: ptr.Int32(1),
			},
		},
		InitiateDeletionTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("GetRetentionSettings.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetRetentionSettings(context.Background(), &GetRetentionSettingsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetRetentionSettings.response", err)
	}
}

func TestCheckResponseSnapshot_GetRoom(t *testing.T) {
	want := &GetRoomOutput{
		Room: &types.Room{
			RoomId:           ptr.String("__RoomId__"),
			Name:             ptr.String("__Name__"),
			AccountId:        ptr.String("__AccountId__"),
			CreatedBy:        ptr.String("__CreatedBy__"),
			CreatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			UpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetRoom.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetRoom(context.Background(), &GetRoomInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetRoom.response", err)
	}
}

func TestCheckResponseSnapshot_GetUser(t *testing.T) {
	want := &GetUserOutput{
		User: &types.User{
			UserId:                   ptr.String("__UserId__"),
			AccountId:                ptr.String("__AccountId__"),
			PrimaryEmail:             ptr.String("__PrimaryEmail__"),
			PrimaryProvisionedNumber: ptr.String("__PrimaryProvisionedNumber__"),
			DisplayName:              ptr.String("__DisplayName__"),
			LicenseType:              types.License("Basic"),
			UserType:                 types.UserType("PrivateUser"),
			UserRegistrationStatus:   types.RegistrationStatus("Unregistered"),
			UserInvitationStatus:     types.InviteStatus("Pending"),
			RegisteredOn:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			InvitedOn:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			AlexaForBusinessMetadata: &types.AlexaForBusinessMetadata{
				IsAlexaForBusinessEnabled: ptr.Bool(true),
				AlexaForBusinessRoomArn:   ptr.String("__AlexaForBusinessRoomArn__"),
			},
			PersonalPIN: ptr.String("__PersonalPIN__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetUser.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetUser(context.Background(), &GetUserInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetUser.response", err)
	}
}

func TestCheckResponseSnapshot_GetUserSettings(t *testing.T) {
	want := &GetUserSettingsOutput{
		UserSettings: &types.UserSettings{
			Telephony: &types.TelephonySettings{
				InboundCalling:  ptr.Bool(true),
				OutboundCalling: ptr.Bool(true),
				SMS:             ptr.Bool(true),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetUserSettings.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetUserSettings(context.Background(), &GetUserSettingsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetUserSettings.response", err)
	}
}

func TestCheckResponseSnapshot_InviteUsers(t *testing.T) {
	want := &InviteUsersOutput{
		Invites: []types.Invite{
			{
				InviteId:     ptr.String("__InviteId__"),
				Status:       types.InviteStatus("Pending"),
				EmailAddress: ptr.String("__EmailAddress__"),
				EmailStatus:  types.EmailStatus("NotSent"),
			},
			{
				InviteId:     ptr.String("__InviteId__"),
				Status:       types.InviteStatus("Pending"),
				EmailAddress: ptr.String("__EmailAddress__"),
				EmailStatus:  types.EmailStatus("NotSent"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("InviteUsers.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.InviteUsers(context.Background(), &InviteUsersInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "InviteUsers.response", err)
	}
}

func TestCheckResponseSnapshot_ListAccounts(t *testing.T) {
	want := &ListAccountsOutput{
		Accounts: []types.Account{
			{
				AwsAccountId:     ptr.String("__AwsAccountId__"),
				AccountId:        ptr.String("__AccountId__"),
				Name:             ptr.String("__Name__"),
				AccountType:      types.AccountType("Team"),
				CreatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				DefaultLicense:   types.License("Basic"),
				SupportedLicenses: []types.License{
					types.License("Basic"),
					types.License("Basic"),
				},
				AccountStatus: types.AccountStatus("Suspended"),
				SigninDelegateGroups: []types.SigninDelegateGroup{
					{
						GroupName: ptr.String("__GroupName__"),
					},
					{
						GroupName: ptr.String("__GroupName__"),
					},
				},
			},
			{
				AwsAccountId:     ptr.String("__AwsAccountId__"),
				AccountId:        ptr.String("__AccountId__"),
				Name:             ptr.String("__Name__"),
				AccountType:      types.AccountType("Team"),
				CreatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				DefaultLicense:   types.License("Basic"),
				SupportedLicenses: []types.License{
					types.License("Basic"),
					types.License("Basic"),
				},
				AccountStatus: types.AccountStatus("Suspended"),
				SigninDelegateGroups: []types.SigninDelegateGroup{
					{
						GroupName: ptr.String("__GroupName__"),
					},
					{
						GroupName: ptr.String("__GroupName__"),
					},
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListAccounts.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListAccounts(context.Background(), &ListAccountsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListAccounts.response", err)
	}
}

func TestCheckResponseSnapshot_ListBots(t *testing.T) {
	want := &ListBotsOutput{
		Bots: []types.Bot{
			{
				BotId:            ptr.String("__BotId__"),
				UserId:           ptr.String("__UserId__"),
				DisplayName:      ptr.String("__DisplayName__"),
				BotType:          types.BotType("ChatBot"),
				Disabled:         ptr.Bool(true),
				CreatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				BotEmail:         ptr.String("__BotEmail__"),
				SecurityToken:    ptr.String("__SecurityToken__"),
			},
			{
				BotId:            ptr.String("__BotId__"),
				UserId:           ptr.String("__UserId__"),
				DisplayName:      ptr.String("__DisplayName__"),
				BotType:          types.BotType("ChatBot"),
				Disabled:         ptr.Bool(true),
				CreatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				BotEmail:         ptr.String("__BotEmail__"),
				SecurityToken:    ptr.String("__SecurityToken__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListBots.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListBots(context.Background(), &ListBotsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListBots.response", err)
	}
}

func TestCheckResponseSnapshot_ListPhoneNumberOrders(t *testing.T) {
	want := &ListPhoneNumberOrdersOutput{
		PhoneNumberOrders: []types.PhoneNumberOrder{
			{
				PhoneNumberOrderId: ptr.String("__PhoneNumberOrderId__"),
				ProductType:        types.PhoneNumberProductType("BusinessCalling"),
				Status:             types.PhoneNumberOrderStatus("Processing"),
				OrderedPhoneNumbers: []types.OrderedPhoneNumber{
					{
						E164PhoneNumber: ptr.String("__E164PhoneNumber__"),
						Status:          types.OrderedPhoneNumberStatus("Processing"),
					},
					{
						E164PhoneNumber: ptr.String("__E164PhoneNumber__"),
						Status:          types.OrderedPhoneNumberStatus("Processing"),
					},
				},
				CreatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				PhoneNumberOrderId: ptr.String("__PhoneNumberOrderId__"),
				ProductType:        types.PhoneNumberProductType("BusinessCalling"),
				Status:             types.PhoneNumberOrderStatus("Processing"),
				OrderedPhoneNumbers: []types.OrderedPhoneNumber{
					{
						E164PhoneNumber: ptr.String("__E164PhoneNumber__"),
						Status:          types.OrderedPhoneNumberStatus("Processing"),
					},
					{
						E164PhoneNumber: ptr.String("__E164PhoneNumber__"),
						Status:          types.OrderedPhoneNumberStatus("Processing"),
					},
				},
				CreatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListPhoneNumberOrders.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListPhoneNumberOrders(context.Background(), &ListPhoneNumberOrdersInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListPhoneNumberOrders.response", err)
	}
}

func TestCheckResponseSnapshot_ListPhoneNumbers(t *testing.T) {
	want := &ListPhoneNumbersOutput{
		PhoneNumbers: []types.PhoneNumber{
			{
				PhoneNumberId:   ptr.String("__PhoneNumberId__"),
				E164PhoneNumber: ptr.String("__E164PhoneNumber__"),
				Country:         ptr.String("__Country__"),
				Type:            types.PhoneNumberType("Local"),
				ProductType:     types.PhoneNumberProductType("BusinessCalling"),
				Status:          types.PhoneNumberStatus("AcquireInProgress"),
				Capabilities: &types.PhoneNumberCapabilities{
					InboundCall:  ptr.Bool(true),
					OutboundCall: ptr.Bool(true),
					InboundSMS:   ptr.Bool(true),
					OutboundSMS:  ptr.Bool(true),
					InboundMMS:   ptr.Bool(true),
					OutboundMMS:  ptr.Bool(true),
				},
				Associations: []types.PhoneNumberAssociation{
					{
						Value:               ptr.String("__Value__"),
						Name:                types.PhoneNumberAssociationName("AccountId"),
						AssociatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
					{
						Value:               ptr.String("__Value__"),
						Name:                types.PhoneNumberAssociationName("AccountId"),
						AssociatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
				},
				CallingName:       ptr.String("__CallingName__"),
				CallingNameStatus: types.CallingNameStatus("Unassigned"),
				CreatedTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				DeletionTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				PhoneNumberId:   ptr.String("__PhoneNumberId__"),
				E164PhoneNumber: ptr.String("__E164PhoneNumber__"),
				Country:         ptr.String("__Country__"),
				Type:            types.PhoneNumberType("Local"),
				ProductType:     types.PhoneNumberProductType("BusinessCalling"),
				Status:          types.PhoneNumberStatus("AcquireInProgress"),
				Capabilities: &types.PhoneNumberCapabilities{
					InboundCall:  ptr.Bool(true),
					OutboundCall: ptr.Bool(true),
					InboundSMS:   ptr.Bool(true),
					OutboundSMS:  ptr.Bool(true),
					InboundMMS:   ptr.Bool(true),
					OutboundMMS:  ptr.Bool(true),
				},
				Associations: []types.PhoneNumberAssociation{
					{
						Value:               ptr.String("__Value__"),
						Name:                types.PhoneNumberAssociationName("AccountId"),
						AssociatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
					{
						Value:               ptr.String("__Value__"),
						Name:                types.PhoneNumberAssociationName("AccountId"),
						AssociatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
				},
				CallingName:       ptr.String("__CallingName__"),
				CallingNameStatus: types.CallingNameStatus("Unassigned"),
				CreatedTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				DeletionTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListPhoneNumbers.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListPhoneNumbers(context.Background(), &ListPhoneNumbersInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListPhoneNumbers.response", err)
	}
}

func TestCheckResponseSnapshot_ListRoomMemberships(t *testing.T) {
	want := &ListRoomMembershipsOutput{
		RoomMemberships: []types.RoomMembership{
			{
				RoomId: ptr.String("__RoomId__"),
				Member: &types.Member{
					MemberId:   ptr.String("__MemberId__"),
					MemberType: types.MemberType("User"),
					Email:      ptr.String("__Email__"),
					FullName:   ptr.String("__FullName__"),
					AccountId:  ptr.String("__AccountId__"),
				},
				Role:             types.RoomMembershipRole("Administrator"),
				InvitedBy:        ptr.String("__InvitedBy__"),
				UpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				RoomId: ptr.String("__RoomId__"),
				Member: &types.Member{
					MemberId:   ptr.String("__MemberId__"),
					MemberType: types.MemberType("User"),
					Email:      ptr.String("__Email__"),
					FullName:   ptr.String("__FullName__"),
					AccountId:  ptr.String("__AccountId__"),
				},
				Role:             types.RoomMembershipRole("Administrator"),
				InvitedBy:        ptr.String("__InvitedBy__"),
				UpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListRoomMemberships.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListRoomMemberships(context.Background(), &ListRoomMembershipsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListRoomMemberships.response", err)
	}
}

func TestCheckResponseSnapshot_ListRooms(t *testing.T) {
	want := &ListRoomsOutput{
		Rooms: []types.Room{
			{
				RoomId:           ptr.String("__RoomId__"),
				Name:             ptr.String("__Name__"),
				AccountId:        ptr.String("__AccountId__"),
				CreatedBy:        ptr.String("__CreatedBy__"),
				CreatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				RoomId:           ptr.String("__RoomId__"),
				Name:             ptr.String("__Name__"),
				AccountId:        ptr.String("__AccountId__"),
				CreatedBy:        ptr.String("__CreatedBy__"),
				CreatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListRooms.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListRooms(context.Background(), &ListRoomsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListRooms.response", err)
	}
}

func TestCheckResponseSnapshot_ListSupportedPhoneNumberCountries(t *testing.T) {
	want := &ListSupportedPhoneNumberCountriesOutput{
		PhoneNumberCountries: []types.PhoneNumberCountry{
			{
				CountryCode: ptr.String("__CountryCode__"),
				SupportedPhoneNumberTypes: []types.PhoneNumberType{
					types.PhoneNumberType("Local"),
					types.PhoneNumberType("Local"),
				},
			},
			{
				CountryCode: ptr.String("__CountryCode__"),
				SupportedPhoneNumberTypes: []types.PhoneNumberType{
					types.PhoneNumberType("Local"),
					types.PhoneNumberType("Local"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListSupportedPhoneNumberCountries.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListSupportedPhoneNumberCountries(context.Background(), &ListSupportedPhoneNumberCountriesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListSupportedPhoneNumberCountries.response", err)
	}
}

func TestCheckResponseSnapshot_ListUsers(t *testing.T) {
	want := &ListUsersOutput{
		Users: []types.User{
			{
				UserId:                   ptr.String("__UserId__"),
				AccountId:                ptr.String("__AccountId__"),
				PrimaryEmail:             ptr.String("__PrimaryEmail__"),
				PrimaryProvisionedNumber: ptr.String("__PrimaryProvisionedNumber__"),
				DisplayName:              ptr.String("__DisplayName__"),
				LicenseType:              types.License("Basic"),
				UserType:                 types.UserType("PrivateUser"),
				UserRegistrationStatus:   types.RegistrationStatus("Unregistered"),
				UserInvitationStatus:     types.InviteStatus("Pending"),
				RegisteredOn:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				InvitedOn:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				AlexaForBusinessMetadata: &types.AlexaForBusinessMetadata{
					IsAlexaForBusinessEnabled: ptr.Bool(true),
					AlexaForBusinessRoomArn:   ptr.String("__AlexaForBusinessRoomArn__"),
				},
				PersonalPIN: ptr.String("__PersonalPIN__"),
			},
			{
				UserId:                   ptr.String("__UserId__"),
				AccountId:                ptr.String("__AccountId__"),
				PrimaryEmail:             ptr.String("__PrimaryEmail__"),
				PrimaryProvisionedNumber: ptr.String("__PrimaryProvisionedNumber__"),
				DisplayName:              ptr.String("__DisplayName__"),
				LicenseType:              types.License("Basic"),
				UserType:                 types.UserType("PrivateUser"),
				UserRegistrationStatus:   types.RegistrationStatus("Unregistered"),
				UserInvitationStatus:     types.InviteStatus("Pending"),
				RegisteredOn:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				InvitedOn:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				AlexaForBusinessMetadata: &types.AlexaForBusinessMetadata{
					IsAlexaForBusinessEnabled: ptr.Bool(true),
					AlexaForBusinessRoomArn:   ptr.String("__AlexaForBusinessRoomArn__"),
				},
				PersonalPIN: ptr.String("__PersonalPIN__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListUsers.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListUsers(context.Background(), &ListUsersInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListUsers.response", err)
	}
}

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

func TestCheckResponseSnapshot_PutEventsConfiguration(t *testing.T) {
	want := &PutEventsConfigurationOutput{
		EventsConfiguration: &types.EventsConfiguration{
			BotId:                       ptr.String("__BotId__"),
			OutboundEventsHTTPSEndpoint: ptr.String("__OutboundEventsHTTPSEndpoint__"),
			LambdaFunctionArn:           ptr.String("__LambdaFunctionArn__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("PutEventsConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutEventsConfiguration(context.Background(), &PutEventsConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutEventsConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_PutRetentionSettings(t *testing.T) {
	want := &PutRetentionSettingsOutput{
		RetentionSettings: &types.RetentionSettings{
			RoomRetentionSettings: &types.RoomRetentionSettings{
				RetentionDays: ptr.Int32(1),
			},
			ConversationRetentionSettings: &types.ConversationRetentionSettings{
				RetentionDays: ptr.Int32(1),
			},
		},
		InitiateDeletionTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("PutRetentionSettings.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutRetentionSettings(context.Background(), &PutRetentionSettingsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutRetentionSettings.response", err)
	}
}

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

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

func TestCheckResponseSnapshot_RegenerateSecurityToken(t *testing.T) {
	want := &RegenerateSecurityTokenOutput{
		Bot: &types.Bot{
			BotId:            ptr.String("__BotId__"),
			UserId:           ptr.String("__UserId__"),
			DisplayName:      ptr.String("__DisplayName__"),
			BotType:          types.BotType("ChatBot"),
			Disabled:         ptr.Bool(true),
			CreatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			UpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			BotEmail:         ptr.String("__BotEmail__"),
			SecurityToken:    ptr.String("__SecurityToken__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("RegenerateSecurityToken.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.RegenerateSecurityToken(context.Background(), &RegenerateSecurityTokenInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "RegenerateSecurityToken.response", err)
	}
}

func TestCheckResponseSnapshot_ResetPersonalPIN(t *testing.T) {
	want := &ResetPersonalPINOutput{
		User: &types.User{
			UserId:                   ptr.String("__UserId__"),
			AccountId:                ptr.String("__AccountId__"),
			PrimaryEmail:             ptr.String("__PrimaryEmail__"),
			PrimaryProvisionedNumber: ptr.String("__PrimaryProvisionedNumber__"),
			DisplayName:              ptr.String("__DisplayName__"),
			LicenseType:              types.License("Basic"),
			UserType:                 types.UserType("PrivateUser"),
			UserRegistrationStatus:   types.RegistrationStatus("Unregistered"),
			UserInvitationStatus:     types.InviteStatus("Pending"),
			RegisteredOn:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			InvitedOn:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			AlexaForBusinessMetadata: &types.AlexaForBusinessMetadata{
				IsAlexaForBusinessEnabled: ptr.Bool(true),
				AlexaForBusinessRoomArn:   ptr.String("__AlexaForBusinessRoomArn__"),
			},
			PersonalPIN: ptr.String("__PersonalPIN__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ResetPersonalPIN.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ResetPersonalPIN(context.Background(), &ResetPersonalPINInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ResetPersonalPIN.response", err)
	}
}

func TestCheckResponseSnapshot_RestorePhoneNumber(t *testing.T) {
	want := &RestorePhoneNumberOutput{
		PhoneNumber: &types.PhoneNumber{
			PhoneNumberId:   ptr.String("__PhoneNumberId__"),
			E164PhoneNumber: ptr.String("__E164PhoneNumber__"),
			Country:         ptr.String("__Country__"),
			Type:            types.PhoneNumberType("Local"),
			ProductType:     types.PhoneNumberProductType("BusinessCalling"),
			Status:          types.PhoneNumberStatus("AcquireInProgress"),
			Capabilities: &types.PhoneNumberCapabilities{
				InboundCall:  ptr.Bool(true),
				OutboundCall: ptr.Bool(true),
				InboundSMS:   ptr.Bool(true),
				OutboundSMS:  ptr.Bool(true),
				InboundMMS:   ptr.Bool(true),
				OutboundMMS:  ptr.Bool(true),
			},
			Associations: []types.PhoneNumberAssociation{
				{
					Value:               ptr.String("__Value__"),
					Name:                types.PhoneNumberAssociationName("AccountId"),
					AssociatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				{
					Value:               ptr.String("__Value__"),
					Name:                types.PhoneNumberAssociationName("AccountId"),
					AssociatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
			CallingName:       ptr.String("__CallingName__"),
			CallingNameStatus: types.CallingNameStatus("Unassigned"),
			CreatedTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			UpdatedTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			DeletionTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("RestorePhoneNumber.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.RestorePhoneNumber(context.Background(), &RestorePhoneNumberInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "RestorePhoneNumber.response", err)
	}
}

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

func TestCheckResponseSnapshot_UpdateAccount(t *testing.T) {
	want := &UpdateAccountOutput{
		Account: &types.Account{
			AwsAccountId:     ptr.String("__AwsAccountId__"),
			AccountId:        ptr.String("__AccountId__"),
			Name:             ptr.String("__Name__"),
			AccountType:      types.AccountType("Team"),
			CreatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			DefaultLicense:   types.License("Basic"),
			SupportedLicenses: []types.License{
				types.License("Basic"),
				types.License("Basic"),
			},
			AccountStatus: types.AccountStatus("Suspended"),
			SigninDelegateGroups: []types.SigninDelegateGroup{
				{
					GroupName: ptr.String("__GroupName__"),
				},
				{
					GroupName: ptr.String("__GroupName__"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateAccount.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateAccount(context.Background(), &UpdateAccountInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateAccount.response", err)
	}
}

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

func TestCheckResponseSnapshot_UpdateBot(t *testing.T) {
	want := &UpdateBotOutput{
		Bot: &types.Bot{
			BotId:            ptr.String("__BotId__"),
			UserId:           ptr.String("__UserId__"),
			DisplayName:      ptr.String("__DisplayName__"),
			BotType:          types.BotType("ChatBot"),
			Disabled:         ptr.Bool(true),
			CreatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			UpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			BotEmail:         ptr.String("__BotEmail__"),
			SecurityToken:    ptr.String("__SecurityToken__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateBot.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateBot(context.Background(), &UpdateBotInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateBot.response", err)
	}
}

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

func TestCheckResponseSnapshot_UpdatePhoneNumber(t *testing.T) {
	want := &UpdatePhoneNumberOutput{
		PhoneNumber: &types.PhoneNumber{
			PhoneNumberId:   ptr.String("__PhoneNumberId__"),
			E164PhoneNumber: ptr.String("__E164PhoneNumber__"),
			Country:         ptr.String("__Country__"),
			Type:            types.PhoneNumberType("Local"),
			ProductType:     types.PhoneNumberProductType("BusinessCalling"),
			Status:          types.PhoneNumberStatus("AcquireInProgress"),
			Capabilities: &types.PhoneNumberCapabilities{
				InboundCall:  ptr.Bool(true),
				OutboundCall: ptr.Bool(true),
				InboundSMS:   ptr.Bool(true),
				OutboundSMS:  ptr.Bool(true),
				InboundMMS:   ptr.Bool(true),
				OutboundMMS:  ptr.Bool(true),
			},
			Associations: []types.PhoneNumberAssociation{
				{
					Value:               ptr.String("__Value__"),
					Name:                types.PhoneNumberAssociationName("AccountId"),
					AssociatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				{
					Value:               ptr.String("__Value__"),
					Name:                types.PhoneNumberAssociationName("AccountId"),
					AssociatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
			CallingName:       ptr.String("__CallingName__"),
			CallingNameStatus: types.CallingNameStatus("Unassigned"),
			CreatedTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			UpdatedTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			DeletionTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdatePhoneNumber.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdatePhoneNumber(context.Background(), &UpdatePhoneNumberInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdatePhoneNumber.response", err)
	}
}

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

func TestCheckResponseSnapshot_UpdateRoom(t *testing.T) {
	want := &UpdateRoomOutput{
		Room: &types.Room{
			RoomId:           ptr.String("__RoomId__"),
			Name:             ptr.String("__Name__"),
			AccountId:        ptr.String("__AccountId__"),
			CreatedBy:        ptr.String("__CreatedBy__"),
			CreatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			UpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateRoom.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateRoom(context.Background(), &UpdateRoomInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateRoom.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateRoomMembership(t *testing.T) {
	want := &UpdateRoomMembershipOutput{
		RoomMembership: &types.RoomMembership{
			RoomId: ptr.String("__RoomId__"),
			Member: &types.Member{
				MemberId:   ptr.String("__MemberId__"),
				MemberType: types.MemberType("User"),
				Email:      ptr.String("__Email__"),
				FullName:   ptr.String("__FullName__"),
				AccountId:  ptr.String("__AccountId__"),
			},
			Role:             types.RoomMembershipRole("Administrator"),
			InvitedBy:        ptr.String("__InvitedBy__"),
			UpdatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateRoomMembership.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateRoomMembership(context.Background(), &UpdateRoomMembershipInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateRoomMembership.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateUser(t *testing.T) {
	want := &UpdateUserOutput{
		User: &types.User{
			UserId:                   ptr.String("__UserId__"),
			AccountId:                ptr.String("__AccountId__"),
			PrimaryEmail:             ptr.String("__PrimaryEmail__"),
			PrimaryProvisionedNumber: ptr.String("__PrimaryProvisionedNumber__"),
			DisplayName:              ptr.String("__DisplayName__"),
			LicenseType:              types.License("Basic"),
			UserType:                 types.UserType("PrivateUser"),
			UserRegistrationStatus:   types.RegistrationStatus("Unregistered"),
			UserInvitationStatus:     types.InviteStatus("Pending"),
			RegisteredOn:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			InvitedOn:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			AlexaForBusinessMetadata: &types.AlexaForBusinessMetadata{
				IsAlexaForBusinessEnabled: ptr.Bool(true),
				AlexaForBusinessRoomArn:   ptr.String("__AlexaForBusinessRoomArn__"),
			},
			PersonalPIN: ptr.String("__PersonalPIN__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateUser.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateUser(context.Background(), &UpdateUserInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateUser.response", err)
	}
}

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

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

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

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

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

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

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

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

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

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

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

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