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

//go:build request_snapshot

package apprunner

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/apprunner/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_AssociateCustomDomain(t *testing.T) {
	input := &AssociateCustomDomainInput{
		ServiceArn:         ptr.String("__ServiceArn__"),
		DomainName:         ptr.String("__DomainName__"),
		EnableWWWSubdomain: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AssociateCustomDomain(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(), "AssociateCustomDomain"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateAutoScalingConfiguration(t *testing.T) {
	input := &CreateAutoScalingConfigurationInput{
		AutoScalingConfigurationName: ptr.String("__AutoScalingConfigurationName__"),
		MaxConcurrency:               ptr.Int32(1),
		MinSize:                      ptr.Int32(1),
		MaxSize:                      ptr.Int32(1),
		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.CreateAutoScalingConfiguration(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(), "CreateAutoScalingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateConnection(t *testing.T) {
	input := &CreateConnectionInput{
		ConnectionName: ptr.String("__ConnectionName__"),
		ProviderType:   types.ProviderType("GITHUB"),
		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.CreateConnection(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(), "CreateConnection"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateObservabilityConfiguration(t *testing.T) {
	input := &CreateObservabilityConfigurationInput{
		ObservabilityConfigurationName: ptr.String("__ObservabilityConfigurationName__"),
		TraceConfiguration: &types.TraceConfiguration{
			Vendor: types.TracingVendor("AWSXRAY"),
		},
		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.CreateObservabilityConfiguration(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(), "CreateObservabilityConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateService(t *testing.T) {
	input := &CreateServiceInput{
		ServiceName: ptr.String("__ServiceName__"),
		SourceConfiguration: &types.SourceConfiguration{
			CodeRepository: &types.CodeRepository{
				RepositoryUrl: ptr.String("__RepositoryUrl__"),
				SourceCodeVersion: &types.SourceCodeVersion{
					Type:  types.SourceCodeVersionType("BRANCH"),
					Value: ptr.String("__Value__"),
				},
				CodeConfiguration: &types.CodeConfiguration{
					ConfigurationSource: types.ConfigurationSource("REPOSITORY"),
					CodeConfigurationValues: &types.CodeConfigurationValues{
						Runtime:      types.Runtime("PYTHON_3"),
						BuildCommand: ptr.String("__BuildCommand__"),
						StartCommand: ptr.String("__StartCommand__"),
						Port:         ptr.String("__Port__"),
						RuntimeEnvironmentVariables: map[string]string{
							"key0": "__Value__",
						},
						RuntimeEnvironmentSecrets: map[string]string{
							"key0": "__Value__",
						},
					},
				},
				SourceDirectory: ptr.String("__SourceDirectory__"),
			},
			ImageRepository: &types.ImageRepository{
				ImageIdentifier: ptr.String("__ImageIdentifier__"),
				ImageConfiguration: &types.ImageConfiguration{
					RuntimeEnvironmentVariables: map[string]string{
						"key0": "__Value__",
					},
					StartCommand: ptr.String("__StartCommand__"),
					Port:         ptr.String("__Port__"),
					RuntimeEnvironmentSecrets: map[string]string{
						"key0": "__Value__",
					},
				},
				ImageRepositoryType: types.ImageRepositoryType("ECR"),
			},
			AutoDeploymentsEnabled: ptr.Bool(true),
			AuthenticationConfiguration: &types.AuthenticationConfiguration{
				ConnectionArn: ptr.String("__ConnectionArn__"),
				AccessRoleArn: ptr.String("__AccessRoleArn__"),
			},
		},
		InstanceConfiguration: &types.InstanceConfiguration{
			Cpu:             ptr.String("__Cpu__"),
			Memory:          ptr.String("__Memory__"),
			InstanceRoleArn: ptr.String("__InstanceRoleArn__"),
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		EncryptionConfiguration: &types.EncryptionConfiguration{
			KmsKey: ptr.String("__KmsKey__"),
		},
		HealthCheckConfiguration: &types.HealthCheckConfiguration{
			Protocol:           types.HealthCheckProtocol("TCP"),
			Path:               ptr.String("__Path__"),
			Interval:           ptr.Int32(1),
			Timeout:            ptr.Int32(1),
			HealthyThreshold:   ptr.Int32(1),
			UnhealthyThreshold: ptr.Int32(1),
		},
		AutoScalingConfigurationArn: ptr.String("__AutoScalingConfigurationArn__"),
		NetworkConfiguration: &types.NetworkConfiguration{
			EgressConfiguration: &types.EgressConfiguration{
				EgressType:      types.EgressType("DEFAULT"),
				VpcConnectorArn: ptr.String("__VpcConnectorArn__"),
			},
			IngressConfiguration: &types.IngressConfiguration{
				IsPubliclyAccessible: true,
			},
			IpAddressType: types.IpAddressType("IPV4"),
		},
		ObservabilityConfiguration: &types.ServiceObservabilityConfiguration{
			ObservabilityEnabled:          true,
			ObservabilityConfigurationArn: ptr.String("__ObservabilityConfigurationArn__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateService(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(), "CreateService"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateVpcConnector(t *testing.T) {
	input := &CreateVpcConnectorInput{
		VpcConnectorName: ptr.String("__VpcConnectorName__"),
		Subnets: []string{
			"__Member__",
			"__Member__",
		},
		SecurityGroups: []string{
			"__Member__",
			"__Member__",
		},
		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.CreateVpcConnector(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(), "CreateVpcConnector"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateVpcIngressConnection(t *testing.T) {
	input := &CreateVpcIngressConnectionInput{
		ServiceArn:               ptr.String("__ServiceArn__"),
		VpcIngressConnectionName: ptr.String("__VpcIngressConnectionName__"),
		IngressVpcConfiguration: &types.IngressVpcConfiguration{
			VpcId:         ptr.String("__VpcId__"),
			VpcEndpointId: ptr.String("__VpcEndpointId__"),
		},
		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.CreateVpcIngressConnection(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(), "CreateVpcIngressConnection"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteAutoScalingConfiguration(t *testing.T) {
	input := &DeleteAutoScalingConfigurationInput{
		AutoScalingConfigurationArn: ptr.String("__AutoScalingConfigurationArn__"),
		DeleteAllRevisions:          true,
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteAutoScalingConfiguration(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(), "DeleteAutoScalingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteConnection(t *testing.T) {
	input := &DeleteConnectionInput{
		ConnectionArn: ptr.String("__ConnectionArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteConnection(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(), "DeleteConnection"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteObservabilityConfiguration(t *testing.T) {
	input := &DeleteObservabilityConfigurationInput{
		ObservabilityConfigurationArn: ptr.String("__ObservabilityConfigurationArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteObservabilityConfiguration(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(), "DeleteObservabilityConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteService(t *testing.T) {
	input := &DeleteServiceInput{
		ServiceArn: ptr.String("__ServiceArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteService(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(), "DeleteService"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteVpcConnector(t *testing.T) {
	input := &DeleteVpcConnectorInput{
		VpcConnectorArn: ptr.String("__VpcConnectorArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteVpcConnector(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(), "DeleteVpcConnector"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteVpcIngressConnection(t *testing.T) {
	input := &DeleteVpcIngressConnectionInput{
		VpcIngressConnectionArn: ptr.String("__VpcIngressConnectionArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteVpcIngressConnection(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(), "DeleteVpcIngressConnection"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeAutoScalingConfiguration(t *testing.T) {
	input := &DescribeAutoScalingConfigurationInput{
		AutoScalingConfigurationArn: ptr.String("__AutoScalingConfigurationArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeAutoScalingConfiguration(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(), "DescribeAutoScalingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeCustomDomains(t *testing.T) {
	input := &DescribeCustomDomainsInput{
		ServiceArn: ptr.String("__ServiceArn__"),
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeCustomDomains(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(), "DescribeCustomDomains"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeObservabilityConfiguration(t *testing.T) {
	input := &DescribeObservabilityConfigurationInput{
		ObservabilityConfigurationArn: ptr.String("__ObservabilityConfigurationArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeObservabilityConfiguration(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(), "DescribeObservabilityConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeService(t *testing.T) {
	input := &DescribeServiceInput{
		ServiceArn: ptr.String("__ServiceArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeService(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(), "DescribeService"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeVpcConnector(t *testing.T) {
	input := &DescribeVpcConnectorInput{
		VpcConnectorArn: ptr.String("__VpcConnectorArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeVpcConnector(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(), "DescribeVpcConnector"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeVpcIngressConnection(t *testing.T) {
	input := &DescribeVpcIngressConnectionInput{
		VpcIngressConnectionArn: ptr.String("__VpcIngressConnectionArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeVpcIngressConnection(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(), "DescribeVpcIngressConnection"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DisassociateCustomDomain(t *testing.T) {
	input := &DisassociateCustomDomainInput{
		ServiceArn: ptr.String("__ServiceArn__"),
		DomainName: ptr.String("__DomainName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DisassociateCustomDomain(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(), "DisassociateCustomDomain"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListAutoScalingConfigurations(t *testing.T) {
	input := &ListAutoScalingConfigurationsInput{
		AutoScalingConfigurationName: ptr.String("__AutoScalingConfigurationName__"),
		LatestOnly:                   true,
		MaxResults:                   ptr.Int32(1),
		NextToken:                    ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListAutoScalingConfigurations(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(), "ListAutoScalingConfigurations"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListConnections(t *testing.T) {
	input := &ListConnectionsInput{
		ConnectionName: ptr.String("__ConnectionName__"),
		MaxResults:     ptr.Int32(1),
		NextToken:      ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListConnections(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(), "ListConnections"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListObservabilityConfigurations(t *testing.T) {
	input := &ListObservabilityConfigurationsInput{
		ObservabilityConfigurationName: ptr.String("__ObservabilityConfigurationName__"),
		LatestOnly:                     true,
		MaxResults:                     ptr.Int32(1),
		NextToken:                      ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListObservabilityConfigurations(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(), "ListObservabilityConfigurations"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListOperations(t *testing.T) {
	input := &ListOperationsInput{
		ServiceArn: ptr.String("__ServiceArn__"),
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListOperations(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(), "ListOperations"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListServices(t *testing.T) {
	input := &ListServicesInput{
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListServices(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(), "ListServices"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListServicesForAutoScalingConfiguration(t *testing.T) {
	input := &ListServicesForAutoScalingConfigurationInput{
		AutoScalingConfigurationArn: ptr.String("__AutoScalingConfigurationArn__"),
		MaxResults:                  ptr.Int32(1),
		NextToken:                   ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListServicesForAutoScalingConfiguration(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(), "ListServicesForAutoScalingConfiguration"); 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_ListVpcConnectors(t *testing.T) {
	input := &ListVpcConnectorsInput{
		MaxResults: ptr.Int32(1),
		NextToken:  ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListVpcConnectors(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(), "ListVpcConnectors"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListVpcIngressConnections(t *testing.T) {
	input := &ListVpcIngressConnectionsInput{
		Filter: &types.ListVpcIngressConnectionsFilter{
			ServiceArn:    ptr.String("__ServiceArn__"),
			VpcEndpointId: ptr.String("__VpcEndpointId__"),
		},
		MaxResults: ptr.Int32(1),
		NextToken:  ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListVpcIngressConnections(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(), "ListVpcIngressConnections"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PauseService(t *testing.T) {
	input := &PauseServiceInput{
		ServiceArn: ptr.String("__ServiceArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PauseService(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(), "PauseService"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ResumeService(t *testing.T) {
	input := &ResumeServiceInput{
		ServiceArn: ptr.String("__ServiceArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ResumeService(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(), "ResumeService"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_StartDeployment(t *testing.T) {
	input := &StartDeploymentInput{
		ServiceArn: ptr.String("__ServiceArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartDeployment(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(), "StartDeployment"); 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_UpdateDefaultAutoScalingConfiguration(t *testing.T) {
	input := &UpdateDefaultAutoScalingConfigurationInput{
		AutoScalingConfigurationArn: ptr.String("__AutoScalingConfigurationArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateDefaultAutoScalingConfiguration(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(), "UpdateDefaultAutoScalingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateService(t *testing.T) {
	input := &UpdateServiceInput{
		ServiceArn: ptr.String("__ServiceArn__"),
		SourceConfiguration: &types.SourceConfiguration{
			CodeRepository: &types.CodeRepository{
				RepositoryUrl: ptr.String("__RepositoryUrl__"),
				SourceCodeVersion: &types.SourceCodeVersion{
					Type:  types.SourceCodeVersionType("BRANCH"),
					Value: ptr.String("__Value__"),
				},
				CodeConfiguration: &types.CodeConfiguration{
					ConfigurationSource: types.ConfigurationSource("REPOSITORY"),
					CodeConfigurationValues: &types.CodeConfigurationValues{
						Runtime:      types.Runtime("PYTHON_3"),
						BuildCommand: ptr.String("__BuildCommand__"),
						StartCommand: ptr.String("__StartCommand__"),
						Port:         ptr.String("__Port__"),
						RuntimeEnvironmentVariables: map[string]string{
							"key0": "__Value__",
						},
						RuntimeEnvironmentSecrets: map[string]string{
							"key0": "__Value__",
						},
					},
				},
				SourceDirectory: ptr.String("__SourceDirectory__"),
			},
			ImageRepository: &types.ImageRepository{
				ImageIdentifier: ptr.String("__ImageIdentifier__"),
				ImageConfiguration: &types.ImageConfiguration{
					RuntimeEnvironmentVariables: map[string]string{
						"key0": "__Value__",
					},
					StartCommand: ptr.String("__StartCommand__"),
					Port:         ptr.String("__Port__"),
					RuntimeEnvironmentSecrets: map[string]string{
						"key0": "__Value__",
					},
				},
				ImageRepositoryType: types.ImageRepositoryType("ECR"),
			},
			AutoDeploymentsEnabled: ptr.Bool(true),
			AuthenticationConfiguration: &types.AuthenticationConfiguration{
				ConnectionArn: ptr.String("__ConnectionArn__"),
				AccessRoleArn: ptr.String("__AccessRoleArn__"),
			},
		},
		InstanceConfiguration: &types.InstanceConfiguration{
			Cpu:             ptr.String("__Cpu__"),
			Memory:          ptr.String("__Memory__"),
			InstanceRoleArn: ptr.String("__InstanceRoleArn__"),
		},
		AutoScalingConfigurationArn: ptr.String("__AutoScalingConfigurationArn__"),
		HealthCheckConfiguration: &types.HealthCheckConfiguration{
			Protocol:           types.HealthCheckProtocol("TCP"),
			Path:               ptr.String("__Path__"),
			Interval:           ptr.Int32(1),
			Timeout:            ptr.Int32(1),
			HealthyThreshold:   ptr.Int32(1),
			UnhealthyThreshold: ptr.Int32(1),
		},
		NetworkConfiguration: &types.NetworkConfiguration{
			EgressConfiguration: &types.EgressConfiguration{
				EgressType:      types.EgressType("DEFAULT"),
				VpcConnectorArn: ptr.String("__VpcConnectorArn__"),
			},
			IngressConfiguration: &types.IngressConfiguration{
				IsPubliclyAccessible: true,
			},
			IpAddressType: types.IpAddressType("IPV4"),
		},
		ObservabilityConfiguration: &types.ServiceObservabilityConfiguration{
			ObservabilityEnabled:          true,
			ObservabilityConfigurationArn: ptr.String("__ObservabilityConfigurationArn__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateService(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(), "UpdateService"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateVpcIngressConnection(t *testing.T) {
	input := &UpdateVpcIngressConnectionInput{
		VpcIngressConnectionArn: ptr.String("__VpcIngressConnectionArn__"),
		IngressVpcConfiguration: &types.IngressVpcConfiguration{
			VpcId:         ptr.String("__VpcId__"),
			VpcEndpointId: ptr.String("__VpcEndpointId__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateVpcIngressConnection(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(), "UpdateVpcIngressConnection"); err != nil {
		t.Fatal(err)
	}
}
func TestUpdateRequestSnapshot_AssociateCustomDomain(t *testing.T) {
	input := &AssociateCustomDomainInput{
		ServiceArn:         ptr.String("__ServiceArn__"),
		DomainName:         ptr.String("__DomainName__"),
		EnableWWWSubdomain: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AssociateCustomDomain(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(), "AssociateCustomDomain"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateAutoScalingConfiguration(t *testing.T) {
	input := &CreateAutoScalingConfigurationInput{
		AutoScalingConfigurationName: ptr.String("__AutoScalingConfigurationName__"),
		MaxConcurrency:               ptr.Int32(1),
		MinSize:                      ptr.Int32(1),
		MaxSize:                      ptr.Int32(1),
		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.CreateAutoScalingConfiguration(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(), "CreateAutoScalingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateConnection(t *testing.T) {
	input := &CreateConnectionInput{
		ConnectionName: ptr.String("__ConnectionName__"),
		ProviderType:   types.ProviderType("GITHUB"),
		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.CreateConnection(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(), "CreateConnection"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateObservabilityConfiguration(t *testing.T) {
	input := &CreateObservabilityConfigurationInput{
		ObservabilityConfigurationName: ptr.String("__ObservabilityConfigurationName__"),
		TraceConfiguration: &types.TraceConfiguration{
			Vendor: types.TracingVendor("AWSXRAY"),
		},
		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.CreateObservabilityConfiguration(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(), "CreateObservabilityConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateService(t *testing.T) {
	input := &CreateServiceInput{
		ServiceName: ptr.String("__ServiceName__"),
		SourceConfiguration: &types.SourceConfiguration{
			CodeRepository: &types.CodeRepository{
				RepositoryUrl: ptr.String("__RepositoryUrl__"),
				SourceCodeVersion: &types.SourceCodeVersion{
					Type:  types.SourceCodeVersionType("BRANCH"),
					Value: ptr.String("__Value__"),
				},
				CodeConfiguration: &types.CodeConfiguration{
					ConfigurationSource: types.ConfigurationSource("REPOSITORY"),
					CodeConfigurationValues: &types.CodeConfigurationValues{
						Runtime:      types.Runtime("PYTHON_3"),
						BuildCommand: ptr.String("__BuildCommand__"),
						StartCommand: ptr.String("__StartCommand__"),
						Port:         ptr.String("__Port__"),
						RuntimeEnvironmentVariables: map[string]string{
							"key0": "__Value__",
						},
						RuntimeEnvironmentSecrets: map[string]string{
							"key0": "__Value__",
						},
					},
				},
				SourceDirectory: ptr.String("__SourceDirectory__"),
			},
			ImageRepository: &types.ImageRepository{
				ImageIdentifier: ptr.String("__ImageIdentifier__"),
				ImageConfiguration: &types.ImageConfiguration{
					RuntimeEnvironmentVariables: map[string]string{
						"key0": "__Value__",
					},
					StartCommand: ptr.String("__StartCommand__"),
					Port:         ptr.String("__Port__"),
					RuntimeEnvironmentSecrets: map[string]string{
						"key0": "__Value__",
					},
				},
				ImageRepositoryType: types.ImageRepositoryType("ECR"),
			},
			AutoDeploymentsEnabled: ptr.Bool(true),
			AuthenticationConfiguration: &types.AuthenticationConfiguration{
				ConnectionArn: ptr.String("__ConnectionArn__"),
				AccessRoleArn: ptr.String("__AccessRoleArn__"),
			},
		},
		InstanceConfiguration: &types.InstanceConfiguration{
			Cpu:             ptr.String("__Cpu__"),
			Memory:          ptr.String("__Memory__"),
			InstanceRoleArn: ptr.String("__InstanceRoleArn__"),
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		EncryptionConfiguration: &types.EncryptionConfiguration{
			KmsKey: ptr.String("__KmsKey__"),
		},
		HealthCheckConfiguration: &types.HealthCheckConfiguration{
			Protocol:           types.HealthCheckProtocol("TCP"),
			Path:               ptr.String("__Path__"),
			Interval:           ptr.Int32(1),
			Timeout:            ptr.Int32(1),
			HealthyThreshold:   ptr.Int32(1),
			UnhealthyThreshold: ptr.Int32(1),
		},
		AutoScalingConfigurationArn: ptr.String("__AutoScalingConfigurationArn__"),
		NetworkConfiguration: &types.NetworkConfiguration{
			EgressConfiguration: &types.EgressConfiguration{
				EgressType:      types.EgressType("DEFAULT"),
				VpcConnectorArn: ptr.String("__VpcConnectorArn__"),
			},
			IngressConfiguration: &types.IngressConfiguration{
				IsPubliclyAccessible: true,
			},
			IpAddressType: types.IpAddressType("IPV4"),
		},
		ObservabilityConfiguration: &types.ServiceObservabilityConfiguration{
			ObservabilityEnabled:          true,
			ObservabilityConfigurationArn: ptr.String("__ObservabilityConfigurationArn__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateService(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(), "CreateService"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateVpcConnector(t *testing.T) {
	input := &CreateVpcConnectorInput{
		VpcConnectorName: ptr.String("__VpcConnectorName__"),
		Subnets: []string{
			"__Member__",
			"__Member__",
		},
		SecurityGroups: []string{
			"__Member__",
			"__Member__",
		},
		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.CreateVpcConnector(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(), "CreateVpcConnector"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateVpcIngressConnection(t *testing.T) {
	input := &CreateVpcIngressConnectionInput{
		ServiceArn:               ptr.String("__ServiceArn__"),
		VpcIngressConnectionName: ptr.String("__VpcIngressConnectionName__"),
		IngressVpcConfiguration: &types.IngressVpcConfiguration{
			VpcId:         ptr.String("__VpcId__"),
			VpcEndpointId: ptr.String("__VpcEndpointId__"),
		},
		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.CreateVpcIngressConnection(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(), "CreateVpcIngressConnection"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteAutoScalingConfiguration(t *testing.T) {
	input := &DeleteAutoScalingConfigurationInput{
		AutoScalingConfigurationArn: ptr.String("__AutoScalingConfigurationArn__"),
		DeleteAllRevisions:          true,
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteAutoScalingConfiguration(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(), "DeleteAutoScalingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteConnection(t *testing.T) {
	input := &DeleteConnectionInput{
		ConnectionArn: ptr.String("__ConnectionArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteConnection(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(), "DeleteConnection"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteObservabilityConfiguration(t *testing.T) {
	input := &DeleteObservabilityConfigurationInput{
		ObservabilityConfigurationArn: ptr.String("__ObservabilityConfigurationArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteObservabilityConfiguration(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(), "DeleteObservabilityConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteService(t *testing.T) {
	input := &DeleteServiceInput{
		ServiceArn: ptr.String("__ServiceArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteService(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(), "DeleteService"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteVpcConnector(t *testing.T) {
	input := &DeleteVpcConnectorInput{
		VpcConnectorArn: ptr.String("__VpcConnectorArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteVpcConnector(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(), "DeleteVpcConnector"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteVpcIngressConnection(t *testing.T) {
	input := &DeleteVpcIngressConnectionInput{
		VpcIngressConnectionArn: ptr.String("__VpcIngressConnectionArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteVpcIngressConnection(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(), "DeleteVpcIngressConnection"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeAutoScalingConfiguration(t *testing.T) {
	input := &DescribeAutoScalingConfigurationInput{
		AutoScalingConfigurationArn: ptr.String("__AutoScalingConfigurationArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeAutoScalingConfiguration(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(), "DescribeAutoScalingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeCustomDomains(t *testing.T) {
	input := &DescribeCustomDomainsInput{
		ServiceArn: ptr.String("__ServiceArn__"),
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeCustomDomains(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(), "DescribeCustomDomains"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeObservabilityConfiguration(t *testing.T) {
	input := &DescribeObservabilityConfigurationInput{
		ObservabilityConfigurationArn: ptr.String("__ObservabilityConfigurationArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeObservabilityConfiguration(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(), "DescribeObservabilityConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeService(t *testing.T) {
	input := &DescribeServiceInput{
		ServiceArn: ptr.String("__ServiceArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeService(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(), "DescribeService"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeVpcConnector(t *testing.T) {
	input := &DescribeVpcConnectorInput{
		VpcConnectorArn: ptr.String("__VpcConnectorArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeVpcConnector(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(), "DescribeVpcConnector"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeVpcIngressConnection(t *testing.T) {
	input := &DescribeVpcIngressConnectionInput{
		VpcIngressConnectionArn: ptr.String("__VpcIngressConnectionArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeVpcIngressConnection(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(), "DescribeVpcIngressConnection"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DisassociateCustomDomain(t *testing.T) {
	input := &DisassociateCustomDomainInput{
		ServiceArn: ptr.String("__ServiceArn__"),
		DomainName: ptr.String("__DomainName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DisassociateCustomDomain(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(), "DisassociateCustomDomain"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListAutoScalingConfigurations(t *testing.T) {
	input := &ListAutoScalingConfigurationsInput{
		AutoScalingConfigurationName: ptr.String("__AutoScalingConfigurationName__"),
		LatestOnly:                   true,
		MaxResults:                   ptr.Int32(1),
		NextToken:                    ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListAutoScalingConfigurations(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(), "ListAutoScalingConfigurations"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListConnections(t *testing.T) {
	input := &ListConnectionsInput{
		ConnectionName: ptr.String("__ConnectionName__"),
		MaxResults:     ptr.Int32(1),
		NextToken:      ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListConnections(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(), "ListConnections"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListObservabilityConfigurations(t *testing.T) {
	input := &ListObservabilityConfigurationsInput{
		ObservabilityConfigurationName: ptr.String("__ObservabilityConfigurationName__"),
		LatestOnly:                     true,
		MaxResults:                     ptr.Int32(1),
		NextToken:                      ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListObservabilityConfigurations(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(), "ListObservabilityConfigurations"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListOperations(t *testing.T) {
	input := &ListOperationsInput{
		ServiceArn: ptr.String("__ServiceArn__"),
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListOperations(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(), "ListOperations"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListServices(t *testing.T) {
	input := &ListServicesInput{
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListServices(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(), "ListServices"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListServicesForAutoScalingConfiguration(t *testing.T) {
	input := &ListServicesForAutoScalingConfigurationInput{
		AutoScalingConfigurationArn: ptr.String("__AutoScalingConfigurationArn__"),
		MaxResults:                  ptr.Int32(1),
		NextToken:                   ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListServicesForAutoScalingConfiguration(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(), "ListServicesForAutoScalingConfiguration"); 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_ListVpcConnectors(t *testing.T) {
	input := &ListVpcConnectorsInput{
		MaxResults: ptr.Int32(1),
		NextToken:  ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListVpcConnectors(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(), "ListVpcConnectors"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListVpcIngressConnections(t *testing.T) {
	input := &ListVpcIngressConnectionsInput{
		Filter: &types.ListVpcIngressConnectionsFilter{
			ServiceArn:    ptr.String("__ServiceArn__"),
			VpcEndpointId: ptr.String("__VpcEndpointId__"),
		},
		MaxResults: ptr.Int32(1),
		NextToken:  ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListVpcIngressConnections(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(), "ListVpcIngressConnections"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PauseService(t *testing.T) {
	input := &PauseServiceInput{
		ServiceArn: ptr.String("__ServiceArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PauseService(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(), "PauseService"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ResumeService(t *testing.T) {
	input := &ResumeServiceInput{
		ServiceArn: ptr.String("__ServiceArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ResumeService(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(), "ResumeService"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_StartDeployment(t *testing.T) {
	input := &StartDeploymentInput{
		ServiceArn: ptr.String("__ServiceArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartDeployment(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(), "StartDeployment"); 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_UpdateDefaultAutoScalingConfiguration(t *testing.T) {
	input := &UpdateDefaultAutoScalingConfigurationInput{
		AutoScalingConfigurationArn: ptr.String("__AutoScalingConfigurationArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateDefaultAutoScalingConfiguration(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(), "UpdateDefaultAutoScalingConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateService(t *testing.T) {
	input := &UpdateServiceInput{
		ServiceArn: ptr.String("__ServiceArn__"),
		SourceConfiguration: &types.SourceConfiguration{
			CodeRepository: &types.CodeRepository{
				RepositoryUrl: ptr.String("__RepositoryUrl__"),
				SourceCodeVersion: &types.SourceCodeVersion{
					Type:  types.SourceCodeVersionType("BRANCH"),
					Value: ptr.String("__Value__"),
				},
				CodeConfiguration: &types.CodeConfiguration{
					ConfigurationSource: types.ConfigurationSource("REPOSITORY"),
					CodeConfigurationValues: &types.CodeConfigurationValues{
						Runtime:      types.Runtime("PYTHON_3"),
						BuildCommand: ptr.String("__BuildCommand__"),
						StartCommand: ptr.String("__StartCommand__"),
						Port:         ptr.String("__Port__"),
						RuntimeEnvironmentVariables: map[string]string{
							"key0": "__Value__",
						},
						RuntimeEnvironmentSecrets: map[string]string{
							"key0": "__Value__",
						},
					},
				},
				SourceDirectory: ptr.String("__SourceDirectory__"),
			},
			ImageRepository: &types.ImageRepository{
				ImageIdentifier: ptr.String("__ImageIdentifier__"),
				ImageConfiguration: &types.ImageConfiguration{
					RuntimeEnvironmentVariables: map[string]string{
						"key0": "__Value__",
					},
					StartCommand: ptr.String("__StartCommand__"),
					Port:         ptr.String("__Port__"),
					RuntimeEnvironmentSecrets: map[string]string{
						"key0": "__Value__",
					},
				},
				ImageRepositoryType: types.ImageRepositoryType("ECR"),
			},
			AutoDeploymentsEnabled: ptr.Bool(true),
			AuthenticationConfiguration: &types.AuthenticationConfiguration{
				ConnectionArn: ptr.String("__ConnectionArn__"),
				AccessRoleArn: ptr.String("__AccessRoleArn__"),
			},
		},
		InstanceConfiguration: &types.InstanceConfiguration{
			Cpu:             ptr.String("__Cpu__"),
			Memory:          ptr.String("__Memory__"),
			InstanceRoleArn: ptr.String("__InstanceRoleArn__"),
		},
		AutoScalingConfigurationArn: ptr.String("__AutoScalingConfigurationArn__"),
		HealthCheckConfiguration: &types.HealthCheckConfiguration{
			Protocol:           types.HealthCheckProtocol("TCP"),
			Path:               ptr.String("__Path__"),
			Interval:           ptr.Int32(1),
			Timeout:            ptr.Int32(1),
			HealthyThreshold:   ptr.Int32(1),
			UnhealthyThreshold: ptr.Int32(1),
		},
		NetworkConfiguration: &types.NetworkConfiguration{
			EgressConfiguration: &types.EgressConfiguration{
				EgressType:      types.EgressType("DEFAULT"),
				VpcConnectorArn: ptr.String("__VpcConnectorArn__"),
			},
			IngressConfiguration: &types.IngressConfiguration{
				IsPubliclyAccessible: true,
			},
			IpAddressType: types.IpAddressType("IPV4"),
		},
		ObservabilityConfiguration: &types.ServiceObservabilityConfiguration{
			ObservabilityEnabled:          true,
			ObservabilityConfigurationArn: ptr.String("__ObservabilityConfigurationArn__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateService(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(), "UpdateService"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateVpcIngressConnection(t *testing.T) {
	input := &UpdateVpcIngressConnectionInput{
		VpcIngressConnectionArn: ptr.String("__VpcIngressConnectionArn__"),
		IngressVpcConfiguration: &types.IngressVpcConfiguration{
			VpcId:         ptr.String("__VpcId__"),
			VpcEndpointId: ptr.String("__VpcEndpointId__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateVpcIngressConnection(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(), "UpdateVpcIngressConnection"); err != nil {
		t.Fatal(err)
	}
}
