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

//go:build request_snapshot

package chimesdkvoice

import (
	"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"
	smithyhttp "github.com/aws/smithy-go/transport/http"
	"io"
	"io/fs"
	"net/url"
	"os"
	"slices"
	"strings"
	"testing"
)

const serdeSSPrefix = "request_snapshot"

// errSerdeSnapshotOK is returned by the capture middleware to abort the request
// pipeline once the serialized request has been captured, so no network call is
// made. It is a control signal, not a failure.
var errSerdeSnapshotOK = errors.New("serde snapshot: request captured")

func serdeCreatePath(path string) (*os.File, error) {
	if err := os.MkdirAll(serdeSSPrefix, 0700); err != nil && !errors.Is(err, fs.ErrExist) {
		return nil, err
	}
	return os.Create(path)
}

func serdeSSPath(op string) string {
	return fmt.Sprintf("%s/%s.request.snap", serdeSSPrefix, op)
}

type captureSerdeRequestMiddleware struct {
	body     *bytes.Buffer
	method   *string
	rawPath  *string
	rawQuery *string
	header   *map[string][]string
}

func (*captureSerdeRequestMiddleware) ID() string { return "captureSerdeRequest" }

func (m *captureSerdeRequestMiddleware) HandleFinalize(
	ctx context.Context, input middleware.FinalizeInput, next middleware.FinalizeHandler,
) (
	middleware.FinalizeOutput, middleware.Metadata, error,
) {
	req, ok := input.Request.(*smithyhttp.Request)
	if !ok {
		return middleware.FinalizeOutput{}, middleware.Metadata{}, fmt.Errorf("unexpected transport type %T", input.Request)
	}

	built := req.Build(ctx)
	*m.method = built.Method
	*m.rawPath = built.URL.RawPath
	if *m.rawPath == "" {
		*m.rawPath = built.URL.Path
	}
	*m.rawQuery = built.URL.RawQuery
	*m.header = built.Header

	if built.Body != nil {
		if _, err := io.Copy(m.body, built.Body); err != nil {
			return middleware.FinalizeOutput{}, middleware.Metadata{}, err
		}
	}

	return middleware.FinalizeOutput{}, middleware.Metadata{}, errSerdeSnapshotOK
}

func serdeFormatRequest(method, rawPath, rawQuery string, header map[string][]string, body []byte) string {
	skipHeaders := map[string]bool{
		"Authorization":         true,
		"User-Agent":            true,
		"X-Amz-Date":            true,
		"X-Amz-Security-Token":  true,
		"Amz-Sdk-Invocation-Id": true,
		"Amz-Sdk-Request":       true,
	}

	var sb strings.Builder
	sb.WriteString(method)
	sb.WriteString(" ")
	sb.WriteString(rawPath)
	if rawQuery != "" {
		sb.WriteString("?")
		sb.WriteString(rawQuery)
	}
	sb.WriteString("\n\n")

	keys := make([]string, 0, len(header))
	for k := range header {
		if skipHeaders[k] {
			continue
		}
		keys = append(keys, k)
	}
	slices.Sort(keys)
	for _, k := range keys {
		for _, v := range header[k] {
			sb.WriteString(k)
			sb.WriteString(": ")
			sb.WriteString(v)
			sb.WriteString("\n")
		}
	}
	sb.WriteString("\n")
	if len(body) > 0 {
		sb.Write(body)
	}
	return sb.String()
}

func serdeUpdateSnapshot(method, rawPath, rawQuery string, header map[string][]string, body []byte, operation string) error {
	content := serdeFormatRequest(method, rawPath, rawQuery, header, body)
	// Leave the snapshot untouched if it's semantically equal to the new one.
	// Some protocols (rpcv2Cbor) serialize map/struct fields in a nondeterministic
	// byte order, so a blind rewrite would churn the file on every run.
	if existing, err := os.ReadFile(serdeSSPath(operation)); err == nil {
		prefix := serdeFormatRequest(method, rawPath, rawQuery, header, nil)
		if strings.HasPrefix(string(existing), prefix) &&
			serdeBodyEqual(body, []byte(string(existing)[len(prefix):])) {
			return nil
		}
	}
	f, err := serdeCreatePath(serdeSSPath(operation))
	if err != nil {
		return err
	}
	defer f.Close()
	if _, err := f.Write([]byte(content)); err != nil {
		return err
	}
	return nil
}

func serdeTestSnapshot(method, rawPath, rawQuery string, header map[string][]string, body []byte, operation string) error {
	f, err := os.Open(serdeSSPath(operation))
	if errors.Is(err, fs.ErrNotExist) {
		return nil
	}
	if err != nil {
		return err
	}
	defer f.Close()
	expected, err := io.ReadAll(f)
	if err != nil {
		return err
	}
	prefix := serdeFormatRequest(method, rawPath, rawQuery, header, nil)
	if !strings.HasPrefix(string(expected), prefix) ||
		!serdeBodyEqual(body, []byte(string(expected)[len(prefix):])) {
		content := serdeFormatRequest(method, rawPath, rawQuery, header, body)
		return fmt.Errorf("serde snapshot mismatch for %s:\nGOT:\n%s:\nEXPECTED:\n%s", operation, content, string(expected))
	}
	return nil
}

type serdeEndpointResolver struct{}

func (*serdeEndpointResolver) ResolveEndpoint(ctx context.Context, params EndpointParameters) (smithyendpoints.Endpoint, error) {
	return smithyendpoints.Endpoint{URI: url.URL{Scheme: "https", Host: "test.example.com"}}, nil
}

