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

//go:build response_snapshot

package chimesdkvoice

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

func TestCheckResponseSnapshot_AssociatePhoneNumbersWithVoiceConnectorGroup(t *testing.T) {
	want := &AssociatePhoneNumbersWithVoiceConnectorGroupOutput{
		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("AssociatePhoneNumbersWithVoiceConnectorGroup.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.AssociatePhoneNumbersWithVoiceConnectorGroup(context.Background(), &AssociatePhoneNumbersWithVoiceConnectorGroupInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "AssociatePhoneNumbersWithVoiceConnectorGroup.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_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_CreatePhoneNumberOrder(t *testing.T) {
	want := &CreatePhoneNumberOrderOutput{
		PhoneNumberOrder: &types.PhoneNumberOrder{
			PhoneNumberOrderId: ptr.String("__PhoneNumberOrderId__"),
			ProductType:        types.PhoneNumberProductType("VoiceConnector"),
			Status:             types.PhoneNumberOrderStatus("Processing"),
			OrderType:          types.PhoneNumberOrderType("New"),
			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)),
			FocDate:          ptr.String("__FocDate__"),
		},
	}
	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_CreateProxySession(t *testing.T) {
	want := &CreateProxySessionOutput{
		ProxySession: &types.ProxySession{
			VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
			ProxySessionId:   ptr.String("__ProxySessionId__"),
			Name:             ptr.String("__Name__"),
			Status:           types.ProxySessionStatus("Open"),
			ExpiryMinutes:    ptr.Int32(1),
			Capabilities: []types.Capability{
				types.Capability("Voice"),
				types.Capability("Voice"),
			},
			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)),
			EndedTimestamp:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			Participants: []types.Participant{
				{
					PhoneNumber:      ptr.String("__PhoneNumber__"),
					ProxyPhoneNumber: ptr.String("__ProxyPhoneNumber__"),
				},
				{
					PhoneNumber:      ptr.String("__PhoneNumber__"),
					ProxyPhoneNumber: ptr.String("__ProxyPhoneNumber__"),
				},
			},
			NumberSelectionBehavior: types.NumberSelectionBehavior("PreferSticky"),
			GeoMatchLevel:           types.GeoMatchLevel("Country"),
			GeoMatchParams: &types.GeoMatchParams{
				Country:  ptr.String("__Country__"),
				AreaCode: ptr.String("__AreaCode__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateProxySession.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateProxySession(context.Background(), &CreateProxySessionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateProxySession.response", err)
	}
}

func TestCheckResponseSnapshot_CreateSipMediaApplication(t *testing.T) {
	want := &CreateSipMediaApplicationOutput{
		SipMediaApplication: &types.SipMediaApplication{
			SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
			AwsRegion:             ptr.String("__AwsRegion__"),
			Name:                  ptr.String("__Name__"),
			Endpoints: []types.SipMediaApplicationEndpoint{
				{
					LambdaArn: ptr.String("__LambdaArn__"),
				},
				{
					LambdaArn: ptr.String("__LambdaArn__"),
				},
			},
			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)),
			SipMediaApplicationArn: ptr.String("__SipMediaApplicationArn__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateSipMediaApplication.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateSipMediaApplication(context.Background(), &CreateSipMediaApplicationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateSipMediaApplication.response", err)
	}
}

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

func TestCheckResponseSnapshot_CreateSipRule(t *testing.T) {
	want := &CreateSipRuleOutput{
		SipRule: &types.SipRule{
			SipRuleId:    ptr.String("__SipRuleId__"),
			Name:         ptr.String("__Name__"),
			Disabled:     ptr.Bool(true),
			TriggerType:  types.SipRuleTriggerType("ToPhoneNumber"),
			TriggerValue: ptr.String("__TriggerValue__"),
			TargetApplications: []types.SipRuleTargetApplication{
				{
					SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
					Priority:              ptr.Int32(1),
					AwsRegion:             ptr.String("__AwsRegion__"),
				},
				{
					SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
					Priority:              ptr.Int32(1),
					AwsRegion:             ptr.String("__AwsRegion__"),
				},
			},
			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("CreateSipRule.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateSipRule(context.Background(), &CreateSipRuleInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateSipRule.response", err)
	}
}

func TestCheckResponseSnapshot_CreateVoiceConnector(t *testing.T) {
	want := &CreateVoiceConnectorOutput{
		VoiceConnector: &types.VoiceConnector{
			VoiceConnectorId:  ptr.String("__VoiceConnectorId__"),
			AwsRegion:         types.VoiceConnectorAwsRegion("us-east-1"),
			Name:              ptr.String("__Name__"),
			OutboundHostName:  ptr.String("__OutboundHostName__"),
			RequireEncryption: 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)),
			VoiceConnectorArn: ptr.String("__VoiceConnectorArn__"),
			IntegrationType:   types.VoiceConnectorIntegrationType("CONNECT_CALL_TRANSFER_CONNECTOR"),
			NetworkType:       types.NetworkType("IPV4_ONLY"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateVoiceConnector.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateVoiceConnector(context.Background(), &CreateVoiceConnectorInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateVoiceConnector.response", err)
	}
}

func TestCheckResponseSnapshot_CreateVoiceConnectorGroup(t *testing.T) {
	want := &CreateVoiceConnectorGroupOutput{
		VoiceConnectorGroup: &types.VoiceConnectorGroup{
			VoiceConnectorGroupId: ptr.String("__VoiceConnectorGroupId__"),
			Name:                  ptr.String("__Name__"),
			VoiceConnectorItems: []types.VoiceConnectorItem{
				{
					VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
					Priority:         ptr.Int32(1),
				},
				{
					VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
					Priority:         ptr.Int32(1),
				},
			},
			CreatedTimestamp:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			UpdatedTimestamp:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			VoiceConnectorGroupArn: ptr.String("__VoiceConnectorGroupArn__"),
			CallDistributionType:   types.CallDistributionType("PriorityWeightedDistribution"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateVoiceConnectorGroup.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateVoiceConnectorGroup(context.Background(), &CreateVoiceConnectorGroupInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateVoiceConnectorGroup.response", err)
	}
}

func TestCheckResponseSnapshot_CreateVoiceProfile(t *testing.T) {
	want := &CreateVoiceProfileOutput{
		VoiceProfile: &types.VoiceProfile{
			VoiceProfileId:       ptr.String("__VoiceProfileId__"),
			VoiceProfileArn:      ptr.String("__VoiceProfileArn__"),
			VoiceProfileDomainId: ptr.String("__VoiceProfileDomainId__"),
			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)),
			ExpirationTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateVoiceProfile.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateVoiceProfile(context.Background(), &CreateVoiceProfileInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateVoiceProfile.response", err)
	}
}

func TestCheckResponseSnapshot_CreateVoiceProfileDomain(t *testing.T) {
	want := &CreateVoiceProfileDomainOutput{
		VoiceProfileDomain: &types.VoiceProfileDomain{
			VoiceProfileDomainId:  ptr.String("__VoiceProfileDomainId__"),
			VoiceProfileDomainArn: ptr.String("__VoiceProfileDomainArn__"),
			Name:                  ptr.String("__Name__"),
			Description:           ptr.String("__Description__"),
			ServerSideEncryptionConfiguration: &types.ServerSideEncryptionConfiguration{
				KmsKeyArn: ptr.String("__KmsKeyArn__"),
			},
			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("CreateVoiceProfileDomain.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateVoiceProfileDomain(context.Background(), &CreateVoiceProfileDomainInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateVoiceProfileDomain.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_DeleteProxySession(t *testing.T) {
	want := &DeleteProxySessionOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteProxySession.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteProxySession(context.Background(), &DeleteProxySessionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteProxySession.response", err)
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func TestCheckResponseSnapshot_GetGlobalSettings(t *testing.T) {
	want := &GetGlobalSettingsOutput{
		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__"),
			PhoneNumberArn:  ptr.String("__PhoneNumberArn__"),
			Country:         ptr.String("__Country__"),
			Type:            types.PhoneNumberType("Local"),
			ProductType:     types.PhoneNumberProductType("VoiceConnector"),
			Status:          types.PhoneNumberStatus("Cancelled"),
			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("VoiceConnectorId"),
					AssociatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				{
					Value:               ptr.String("__Value__"),
					Name:                types.PhoneNumberAssociationName("VoiceConnectorId"),
					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)),
			OrderId:           ptr.String("__OrderId__"),
			Name:              ptr.String("__Name__"),
		},
	}
	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("VoiceConnector"),
			Status:             types.PhoneNumberOrderStatus("Processing"),
			OrderType:          types.PhoneNumberOrderType("New"),
			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)),
			FocDate:          ptr.String("__FocDate__"),
		},
	}
	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_GetProxySession(t *testing.T) {
	want := &GetProxySessionOutput{
		ProxySession: &types.ProxySession{
			VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
			ProxySessionId:   ptr.String("__ProxySessionId__"),
			Name:             ptr.String("__Name__"),
			Status:           types.ProxySessionStatus("Open"),
			ExpiryMinutes:    ptr.Int32(1),
			Capabilities: []types.Capability{
				types.Capability("Voice"),
				types.Capability("Voice"),
			},
			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)),
			EndedTimestamp:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			Participants: []types.Participant{
				{
					PhoneNumber:      ptr.String("__PhoneNumber__"),
					ProxyPhoneNumber: ptr.String("__ProxyPhoneNumber__"),
				},
				{
					PhoneNumber:      ptr.String("__PhoneNumber__"),
					ProxyPhoneNumber: ptr.String("__ProxyPhoneNumber__"),
				},
			},
			NumberSelectionBehavior: types.NumberSelectionBehavior("PreferSticky"),
			GeoMatchLevel:           types.GeoMatchLevel("Country"),
			GeoMatchParams: &types.GeoMatchParams{
				Country:  ptr.String("__Country__"),
				AreaCode: ptr.String("__AreaCode__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetProxySession.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetProxySession(context.Background(), &GetProxySessionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetProxySession.response", err)
	}
}

func TestCheckResponseSnapshot_GetSipMediaApplication(t *testing.T) {
	want := &GetSipMediaApplicationOutput{
		SipMediaApplication: &types.SipMediaApplication{
			SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
			AwsRegion:             ptr.String("__AwsRegion__"),
			Name:                  ptr.String("__Name__"),
			Endpoints: []types.SipMediaApplicationEndpoint{
				{
					LambdaArn: ptr.String("__LambdaArn__"),
				},
				{
					LambdaArn: ptr.String("__LambdaArn__"),
				},
			},
			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)),
			SipMediaApplicationArn: ptr.String("__SipMediaApplicationArn__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetSipMediaApplication.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetSipMediaApplication(context.Background(), &GetSipMediaApplicationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetSipMediaApplication.response", err)
	}
}

func TestCheckResponseSnapshot_GetSipMediaApplicationAlexaSkillConfiguration(t *testing.T) {
	want := &GetSipMediaApplicationAlexaSkillConfigurationOutput{
		SipMediaApplicationAlexaSkillConfiguration: &types.SipMediaApplicationAlexaSkillConfiguration{
			AlexaSkillStatus: types.AlexaSkillStatus("ACTIVE"),
			AlexaSkillIds: []string{
				"__Member__",
				"__Member__",
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetSipMediaApplicationAlexaSkillConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetSipMediaApplicationAlexaSkillConfiguration(context.Background(), &GetSipMediaApplicationAlexaSkillConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetSipMediaApplicationAlexaSkillConfiguration.response", err)
	}
}

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

func TestCheckResponseSnapshot_GetSipRule(t *testing.T) {
	want := &GetSipRuleOutput{
		SipRule: &types.SipRule{
			SipRuleId:    ptr.String("__SipRuleId__"),
			Name:         ptr.String("__Name__"),
			Disabled:     ptr.Bool(true),
			TriggerType:  types.SipRuleTriggerType("ToPhoneNumber"),
			TriggerValue: ptr.String("__TriggerValue__"),
			TargetApplications: []types.SipRuleTargetApplication{
				{
					SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
					Priority:              ptr.Int32(1),
					AwsRegion:             ptr.String("__AwsRegion__"),
				},
				{
					SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
					Priority:              ptr.Int32(1),
					AwsRegion:             ptr.String("__AwsRegion__"),
				},
			},
			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("GetSipRule.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetSipRule(context.Background(), &GetSipRuleInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetSipRule.response", err)
	}
}

func TestCheckResponseSnapshot_GetSpeakerSearchTask(t *testing.T) {
	want := &GetSpeakerSearchTaskOutput{
		SpeakerSearchTask: &types.SpeakerSearchTask{
			SpeakerSearchTaskId:     ptr.String("__SpeakerSearchTaskId__"),
			SpeakerSearchTaskStatus: ptr.String("__SpeakerSearchTaskStatus__"),
			CallDetails: &types.CallDetails{
				VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
				TransactionId:    ptr.String("__TransactionId__"),
				IsCaller:         ptr.Bool(true),
			},
			SpeakerSearchDetails: &types.SpeakerSearchDetails{
				Results: []types.SpeakerSearchResult{
					{
						ConfidenceScore: 1.0,
						VoiceProfileId:  ptr.String("__VoiceProfileId__"),
					},
					{
						ConfidenceScore: 1.0,
						VoiceProfileId:  ptr.String("__VoiceProfileId__"),
					},
				},
				VoiceprintGenerationStatus: ptr.String("__VoiceprintGenerationStatus__"),
			},
			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)),
			StartedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			StatusMessage:    ptr.String("__StatusMessage__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetSpeakerSearchTask.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetSpeakerSearchTask(context.Background(), &GetSpeakerSearchTaskInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetSpeakerSearchTask.response", err)
	}
}

func TestCheckResponseSnapshot_GetVoiceConnector(t *testing.T) {
	want := &GetVoiceConnectorOutput{
		VoiceConnector: &types.VoiceConnector{
			VoiceConnectorId:  ptr.String("__VoiceConnectorId__"),
			AwsRegion:         types.VoiceConnectorAwsRegion("us-east-1"),
			Name:              ptr.String("__Name__"),
			OutboundHostName:  ptr.String("__OutboundHostName__"),
			RequireEncryption: 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)),
			VoiceConnectorArn: ptr.String("__VoiceConnectorArn__"),
			IntegrationType:   types.VoiceConnectorIntegrationType("CONNECT_CALL_TRANSFER_CONNECTOR"),
			NetworkType:       types.NetworkType("IPV4_ONLY"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetVoiceConnector.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetVoiceConnector(context.Background(), &GetVoiceConnectorInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetVoiceConnector.response", err)
	}
}

func TestCheckResponseSnapshot_GetVoiceConnectorEmergencyCallingConfiguration(t *testing.T) {
	want := &GetVoiceConnectorEmergencyCallingConfigurationOutput{
		EmergencyCallingConfiguration: &types.EmergencyCallingConfiguration{
			DNIS: []types.DNISEmergencyCallingConfiguration{
				{
					EmergencyPhoneNumber: ptr.String("__EmergencyPhoneNumber__"),
					TestPhoneNumber:      ptr.String("__TestPhoneNumber__"),
					CallingCountry:       ptr.String("__CallingCountry__"),
				},
				{
					EmergencyPhoneNumber: ptr.String("__EmergencyPhoneNumber__"),
					TestPhoneNumber:      ptr.String("__TestPhoneNumber__"),
					CallingCountry:       ptr.String("__CallingCountry__"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetVoiceConnectorEmergencyCallingConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetVoiceConnectorEmergencyCallingConfiguration(context.Background(), &GetVoiceConnectorEmergencyCallingConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetVoiceConnectorEmergencyCallingConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_GetVoiceConnectorExternalSystemsConfiguration(t *testing.T) {
	want := &GetVoiceConnectorExternalSystemsConfigurationOutput{
		ExternalSystemsConfiguration: &types.ExternalSystemsConfiguration{
			SessionBorderControllerTypes: []types.SessionBorderControllerType{
				types.SessionBorderControllerType("RIBBON_SBC"),
				types.SessionBorderControllerType("RIBBON_SBC"),
			},
			ContactCenterSystemTypes: []types.ContactCenterSystemType{
				types.ContactCenterSystemType("GENESYS_ENGAGE_ON_PREMISES"),
				types.ContactCenterSystemType("GENESYS_ENGAGE_ON_PREMISES"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetVoiceConnectorExternalSystemsConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetVoiceConnectorExternalSystemsConfiguration(context.Background(), &GetVoiceConnectorExternalSystemsConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetVoiceConnectorExternalSystemsConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_GetVoiceConnectorGroup(t *testing.T) {
	want := &GetVoiceConnectorGroupOutput{
		VoiceConnectorGroup: &types.VoiceConnectorGroup{
			VoiceConnectorGroupId: ptr.String("__VoiceConnectorGroupId__"),
			Name:                  ptr.String("__Name__"),
			VoiceConnectorItems: []types.VoiceConnectorItem{
				{
					VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
					Priority:         ptr.Int32(1),
				},
				{
					VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
					Priority:         ptr.Int32(1),
				},
			},
			CreatedTimestamp:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			UpdatedTimestamp:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			VoiceConnectorGroupArn: ptr.String("__VoiceConnectorGroupArn__"),
			CallDistributionType:   types.CallDistributionType("PriorityWeightedDistribution"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetVoiceConnectorGroup.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetVoiceConnectorGroup(context.Background(), &GetVoiceConnectorGroupInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetVoiceConnectorGroup.response", err)
	}
}

func TestCheckResponseSnapshot_GetVoiceConnectorLoggingConfiguration(t *testing.T) {
	want := &GetVoiceConnectorLoggingConfigurationOutput{
		LoggingConfiguration: &types.LoggingConfiguration{
			EnableSIPLogs:         ptr.Bool(true),
			EnableMediaMetricLogs: ptr.Bool(true),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetVoiceConnectorLoggingConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetVoiceConnectorLoggingConfiguration(context.Background(), &GetVoiceConnectorLoggingConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetVoiceConnectorLoggingConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_GetVoiceConnectorOrigination(t *testing.T) {
	want := &GetVoiceConnectorOriginationOutput{
		Origination: &types.Origination{
			Routes: []types.OriginationRoute{
				{
					Host:     ptr.String("__Host__"),
					Port:     ptr.Int32(1),
					Protocol: types.OriginationRouteProtocol("TCP"),
					Priority: ptr.Int32(1),
					Weight:   ptr.Int32(1),
				},
				{
					Host:     ptr.String("__Host__"),
					Port:     ptr.Int32(1),
					Protocol: types.OriginationRouteProtocol("TCP"),
					Priority: ptr.Int32(1),
					Weight:   ptr.Int32(1),
				},
			},
			Disabled: ptr.Bool(true),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetVoiceConnectorOrigination.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetVoiceConnectorOrigination(context.Background(), &GetVoiceConnectorOriginationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetVoiceConnectorOrigination.response", err)
	}
}

func TestCheckResponseSnapshot_GetVoiceConnectorProxy(t *testing.T) {
	want := &GetVoiceConnectorProxyOutput{
		Proxy: &types.Proxy{
			DefaultSessionExpiryMinutes: ptr.Int32(1),
			Disabled:                    ptr.Bool(true),
			FallBackPhoneNumber:         ptr.String("__FallBackPhoneNumber__"),
			PhoneNumberCountries: []string{
				"__Member__",
				"__Member__",
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetVoiceConnectorProxy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetVoiceConnectorProxy(context.Background(), &GetVoiceConnectorProxyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetVoiceConnectorProxy.response", err)
	}
}

func TestCheckResponseSnapshot_GetVoiceConnectorStreamingConfiguration(t *testing.T) {
	want := &GetVoiceConnectorStreamingConfigurationOutput{
		StreamingConfiguration: &types.StreamingConfiguration{
			DataRetentionInHours: ptr.Int32(1),
			Disabled:             ptr.Bool(true),
			StreamingNotificationTargets: []types.StreamingNotificationTarget{
				{
					NotificationTarget: types.NotificationTarget("EventBridge"),
				},
				{
					NotificationTarget: types.NotificationTarget("EventBridge"),
				},
			},
			MediaInsightsConfiguration: &types.MediaInsightsConfiguration{
				Disabled:         ptr.Bool(true),
				ConfigurationArn: ptr.String("__ConfigurationArn__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetVoiceConnectorStreamingConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetVoiceConnectorStreamingConfiguration(context.Background(), &GetVoiceConnectorStreamingConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetVoiceConnectorStreamingConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_GetVoiceConnectorTermination(t *testing.T) {
	want := &GetVoiceConnectorTerminationOutput{
		Termination: &types.Termination{
			CpsLimit:           ptr.Int32(1),
			DefaultPhoneNumber: ptr.String("__DefaultPhoneNumber__"),
			CallingRegions: []string{
				"__Member__",
				"__Member__",
			},
			CidrAllowedList: []string{
				"__Member__",
				"__Member__",
			},
			Disabled: ptr.Bool(true),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetVoiceConnectorTermination.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetVoiceConnectorTermination(context.Background(), &GetVoiceConnectorTerminationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetVoiceConnectorTermination.response", err)
	}
}

func TestCheckResponseSnapshot_GetVoiceConnectorTerminationHealth(t *testing.T) {
	want := &GetVoiceConnectorTerminationHealthOutput{
		TerminationHealth: &types.TerminationHealth{
			Timestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			Source:    ptr.String("__Source__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetVoiceConnectorTerminationHealth.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetVoiceConnectorTerminationHealth(context.Background(), &GetVoiceConnectorTerminationHealthInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetVoiceConnectorTerminationHealth.response", err)
	}
}

func TestCheckResponseSnapshot_GetVoiceProfile(t *testing.T) {
	want := &GetVoiceProfileOutput{
		VoiceProfile: &types.VoiceProfile{
			VoiceProfileId:       ptr.String("__VoiceProfileId__"),
			VoiceProfileArn:      ptr.String("__VoiceProfileArn__"),
			VoiceProfileDomainId: ptr.String("__VoiceProfileDomainId__"),
			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)),
			ExpirationTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetVoiceProfile.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetVoiceProfile(context.Background(), &GetVoiceProfileInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetVoiceProfile.response", err)
	}
}

func TestCheckResponseSnapshot_GetVoiceProfileDomain(t *testing.T) {
	want := &GetVoiceProfileDomainOutput{
		VoiceProfileDomain: &types.VoiceProfileDomain{
			VoiceProfileDomainId:  ptr.String("__VoiceProfileDomainId__"),
			VoiceProfileDomainArn: ptr.String("__VoiceProfileDomainArn__"),
			Name:                  ptr.String("__Name__"),
			Description:           ptr.String("__Description__"),
			ServerSideEncryptionConfiguration: &types.ServerSideEncryptionConfiguration{
				KmsKeyArn: ptr.String("__KmsKeyArn__"),
			},
			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("GetVoiceProfileDomain.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetVoiceProfileDomain(context.Background(), &GetVoiceProfileDomainInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetVoiceProfileDomain.response", err)
	}
}

func TestCheckResponseSnapshot_GetVoiceToneAnalysisTask(t *testing.T) {
	want := &GetVoiceToneAnalysisTaskOutput{
		VoiceToneAnalysisTask: &types.VoiceToneAnalysisTask{
			VoiceToneAnalysisTaskId:     ptr.String("__VoiceToneAnalysisTaskId__"),
			VoiceToneAnalysisTaskStatus: ptr.String("__VoiceToneAnalysisTaskStatus__"),
			CallDetails: &types.CallDetails{
				VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
				TransactionId:    ptr.String("__TransactionId__"),
				IsCaller:         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)),
			StartedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			StatusMessage:    ptr.String("__StatusMessage__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetVoiceToneAnalysisTask.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetVoiceToneAnalysisTask(context.Background(), &GetVoiceToneAnalysisTaskInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetVoiceToneAnalysisTask.response", err)
	}
}

func TestCheckResponseSnapshot_ListAvailableVoiceConnectorRegions(t *testing.T) {
	want := &ListAvailableVoiceConnectorRegionsOutput{
		VoiceConnectorRegions: []types.VoiceConnectorAwsRegion{
			types.VoiceConnectorAwsRegion("us-east-1"),
			types.VoiceConnectorAwsRegion("us-east-1"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListAvailableVoiceConnectorRegions.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListAvailableVoiceConnectorRegions(context.Background(), &ListAvailableVoiceConnectorRegionsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListAvailableVoiceConnectorRegions.response", err)
	}
}

func TestCheckResponseSnapshot_ListPhoneNumberOrders(t *testing.T) {
	want := &ListPhoneNumberOrdersOutput{
		PhoneNumberOrders: []types.PhoneNumberOrder{
			{
				PhoneNumberOrderId: ptr.String("__PhoneNumberOrderId__"),
				ProductType:        types.PhoneNumberProductType("VoiceConnector"),
				Status:             types.PhoneNumberOrderStatus("Processing"),
				OrderType:          types.PhoneNumberOrderType("New"),
				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)),
				FocDate:          ptr.String("__FocDate__"),
			},
			{
				PhoneNumberOrderId: ptr.String("__PhoneNumberOrderId__"),
				ProductType:        types.PhoneNumberProductType("VoiceConnector"),
				Status:             types.PhoneNumberOrderStatus("Processing"),
				OrderType:          types.PhoneNumberOrderType("New"),
				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)),
				FocDate:          ptr.String("__FocDate__"),
			},
		},
		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__"),
				PhoneNumberArn:  ptr.String("__PhoneNumberArn__"),
				Country:         ptr.String("__Country__"),
				Type:            types.PhoneNumberType("Local"),
				ProductType:     types.PhoneNumberProductType("VoiceConnector"),
				Status:          types.PhoneNumberStatus("Cancelled"),
				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("VoiceConnectorId"),
						AssociatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
					{
						Value:               ptr.String("__Value__"),
						Name:                types.PhoneNumberAssociationName("VoiceConnectorId"),
						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)),
				OrderId:           ptr.String("__OrderId__"),
				Name:              ptr.String("__Name__"),
			},
			{
				PhoneNumberId:   ptr.String("__PhoneNumberId__"),
				E164PhoneNumber: ptr.String("__E164PhoneNumber__"),
				PhoneNumberArn:  ptr.String("__PhoneNumberArn__"),
				Country:         ptr.String("__Country__"),
				Type:            types.PhoneNumberType("Local"),
				ProductType:     types.PhoneNumberProductType("VoiceConnector"),
				Status:          types.PhoneNumberStatus("Cancelled"),
				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("VoiceConnectorId"),
						AssociatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
					{
						Value:               ptr.String("__Value__"),
						Name:                types.PhoneNumberAssociationName("VoiceConnectorId"),
						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)),
				OrderId:           ptr.String("__OrderId__"),
				Name:              ptr.String("__Name__"),
			},
		},
		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_ListProxySessions(t *testing.T) {
	want := &ListProxySessionsOutput{
		ProxySessions: []types.ProxySession{
			{
				VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
				ProxySessionId:   ptr.String("__ProxySessionId__"),
				Name:             ptr.String("__Name__"),
				Status:           types.ProxySessionStatus("Open"),
				ExpiryMinutes:    ptr.Int32(1),
				Capabilities: []types.Capability{
					types.Capability("Voice"),
					types.Capability("Voice"),
				},
				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)),
				EndedTimestamp:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Participants: []types.Participant{
					{
						PhoneNumber:      ptr.String("__PhoneNumber__"),
						ProxyPhoneNumber: ptr.String("__ProxyPhoneNumber__"),
					},
					{
						PhoneNumber:      ptr.String("__PhoneNumber__"),
						ProxyPhoneNumber: ptr.String("__ProxyPhoneNumber__"),
					},
				},
				NumberSelectionBehavior: types.NumberSelectionBehavior("PreferSticky"),
				GeoMatchLevel:           types.GeoMatchLevel("Country"),
				GeoMatchParams: &types.GeoMatchParams{
					Country:  ptr.String("__Country__"),
					AreaCode: ptr.String("__AreaCode__"),
				},
			},
			{
				VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
				ProxySessionId:   ptr.String("__ProxySessionId__"),
				Name:             ptr.String("__Name__"),
				Status:           types.ProxySessionStatus("Open"),
				ExpiryMinutes:    ptr.Int32(1),
				Capabilities: []types.Capability{
					types.Capability("Voice"),
					types.Capability("Voice"),
				},
				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)),
				EndedTimestamp:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Participants: []types.Participant{
					{
						PhoneNumber:      ptr.String("__PhoneNumber__"),
						ProxyPhoneNumber: ptr.String("__ProxyPhoneNumber__"),
					},
					{
						PhoneNumber:      ptr.String("__PhoneNumber__"),
						ProxyPhoneNumber: ptr.String("__ProxyPhoneNumber__"),
					},
				},
				NumberSelectionBehavior: types.NumberSelectionBehavior("PreferSticky"),
				GeoMatchLevel:           types.GeoMatchLevel("Country"),
				GeoMatchParams: &types.GeoMatchParams{
					Country:  ptr.String("__Country__"),
					AreaCode: ptr.String("__AreaCode__"),
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListProxySessions.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListProxySessions(context.Background(), &ListProxySessionsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListProxySessions.response", err)
	}
}

func TestCheckResponseSnapshot_ListSipMediaApplications(t *testing.T) {
	want := &ListSipMediaApplicationsOutput{
		SipMediaApplications: []types.SipMediaApplication{
			{
				SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
				AwsRegion:             ptr.String("__AwsRegion__"),
				Name:                  ptr.String("__Name__"),
				Endpoints: []types.SipMediaApplicationEndpoint{
					{
						LambdaArn: ptr.String("__LambdaArn__"),
					},
					{
						LambdaArn: ptr.String("__LambdaArn__"),
					},
				},
				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)),
				SipMediaApplicationArn: ptr.String("__SipMediaApplicationArn__"),
			},
			{
				SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
				AwsRegion:             ptr.String("__AwsRegion__"),
				Name:                  ptr.String("__Name__"),
				Endpoints: []types.SipMediaApplicationEndpoint{
					{
						LambdaArn: ptr.String("__LambdaArn__"),
					},
					{
						LambdaArn: ptr.String("__LambdaArn__"),
					},
				},
				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)),
				SipMediaApplicationArn: ptr.String("__SipMediaApplicationArn__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListSipMediaApplications.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListSipMediaApplications(context.Background(), &ListSipMediaApplicationsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListSipMediaApplications.response", err)
	}
}

func TestCheckResponseSnapshot_ListSipRules(t *testing.T) {
	want := &ListSipRulesOutput{
		SipRules: []types.SipRule{
			{
				SipRuleId:    ptr.String("__SipRuleId__"),
				Name:         ptr.String("__Name__"),
				Disabled:     ptr.Bool(true),
				TriggerType:  types.SipRuleTriggerType("ToPhoneNumber"),
				TriggerValue: ptr.String("__TriggerValue__"),
				TargetApplications: []types.SipRuleTargetApplication{
					{
						SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
						Priority:              ptr.Int32(1),
						AwsRegion:             ptr.String("__AwsRegion__"),
					},
					{
						SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
						Priority:              ptr.Int32(1),
						AwsRegion:             ptr.String("__AwsRegion__"),
					},
				},
				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)),
			},
			{
				SipRuleId:    ptr.String("__SipRuleId__"),
				Name:         ptr.String("__Name__"),
				Disabled:     ptr.Bool(true),
				TriggerType:  types.SipRuleTriggerType("ToPhoneNumber"),
				TriggerValue: ptr.String("__TriggerValue__"),
				TargetApplications: []types.SipRuleTargetApplication{
					{
						SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
						Priority:              ptr.Int32(1),
						AwsRegion:             ptr.String("__AwsRegion__"),
					},
					{
						SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
						Priority:              ptr.Int32(1),
						AwsRegion:             ptr.String("__AwsRegion__"),
					},
				},
				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("ListSipRules.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListSipRules(context.Background(), &ListSipRulesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListSipRules.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_ListTagsForResource(t *testing.T) {
	want := &ListTagsForResourceOutput{
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__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_ListVoiceConnectorGroups(t *testing.T) {
	want := &ListVoiceConnectorGroupsOutput{
		VoiceConnectorGroups: []types.VoiceConnectorGroup{
			{
				VoiceConnectorGroupId: ptr.String("__VoiceConnectorGroupId__"),
				Name:                  ptr.String("__Name__"),
				VoiceConnectorItems: []types.VoiceConnectorItem{
					{
						VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
						Priority:         ptr.Int32(1),
					},
					{
						VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
						Priority:         ptr.Int32(1),
					},
				},
				CreatedTimestamp:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedTimestamp:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				VoiceConnectorGroupArn: ptr.String("__VoiceConnectorGroupArn__"),
				CallDistributionType:   types.CallDistributionType("PriorityWeightedDistribution"),
			},
			{
				VoiceConnectorGroupId: ptr.String("__VoiceConnectorGroupId__"),
				Name:                  ptr.String("__Name__"),
				VoiceConnectorItems: []types.VoiceConnectorItem{
					{
						VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
						Priority:         ptr.Int32(1),
					},
					{
						VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
						Priority:         ptr.Int32(1),
					},
				},
				CreatedTimestamp:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedTimestamp:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				VoiceConnectorGroupArn: ptr.String("__VoiceConnectorGroupArn__"),
				CallDistributionType:   types.CallDistributionType("PriorityWeightedDistribution"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListVoiceConnectorGroups.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListVoiceConnectorGroups(context.Background(), &ListVoiceConnectorGroupsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListVoiceConnectorGroups.response", err)
	}
}

func TestCheckResponseSnapshot_ListVoiceConnectorTerminationCredentials(t *testing.T) {
	want := &ListVoiceConnectorTerminationCredentialsOutput{
		Usernames: []string{
			"__Member__",
			"__Member__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListVoiceConnectorTerminationCredentials.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListVoiceConnectorTerminationCredentials(context.Background(), &ListVoiceConnectorTerminationCredentialsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListVoiceConnectorTerminationCredentials.response", err)
	}
}

func TestCheckResponseSnapshot_ListVoiceConnectors(t *testing.T) {
	want := &ListVoiceConnectorsOutput{
		VoiceConnectors: []types.VoiceConnector{
			{
				VoiceConnectorId:  ptr.String("__VoiceConnectorId__"),
				AwsRegion:         types.VoiceConnectorAwsRegion("us-east-1"),
				Name:              ptr.String("__Name__"),
				OutboundHostName:  ptr.String("__OutboundHostName__"),
				RequireEncryption: 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)),
				VoiceConnectorArn: ptr.String("__VoiceConnectorArn__"),
				IntegrationType:   types.VoiceConnectorIntegrationType("CONNECT_CALL_TRANSFER_CONNECTOR"),
				NetworkType:       types.NetworkType("IPV4_ONLY"),
			},
			{
				VoiceConnectorId:  ptr.String("__VoiceConnectorId__"),
				AwsRegion:         types.VoiceConnectorAwsRegion("us-east-1"),
				Name:              ptr.String("__Name__"),
				OutboundHostName:  ptr.String("__OutboundHostName__"),
				RequireEncryption: 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)),
				VoiceConnectorArn: ptr.String("__VoiceConnectorArn__"),
				IntegrationType:   types.VoiceConnectorIntegrationType("CONNECT_CALL_TRANSFER_CONNECTOR"),
				NetworkType:       types.NetworkType("IPV4_ONLY"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListVoiceConnectors.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListVoiceConnectors(context.Background(), &ListVoiceConnectorsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListVoiceConnectors.response", err)
	}
}

func TestCheckResponseSnapshot_ListVoiceProfileDomains(t *testing.T) {
	want := &ListVoiceProfileDomainsOutput{
		VoiceProfileDomains: []types.VoiceProfileDomainSummary{
			{
				VoiceProfileDomainId:  ptr.String("__VoiceProfileDomainId__"),
				VoiceProfileDomainArn: ptr.String("__VoiceProfileDomainArn__"),
				Name:                  ptr.String("__Name__"),
				Description:           ptr.String("__Description__"),
				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)),
			},
			{
				VoiceProfileDomainId:  ptr.String("__VoiceProfileDomainId__"),
				VoiceProfileDomainArn: ptr.String("__VoiceProfileDomainArn__"),
				Name:                  ptr.String("__Name__"),
				Description:           ptr.String("__Description__"),
				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("ListVoiceProfileDomains.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListVoiceProfileDomains(context.Background(), &ListVoiceProfileDomainsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListVoiceProfileDomains.response", err)
	}
}

func TestCheckResponseSnapshot_ListVoiceProfiles(t *testing.T) {
	want := &ListVoiceProfilesOutput{
		VoiceProfiles: []types.VoiceProfileSummary{
			{
				VoiceProfileId:       ptr.String("__VoiceProfileId__"),
				VoiceProfileArn:      ptr.String("__VoiceProfileArn__"),
				VoiceProfileDomainId: ptr.String("__VoiceProfileDomainId__"),
				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)),
				ExpirationTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				VoiceProfileId:       ptr.String("__VoiceProfileId__"),
				VoiceProfileArn:      ptr.String("__VoiceProfileArn__"),
				VoiceProfileDomainId: ptr.String("__VoiceProfileDomainId__"),
				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)),
				ExpirationTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListVoiceProfiles.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListVoiceProfiles(context.Background(), &ListVoiceProfilesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListVoiceProfiles.response", err)
	}
}

func TestCheckResponseSnapshot_PutSipMediaApplicationAlexaSkillConfiguration(t *testing.T) {
	want := &PutSipMediaApplicationAlexaSkillConfigurationOutput{
		SipMediaApplicationAlexaSkillConfiguration: &types.SipMediaApplicationAlexaSkillConfiguration{
			AlexaSkillStatus: types.AlexaSkillStatus("ACTIVE"),
			AlexaSkillIds: []string{
				"__Member__",
				"__Member__",
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("PutSipMediaApplicationAlexaSkillConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutSipMediaApplicationAlexaSkillConfiguration(context.Background(), &PutSipMediaApplicationAlexaSkillConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutSipMediaApplicationAlexaSkillConfiguration.response", err)
	}
}

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

func TestCheckResponseSnapshot_PutVoiceConnectorEmergencyCallingConfiguration(t *testing.T) {
	want := &PutVoiceConnectorEmergencyCallingConfigurationOutput{
		EmergencyCallingConfiguration: &types.EmergencyCallingConfiguration{
			DNIS: []types.DNISEmergencyCallingConfiguration{
				{
					EmergencyPhoneNumber: ptr.String("__EmergencyPhoneNumber__"),
					TestPhoneNumber:      ptr.String("__TestPhoneNumber__"),
					CallingCountry:       ptr.String("__CallingCountry__"),
				},
				{
					EmergencyPhoneNumber: ptr.String("__EmergencyPhoneNumber__"),
					TestPhoneNumber:      ptr.String("__TestPhoneNumber__"),
					CallingCountry:       ptr.String("__CallingCountry__"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("PutVoiceConnectorEmergencyCallingConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutVoiceConnectorEmergencyCallingConfiguration(context.Background(), &PutVoiceConnectorEmergencyCallingConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutVoiceConnectorEmergencyCallingConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_PutVoiceConnectorExternalSystemsConfiguration(t *testing.T) {
	want := &PutVoiceConnectorExternalSystemsConfigurationOutput{
		ExternalSystemsConfiguration: &types.ExternalSystemsConfiguration{
			SessionBorderControllerTypes: []types.SessionBorderControllerType{
				types.SessionBorderControllerType("RIBBON_SBC"),
				types.SessionBorderControllerType("RIBBON_SBC"),
			},
			ContactCenterSystemTypes: []types.ContactCenterSystemType{
				types.ContactCenterSystemType("GENESYS_ENGAGE_ON_PREMISES"),
				types.ContactCenterSystemType("GENESYS_ENGAGE_ON_PREMISES"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("PutVoiceConnectorExternalSystemsConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutVoiceConnectorExternalSystemsConfiguration(context.Background(), &PutVoiceConnectorExternalSystemsConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutVoiceConnectorExternalSystemsConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_PutVoiceConnectorLoggingConfiguration(t *testing.T) {
	want := &PutVoiceConnectorLoggingConfigurationOutput{
		LoggingConfiguration: &types.LoggingConfiguration{
			EnableSIPLogs:         ptr.Bool(true),
			EnableMediaMetricLogs: ptr.Bool(true),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("PutVoiceConnectorLoggingConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutVoiceConnectorLoggingConfiguration(context.Background(), &PutVoiceConnectorLoggingConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutVoiceConnectorLoggingConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_PutVoiceConnectorOrigination(t *testing.T) {
	want := &PutVoiceConnectorOriginationOutput{
		Origination: &types.Origination{
			Routes: []types.OriginationRoute{
				{
					Host:     ptr.String("__Host__"),
					Port:     ptr.Int32(1),
					Protocol: types.OriginationRouteProtocol("TCP"),
					Priority: ptr.Int32(1),
					Weight:   ptr.Int32(1),
				},
				{
					Host:     ptr.String("__Host__"),
					Port:     ptr.Int32(1),
					Protocol: types.OriginationRouteProtocol("TCP"),
					Priority: ptr.Int32(1),
					Weight:   ptr.Int32(1),
				},
			},
			Disabled: ptr.Bool(true),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("PutVoiceConnectorOrigination.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutVoiceConnectorOrigination(context.Background(), &PutVoiceConnectorOriginationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutVoiceConnectorOrigination.response", err)
	}
}

func TestCheckResponseSnapshot_PutVoiceConnectorProxy(t *testing.T) {
	want := &PutVoiceConnectorProxyOutput{
		Proxy: &types.Proxy{
			DefaultSessionExpiryMinutes: ptr.Int32(1),
			Disabled:                    ptr.Bool(true),
			FallBackPhoneNumber:         ptr.String("__FallBackPhoneNumber__"),
			PhoneNumberCountries: []string{
				"__Member__",
				"__Member__",
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("PutVoiceConnectorProxy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutVoiceConnectorProxy(context.Background(), &PutVoiceConnectorProxyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutVoiceConnectorProxy.response", err)
	}
}

func TestCheckResponseSnapshot_PutVoiceConnectorStreamingConfiguration(t *testing.T) {
	want := &PutVoiceConnectorStreamingConfigurationOutput{
		StreamingConfiguration: &types.StreamingConfiguration{
			DataRetentionInHours: ptr.Int32(1),
			Disabled:             ptr.Bool(true),
			StreamingNotificationTargets: []types.StreamingNotificationTarget{
				{
					NotificationTarget: types.NotificationTarget("EventBridge"),
				},
				{
					NotificationTarget: types.NotificationTarget("EventBridge"),
				},
			},
			MediaInsightsConfiguration: &types.MediaInsightsConfiguration{
				Disabled:         ptr.Bool(true),
				ConfigurationArn: ptr.String("__ConfigurationArn__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("PutVoiceConnectorStreamingConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutVoiceConnectorStreamingConfiguration(context.Background(), &PutVoiceConnectorStreamingConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutVoiceConnectorStreamingConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_PutVoiceConnectorTermination(t *testing.T) {
	want := &PutVoiceConnectorTerminationOutput{
		Termination: &types.Termination{
			CpsLimit:           ptr.Int32(1),
			DefaultPhoneNumber: ptr.String("__DefaultPhoneNumber__"),
			CallingRegions: []string{
				"__Member__",
				"__Member__",
			},
			CidrAllowedList: []string{
				"__Member__",
				"__Member__",
			},
			Disabled: ptr.Bool(true),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("PutVoiceConnectorTermination.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutVoiceConnectorTermination(context.Background(), &PutVoiceConnectorTerminationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutVoiceConnectorTermination.response", err)
	}
}

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

func TestCheckResponseSnapshot_RestorePhoneNumber(t *testing.T) {
	want := &RestorePhoneNumberOutput{
		PhoneNumber: &types.PhoneNumber{
			PhoneNumberId:   ptr.String("__PhoneNumberId__"),
			E164PhoneNumber: ptr.String("__E164PhoneNumber__"),
			PhoneNumberArn:  ptr.String("__PhoneNumberArn__"),
			Country:         ptr.String("__Country__"),
			Type:            types.PhoneNumberType("Local"),
			ProductType:     types.PhoneNumberProductType("VoiceConnector"),
			Status:          types.PhoneNumberStatus("Cancelled"),
			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("VoiceConnectorId"),
					AssociatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				{
					Value:               ptr.String("__Value__"),
					Name:                types.PhoneNumberAssociationName("VoiceConnectorId"),
					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)),
			OrderId:           ptr.String("__OrderId__"),
			Name:              ptr.String("__Name__"),
		},
	}
	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_StartSpeakerSearchTask(t *testing.T) {
	want := &StartSpeakerSearchTaskOutput{
		SpeakerSearchTask: &types.SpeakerSearchTask{
			SpeakerSearchTaskId:     ptr.String("__SpeakerSearchTaskId__"),
			SpeakerSearchTaskStatus: ptr.String("__SpeakerSearchTaskStatus__"),
			CallDetails: &types.CallDetails{
				VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
				TransactionId:    ptr.String("__TransactionId__"),
				IsCaller:         ptr.Bool(true),
			},
			SpeakerSearchDetails: &types.SpeakerSearchDetails{
				Results: []types.SpeakerSearchResult{
					{
						ConfidenceScore: 1.0,
						VoiceProfileId:  ptr.String("__VoiceProfileId__"),
					},
					{
						ConfidenceScore: 1.0,
						VoiceProfileId:  ptr.String("__VoiceProfileId__"),
					},
				},
				VoiceprintGenerationStatus: ptr.String("__VoiceprintGenerationStatus__"),
			},
			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)),
			StartedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			StatusMessage:    ptr.String("__StatusMessage__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("StartSpeakerSearchTask.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.StartSpeakerSearchTask(context.Background(), &StartSpeakerSearchTaskInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StartSpeakerSearchTask.response", err)
	}
}

func TestCheckResponseSnapshot_StartVoiceToneAnalysisTask(t *testing.T) {
	want := &StartVoiceToneAnalysisTaskOutput{
		VoiceToneAnalysisTask: &types.VoiceToneAnalysisTask{
			VoiceToneAnalysisTaskId:     ptr.String("__VoiceToneAnalysisTaskId__"),
			VoiceToneAnalysisTaskStatus: ptr.String("__VoiceToneAnalysisTaskStatus__"),
			CallDetails: &types.CallDetails{
				VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
				TransactionId:    ptr.String("__TransactionId__"),
				IsCaller:         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)),
			StartedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			StatusMessage:    ptr.String("__StatusMessage__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("StartVoiceToneAnalysisTask.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.StartVoiceToneAnalysisTask(context.Background(), &StartVoiceToneAnalysisTaskInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StartVoiceToneAnalysisTask.response", err)
	}
}

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

func TestCheckResponseSnapshot_StopVoiceToneAnalysisTask(t *testing.T) {
	want := &StopVoiceToneAnalysisTaskOutput{}
	status, header, body, err := serdeRespReadSnapshot("StopVoiceToneAnalysisTask.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.StopVoiceToneAnalysisTask(context.Background(), &StopVoiceToneAnalysisTaskInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StopVoiceToneAnalysisTask.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_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__"),
			PhoneNumberArn:  ptr.String("__PhoneNumberArn__"),
			Country:         ptr.String("__Country__"),
			Type:            types.PhoneNumberType("Local"),
			ProductType:     types.PhoneNumberProductType("VoiceConnector"),
			Status:          types.PhoneNumberStatus("Cancelled"),
			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("VoiceConnectorId"),
					AssociatedTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				{
					Value:               ptr.String("__Value__"),
					Name:                types.PhoneNumberAssociationName("VoiceConnectorId"),
					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)),
			OrderId:           ptr.String("__OrderId__"),
			Name:              ptr.String("__Name__"),
		},
	}
	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_UpdateProxySession(t *testing.T) {
	want := &UpdateProxySessionOutput{
		ProxySession: &types.ProxySession{
			VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
			ProxySessionId:   ptr.String("__ProxySessionId__"),
			Name:             ptr.String("__Name__"),
			Status:           types.ProxySessionStatus("Open"),
			ExpiryMinutes:    ptr.Int32(1),
			Capabilities: []types.Capability{
				types.Capability("Voice"),
				types.Capability("Voice"),
			},
			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)),
			EndedTimestamp:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			Participants: []types.Participant{
				{
					PhoneNumber:      ptr.String("__PhoneNumber__"),
					ProxyPhoneNumber: ptr.String("__ProxyPhoneNumber__"),
				},
				{
					PhoneNumber:      ptr.String("__PhoneNumber__"),
					ProxyPhoneNumber: ptr.String("__ProxyPhoneNumber__"),
				},
			},
			NumberSelectionBehavior: types.NumberSelectionBehavior("PreferSticky"),
			GeoMatchLevel:           types.GeoMatchLevel("Country"),
			GeoMatchParams: &types.GeoMatchParams{
				Country:  ptr.String("__Country__"),
				AreaCode: ptr.String("__AreaCode__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateProxySession.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateProxySession(context.Background(), &UpdateProxySessionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateProxySession.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateSipMediaApplication(t *testing.T) {
	want := &UpdateSipMediaApplicationOutput{
		SipMediaApplication: &types.SipMediaApplication{
			SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
			AwsRegion:             ptr.String("__AwsRegion__"),
			Name:                  ptr.String("__Name__"),
			Endpoints: []types.SipMediaApplicationEndpoint{
				{
					LambdaArn: ptr.String("__LambdaArn__"),
				},
				{
					LambdaArn: ptr.String("__LambdaArn__"),
				},
			},
			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)),
			SipMediaApplicationArn: ptr.String("__SipMediaApplicationArn__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateSipMediaApplication.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateSipMediaApplication(context.Background(), &UpdateSipMediaApplicationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateSipMediaApplication.response", err)
	}
}

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

func TestCheckResponseSnapshot_UpdateSipRule(t *testing.T) {
	want := &UpdateSipRuleOutput{
		SipRule: &types.SipRule{
			SipRuleId:    ptr.String("__SipRuleId__"),
			Name:         ptr.String("__Name__"),
			Disabled:     ptr.Bool(true),
			TriggerType:  types.SipRuleTriggerType("ToPhoneNumber"),
			TriggerValue: ptr.String("__TriggerValue__"),
			TargetApplications: []types.SipRuleTargetApplication{
				{
					SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
					Priority:              ptr.Int32(1),
					AwsRegion:             ptr.String("__AwsRegion__"),
				},
				{
					SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
					Priority:              ptr.Int32(1),
					AwsRegion:             ptr.String("__AwsRegion__"),
				},
			},
			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("UpdateSipRule.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateSipRule(context.Background(), &UpdateSipRuleInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateSipRule.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateVoiceConnector(t *testing.T) {
	want := &UpdateVoiceConnectorOutput{
		VoiceConnector: &types.VoiceConnector{
			VoiceConnectorId:  ptr.String("__VoiceConnectorId__"),
			AwsRegion:         types.VoiceConnectorAwsRegion("us-east-1"),
			Name:              ptr.String("__Name__"),
			OutboundHostName:  ptr.String("__OutboundHostName__"),
			RequireEncryption: 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)),
			VoiceConnectorArn: ptr.String("__VoiceConnectorArn__"),
			IntegrationType:   types.VoiceConnectorIntegrationType("CONNECT_CALL_TRANSFER_CONNECTOR"),
			NetworkType:       types.NetworkType("IPV4_ONLY"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateVoiceConnector.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateVoiceConnector(context.Background(), &UpdateVoiceConnectorInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateVoiceConnector.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateVoiceConnectorGroup(t *testing.T) {
	want := &UpdateVoiceConnectorGroupOutput{
		VoiceConnectorGroup: &types.VoiceConnectorGroup{
			VoiceConnectorGroupId: ptr.String("__VoiceConnectorGroupId__"),
			Name:                  ptr.String("__Name__"),
			VoiceConnectorItems: []types.VoiceConnectorItem{
				{
					VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
					Priority:         ptr.Int32(1),
				},
				{
					VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
					Priority:         ptr.Int32(1),
				},
			},
			CreatedTimestamp:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			UpdatedTimestamp:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			VoiceConnectorGroupArn: ptr.String("__VoiceConnectorGroupArn__"),
			CallDistributionType:   types.CallDistributionType("PriorityWeightedDistribution"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateVoiceConnectorGroup.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateVoiceConnectorGroup(context.Background(), &UpdateVoiceConnectorGroupInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateVoiceConnectorGroup.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateVoiceProfile(t *testing.T) {
	want := &UpdateVoiceProfileOutput{
		VoiceProfile: &types.VoiceProfile{
			VoiceProfileId:       ptr.String("__VoiceProfileId__"),
			VoiceProfileArn:      ptr.String("__VoiceProfileArn__"),
			VoiceProfileDomainId: ptr.String("__VoiceProfileDomainId__"),
			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)),
			ExpirationTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateVoiceProfile.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateVoiceProfile(context.Background(), &UpdateVoiceProfileInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateVoiceProfile.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateVoiceProfileDomain(t *testing.T) {
	want := &UpdateVoiceProfileDomainOutput{
		VoiceProfileDomain: &types.VoiceProfileDomain{
			VoiceProfileDomainId:  ptr.String("__VoiceProfileDomainId__"),
			VoiceProfileDomainArn: ptr.String("__VoiceProfileDomainArn__"),
			Name:                  ptr.String("__Name__"),
			Description:           ptr.String("__Description__"),
			ServerSideEncryptionConfiguration: &types.ServerSideEncryptionConfiguration{
				KmsKeyArn: ptr.String("__KmsKeyArn__"),
			},
			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("UpdateVoiceProfileDomain.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateVoiceProfileDomain(context.Background(), &UpdateVoiceProfileDomainInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateVoiceProfileDomain.response", err)
	}
}

func TestCheckResponseSnapshot_ValidateE911Address(t *testing.T) {
	want := &ValidateE911AddressOutput{
		ValidationResult:  1,
		AddressExternalId: ptr.String("__AddressExternalId__"),
		Address: &types.Address{
			StreetName:      ptr.String("__StreetName__"),
			StreetSuffix:    ptr.String("__StreetSuffix__"),
			PostDirectional: ptr.String("__PostDirectional__"),
			PreDirectional:  ptr.String("__PreDirectional__"),
			StreetNumber:    ptr.String("__StreetNumber__"),
			City:            ptr.String("__City__"),
			State:           ptr.String("__State__"),
			PostalCode:      ptr.String("__PostalCode__"),
			PostalCodePlus4: ptr.String("__PostalCodePlus4__"),
			Country:         ptr.String("__Country__"),
		},
		CandidateAddressList: []types.CandidateAddress{
			{
				StreetInfo:      ptr.String("__StreetInfo__"),
				StreetNumber:    ptr.String("__StreetNumber__"),
				City:            ptr.String("__City__"),
				State:           ptr.String("__State__"),
				PostalCode:      ptr.String("__PostalCode__"),
				PostalCodePlus4: ptr.String("__PostalCodePlus4__"),
				Country:         ptr.String("__Country__"),
			},
			{
				StreetInfo:      ptr.String("__StreetInfo__"),
				StreetNumber:    ptr.String("__StreetNumber__"),
				City:            ptr.String("__City__"),
				State:           ptr.String("__State__"),
				PostalCode:      ptr.String("__PostalCode__"),
				PostalCodePlus4: ptr.String("__PostalCodePlus4__"),
				Country:         ptr.String("__Country__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ValidateE911Address.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ValidateE911Address(context.Background(), &ValidateE911AddressInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ValidateE911Address.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.AssociatePhoneNumbersWithVoiceConnector(context.Background(), &AssociatePhoneNumbersWithVoiceConnectorInput{})
	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.AssociatePhoneNumbersWithVoiceConnector(context.Background(), &AssociatePhoneNumbersWithVoiceConnectorInput{})
	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.CreateSipMediaApplication(context.Background(), &CreateSipMediaApplicationInput{})
	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.AssociatePhoneNumbersWithVoiceConnector(context.Background(), &AssociatePhoneNumbersWithVoiceConnectorInput{})
	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_GoneException(t *testing.T) {
	want := &types.GoneException{
		Code:    types.ErrorCode("BadRequest"),
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GoneException.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.CreateVoiceProfile(context.Background(), &CreateVoiceProfileInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.GoneException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.GoneException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "GoneException.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.AssociatePhoneNumbersWithVoiceConnector(context.Background(), &AssociatePhoneNumbersWithVoiceConnectorInput{})
	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.CreatePhoneNumberOrder(context.Background(), &CreatePhoneNumberOrderInput{})
	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.AssociatePhoneNumbersWithVoiceConnector(context.Background(), &AssociatePhoneNumbersWithVoiceConnectorInput{})
	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.AssociatePhoneNumbersWithVoiceConnector(context.Background(), &AssociatePhoneNumbersWithVoiceConnectorInput{})
	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.AssociatePhoneNumbersWithVoiceConnector(context.Background(), &AssociatePhoneNumbersWithVoiceConnectorInput{})
	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.AssociatePhoneNumbersWithVoiceConnector(context.Background(), &AssociatePhoneNumbersWithVoiceConnectorInput{})
	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.StartSpeakerSearchTask(context.Background(), &StartSpeakerSearchTaskInput{})
	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)
	}
}