func serdeNewClient() *Client {
	return New(Options{
		Region:             "us-east-1",
		EndpointResolverV2: &serdeEndpointResolver{},
	})
}
func serdeBodyEqual(got, expected []byte) bool {
	return bytes.Equal(got, expected)
}
func TestCheckRequestSnapshot_AssociatePhoneNumbersWithVoiceConnector(t *testing.T) {
	input := &AssociatePhoneNumbersWithVoiceConnectorInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		E164PhoneNumbers: []string{
			"__Member__",
			"__Member__",
		},
		ForceAssociate: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AssociatePhoneNumbersWithVoiceConnector(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AssociatePhoneNumbersWithVoiceConnector"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_AssociatePhoneNumbersWithVoiceConnectorGroup(t *testing.T) {
	input := &AssociatePhoneNumbersWithVoiceConnectorGroupInput{
		VoiceConnectorGroupId: ptr.String("__VoiceConnectorGroupId__"),
		E164PhoneNumbers: []string{
			"__Member__",
			"__Member__",
		},
		ForceAssociate: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AssociatePhoneNumbersWithVoiceConnectorGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AssociatePhoneNumbersWithVoiceConnectorGroup"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_BatchDeletePhoneNumber(t *testing.T) {
	input := &BatchDeletePhoneNumberInput{
		PhoneNumberIds: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchDeletePhoneNumber(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchDeletePhoneNumber"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_BatchUpdatePhoneNumber(t *testing.T) {
	input := &BatchUpdatePhoneNumberInput{
		UpdatePhoneNumberRequestItems: []types.UpdatePhoneNumberRequestItem{
			{
				PhoneNumberId: ptr.String("__PhoneNumberId__"),
				ProductType:   types.PhoneNumberProductType("VoiceConnector"),
				CallingName:   ptr.String("__CallingName__"),
				Name:          ptr.String("__Name__"),
			},
			{
				PhoneNumberId: ptr.String("__PhoneNumberId__"),
				ProductType:   types.PhoneNumberProductType("VoiceConnector"),
				CallingName:   ptr.String("__CallingName__"),
				Name:          ptr.String("__Name__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchUpdatePhoneNumber(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchUpdatePhoneNumber"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreatePhoneNumberOrder(t *testing.T) {
	input := &CreatePhoneNumberOrderInput{
		ProductType: types.PhoneNumberProductType("VoiceConnector"),
		E164PhoneNumbers: []string{
			"__Member__",
			"__Member__",
		},
		Name: ptr.String("__Name__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreatePhoneNumberOrder(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreatePhoneNumberOrder"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateProxySession(t *testing.T) {
	input := &CreateProxySessionInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		ParticipantPhoneNumbers: []string{
			"__Member__",
			"__Member__",
		},
		Name:          ptr.String("__Name__"),
		ExpiryMinutes: ptr.Int32(1),
		Capabilities: []types.Capability{
			types.Capability("Voice"),
			types.Capability("Voice"),
		},
		NumberSelectionBehavior: types.NumberSelectionBehavior("PreferSticky"),
		GeoMatchLevel:           types.GeoMatchLevel("Country"),
		GeoMatchParams: &types.GeoMatchParams{
			Country:  ptr.String("__Country__"),
			AreaCode: ptr.String("__AreaCode__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateProxySession(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateProxySession"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateSipMediaApplication(t *testing.T) {
	input := &CreateSipMediaApplicationInput{
		AwsRegion: ptr.String("__AwsRegion__"),
		Name:      ptr.String("__Name__"),
		Endpoints: []types.SipMediaApplicationEndpoint{
			{
				LambdaArn: ptr.String("__LambdaArn__"),
			},
			{
				LambdaArn: ptr.String("__LambdaArn__"),
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateSipMediaApplication(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateSipMediaApplication"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateSipMediaApplicationCall(t *testing.T) {
	input := &CreateSipMediaApplicationCallInput{
		FromPhoneNumber:       ptr.String("__FromPhoneNumber__"),
		ToPhoneNumber:         ptr.String("__ToPhoneNumber__"),
		SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
		SipHeaders: map[string]string{
			"key0": "__Value__",
		},
		ArgumentsMap: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateSipMediaApplicationCall(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateSipMediaApplicationCall"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateSipRule(t *testing.T) {
	input := &CreateSipRuleInput{
		Name:         ptr.String("__Name__"),
		TriggerType:  types.SipRuleTriggerType("ToPhoneNumber"),
		TriggerValue: ptr.String("__TriggerValue__"),
		Disabled:     ptr.Bool(true),
		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__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateSipRule(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateSipRule"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateVoiceConnector(t *testing.T) {
	input := &CreateVoiceConnectorInput{
		Name:              ptr.String("__Name__"),
		AwsRegion:         types.VoiceConnectorAwsRegion("us-east-1"),
		RequireEncryption: ptr.Bool(true),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		IntegrationType: types.VoiceConnectorIntegrationType("CONNECT_CALL_TRANSFER_CONNECTOR"),
		NetworkType:     types.NetworkType("IPV4_ONLY"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateVoiceConnector(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateVoiceConnector"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateVoiceConnectorGroup(t *testing.T) {
	input := &CreateVoiceConnectorGroupInput{
		Name: ptr.String("__Name__"),
		VoiceConnectorItems: []types.VoiceConnectorItem{
			{
				VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
				Priority:         ptr.Int32(1),
			},
			{
				VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
				Priority:         ptr.Int32(1),
			},
		},
		CallDistributionType: types.CallDistributionType("PriorityWeightedDistribution"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateVoiceConnectorGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateVoiceConnectorGroup"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateVoiceProfile(t *testing.T) {
	input := &CreateVoiceProfileInput{
		SpeakerSearchTaskId: ptr.String("__SpeakerSearchTaskId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateVoiceProfile(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateVoiceProfile"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateVoiceProfileDomain(t *testing.T) {
	input := &CreateVoiceProfileDomainInput{
		Name:        ptr.String("__Name__"),
		Description: ptr.String("__Description__"),
		ServerSideEncryptionConfiguration: &types.ServerSideEncryptionConfiguration{
			KmsKeyArn: ptr.String("__KmsKeyArn__"),
		},
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateVoiceProfileDomain(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateVoiceProfileDomain"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeletePhoneNumber(t *testing.T) {
	input := &DeletePhoneNumberInput{
		PhoneNumberId: ptr.String("__PhoneNumberId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeletePhoneNumber(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeletePhoneNumber"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteProxySession(t *testing.T) {
	input := &DeleteProxySessionInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		ProxySessionId:   ptr.String("__ProxySessionId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteProxySession(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteProxySession"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteSipMediaApplication(t *testing.T) {
	input := &DeleteSipMediaApplicationInput{
		SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteSipMediaApplication(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteSipMediaApplication"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteSipRule(t *testing.T) {
	input := &DeleteSipRuleInput{
		SipRuleId: ptr.String("__SipRuleId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteSipRule(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteSipRule"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteVoiceConnector(t *testing.T) {
	input := &DeleteVoiceConnectorInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteVoiceConnector(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteVoiceConnector"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteVoiceConnectorEmergencyCallingConfiguration(t *testing.T) {
	input := &DeleteVoiceConnectorEmergencyCallingConfigurationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteVoiceConnectorEmergencyCallingConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteVoiceConnectorEmergencyCallingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteVoiceConnectorExternalSystemsConfiguration(t *testing.T) {
	input := &DeleteVoiceConnectorExternalSystemsConfigurationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteVoiceConnectorExternalSystemsConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteVoiceConnectorExternalSystemsConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteVoiceConnectorGroup(t *testing.T) {
	input := &DeleteVoiceConnectorGroupInput{
		VoiceConnectorGroupId: ptr.String("__VoiceConnectorGroupId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteVoiceConnectorGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteVoiceConnectorGroup"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteVoiceConnectorOrigination(t *testing.T) {
	input := &DeleteVoiceConnectorOriginationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteVoiceConnectorOrigination(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteVoiceConnectorOrigination"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteVoiceConnectorProxy(t *testing.T) {
	input := &DeleteVoiceConnectorProxyInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteVoiceConnectorProxy(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteVoiceConnectorProxy"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteVoiceConnectorStreamingConfiguration(t *testing.T) {
	input := &DeleteVoiceConnectorStreamingConfigurationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteVoiceConnectorStreamingConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteVoiceConnectorStreamingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteVoiceConnectorTermination(t *testing.T) {
	input := &DeleteVoiceConnectorTerminationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteVoiceConnectorTermination(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteVoiceConnectorTermination"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteVoiceConnectorTerminationCredentials(t *testing.T) {
	input := &DeleteVoiceConnectorTerminationCredentialsInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		Usernames: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteVoiceConnectorTerminationCredentials(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteVoiceConnectorTerminationCredentials"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteVoiceProfile(t *testing.T) {
	input := &DeleteVoiceProfileInput{
		VoiceProfileId: ptr.String("__VoiceProfileId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteVoiceProfile(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteVoiceProfile"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteVoiceProfileDomain(t *testing.T) {
	input := &DeleteVoiceProfileDomainInput{
		VoiceProfileDomainId: ptr.String("__VoiceProfileDomainId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteVoiceProfileDomain(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteVoiceProfileDomain"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DisassociatePhoneNumbersFromVoiceConnector(t *testing.T) {
	input := &DisassociatePhoneNumbersFromVoiceConnectorInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		E164PhoneNumbers: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DisassociatePhoneNumbersFromVoiceConnector(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DisassociatePhoneNumbersFromVoiceConnector"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DisassociatePhoneNumbersFromVoiceConnectorGroup(t *testing.T) {
	input := &DisassociatePhoneNumbersFromVoiceConnectorGroupInput{
		VoiceConnectorGroupId: ptr.String("__VoiceConnectorGroupId__"),
		E164PhoneNumbers: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DisassociatePhoneNumbersFromVoiceConnectorGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DisassociatePhoneNumbersFromVoiceConnectorGroup"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetGlobalSettings(t *testing.T) {
	input := &GetGlobalSettingsInput{}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetGlobalSettings(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetGlobalSettings"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetPhoneNumber(t *testing.T) {
	input := &GetPhoneNumberInput{
		PhoneNumberId: ptr.String("__PhoneNumberId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetPhoneNumber(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetPhoneNumber"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetPhoneNumberOrder(t *testing.T) {
	input := &GetPhoneNumberOrderInput{
		PhoneNumberOrderId: ptr.String("__PhoneNumberOrderId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetPhoneNumberOrder(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetPhoneNumberOrder"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetPhoneNumberSettings(t *testing.T) {
	input := &GetPhoneNumberSettingsInput{}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetPhoneNumberSettings(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetPhoneNumberSettings"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetProxySession(t *testing.T) {
	input := &GetProxySessionInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		ProxySessionId:   ptr.String("__ProxySessionId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetProxySession(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetProxySession"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetSipMediaApplication(t *testing.T) {
	input := &GetSipMediaApplicationInput{
		SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetSipMediaApplication(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetSipMediaApplication"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetSipMediaApplicationAlexaSkillConfiguration(t *testing.T) {
	input := &GetSipMediaApplicationAlexaSkillConfigurationInput{
		SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetSipMediaApplicationAlexaSkillConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetSipMediaApplicationAlexaSkillConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetSipMediaApplicationLoggingConfiguration(t *testing.T) {
	input := &GetSipMediaApplicationLoggingConfigurationInput{
		SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetSipMediaApplicationLoggingConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetSipMediaApplicationLoggingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetSipRule(t *testing.T) {
	input := &GetSipRuleInput{
		SipRuleId: ptr.String("__SipRuleId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetSipRule(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetSipRule"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetSpeakerSearchTask(t *testing.T) {
	input := &GetSpeakerSearchTaskInput{
		VoiceConnectorId:    ptr.String("__VoiceConnectorId__"),
		SpeakerSearchTaskId: ptr.String("__SpeakerSearchTaskId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetSpeakerSearchTask(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetSpeakerSearchTask"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetVoiceConnector(t *testing.T) {
	input := &GetVoiceConnectorInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetVoiceConnector(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetVoiceConnector"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetVoiceConnectorEmergencyCallingConfiguration(t *testing.T) {
	input := &GetVoiceConnectorEmergencyCallingConfigurationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetVoiceConnectorEmergencyCallingConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetVoiceConnectorEmergencyCallingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetVoiceConnectorExternalSystemsConfiguration(t *testing.T) {
	input := &GetVoiceConnectorExternalSystemsConfigurationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetVoiceConnectorExternalSystemsConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetVoiceConnectorExternalSystemsConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetVoiceConnectorGroup(t *testing.T) {
	input := &GetVoiceConnectorGroupInput{
		VoiceConnectorGroupId: ptr.String("__VoiceConnectorGroupId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetVoiceConnectorGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetVoiceConnectorGroup"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetVoiceConnectorLoggingConfiguration(t *testing.T) {
	input := &GetVoiceConnectorLoggingConfigurationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetVoiceConnectorLoggingConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetVoiceConnectorLoggingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetVoiceConnectorOrigination(t *testing.T) {
	input := &GetVoiceConnectorOriginationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetVoiceConnectorOrigination(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetVoiceConnectorOrigination"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetVoiceConnectorProxy(t *testing.T) {
	input := &GetVoiceConnectorProxyInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetVoiceConnectorProxy(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetVoiceConnectorProxy"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetVoiceConnectorStreamingConfiguration(t *testing.T) {
	input := &GetVoiceConnectorStreamingConfigurationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetVoiceConnectorStreamingConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetVoiceConnectorStreamingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetVoiceConnectorTermination(t *testing.T) {
	input := &GetVoiceConnectorTerminationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetVoiceConnectorTermination(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetVoiceConnectorTermination"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetVoiceConnectorTerminationHealth(t *testing.T) {
	input := &GetVoiceConnectorTerminationHealthInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetVoiceConnectorTerminationHealth(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetVoiceConnectorTerminationHealth"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetVoiceProfile(t *testing.T) {
	input := &GetVoiceProfileInput{
		VoiceProfileId: ptr.String("__VoiceProfileId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetVoiceProfile(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetVoiceProfile"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetVoiceProfileDomain(t *testing.T) {
	input := &GetVoiceProfileDomainInput{
		VoiceProfileDomainId: ptr.String("__VoiceProfileDomainId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetVoiceProfileDomain(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetVoiceProfileDomain"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetVoiceToneAnalysisTask(t *testing.T) {
	input := &GetVoiceToneAnalysisTaskInput{
		VoiceConnectorId:        ptr.String("__VoiceConnectorId__"),
		VoiceToneAnalysisTaskId: ptr.String("__VoiceToneAnalysisTaskId__"),
		IsCaller:                ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetVoiceToneAnalysisTask(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetVoiceToneAnalysisTask"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListAvailableVoiceConnectorRegions(t *testing.T) {
	input := &ListAvailableVoiceConnectorRegionsInput{}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListAvailableVoiceConnectorRegions(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListAvailableVoiceConnectorRegions"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListPhoneNumberOrders(t *testing.T) {
	input := &ListPhoneNumberOrdersInput{
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListPhoneNumberOrders(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListPhoneNumberOrders"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListPhoneNumbers(t *testing.T) {
	input := &ListPhoneNumbersInput{
		Status:      ptr.String("__Status__"),
		ProductType: types.PhoneNumberProductType("VoiceConnector"),
		FilterName:  types.PhoneNumberAssociationName("VoiceConnectorId"),
		FilterValue: ptr.String("__FilterValue__"),
		MaxResults:  ptr.Int32(1),
		NextToken:   ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListPhoneNumbers(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListPhoneNumbers"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListProxySessions(t *testing.T) {
	input := &ListProxySessionsInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		Status:           types.ProxySessionStatus("Open"),
		NextToken:        ptr.String("__NextToken__"),
		MaxResults:       ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListProxySessions(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListProxySessions"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListSipMediaApplications(t *testing.T) {
	input := &ListSipMediaApplicationsInput{
		MaxResults: ptr.Int32(1),
		NextToken:  ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListSipMediaApplications(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListSipMediaApplications"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListSipRules(t *testing.T) {
	input := &ListSipRulesInput{
		SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
		MaxResults:            ptr.Int32(1),
		NextToken:             ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListSipRules(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListSipRules"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListSupportedPhoneNumberCountries(t *testing.T) {
	input := &ListSupportedPhoneNumberCountriesInput{
		ProductType: types.PhoneNumberProductType("VoiceConnector"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListSupportedPhoneNumberCountries(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListSupportedPhoneNumberCountries"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListTagsForResource(t *testing.T) {
	input := &ListTagsForResourceInput{
		ResourceARN: ptr.String("__ResourceARN__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListTagsForResource(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListTagsForResource"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListVoiceConnectorGroups(t *testing.T) {
	input := &ListVoiceConnectorGroupsInput{
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListVoiceConnectorGroups(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListVoiceConnectorGroups"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListVoiceConnectors(t *testing.T) {
	input := &ListVoiceConnectorsInput{
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListVoiceConnectors(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListVoiceConnectors"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListVoiceConnectorTerminationCredentials(t *testing.T) {
	input := &ListVoiceConnectorTerminationCredentialsInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListVoiceConnectorTerminationCredentials(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListVoiceConnectorTerminationCredentials"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListVoiceProfileDomains(t *testing.T) {
	input := &ListVoiceProfileDomainsInput{
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListVoiceProfileDomains(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListVoiceProfileDomains"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListVoiceProfiles(t *testing.T) {
	input := &ListVoiceProfilesInput{
		VoiceProfileDomainId: ptr.String("__VoiceProfileDomainId__"),
		NextToken:            ptr.String("__NextToken__"),
		MaxResults:           ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListVoiceProfiles(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListVoiceProfiles"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutSipMediaApplicationAlexaSkillConfiguration(t *testing.T) {
	input := &PutSipMediaApplicationAlexaSkillConfigurationInput{
		SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
		SipMediaApplicationAlexaSkillConfiguration: &types.SipMediaApplicationAlexaSkillConfiguration{
			AlexaSkillStatus: types.AlexaSkillStatus("ACTIVE"),
			AlexaSkillIds: []string{
				"__Member__",
				"__Member__",
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutSipMediaApplicationAlexaSkillConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "PutSipMediaApplicationAlexaSkillConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutSipMediaApplicationLoggingConfiguration(t *testing.T) {
	input := &PutSipMediaApplicationLoggingConfigurationInput{
		SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
		SipMediaApplicationLoggingConfiguration: &types.SipMediaApplicationLoggingConfiguration{
			EnableSipMediaApplicationMessageLogs: ptr.Bool(true),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutSipMediaApplicationLoggingConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "PutSipMediaApplicationLoggingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutVoiceConnectorEmergencyCallingConfiguration(t *testing.T) {
	input := &PutVoiceConnectorEmergencyCallingConfigurationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		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__"),
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutVoiceConnectorEmergencyCallingConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "PutVoiceConnectorEmergencyCallingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutVoiceConnectorExternalSystemsConfiguration(t *testing.T) {
	input := &PutVoiceConnectorExternalSystemsConfigurationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		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"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutVoiceConnectorExternalSystemsConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "PutVoiceConnectorExternalSystemsConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutVoiceConnectorLoggingConfiguration(t *testing.T) {
	input := &PutVoiceConnectorLoggingConfigurationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		LoggingConfiguration: &types.LoggingConfiguration{
			EnableSIPLogs:         ptr.Bool(true),
			EnableMediaMetricLogs: ptr.Bool(true),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutVoiceConnectorLoggingConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "PutVoiceConnectorLoggingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutVoiceConnectorOrigination(t *testing.T) {
	input := &PutVoiceConnectorOriginationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		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),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutVoiceConnectorOrigination(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "PutVoiceConnectorOrigination"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutVoiceConnectorProxy(t *testing.T) {
	input := &PutVoiceConnectorProxyInput{
		VoiceConnectorId:            ptr.String("__VoiceConnectorId__"),
		DefaultSessionExpiryMinutes: ptr.Int32(1),
		PhoneNumberPoolCountries: []string{
			"__Member__",
			"__Member__",
		},
		FallBackPhoneNumber: ptr.String("__FallBackPhoneNumber__"),
		Disabled:            ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutVoiceConnectorProxy(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "PutVoiceConnectorProxy"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutVoiceConnectorStreamingConfiguration(t *testing.T) {
	input := &PutVoiceConnectorStreamingConfigurationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		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__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutVoiceConnectorStreamingConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "PutVoiceConnectorStreamingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutVoiceConnectorTermination(t *testing.T) {
	input := &PutVoiceConnectorTerminationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		Termination: &types.Termination{
			CpsLimit:           ptr.Int32(1),
			DefaultPhoneNumber: ptr.String("__DefaultPhoneNumber__"),
			CallingRegions: []string{
				"__Member__",
				"__Member__",
			},
			CidrAllowedList: []string{
				"__Member__",
				"__Member__",
			},
			Disabled: ptr.Bool(true),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutVoiceConnectorTermination(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "PutVoiceConnectorTermination"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutVoiceConnectorTerminationCredentials(t *testing.T) {
	input := &PutVoiceConnectorTerminationCredentialsInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		Credentials: []types.Credential{
			{
				Username: ptr.String("__Username__"),
				Password: ptr.String("__Password__"),
			},
			{
				Username: ptr.String("__Username__"),
				Password: ptr.String("__Password__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutVoiceConnectorTerminationCredentials(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "PutVoiceConnectorTerminationCredentials"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_RestorePhoneNumber(t *testing.T) {
	input := &RestorePhoneNumberInput{
		PhoneNumberId: ptr.String("__PhoneNumberId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.RestorePhoneNumber(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "RestorePhoneNumber"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_SearchAvailablePhoneNumbers(t *testing.T) {
	input := &SearchAvailablePhoneNumbersInput{
		AreaCode:        ptr.String("__AreaCode__"),
		City:            ptr.String("__City__"),
		Country:         ptr.String("__Country__"),
		State:           ptr.String("__State__"),
		TollFreePrefix:  ptr.String("__TollFreePrefix__"),
		PhoneNumberType: types.PhoneNumberType("Local"),
		MaxResults:      ptr.Int32(1),
		NextToken:       ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.SearchAvailablePhoneNumbers(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "SearchAvailablePhoneNumbers"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_StartSpeakerSearchTask(t *testing.T) {
	input := &StartSpeakerSearchTaskInput{
		VoiceConnectorId:     ptr.String("__VoiceConnectorId__"),
		TransactionId:        ptr.String("__TransactionId__"),
		VoiceProfileDomainId: ptr.String("__VoiceProfileDomainId__"),
		ClientRequestToken:   ptr.String("__ClientRequestToken__"),
		CallLeg:              types.CallLegType("Caller"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartSpeakerSearchTask(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartSpeakerSearchTask"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_StartVoiceToneAnalysisTask(t *testing.T) {
	input := &StartVoiceToneAnalysisTaskInput{
		VoiceConnectorId:   ptr.String("__VoiceConnectorId__"),
		TransactionId:      ptr.String("__TransactionId__"),
		LanguageCode:       types.LanguageCode("en-US"),
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartVoiceToneAnalysisTask(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartVoiceToneAnalysisTask"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_StopSpeakerSearchTask(t *testing.T) {
	input := &StopSpeakerSearchTaskInput{
		VoiceConnectorId:    ptr.String("__VoiceConnectorId__"),
		SpeakerSearchTaskId: ptr.String("__SpeakerSearchTaskId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopSpeakerSearchTask(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StopSpeakerSearchTask"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_StopVoiceToneAnalysisTask(t *testing.T) {
	input := &StopVoiceToneAnalysisTaskInput{
		VoiceConnectorId:        ptr.String("__VoiceConnectorId__"),
		VoiceToneAnalysisTaskId: ptr.String("__VoiceToneAnalysisTaskId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopVoiceToneAnalysisTask(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StopVoiceToneAnalysisTask"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_TagResource(t *testing.T) {
	input := &TagResourceInput{
		ResourceARN: ptr.String("__ResourceARN__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.TagResource(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "TagResource"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UntagResource(t *testing.T) {
	input := &UntagResourceInput{
		ResourceARN: ptr.String("__ResourceARN__"),
		TagKeys: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UntagResource(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UntagResource"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateGlobalSettings(t *testing.T) {
	input := &UpdateGlobalSettingsInput{
		VoiceConnector: &types.VoiceConnectorSettings{
			CdrBucket: ptr.String("__CdrBucket__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateGlobalSettings(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateGlobalSettings"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdatePhoneNumber(t *testing.T) {
	input := &UpdatePhoneNumberInput{
		PhoneNumberId: ptr.String("__PhoneNumberId__"),
		ProductType:   types.PhoneNumberProductType("VoiceConnector"),
		CallingName:   ptr.String("__CallingName__"),
		Name:          ptr.String("__Name__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdatePhoneNumber(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdatePhoneNumber"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdatePhoneNumberSettings(t *testing.T) {
	input := &UpdatePhoneNumberSettingsInput{
		CallingName: ptr.String("__CallingName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdatePhoneNumberSettings(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdatePhoneNumberSettings"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateProxySession(t *testing.T) {
	input := &UpdateProxySessionInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		ProxySessionId:   ptr.String("__ProxySessionId__"),
		Capabilities: []types.Capability{
			types.Capability("Voice"),
			types.Capability("Voice"),
		},
		ExpiryMinutes: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateProxySession(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateProxySession"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateSipMediaApplication(t *testing.T) {
	input := &UpdateSipMediaApplicationInput{
		SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
		Name:                  ptr.String("__Name__"),
		Endpoints: []types.SipMediaApplicationEndpoint{
			{
				LambdaArn: ptr.String("__LambdaArn__"),
			},
			{
				LambdaArn: ptr.String("__LambdaArn__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateSipMediaApplication(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateSipMediaApplication"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateSipMediaApplicationCall(t *testing.T) {
	input := &UpdateSipMediaApplicationCallInput{
		SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
		TransactionId:         ptr.String("__TransactionId__"),
		Arguments: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateSipMediaApplicationCall(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateSipMediaApplicationCall"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateSipRule(t *testing.T) {
	input := &UpdateSipRuleInput{
		SipRuleId: ptr.String("__SipRuleId__"),
		Name:      ptr.String("__Name__"),
		Disabled:  ptr.Bool(true),
		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__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateSipRule(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateSipRule"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateVoiceConnector(t *testing.T) {
	input := &UpdateVoiceConnectorInput{
		VoiceConnectorId:  ptr.String("__VoiceConnectorId__"),
		Name:              ptr.String("__Name__"),
		RequireEncryption: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateVoiceConnector(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateVoiceConnector"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateVoiceConnectorGroup(t *testing.T) {
	input := &UpdateVoiceConnectorGroupInput{
		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),
			},
		},
		CallDistributionType: types.CallDistributionType("PriorityWeightedDistribution"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateVoiceConnectorGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateVoiceConnectorGroup"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateVoiceProfile(t *testing.T) {
	input := &UpdateVoiceProfileInput{
		VoiceProfileId:      ptr.String("__VoiceProfileId__"),
		SpeakerSearchTaskId: ptr.String("__SpeakerSearchTaskId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateVoiceProfile(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateVoiceProfile"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateVoiceProfileDomain(t *testing.T) {
	input := &UpdateVoiceProfileDomainInput{
		VoiceProfileDomainId: ptr.String("__VoiceProfileDomainId__"),
		Name:                 ptr.String("__Name__"),
		Description:          ptr.String("__Description__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateVoiceProfileDomain(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateVoiceProfileDomain"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ValidateE911Address(t *testing.T) {
	input := &ValidateE911AddressInput{
		AwsAccountId: ptr.String("__AwsAccountId__"),
		StreetNumber: ptr.String("__StreetNumber__"),
		StreetInfo:   ptr.String("__StreetInfo__"),
		City:         ptr.String("__City__"),
		State:        ptr.String("__State__"),
		Country:      ptr.String("__Country__"),
		PostalCode:   ptr.String("__PostalCode__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ValidateE911Address(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ValidateE911Address"); err != nil {
		t.Fatal(err)
	}
}
func TestUpdateRequestSnapshot_AssociatePhoneNumbersWithVoiceConnector(t *testing.T) {
	input := &AssociatePhoneNumbersWithVoiceConnectorInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		E164PhoneNumbers: []string{
			"__Member__",
			"__Member__",
		},
		ForceAssociate: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AssociatePhoneNumbersWithVoiceConnector(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AssociatePhoneNumbersWithVoiceConnector"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_AssociatePhoneNumbersWithVoiceConnectorGroup(t *testing.T) {
	input := &AssociatePhoneNumbersWithVoiceConnectorGroupInput{
		VoiceConnectorGroupId: ptr.String("__VoiceConnectorGroupId__"),
		E164PhoneNumbers: []string{
			"__Member__",
			"__Member__",
		},
		ForceAssociate: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AssociatePhoneNumbersWithVoiceConnectorGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AssociatePhoneNumbersWithVoiceConnectorGroup"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_BatchDeletePhoneNumber(t *testing.T) {
	input := &BatchDeletePhoneNumberInput{
		PhoneNumberIds: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchDeletePhoneNumber(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchDeletePhoneNumber"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_BatchUpdatePhoneNumber(t *testing.T) {
	input := &BatchUpdatePhoneNumberInput{
		UpdatePhoneNumberRequestItems: []types.UpdatePhoneNumberRequestItem{
			{
				PhoneNumberId: ptr.String("__PhoneNumberId__"),
				ProductType:   types.PhoneNumberProductType("VoiceConnector"),
				CallingName:   ptr.String("__CallingName__"),
				Name:          ptr.String("__Name__"),
			},
			{
				PhoneNumberId: ptr.String("__PhoneNumberId__"),
				ProductType:   types.PhoneNumberProductType("VoiceConnector"),
				CallingName:   ptr.String("__CallingName__"),
				Name:          ptr.String("__Name__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchUpdatePhoneNumber(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchUpdatePhoneNumber"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreatePhoneNumberOrder(t *testing.T) {
	input := &CreatePhoneNumberOrderInput{
		ProductType: types.PhoneNumberProductType("VoiceConnector"),
		E164PhoneNumbers: []string{
			"__Member__",
			"__Member__",
		},
		Name: ptr.String("__Name__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreatePhoneNumberOrder(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreatePhoneNumberOrder"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateProxySession(t *testing.T) {
	input := &CreateProxySessionInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		ParticipantPhoneNumbers: []string{
			"__Member__",
			"__Member__",
		},
		Name:          ptr.String("__Name__"),
		ExpiryMinutes: ptr.Int32(1),
		Capabilities: []types.Capability{
			types.Capability("Voice"),
			types.Capability("Voice"),
		},
		NumberSelectionBehavior: types.NumberSelectionBehavior("PreferSticky"),
		GeoMatchLevel:           types.GeoMatchLevel("Country"),
		GeoMatchParams: &types.GeoMatchParams{
			Country:  ptr.String("__Country__"),
			AreaCode: ptr.String("__AreaCode__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateProxySession(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateProxySession"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateSipMediaApplication(t *testing.T) {
	input := &CreateSipMediaApplicationInput{
		AwsRegion: ptr.String("__AwsRegion__"),
		Name:      ptr.String("__Name__"),
		Endpoints: []types.SipMediaApplicationEndpoint{
			{
				LambdaArn: ptr.String("__LambdaArn__"),
			},
			{
				LambdaArn: ptr.String("__LambdaArn__"),
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateSipMediaApplication(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateSipMediaApplication"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateSipMediaApplicationCall(t *testing.T) {
	input := &CreateSipMediaApplicationCallInput{
		FromPhoneNumber:       ptr.String("__FromPhoneNumber__"),
		ToPhoneNumber:         ptr.String("__ToPhoneNumber__"),
		SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
		SipHeaders: map[string]string{
			"key0": "__Value__",
		},
		ArgumentsMap: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateSipMediaApplicationCall(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateSipMediaApplicationCall"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateSipRule(t *testing.T) {
	input := &CreateSipRuleInput{
		Name:         ptr.String("__Name__"),
		TriggerType:  types.SipRuleTriggerType("ToPhoneNumber"),
		TriggerValue: ptr.String("__TriggerValue__"),
		Disabled:     ptr.Bool(true),
		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__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateSipRule(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateSipRule"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateVoiceConnector(t *testing.T) {
	input := &CreateVoiceConnectorInput{
		Name:              ptr.String("__Name__"),
		AwsRegion:         types.VoiceConnectorAwsRegion("us-east-1"),
		RequireEncryption: ptr.Bool(true),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		IntegrationType: types.VoiceConnectorIntegrationType("CONNECT_CALL_TRANSFER_CONNECTOR"),
		NetworkType:     types.NetworkType("IPV4_ONLY"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateVoiceConnector(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateVoiceConnector"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateVoiceConnectorGroup(t *testing.T) {
	input := &CreateVoiceConnectorGroupInput{
		Name: ptr.String("__Name__"),
		VoiceConnectorItems: []types.VoiceConnectorItem{
			{
				VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
				Priority:         ptr.Int32(1),
			},
			{
				VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
				Priority:         ptr.Int32(1),
			},
		},
		CallDistributionType: types.CallDistributionType("PriorityWeightedDistribution"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateVoiceConnectorGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateVoiceConnectorGroup"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateVoiceProfile(t *testing.T) {
	input := &CreateVoiceProfileInput{
		SpeakerSearchTaskId: ptr.String("__SpeakerSearchTaskId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateVoiceProfile(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateVoiceProfile"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateVoiceProfileDomain(t *testing.T) {
	input := &CreateVoiceProfileDomainInput{
		Name:        ptr.String("__Name__"),
		Description: ptr.String("__Description__"),
		ServerSideEncryptionConfiguration: &types.ServerSideEncryptionConfiguration{
			KmsKeyArn: ptr.String("__KmsKeyArn__"),
		},
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateVoiceProfileDomain(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateVoiceProfileDomain"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeletePhoneNumber(t *testing.T) {
	input := &DeletePhoneNumberInput{
		PhoneNumberId: ptr.String("__PhoneNumberId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeletePhoneNumber(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeletePhoneNumber"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteProxySession(t *testing.T) {
	input := &DeleteProxySessionInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		ProxySessionId:   ptr.String("__ProxySessionId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteProxySession(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteProxySession"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteSipMediaApplication(t *testing.T) {
	input := &DeleteSipMediaApplicationInput{
		SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteSipMediaApplication(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteSipMediaApplication"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteSipRule(t *testing.T) {
	input := &DeleteSipRuleInput{
		SipRuleId: ptr.String("__SipRuleId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteSipRule(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteSipRule"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteVoiceConnector(t *testing.T) {
	input := &DeleteVoiceConnectorInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteVoiceConnector(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteVoiceConnector"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteVoiceConnectorEmergencyCallingConfiguration(t *testing.T) {
	input := &DeleteVoiceConnectorEmergencyCallingConfigurationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteVoiceConnectorEmergencyCallingConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteVoiceConnectorEmergencyCallingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteVoiceConnectorExternalSystemsConfiguration(t *testing.T) {
	input := &DeleteVoiceConnectorExternalSystemsConfigurationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteVoiceConnectorExternalSystemsConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteVoiceConnectorExternalSystemsConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteVoiceConnectorGroup(t *testing.T) {
	input := &DeleteVoiceConnectorGroupInput{
		VoiceConnectorGroupId: ptr.String("__VoiceConnectorGroupId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteVoiceConnectorGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteVoiceConnectorGroup"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteVoiceConnectorOrigination(t *testing.T) {
	input := &DeleteVoiceConnectorOriginationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteVoiceConnectorOrigination(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteVoiceConnectorOrigination"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteVoiceConnectorProxy(t *testing.T) {
	input := &DeleteVoiceConnectorProxyInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteVoiceConnectorProxy(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteVoiceConnectorProxy"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteVoiceConnectorStreamingConfiguration(t *testing.T) {
	input := &DeleteVoiceConnectorStreamingConfigurationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteVoiceConnectorStreamingConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteVoiceConnectorStreamingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteVoiceConnectorTermination(t *testing.T) {
	input := &DeleteVoiceConnectorTerminationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteVoiceConnectorTermination(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteVoiceConnectorTermination"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteVoiceConnectorTerminationCredentials(t *testing.T) {
	input := &DeleteVoiceConnectorTerminationCredentialsInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		Usernames: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteVoiceConnectorTerminationCredentials(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteVoiceConnectorTerminationCredentials"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteVoiceProfile(t *testing.T) {
	input := &DeleteVoiceProfileInput{
		VoiceProfileId: ptr.String("__VoiceProfileId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteVoiceProfile(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteVoiceProfile"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteVoiceProfileDomain(t *testing.T) {
	input := &DeleteVoiceProfileDomainInput{
		VoiceProfileDomainId: ptr.String("__VoiceProfileDomainId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteVoiceProfileDomain(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteVoiceProfileDomain"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DisassociatePhoneNumbersFromVoiceConnector(t *testing.T) {
	input := &DisassociatePhoneNumbersFromVoiceConnectorInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		E164PhoneNumbers: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DisassociatePhoneNumbersFromVoiceConnector(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DisassociatePhoneNumbersFromVoiceConnector"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DisassociatePhoneNumbersFromVoiceConnectorGroup(t *testing.T) {
	input := &DisassociatePhoneNumbersFromVoiceConnectorGroupInput{
		VoiceConnectorGroupId: ptr.String("__VoiceConnectorGroupId__"),
		E164PhoneNumbers: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DisassociatePhoneNumbersFromVoiceConnectorGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DisassociatePhoneNumbersFromVoiceConnectorGroup"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetGlobalSettings(t *testing.T) {
	input := &GetGlobalSettingsInput{}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetGlobalSettings(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetGlobalSettings"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetPhoneNumber(t *testing.T) {
	input := &GetPhoneNumberInput{
		PhoneNumberId: ptr.String("__PhoneNumberId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetPhoneNumber(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetPhoneNumber"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetPhoneNumberOrder(t *testing.T) {
	input := &GetPhoneNumberOrderInput{
		PhoneNumberOrderId: ptr.String("__PhoneNumberOrderId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetPhoneNumberOrder(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetPhoneNumberOrder"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetPhoneNumberSettings(t *testing.T) {
	input := &GetPhoneNumberSettingsInput{}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetPhoneNumberSettings(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetPhoneNumberSettings"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetProxySession(t *testing.T) {
	input := &GetProxySessionInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		ProxySessionId:   ptr.String("__ProxySessionId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetProxySession(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetProxySession"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetSipMediaApplication(t *testing.T) {
	input := &GetSipMediaApplicationInput{
		SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetSipMediaApplication(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetSipMediaApplication"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetSipMediaApplicationAlexaSkillConfiguration(t *testing.T) {
	input := &GetSipMediaApplicationAlexaSkillConfigurationInput{
		SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetSipMediaApplicationAlexaSkillConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetSipMediaApplicationAlexaSkillConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetSipMediaApplicationLoggingConfiguration(t *testing.T) {
	input := &GetSipMediaApplicationLoggingConfigurationInput{
		SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetSipMediaApplicationLoggingConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetSipMediaApplicationLoggingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetSipRule(t *testing.T) {
	input := &GetSipRuleInput{
		SipRuleId: ptr.String("__SipRuleId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetSipRule(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetSipRule"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetSpeakerSearchTask(t *testing.T) {
	input := &GetSpeakerSearchTaskInput{
		VoiceConnectorId:    ptr.String("__VoiceConnectorId__"),
		SpeakerSearchTaskId: ptr.String("__SpeakerSearchTaskId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetSpeakerSearchTask(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetSpeakerSearchTask"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetVoiceConnector(t *testing.T) {
	input := &GetVoiceConnectorInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetVoiceConnector(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetVoiceConnector"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetVoiceConnectorEmergencyCallingConfiguration(t *testing.T) {
	input := &GetVoiceConnectorEmergencyCallingConfigurationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetVoiceConnectorEmergencyCallingConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetVoiceConnectorEmergencyCallingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetVoiceConnectorExternalSystemsConfiguration(t *testing.T) {
	input := &GetVoiceConnectorExternalSystemsConfigurationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetVoiceConnectorExternalSystemsConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetVoiceConnectorExternalSystemsConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetVoiceConnectorGroup(t *testing.T) {
	input := &GetVoiceConnectorGroupInput{
		VoiceConnectorGroupId: ptr.String("__VoiceConnectorGroupId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetVoiceConnectorGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetVoiceConnectorGroup"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetVoiceConnectorLoggingConfiguration(t *testing.T) {
	input := &GetVoiceConnectorLoggingConfigurationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetVoiceConnectorLoggingConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetVoiceConnectorLoggingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetVoiceConnectorOrigination(t *testing.T) {
	input := &GetVoiceConnectorOriginationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetVoiceConnectorOrigination(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetVoiceConnectorOrigination"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetVoiceConnectorProxy(t *testing.T) {
	input := &GetVoiceConnectorProxyInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetVoiceConnectorProxy(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetVoiceConnectorProxy"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetVoiceConnectorStreamingConfiguration(t *testing.T) {
	input := &GetVoiceConnectorStreamingConfigurationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetVoiceConnectorStreamingConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetVoiceConnectorStreamingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetVoiceConnectorTermination(t *testing.T) {
	input := &GetVoiceConnectorTerminationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetVoiceConnectorTermination(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetVoiceConnectorTermination"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetVoiceConnectorTerminationHealth(t *testing.T) {
	input := &GetVoiceConnectorTerminationHealthInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetVoiceConnectorTerminationHealth(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetVoiceConnectorTerminationHealth"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetVoiceProfile(t *testing.T) {
	input := &GetVoiceProfileInput{
		VoiceProfileId: ptr.String("__VoiceProfileId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetVoiceProfile(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetVoiceProfile"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetVoiceProfileDomain(t *testing.T) {
	input := &GetVoiceProfileDomainInput{
		VoiceProfileDomainId: ptr.String("__VoiceProfileDomainId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetVoiceProfileDomain(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetVoiceProfileDomain"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetVoiceToneAnalysisTask(t *testing.T) {
	input := &GetVoiceToneAnalysisTaskInput{
		VoiceConnectorId:        ptr.String("__VoiceConnectorId__"),
		VoiceToneAnalysisTaskId: ptr.String("__VoiceToneAnalysisTaskId__"),
		IsCaller:                ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetVoiceToneAnalysisTask(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetVoiceToneAnalysisTask"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListAvailableVoiceConnectorRegions(t *testing.T) {
	input := &ListAvailableVoiceConnectorRegionsInput{}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListAvailableVoiceConnectorRegions(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListAvailableVoiceConnectorRegions"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListPhoneNumberOrders(t *testing.T) {
	input := &ListPhoneNumberOrdersInput{
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListPhoneNumberOrders(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListPhoneNumberOrders"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListPhoneNumbers(t *testing.T) {
	input := &ListPhoneNumbersInput{
		Status:      ptr.String("__Status__"),
		ProductType: types.PhoneNumberProductType("VoiceConnector"),
		FilterName:  types.PhoneNumberAssociationName("VoiceConnectorId"),
		FilterValue: ptr.String("__FilterValue__"),
		MaxResults:  ptr.Int32(1),
		NextToken:   ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListPhoneNumbers(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListPhoneNumbers"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListProxySessions(t *testing.T) {
	input := &ListProxySessionsInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		Status:           types.ProxySessionStatus("Open"),
		NextToken:        ptr.String("__NextToken__"),
		MaxResults:       ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListProxySessions(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListProxySessions"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListSipMediaApplications(t *testing.T) {
	input := &ListSipMediaApplicationsInput{
		MaxResults: ptr.Int32(1),
		NextToken:  ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListSipMediaApplications(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListSipMediaApplications"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListSipRules(t *testing.T) {
	input := &ListSipRulesInput{
		SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
		MaxResults:            ptr.Int32(1),
		NextToken:             ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListSipRules(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListSipRules"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListSupportedPhoneNumberCountries(t *testing.T) {
	input := &ListSupportedPhoneNumberCountriesInput{
		ProductType: types.PhoneNumberProductType("VoiceConnector"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListSupportedPhoneNumberCountries(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListSupportedPhoneNumberCountries"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListTagsForResource(t *testing.T) {
	input := &ListTagsForResourceInput{
		ResourceARN: ptr.String("__ResourceARN__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListTagsForResource(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListTagsForResource"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListVoiceConnectorGroups(t *testing.T) {
	input := &ListVoiceConnectorGroupsInput{
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListVoiceConnectorGroups(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListVoiceConnectorGroups"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListVoiceConnectors(t *testing.T) {
	input := &ListVoiceConnectorsInput{
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListVoiceConnectors(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListVoiceConnectors"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListVoiceConnectorTerminationCredentials(t *testing.T) {
	input := &ListVoiceConnectorTerminationCredentialsInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListVoiceConnectorTerminationCredentials(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListVoiceConnectorTerminationCredentials"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListVoiceProfileDomains(t *testing.T) {
	input := &ListVoiceProfileDomainsInput{
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListVoiceProfileDomains(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListVoiceProfileDomains"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListVoiceProfiles(t *testing.T) {
	input := &ListVoiceProfilesInput{
		VoiceProfileDomainId: ptr.String("__VoiceProfileDomainId__"),
		NextToken:            ptr.String("__NextToken__"),
		MaxResults:           ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListVoiceProfiles(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListVoiceProfiles"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutSipMediaApplicationAlexaSkillConfiguration(t *testing.T) {
	input := &PutSipMediaApplicationAlexaSkillConfigurationInput{
		SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
		SipMediaApplicationAlexaSkillConfiguration: &types.SipMediaApplicationAlexaSkillConfiguration{
			AlexaSkillStatus: types.AlexaSkillStatus("ACTIVE"),
			AlexaSkillIds: []string{
				"__Member__",
				"__Member__",
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutSipMediaApplicationAlexaSkillConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "PutSipMediaApplicationAlexaSkillConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutSipMediaApplicationLoggingConfiguration(t *testing.T) {
	input := &PutSipMediaApplicationLoggingConfigurationInput{
		SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
		SipMediaApplicationLoggingConfiguration: &types.SipMediaApplicationLoggingConfiguration{
			EnableSipMediaApplicationMessageLogs: ptr.Bool(true),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutSipMediaApplicationLoggingConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "PutSipMediaApplicationLoggingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutVoiceConnectorEmergencyCallingConfiguration(t *testing.T) {
	input := &PutVoiceConnectorEmergencyCallingConfigurationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		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__"),
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutVoiceConnectorEmergencyCallingConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "PutVoiceConnectorEmergencyCallingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutVoiceConnectorExternalSystemsConfiguration(t *testing.T) {
	input := &PutVoiceConnectorExternalSystemsConfigurationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		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"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutVoiceConnectorExternalSystemsConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "PutVoiceConnectorExternalSystemsConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutVoiceConnectorLoggingConfiguration(t *testing.T) {
	input := &PutVoiceConnectorLoggingConfigurationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		LoggingConfiguration: &types.LoggingConfiguration{
			EnableSIPLogs:         ptr.Bool(true),
			EnableMediaMetricLogs: ptr.Bool(true),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutVoiceConnectorLoggingConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "PutVoiceConnectorLoggingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutVoiceConnectorOrigination(t *testing.T) {
	input := &PutVoiceConnectorOriginationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		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),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutVoiceConnectorOrigination(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "PutVoiceConnectorOrigination"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutVoiceConnectorProxy(t *testing.T) {
	input := &PutVoiceConnectorProxyInput{
		VoiceConnectorId:            ptr.String("__VoiceConnectorId__"),
		DefaultSessionExpiryMinutes: ptr.Int32(1),
		PhoneNumberPoolCountries: []string{
			"__Member__",
			"__Member__",
		},
		FallBackPhoneNumber: ptr.String("__FallBackPhoneNumber__"),
		Disabled:            ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutVoiceConnectorProxy(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "PutVoiceConnectorProxy"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutVoiceConnectorStreamingConfiguration(t *testing.T) {
	input := &PutVoiceConnectorStreamingConfigurationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		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__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutVoiceConnectorStreamingConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "PutVoiceConnectorStreamingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutVoiceConnectorTermination(t *testing.T) {
	input := &PutVoiceConnectorTerminationInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		Termination: &types.Termination{
			CpsLimit:           ptr.Int32(1),
			DefaultPhoneNumber: ptr.String("__DefaultPhoneNumber__"),
			CallingRegions: []string{
				"__Member__",
				"__Member__",
			},
			CidrAllowedList: []string{
				"__Member__",
				"__Member__",
			},
			Disabled: ptr.Bool(true),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutVoiceConnectorTermination(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "PutVoiceConnectorTermination"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutVoiceConnectorTerminationCredentials(t *testing.T) {
	input := &PutVoiceConnectorTerminationCredentialsInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		Credentials: []types.Credential{
			{
				Username: ptr.String("__Username__"),
				Password: ptr.String("__Password__"),
			},
			{
				Username: ptr.String("__Username__"),
				Password: ptr.String("__Password__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutVoiceConnectorTerminationCredentials(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "PutVoiceConnectorTerminationCredentials"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_RestorePhoneNumber(t *testing.T) {
	input := &RestorePhoneNumberInput{
		PhoneNumberId: ptr.String("__PhoneNumberId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.RestorePhoneNumber(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "RestorePhoneNumber"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_SearchAvailablePhoneNumbers(t *testing.T) {
	input := &SearchAvailablePhoneNumbersInput{
		AreaCode:        ptr.String("__AreaCode__"),
		City:            ptr.String("__City__"),
		Country:         ptr.String("__Country__"),
		State:           ptr.String("__State__"),
		TollFreePrefix:  ptr.String("__TollFreePrefix__"),
		PhoneNumberType: types.PhoneNumberType("Local"),
		MaxResults:      ptr.Int32(1),
		NextToken:       ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.SearchAvailablePhoneNumbers(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "SearchAvailablePhoneNumbers"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_StartSpeakerSearchTask(t *testing.T) {
	input := &StartSpeakerSearchTaskInput{
		VoiceConnectorId:     ptr.String("__VoiceConnectorId__"),
		TransactionId:        ptr.String("__TransactionId__"),
		VoiceProfileDomainId: ptr.String("__VoiceProfileDomainId__"),
		ClientRequestToken:   ptr.String("__ClientRequestToken__"),
		CallLeg:              types.CallLegType("Caller"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartSpeakerSearchTask(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartSpeakerSearchTask"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_StartVoiceToneAnalysisTask(t *testing.T) {
	input := &StartVoiceToneAnalysisTaskInput{
		VoiceConnectorId:   ptr.String("__VoiceConnectorId__"),
		TransactionId:      ptr.String("__TransactionId__"),
		LanguageCode:       types.LanguageCode("en-US"),
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartVoiceToneAnalysisTask(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartVoiceToneAnalysisTask"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_StopSpeakerSearchTask(t *testing.T) {
	input := &StopSpeakerSearchTaskInput{
		VoiceConnectorId:    ptr.String("__VoiceConnectorId__"),
		SpeakerSearchTaskId: ptr.String("__SpeakerSearchTaskId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopSpeakerSearchTask(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StopSpeakerSearchTask"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_StopVoiceToneAnalysisTask(t *testing.T) {
	input := &StopVoiceToneAnalysisTaskInput{
		VoiceConnectorId:        ptr.String("__VoiceConnectorId__"),
		VoiceToneAnalysisTaskId: ptr.String("__VoiceToneAnalysisTaskId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopVoiceToneAnalysisTask(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StopVoiceToneAnalysisTask"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_TagResource(t *testing.T) {
	input := &TagResourceInput{
		ResourceARN: ptr.String("__ResourceARN__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.TagResource(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "TagResource"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UntagResource(t *testing.T) {
	input := &UntagResourceInput{
		ResourceARN: ptr.String("__ResourceARN__"),
		TagKeys: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UntagResource(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UntagResource"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateGlobalSettings(t *testing.T) {
	input := &UpdateGlobalSettingsInput{
		VoiceConnector: &types.VoiceConnectorSettings{
			CdrBucket: ptr.String("__CdrBucket__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateGlobalSettings(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateGlobalSettings"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdatePhoneNumber(t *testing.T) {
	input := &UpdatePhoneNumberInput{
		PhoneNumberId: ptr.String("__PhoneNumberId__"),
		ProductType:   types.PhoneNumberProductType("VoiceConnector"),
		CallingName:   ptr.String("__CallingName__"),
		Name:          ptr.String("__Name__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdatePhoneNumber(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdatePhoneNumber"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdatePhoneNumberSettings(t *testing.T) {
	input := &UpdatePhoneNumberSettingsInput{
		CallingName: ptr.String("__CallingName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdatePhoneNumberSettings(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdatePhoneNumberSettings"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateProxySession(t *testing.T) {
	input := &UpdateProxySessionInput{
		VoiceConnectorId: ptr.String("__VoiceConnectorId__"),
		ProxySessionId:   ptr.String("__ProxySessionId__"),
		Capabilities: []types.Capability{
			types.Capability("Voice"),
			types.Capability("Voice"),
		},
		ExpiryMinutes: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateProxySession(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateProxySession"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateSipMediaApplication(t *testing.T) {
	input := &UpdateSipMediaApplicationInput{
		SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
		Name:                  ptr.String("__Name__"),
		Endpoints: []types.SipMediaApplicationEndpoint{
			{
				LambdaArn: ptr.String("__LambdaArn__"),
			},
			{
				LambdaArn: ptr.String("__LambdaArn__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateSipMediaApplication(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateSipMediaApplication"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateSipMediaApplicationCall(t *testing.T) {
	input := &UpdateSipMediaApplicationCallInput{
		SipMediaApplicationId: ptr.String("__SipMediaApplicationId__"),
		TransactionId:         ptr.String("__TransactionId__"),
		Arguments: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateSipMediaApplicationCall(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateSipMediaApplicationCall"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateSipRule(t *testing.T) {
	input := &UpdateSipRuleInput{
		SipRuleId: ptr.String("__SipRuleId__"),
		Name:      ptr.String("__Name__"),
		Disabled:  ptr.Bool(true),
		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__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateSipRule(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateSipRule"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateVoiceConnector(t *testing.T) {
	input := &UpdateVoiceConnectorInput{
		VoiceConnectorId:  ptr.String("__VoiceConnectorId__"),
		Name:              ptr.String("__Name__"),
		RequireEncryption: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateVoiceConnector(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateVoiceConnector"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateVoiceConnectorGroup(t *testing.T) {
	input := &UpdateVoiceConnectorGroupInput{
		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),
			},
		},
		CallDistributionType: types.CallDistributionType("PriorityWeightedDistribution"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateVoiceConnectorGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateVoiceConnectorGroup"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateVoiceProfile(t *testing.T) {
	input := &UpdateVoiceProfileInput{
		VoiceProfileId:      ptr.String("__VoiceProfileId__"),
		SpeakerSearchTaskId: ptr.String("__SpeakerSearchTaskId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateVoiceProfile(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateVoiceProfile"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateVoiceProfileDomain(t *testing.T) {
	input := &UpdateVoiceProfileDomainInput{
		VoiceProfileDomainId: ptr.String("__VoiceProfileDomainId__"),
		Name:                 ptr.String("__Name__"),
		Description:          ptr.String("__Description__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateVoiceProfileDomain(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateVoiceProfileDomain"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ValidateE911Address(t *testing.T) {
	input := &ValidateE911AddressInput{
		AwsAccountId: ptr.String("__AwsAccountId__"),
		StreetNumber: ptr.String("__StreetNumber__"),
		StreetInfo:   ptr.String("__StreetInfo__"),
		City:         ptr.String("__City__"),
		State:        ptr.String("__State__"),
		Country:      ptr.String("__Country__"),
		PostalCode:   ptr.String("__PostalCode__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ValidateE911Address(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ValidateE911Address"); err != nil {
		t.Fatal(err)
	}
}
