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

//go:build request_snapshot

package codedeploy

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/codedeploy/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"
	"time"
)

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_AddTagsToOnPremisesInstances(t *testing.T) {
	input := &AddTagsToOnPremisesInstancesInput{
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		InstanceNames: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AddTagsToOnPremisesInstances(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "AddTagsToOnPremisesInstances"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_BatchGetApplicationRevisions(t *testing.T) {
	input := &BatchGetApplicationRevisionsInput{
		ApplicationName: ptr.String("__ApplicationName__"),
		Revisions: []types.RevisionLocation{
			{
				RevisionType: types.RevisionLocationType("S3"),
				S3Location: &types.S3Location{
					Bucket:     ptr.String("__Bucket__"),
					Key:        ptr.String("__Key__"),
					BundleType: types.BundleType("tar"),
					Version:    ptr.String("__Version__"),
					ETag:       ptr.String("__ETag__"),
				},
				GitHubLocation: &types.GitHubLocation{
					Repository: ptr.String("__Repository__"),
					CommitId:   ptr.String("__CommitId__"),
				},
				String_: &types.RawString{
					Content: ptr.String("__Content__"),
					Sha256:  ptr.String("__Sha256__"),
				},
				AppSpecContent: &types.AppSpecContent{
					Content: ptr.String("__Content__"),
					Sha256:  ptr.String("__Sha256__"),
				},
			},
			{
				RevisionType: types.RevisionLocationType("S3"),
				S3Location: &types.S3Location{
					Bucket:     ptr.String("__Bucket__"),
					Key:        ptr.String("__Key__"),
					BundleType: types.BundleType("tar"),
					Version:    ptr.String("__Version__"),
					ETag:       ptr.String("__ETag__"),
				},
				GitHubLocation: &types.GitHubLocation{
					Repository: ptr.String("__Repository__"),
					CommitId:   ptr.String("__CommitId__"),
				},
				String_: &types.RawString{
					Content: ptr.String("__Content__"),
					Sha256:  ptr.String("__Sha256__"),
				},
				AppSpecContent: &types.AppSpecContent{
					Content: ptr.String("__Content__"),
					Sha256:  ptr.String("__Sha256__"),
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchGetApplicationRevisions(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "BatchGetApplicationRevisions"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_BatchGetApplications(t *testing.T) {
	input := &BatchGetApplicationsInput{
		ApplicationNames: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchGetApplications(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "BatchGetApplications"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_BatchGetDeploymentGroups(t *testing.T) {
	input := &BatchGetDeploymentGroupsInput{
		ApplicationName: ptr.String("__ApplicationName__"),
		DeploymentGroupNames: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchGetDeploymentGroups(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "BatchGetDeploymentGroups"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_BatchGetDeploymentInstances(t *testing.T) {
	input := &BatchGetDeploymentInstancesInput{
		DeploymentId: ptr.String("__DeploymentId__"),
		InstanceIds: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchGetDeploymentInstances(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "BatchGetDeploymentInstances"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_BatchGetDeployments(t *testing.T) {
	input := &BatchGetDeploymentsInput{
		DeploymentIds: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchGetDeployments(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "BatchGetDeployments"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_BatchGetDeploymentTargets(t *testing.T) {
	input := &BatchGetDeploymentTargetsInput{
		DeploymentId: ptr.String("__DeploymentId__"),
		TargetIds: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchGetDeploymentTargets(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "BatchGetDeploymentTargets"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_BatchGetOnPremisesInstances(t *testing.T) {
	input := &BatchGetOnPremisesInstancesInput{
		InstanceNames: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchGetOnPremisesInstances(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "BatchGetOnPremisesInstances"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ContinueDeployment(t *testing.T) {
	input := &ContinueDeploymentInput{
		DeploymentId:       ptr.String("__DeploymentId__"),
		DeploymentWaitType: types.DeploymentWaitType("READY_WAIT"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ContinueDeployment(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ContinueDeployment"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateApplication(t *testing.T) {
	input := &CreateApplicationInput{
		ApplicationName: ptr.String("__ApplicationName__"),
		ComputePlatform: types.ComputePlatform("Server"),
		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.CreateApplication(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateApplication"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateDeployment(t *testing.T) {
	input := &CreateDeploymentInput{
		ApplicationName:     ptr.String("__ApplicationName__"),
		DeploymentGroupName: ptr.String("__DeploymentGroupName__"),
		Revision: &types.RevisionLocation{
			RevisionType: types.RevisionLocationType("S3"),
			S3Location: &types.S3Location{
				Bucket:     ptr.String("__Bucket__"),
				Key:        ptr.String("__Key__"),
				BundleType: types.BundleType("tar"),
				Version:    ptr.String("__Version__"),
				ETag:       ptr.String("__ETag__"),
			},
			GitHubLocation: &types.GitHubLocation{
				Repository: ptr.String("__Repository__"),
				CommitId:   ptr.String("__CommitId__"),
			},
			String_: &types.RawString{
				Content: ptr.String("__Content__"),
				Sha256:  ptr.String("__Sha256__"),
			},
			AppSpecContent: &types.AppSpecContent{
				Content: ptr.String("__Content__"),
				Sha256:  ptr.String("__Sha256__"),
			},
		},
		DeploymentConfigName:          ptr.String("__DeploymentConfigName__"),
		Description:                   ptr.String("__Description__"),
		IgnoreApplicationStopFailures: true,
		TargetInstances: &types.TargetInstances{
			TagFilters: []types.EC2TagFilter{
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
					Type:  types.EC2TagFilterType("KEY_ONLY"),
				},
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
					Type:  types.EC2TagFilterType("KEY_ONLY"),
				},
			},
			AutoScalingGroups: []string{
				"__Member__",
				"__Member__",
			},
			Ec2TagSet: &types.EC2TagSet{
				Ec2TagSetList: [][]types.EC2TagFilter{
					{
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
							Type:  types.EC2TagFilterType("KEY_ONLY"),
						},
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
							Type:  types.EC2TagFilterType("KEY_ONLY"),
						},
					},
					{
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
							Type:  types.EC2TagFilterType("KEY_ONLY"),
						},
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
							Type:  types.EC2TagFilterType("KEY_ONLY"),
						},
					},
				},
			},
		},
		AutoRollbackConfiguration: &types.AutoRollbackConfiguration{
			Enabled: true,
			Events: []types.AutoRollbackEvent{
				types.AutoRollbackEvent("DEPLOYMENT_FAILURE"),
				types.AutoRollbackEvent("DEPLOYMENT_FAILURE"),
			},
		},
		UpdateOutdatedInstancesOnly: true,
		FileExistsBehavior:          types.FileExistsBehavior("DISALLOW"),
		OverrideAlarmConfiguration: &types.AlarmConfiguration{
			Enabled:                true,
			IgnorePollAlarmFailure: true,
			Alarms: []types.Alarm{
				{
					Name: ptr.String("__Name__"),
				},
				{
					Name: ptr.String("__Name__"),
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateDeployment(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateDeployment"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateDeploymentConfig(t *testing.T) {
	input := &CreateDeploymentConfigInput{
		DeploymentConfigName: ptr.String("__DeploymentConfigName__"),
		MinimumHealthyHosts: &types.MinimumHealthyHosts{
			Type:  types.MinimumHealthyHostsType("HOST_COUNT"),
			Value: 1,
		},
		TrafficRoutingConfig: &types.TrafficRoutingConfig{
			Type: types.TrafficRoutingType("TimeBasedCanary"),
			TimeBasedCanary: &types.TimeBasedCanary{
				CanaryPercentage: 1,
				CanaryInterval:   1,
			},
			TimeBasedLinear: &types.TimeBasedLinear{
				LinearPercentage: 1,
				LinearInterval:   1,
			},
		},
		ComputePlatform: types.ComputePlatform("Server"),
		ZonalConfig: &types.ZonalConfig{
			FirstZoneMonitorDurationInSeconds: ptr.Int64(1),
			MonitorDurationInSeconds:          ptr.Int64(1),
			MinimumHealthyHostsPerZone: &types.MinimumHealthyHostsPerZone{
				Type:  types.MinimumHealthyHostsPerZoneType("HOST_COUNT"),
				Value: 1,
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateDeploymentConfig(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateDeploymentConfig"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateDeploymentGroup(t *testing.T) {
	input := &CreateDeploymentGroupInput{
		ApplicationName:      ptr.String("__ApplicationName__"),
		DeploymentGroupName:  ptr.String("__DeploymentGroupName__"),
		DeploymentConfigName: ptr.String("__DeploymentConfigName__"),
		Ec2TagFilters: []types.EC2TagFilter{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
				Type:  types.EC2TagFilterType("KEY_ONLY"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
				Type:  types.EC2TagFilterType("KEY_ONLY"),
			},
		},
		OnPremisesInstanceTagFilters: []types.TagFilter{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
				Type:  types.TagFilterType("KEY_ONLY"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
				Type:  types.TagFilterType("KEY_ONLY"),
			},
		},
		AutoScalingGroups: []string{
			"__Member__",
			"__Member__",
		},
		ServiceRoleArn: ptr.String("__ServiceRoleArn__"),
		TriggerConfigurations: []types.TriggerConfig{
			{
				TriggerName:      ptr.String("__TriggerName__"),
				TriggerTargetArn: ptr.String("__TriggerTargetArn__"),
				TriggerEvents: []types.TriggerEventType{
					types.TriggerEventType("DeploymentStart"),
					types.TriggerEventType("DeploymentStart"),
				},
			},
			{
				TriggerName:      ptr.String("__TriggerName__"),
				TriggerTargetArn: ptr.String("__TriggerTargetArn__"),
				TriggerEvents: []types.TriggerEventType{
					types.TriggerEventType("DeploymentStart"),
					types.TriggerEventType("DeploymentStart"),
				},
			},
		},
		AlarmConfiguration: &types.AlarmConfiguration{
			Enabled:                true,
			IgnorePollAlarmFailure: true,
			Alarms: []types.Alarm{
				{
					Name: ptr.String("__Name__"),
				},
				{
					Name: ptr.String("__Name__"),
				},
			},
		},
		AutoRollbackConfiguration: &types.AutoRollbackConfiguration{
			Enabled: true,
			Events: []types.AutoRollbackEvent{
				types.AutoRollbackEvent("DEPLOYMENT_FAILURE"),
				types.AutoRollbackEvent("DEPLOYMENT_FAILURE"),
			},
		},
		OutdatedInstancesStrategy: types.OutdatedInstancesStrategy("UPDATE"),
		DeploymentStyle: &types.DeploymentStyle{
			DeploymentType:   types.DeploymentType("IN_PLACE"),
			DeploymentOption: types.DeploymentOption("WITH_TRAFFIC_CONTROL"),
		},
		BlueGreenDeploymentConfiguration: &types.BlueGreenDeploymentConfiguration{
			TerminateBlueInstancesOnDeploymentSuccess: &types.BlueInstanceTerminationOption{
				Action:                       types.InstanceAction("TERMINATE"),
				TerminationWaitTimeInMinutes: 1,
			},
			DeploymentReadyOption: &types.DeploymentReadyOption{
				ActionOnTimeout:   types.DeploymentReadyAction("CONTINUE_DEPLOYMENT"),
				WaitTimeInMinutes: 1,
			},
			GreenFleetProvisioningOption: &types.GreenFleetProvisioningOption{
				Action: types.GreenFleetProvisioningAction("DISCOVER_EXISTING"),
			},
		},
		LoadBalancerInfo: &types.LoadBalancerInfo{
			ElbInfoList: []types.ELBInfo{
				{
					Name: ptr.String("__Name__"),
				},
				{
					Name: ptr.String("__Name__"),
				},
			},
			TargetGroupInfoList: []types.TargetGroupInfo{
				{
					Name: ptr.String("__Name__"),
				},
				{
					Name: ptr.String("__Name__"),
				},
			},
			TargetGroupPairInfoList: []types.TargetGroupPairInfo{
				{
					TargetGroups: []types.TargetGroupInfo{
						{
							Name: ptr.String("__Name__"),
						},
						{
							Name: ptr.String("__Name__"),
						},
					},
					ProdTrafficRoute: &types.TrafficRoute{
						ListenerArns: []string{
							"__Member__",
							"__Member__",
						},
					},
					TestTrafficRoute: &types.TrafficRoute{
						ListenerArns: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
				{
					TargetGroups: []types.TargetGroupInfo{
						{
							Name: ptr.String("__Name__"),
						},
						{
							Name: ptr.String("__Name__"),
						},
					},
					ProdTrafficRoute: &types.TrafficRoute{
						ListenerArns: []string{
							"__Member__",
							"__Member__",
						},
					},
					TestTrafficRoute: &types.TrafficRoute{
						ListenerArns: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
			},
		},
		Ec2TagSet: &types.EC2TagSet{
			Ec2TagSetList: [][]types.EC2TagFilter{
				{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.EC2TagFilterType("KEY_ONLY"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.EC2TagFilterType("KEY_ONLY"),
					},
				},
				{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.EC2TagFilterType("KEY_ONLY"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.EC2TagFilterType("KEY_ONLY"),
					},
				},
			},
		},
		EcsServices: []types.ECSService{
			{
				ServiceName: ptr.String("__ServiceName__"),
				ClusterName: ptr.String("__ClusterName__"),
			},
			{
				ServiceName: ptr.String("__ServiceName__"),
				ClusterName: ptr.String("__ClusterName__"),
			},
		},
		OnPremisesTagSet: &types.OnPremisesTagSet{
			OnPremisesTagSetList: [][]types.TagFilter{
				{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.TagFilterType("KEY_ONLY"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.TagFilterType("KEY_ONLY"),
					},
				},
				{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.TagFilterType("KEY_ONLY"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.TagFilterType("KEY_ONLY"),
					},
				},
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		TerminationHookEnabled: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateDeploymentGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateDeploymentGroup"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteApplication(t *testing.T) {
	input := &DeleteApplicationInput{
		ApplicationName: ptr.String("__ApplicationName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteApplication(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteApplication"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteDeploymentConfig(t *testing.T) {
	input := &DeleteDeploymentConfigInput{
		DeploymentConfigName: ptr.String("__DeploymentConfigName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteDeploymentConfig(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteDeploymentConfig"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteDeploymentGroup(t *testing.T) {
	input := &DeleteDeploymentGroupInput{
		ApplicationName:     ptr.String("__ApplicationName__"),
		DeploymentGroupName: ptr.String("__DeploymentGroupName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteDeploymentGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteDeploymentGroup"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteGitHubAccountToken(t *testing.T) {
	input := &DeleteGitHubAccountTokenInput{
		TokenName: ptr.String("__TokenName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteGitHubAccountToken(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteGitHubAccountToken"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeleteResourcesByExternalId(t *testing.T) {
	input := &DeleteResourcesByExternalIdInput{
		ExternalId: ptr.String("__ExternalId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteResourcesByExternalId(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteResourcesByExternalId"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DeregisterOnPremisesInstance(t *testing.T) {
	input := &DeregisterOnPremisesInstanceInput{
		InstanceName: ptr.String("__InstanceName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeregisterOnPremisesInstance(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeregisterOnPremisesInstance"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetApplication(t *testing.T) {
	input := &GetApplicationInput{
		ApplicationName: ptr.String("__ApplicationName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetApplication(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetApplication"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetApplicationRevision(t *testing.T) {
	input := &GetApplicationRevisionInput{
		ApplicationName: ptr.String("__ApplicationName__"),
		Revision: &types.RevisionLocation{
			RevisionType: types.RevisionLocationType("S3"),
			S3Location: &types.S3Location{
				Bucket:     ptr.String("__Bucket__"),
				Key:        ptr.String("__Key__"),
				BundleType: types.BundleType("tar"),
				Version:    ptr.String("__Version__"),
				ETag:       ptr.String("__ETag__"),
			},
			GitHubLocation: &types.GitHubLocation{
				Repository: ptr.String("__Repository__"),
				CommitId:   ptr.String("__CommitId__"),
			},
			String_: &types.RawString{
				Content: ptr.String("__Content__"),
				Sha256:  ptr.String("__Sha256__"),
			},
			AppSpecContent: &types.AppSpecContent{
				Content: ptr.String("__Content__"),
				Sha256:  ptr.String("__Sha256__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetApplicationRevision(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetApplicationRevision"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetDeployment(t *testing.T) {
	input := &GetDeploymentInput{
		DeploymentId: ptr.String("__DeploymentId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetDeployment(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetDeployment"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetDeploymentConfig(t *testing.T) {
	input := &GetDeploymentConfigInput{
		DeploymentConfigName: ptr.String("__DeploymentConfigName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetDeploymentConfig(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetDeploymentConfig"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetDeploymentGroup(t *testing.T) {
	input := &GetDeploymentGroupInput{
		ApplicationName:     ptr.String("__ApplicationName__"),
		DeploymentGroupName: ptr.String("__DeploymentGroupName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetDeploymentGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetDeploymentGroup"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetDeploymentInstance(t *testing.T) {
	input := &GetDeploymentInstanceInput{
		DeploymentId: ptr.String("__DeploymentId__"),
		InstanceId:   ptr.String("__InstanceId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetDeploymentInstance(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetDeploymentInstance"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetDeploymentTarget(t *testing.T) {
	input := &GetDeploymentTargetInput{
		DeploymentId: ptr.String("__DeploymentId__"),
		TargetId:     ptr.String("__TargetId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetDeploymentTarget(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetDeploymentTarget"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetOnPremisesInstance(t *testing.T) {
	input := &GetOnPremisesInstanceInput{
		InstanceName: ptr.String("__InstanceName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetOnPremisesInstance(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetOnPremisesInstance"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListApplicationRevisions(t *testing.T) {
	input := &ListApplicationRevisionsInput{
		ApplicationName: ptr.String("__ApplicationName__"),
		SortBy:          types.ApplicationRevisionSortBy("registerTime"),
		SortOrder:       types.SortOrder("ascending"),
		S3Bucket:        ptr.String("__S3Bucket__"),
		S3KeyPrefix:     ptr.String("__S3KeyPrefix__"),
		Deployed:        types.ListStateFilterAction("include"),
		NextToken:       ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListApplicationRevisions(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListApplicationRevisions"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListApplications(t *testing.T) {
	input := &ListApplicationsInput{
		NextToken: ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListApplications(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListApplications"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListDeploymentConfigs(t *testing.T) {
	input := &ListDeploymentConfigsInput{
		NextToken: ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListDeploymentConfigs(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListDeploymentConfigs"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListDeploymentGroups(t *testing.T) {
	input := &ListDeploymentGroupsInput{
		ApplicationName: ptr.String("__ApplicationName__"),
		NextToken:       ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListDeploymentGroups(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListDeploymentGroups"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListDeploymentInstances(t *testing.T) {
	input := &ListDeploymentInstancesInput{
		DeploymentId: ptr.String("__DeploymentId__"),
		NextToken:    ptr.String("__NextToken__"),
		InstanceStatusFilter: []types.InstanceStatus{
			types.InstanceStatus("Pending"),
			types.InstanceStatus("Pending"),
		},
		InstanceTypeFilter: []types.InstanceType{
			types.InstanceType("Blue"),
			types.InstanceType("Blue"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListDeploymentInstances(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListDeploymentInstances"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListDeployments(t *testing.T) {
	input := &ListDeploymentsInput{
		ApplicationName:     ptr.String("__ApplicationName__"),
		DeploymentGroupName: ptr.String("__DeploymentGroupName__"),
		ExternalId:          ptr.String("__ExternalId__"),
		IncludeOnlyStatuses: []types.DeploymentStatus{
			types.DeploymentStatus("Created"),
			types.DeploymentStatus("Created"),
		},
		CreateTimeRange: &types.TimeRange{
			Start: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			End:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken: ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListDeployments(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListDeployments"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListDeploymentTargets(t *testing.T) {
	input := &ListDeploymentTargetsInput{
		DeploymentId: ptr.String("__DeploymentId__"),
		NextToken:    ptr.String("__NextToken__"),
		TargetFilters: map[string][]string{
			"key0": {
				"__Member__",
				"__Member__",
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListDeploymentTargets(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListDeploymentTargets"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListGitHubAccountTokenNames(t *testing.T) {
	input := &ListGitHubAccountTokenNamesInput{
		NextToken: ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListGitHubAccountTokenNames(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListGitHubAccountTokenNames"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListOnPremisesInstances(t *testing.T) {
	input := &ListOnPremisesInstancesInput{
		RegistrationStatus: types.RegistrationStatus("Registered"),
		TagFilters: []types.TagFilter{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
				Type:  types.TagFilterType("KEY_ONLY"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
				Type:  types.TagFilterType("KEY_ONLY"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListOnPremisesInstances(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListOnPremisesInstances"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListTagsForResource(t *testing.T) {
	input := &ListTagsForResourceInput{
		ResourceArn: ptr.String("__ResourceArn__"),
		NextToken:   ptr.String("__NextToken__"),
	}
	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_PutLifecycleEventHookExecutionStatus(t *testing.T) {
	input := &PutLifecycleEventHookExecutionStatusInput{
		DeploymentId:                  ptr.String("__DeploymentId__"),
		LifecycleEventHookExecutionId: ptr.String("__LifecycleEventHookExecutionId__"),
		Status:                        types.LifecycleEventStatus("Pending"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutLifecycleEventHookExecutionStatus(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutLifecycleEventHookExecutionStatus"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_RegisterApplicationRevision(t *testing.T) {
	input := &RegisterApplicationRevisionInput{
		ApplicationName: ptr.String("__ApplicationName__"),
		Description:     ptr.String("__Description__"),
		Revision: &types.RevisionLocation{
			RevisionType: types.RevisionLocationType("S3"),
			S3Location: &types.S3Location{
				Bucket:     ptr.String("__Bucket__"),
				Key:        ptr.String("__Key__"),
				BundleType: types.BundleType("tar"),
				Version:    ptr.String("__Version__"),
				ETag:       ptr.String("__ETag__"),
			},
			GitHubLocation: &types.GitHubLocation{
				Repository: ptr.String("__Repository__"),
				CommitId:   ptr.String("__CommitId__"),
			},
			String_: &types.RawString{
				Content: ptr.String("__Content__"),
				Sha256:  ptr.String("__Sha256__"),
			},
			AppSpecContent: &types.AppSpecContent{
				Content: ptr.String("__Content__"),
				Sha256:  ptr.String("__Sha256__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.RegisterApplicationRevision(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "RegisterApplicationRevision"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_RegisterOnPremisesInstance(t *testing.T) {
	input := &RegisterOnPremisesInstanceInput{
		InstanceName:  ptr.String("__InstanceName__"),
		IamSessionArn: ptr.String("__IamSessionArn__"),
		IamUserArn:    ptr.String("__IamUserArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.RegisterOnPremisesInstance(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "RegisterOnPremisesInstance"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_RemoveTagsFromOnPremisesInstances(t *testing.T) {
	input := &RemoveTagsFromOnPremisesInstancesInput{
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		InstanceNames: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.RemoveTagsFromOnPremisesInstances(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "RemoveTagsFromOnPremisesInstances"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_SkipWaitTimeForInstanceTermination(t *testing.T) {
	input := &SkipWaitTimeForInstanceTerminationInput{
		DeploymentId: ptr.String("__DeploymentId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.SkipWaitTimeForInstanceTermination(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "SkipWaitTimeForInstanceTermination"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_StopDeployment(t *testing.T) {
	input := &StopDeploymentInput{
		DeploymentId:        ptr.String("__DeploymentId__"),
		AutoRollbackEnabled: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopDeployment(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "StopDeployment"); 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_UpdateApplication(t *testing.T) {
	input := &UpdateApplicationInput{
		ApplicationName:    ptr.String("__ApplicationName__"),
		NewApplicationName: ptr.String("__NewApplicationName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateApplication(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UpdateApplication"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateDeploymentGroup(t *testing.T) {
	input := &UpdateDeploymentGroupInput{
		ApplicationName:            ptr.String("__ApplicationName__"),
		CurrentDeploymentGroupName: ptr.String("__CurrentDeploymentGroupName__"),
		NewDeploymentGroupName:     ptr.String("__NewDeploymentGroupName__"),
		DeploymentConfigName:       ptr.String("__DeploymentConfigName__"),
		Ec2TagFilters: []types.EC2TagFilter{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
				Type:  types.EC2TagFilterType("KEY_ONLY"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
				Type:  types.EC2TagFilterType("KEY_ONLY"),
			},
		},
		OnPremisesInstanceTagFilters: []types.TagFilter{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
				Type:  types.TagFilterType("KEY_ONLY"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
				Type:  types.TagFilterType("KEY_ONLY"),
			},
		},
		AutoScalingGroups: []string{
			"__Member__",
			"__Member__",
		},
		ServiceRoleArn: ptr.String("__ServiceRoleArn__"),
		TriggerConfigurations: []types.TriggerConfig{
			{
				TriggerName:      ptr.String("__TriggerName__"),
				TriggerTargetArn: ptr.String("__TriggerTargetArn__"),
				TriggerEvents: []types.TriggerEventType{
					types.TriggerEventType("DeploymentStart"),
					types.TriggerEventType("DeploymentStart"),
				},
			},
			{
				TriggerName:      ptr.String("__TriggerName__"),
				TriggerTargetArn: ptr.String("__TriggerTargetArn__"),
				TriggerEvents: []types.TriggerEventType{
					types.TriggerEventType("DeploymentStart"),
					types.TriggerEventType("DeploymentStart"),
				},
			},
		},
		AlarmConfiguration: &types.AlarmConfiguration{
			Enabled:                true,
			IgnorePollAlarmFailure: true,
			Alarms: []types.Alarm{
				{
					Name: ptr.String("__Name__"),
				},
				{
					Name: ptr.String("__Name__"),
				},
			},
		},
		AutoRollbackConfiguration: &types.AutoRollbackConfiguration{
			Enabled: true,
			Events: []types.AutoRollbackEvent{
				types.AutoRollbackEvent("DEPLOYMENT_FAILURE"),
				types.AutoRollbackEvent("DEPLOYMENT_FAILURE"),
			},
		},
		OutdatedInstancesStrategy: types.OutdatedInstancesStrategy("UPDATE"),
		DeploymentStyle: &types.DeploymentStyle{
			DeploymentType:   types.DeploymentType("IN_PLACE"),
			DeploymentOption: types.DeploymentOption("WITH_TRAFFIC_CONTROL"),
		},
		BlueGreenDeploymentConfiguration: &types.BlueGreenDeploymentConfiguration{
			TerminateBlueInstancesOnDeploymentSuccess: &types.BlueInstanceTerminationOption{
				Action:                       types.InstanceAction("TERMINATE"),
				TerminationWaitTimeInMinutes: 1,
			},
			DeploymentReadyOption: &types.DeploymentReadyOption{
				ActionOnTimeout:   types.DeploymentReadyAction("CONTINUE_DEPLOYMENT"),
				WaitTimeInMinutes: 1,
			},
			GreenFleetProvisioningOption: &types.GreenFleetProvisioningOption{
				Action: types.GreenFleetProvisioningAction("DISCOVER_EXISTING"),
			},
		},
		LoadBalancerInfo: &types.LoadBalancerInfo{
			ElbInfoList: []types.ELBInfo{
				{
					Name: ptr.String("__Name__"),
				},
				{
					Name: ptr.String("__Name__"),
				},
			},
			TargetGroupInfoList: []types.TargetGroupInfo{
				{
					Name: ptr.String("__Name__"),
				},
				{
					Name: ptr.String("__Name__"),
				},
			},
			TargetGroupPairInfoList: []types.TargetGroupPairInfo{
				{
					TargetGroups: []types.TargetGroupInfo{
						{
							Name: ptr.String("__Name__"),
						},
						{
							Name: ptr.String("__Name__"),
						},
					},
					ProdTrafficRoute: &types.TrafficRoute{
						ListenerArns: []string{
							"__Member__",
							"__Member__",
						},
					},
					TestTrafficRoute: &types.TrafficRoute{
						ListenerArns: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
				{
					TargetGroups: []types.TargetGroupInfo{
						{
							Name: ptr.String("__Name__"),
						},
						{
							Name: ptr.String("__Name__"),
						},
					},
					ProdTrafficRoute: &types.TrafficRoute{
						ListenerArns: []string{
							"__Member__",
							"__Member__",
						},
					},
					TestTrafficRoute: &types.TrafficRoute{
						ListenerArns: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
			},
		},
		Ec2TagSet: &types.EC2TagSet{
			Ec2TagSetList: [][]types.EC2TagFilter{
				{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.EC2TagFilterType("KEY_ONLY"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.EC2TagFilterType("KEY_ONLY"),
					},
				},
				{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.EC2TagFilterType("KEY_ONLY"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.EC2TagFilterType("KEY_ONLY"),
					},
				},
			},
		},
		EcsServices: []types.ECSService{
			{
				ServiceName: ptr.String("__ServiceName__"),
				ClusterName: ptr.String("__ClusterName__"),
			},
			{
				ServiceName: ptr.String("__ServiceName__"),
				ClusterName: ptr.String("__ClusterName__"),
			},
		},
		OnPremisesTagSet: &types.OnPremisesTagSet{
			OnPremisesTagSetList: [][]types.TagFilter{
				{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.TagFilterType("KEY_ONLY"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.TagFilterType("KEY_ONLY"),
					},
				},
				{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.TagFilterType("KEY_ONLY"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.TagFilterType("KEY_ONLY"),
					},
				},
			},
		},
		TerminationHookEnabled: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateDeploymentGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UpdateDeploymentGroup"); err != nil {
		t.Fatal(err)
	}
}
func TestUpdateRequestSnapshot_AddTagsToOnPremisesInstances(t *testing.T) {
	input := &AddTagsToOnPremisesInstancesInput{
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		InstanceNames: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AddTagsToOnPremisesInstances(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "AddTagsToOnPremisesInstances"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_BatchGetApplicationRevisions(t *testing.T) {
	input := &BatchGetApplicationRevisionsInput{
		ApplicationName: ptr.String("__ApplicationName__"),
		Revisions: []types.RevisionLocation{
			{
				RevisionType: types.RevisionLocationType("S3"),
				S3Location: &types.S3Location{
					Bucket:     ptr.String("__Bucket__"),
					Key:        ptr.String("__Key__"),
					BundleType: types.BundleType("tar"),
					Version:    ptr.String("__Version__"),
					ETag:       ptr.String("__ETag__"),
				},
				GitHubLocation: &types.GitHubLocation{
					Repository: ptr.String("__Repository__"),
					CommitId:   ptr.String("__CommitId__"),
				},
				String_: &types.RawString{
					Content: ptr.String("__Content__"),
					Sha256:  ptr.String("__Sha256__"),
				},
				AppSpecContent: &types.AppSpecContent{
					Content: ptr.String("__Content__"),
					Sha256:  ptr.String("__Sha256__"),
				},
			},
			{
				RevisionType: types.RevisionLocationType("S3"),
				S3Location: &types.S3Location{
					Bucket:     ptr.String("__Bucket__"),
					Key:        ptr.String("__Key__"),
					BundleType: types.BundleType("tar"),
					Version:    ptr.String("__Version__"),
					ETag:       ptr.String("__ETag__"),
				},
				GitHubLocation: &types.GitHubLocation{
					Repository: ptr.String("__Repository__"),
					CommitId:   ptr.String("__CommitId__"),
				},
				String_: &types.RawString{
					Content: ptr.String("__Content__"),
					Sha256:  ptr.String("__Sha256__"),
				},
				AppSpecContent: &types.AppSpecContent{
					Content: ptr.String("__Content__"),
					Sha256:  ptr.String("__Sha256__"),
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchGetApplicationRevisions(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "BatchGetApplicationRevisions"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_BatchGetApplications(t *testing.T) {
	input := &BatchGetApplicationsInput{
		ApplicationNames: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchGetApplications(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "BatchGetApplications"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_BatchGetDeploymentGroups(t *testing.T) {
	input := &BatchGetDeploymentGroupsInput{
		ApplicationName: ptr.String("__ApplicationName__"),
		DeploymentGroupNames: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchGetDeploymentGroups(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "BatchGetDeploymentGroups"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_BatchGetDeploymentInstances(t *testing.T) {
	input := &BatchGetDeploymentInstancesInput{
		DeploymentId: ptr.String("__DeploymentId__"),
		InstanceIds: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchGetDeploymentInstances(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "BatchGetDeploymentInstances"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_BatchGetDeployments(t *testing.T) {
	input := &BatchGetDeploymentsInput{
		DeploymentIds: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchGetDeployments(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "BatchGetDeployments"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_BatchGetDeploymentTargets(t *testing.T) {
	input := &BatchGetDeploymentTargetsInput{
		DeploymentId: ptr.String("__DeploymentId__"),
		TargetIds: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchGetDeploymentTargets(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "BatchGetDeploymentTargets"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_BatchGetOnPremisesInstances(t *testing.T) {
	input := &BatchGetOnPremisesInstancesInput{
		InstanceNames: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchGetOnPremisesInstances(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "BatchGetOnPremisesInstances"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ContinueDeployment(t *testing.T) {
	input := &ContinueDeploymentInput{
		DeploymentId:       ptr.String("__DeploymentId__"),
		DeploymentWaitType: types.DeploymentWaitType("READY_WAIT"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ContinueDeployment(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ContinueDeployment"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateApplication(t *testing.T) {
	input := &CreateApplicationInput{
		ApplicationName: ptr.String("__ApplicationName__"),
		ComputePlatform: types.ComputePlatform("Server"),
		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.CreateApplication(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateApplication"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateDeployment(t *testing.T) {
	input := &CreateDeploymentInput{
		ApplicationName:     ptr.String("__ApplicationName__"),
		DeploymentGroupName: ptr.String("__DeploymentGroupName__"),
		Revision: &types.RevisionLocation{
			RevisionType: types.RevisionLocationType("S3"),
			S3Location: &types.S3Location{
				Bucket:     ptr.String("__Bucket__"),
				Key:        ptr.String("__Key__"),
				BundleType: types.BundleType("tar"),
				Version:    ptr.String("__Version__"),
				ETag:       ptr.String("__ETag__"),
			},
			GitHubLocation: &types.GitHubLocation{
				Repository: ptr.String("__Repository__"),
				CommitId:   ptr.String("__CommitId__"),
			},
			String_: &types.RawString{
				Content: ptr.String("__Content__"),
				Sha256:  ptr.String("__Sha256__"),
			},
			AppSpecContent: &types.AppSpecContent{
				Content: ptr.String("__Content__"),
				Sha256:  ptr.String("__Sha256__"),
			},
		},
		DeploymentConfigName:          ptr.String("__DeploymentConfigName__"),
		Description:                   ptr.String("__Description__"),
		IgnoreApplicationStopFailures: true,
		TargetInstances: &types.TargetInstances{
			TagFilters: []types.EC2TagFilter{
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
					Type:  types.EC2TagFilterType("KEY_ONLY"),
				},
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
					Type:  types.EC2TagFilterType("KEY_ONLY"),
				},
			},
			AutoScalingGroups: []string{
				"__Member__",
				"__Member__",
			},
			Ec2TagSet: &types.EC2TagSet{
				Ec2TagSetList: [][]types.EC2TagFilter{
					{
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
							Type:  types.EC2TagFilterType("KEY_ONLY"),
						},
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
							Type:  types.EC2TagFilterType("KEY_ONLY"),
						},
					},
					{
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
							Type:  types.EC2TagFilterType("KEY_ONLY"),
						},
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
							Type:  types.EC2TagFilterType("KEY_ONLY"),
						},
					},
				},
			},
		},
		AutoRollbackConfiguration: &types.AutoRollbackConfiguration{
			Enabled: true,
			Events: []types.AutoRollbackEvent{
				types.AutoRollbackEvent("DEPLOYMENT_FAILURE"),
				types.AutoRollbackEvent("DEPLOYMENT_FAILURE"),
			},
		},
		UpdateOutdatedInstancesOnly: true,
		FileExistsBehavior:          types.FileExistsBehavior("DISALLOW"),
		OverrideAlarmConfiguration: &types.AlarmConfiguration{
			Enabled:                true,
			IgnorePollAlarmFailure: true,
			Alarms: []types.Alarm{
				{
					Name: ptr.String("__Name__"),
				},
				{
					Name: ptr.String("__Name__"),
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateDeployment(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateDeployment"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateDeploymentConfig(t *testing.T) {
	input := &CreateDeploymentConfigInput{
		DeploymentConfigName: ptr.String("__DeploymentConfigName__"),
		MinimumHealthyHosts: &types.MinimumHealthyHosts{
			Type:  types.MinimumHealthyHostsType("HOST_COUNT"),
			Value: 1,
		},
		TrafficRoutingConfig: &types.TrafficRoutingConfig{
			Type: types.TrafficRoutingType("TimeBasedCanary"),
			TimeBasedCanary: &types.TimeBasedCanary{
				CanaryPercentage: 1,
				CanaryInterval:   1,
			},
			TimeBasedLinear: &types.TimeBasedLinear{
				LinearPercentage: 1,
				LinearInterval:   1,
			},
		},
		ComputePlatform: types.ComputePlatform("Server"),
		ZonalConfig: &types.ZonalConfig{
			FirstZoneMonitorDurationInSeconds: ptr.Int64(1),
			MonitorDurationInSeconds:          ptr.Int64(1),
			MinimumHealthyHostsPerZone: &types.MinimumHealthyHostsPerZone{
				Type:  types.MinimumHealthyHostsPerZoneType("HOST_COUNT"),
				Value: 1,
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateDeploymentConfig(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateDeploymentConfig"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateDeploymentGroup(t *testing.T) {
	input := &CreateDeploymentGroupInput{
		ApplicationName:      ptr.String("__ApplicationName__"),
		DeploymentGroupName:  ptr.String("__DeploymentGroupName__"),
		DeploymentConfigName: ptr.String("__DeploymentConfigName__"),
		Ec2TagFilters: []types.EC2TagFilter{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
				Type:  types.EC2TagFilterType("KEY_ONLY"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
				Type:  types.EC2TagFilterType("KEY_ONLY"),
			},
		},
		OnPremisesInstanceTagFilters: []types.TagFilter{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
				Type:  types.TagFilterType("KEY_ONLY"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
				Type:  types.TagFilterType("KEY_ONLY"),
			},
		},
		AutoScalingGroups: []string{
			"__Member__",
			"__Member__",
		},
		ServiceRoleArn: ptr.String("__ServiceRoleArn__"),
		TriggerConfigurations: []types.TriggerConfig{
			{
				TriggerName:      ptr.String("__TriggerName__"),
				TriggerTargetArn: ptr.String("__TriggerTargetArn__"),
				TriggerEvents: []types.TriggerEventType{
					types.TriggerEventType("DeploymentStart"),
					types.TriggerEventType("DeploymentStart"),
				},
			},
			{
				TriggerName:      ptr.String("__TriggerName__"),
				TriggerTargetArn: ptr.String("__TriggerTargetArn__"),
				TriggerEvents: []types.TriggerEventType{
					types.TriggerEventType("DeploymentStart"),
					types.TriggerEventType("DeploymentStart"),
				},
			},
		},
		AlarmConfiguration: &types.AlarmConfiguration{
			Enabled:                true,
			IgnorePollAlarmFailure: true,
			Alarms: []types.Alarm{
				{
					Name: ptr.String("__Name__"),
				},
				{
					Name: ptr.String("__Name__"),
				},
			},
		},
		AutoRollbackConfiguration: &types.AutoRollbackConfiguration{
			Enabled: true,
			Events: []types.AutoRollbackEvent{
				types.AutoRollbackEvent("DEPLOYMENT_FAILURE"),
				types.AutoRollbackEvent("DEPLOYMENT_FAILURE"),
			},
		},
		OutdatedInstancesStrategy: types.OutdatedInstancesStrategy("UPDATE"),
		DeploymentStyle: &types.DeploymentStyle{
			DeploymentType:   types.DeploymentType("IN_PLACE"),
			DeploymentOption: types.DeploymentOption("WITH_TRAFFIC_CONTROL"),
		},
		BlueGreenDeploymentConfiguration: &types.BlueGreenDeploymentConfiguration{
			TerminateBlueInstancesOnDeploymentSuccess: &types.BlueInstanceTerminationOption{
				Action:                       types.InstanceAction("TERMINATE"),
				TerminationWaitTimeInMinutes: 1,
			},
			DeploymentReadyOption: &types.DeploymentReadyOption{
				ActionOnTimeout:   types.DeploymentReadyAction("CONTINUE_DEPLOYMENT"),
				WaitTimeInMinutes: 1,
			},
			GreenFleetProvisioningOption: &types.GreenFleetProvisioningOption{
				Action: types.GreenFleetProvisioningAction("DISCOVER_EXISTING"),
			},
		},
		LoadBalancerInfo: &types.LoadBalancerInfo{
			ElbInfoList: []types.ELBInfo{
				{
					Name: ptr.String("__Name__"),
				},
				{
					Name: ptr.String("__Name__"),
				},
			},
			TargetGroupInfoList: []types.TargetGroupInfo{
				{
					Name: ptr.String("__Name__"),
				},
				{
					Name: ptr.String("__Name__"),
				},
			},
			TargetGroupPairInfoList: []types.TargetGroupPairInfo{
				{
					TargetGroups: []types.TargetGroupInfo{
						{
							Name: ptr.String("__Name__"),
						},
						{
							Name: ptr.String("__Name__"),
						},
					},
					ProdTrafficRoute: &types.TrafficRoute{
						ListenerArns: []string{
							"__Member__",
							"__Member__",
						},
					},
					TestTrafficRoute: &types.TrafficRoute{
						ListenerArns: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
				{
					TargetGroups: []types.TargetGroupInfo{
						{
							Name: ptr.String("__Name__"),
						},
						{
							Name: ptr.String("__Name__"),
						},
					},
					ProdTrafficRoute: &types.TrafficRoute{
						ListenerArns: []string{
							"__Member__",
							"__Member__",
						},
					},
					TestTrafficRoute: &types.TrafficRoute{
						ListenerArns: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
			},
		},
		Ec2TagSet: &types.EC2TagSet{
			Ec2TagSetList: [][]types.EC2TagFilter{
				{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.EC2TagFilterType("KEY_ONLY"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.EC2TagFilterType("KEY_ONLY"),
					},
				},
				{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.EC2TagFilterType("KEY_ONLY"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.EC2TagFilterType("KEY_ONLY"),
					},
				},
			},
		},
		EcsServices: []types.ECSService{
			{
				ServiceName: ptr.String("__ServiceName__"),
				ClusterName: ptr.String("__ClusterName__"),
			},
			{
				ServiceName: ptr.String("__ServiceName__"),
				ClusterName: ptr.String("__ClusterName__"),
			},
		},
		OnPremisesTagSet: &types.OnPremisesTagSet{
			OnPremisesTagSetList: [][]types.TagFilter{
				{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.TagFilterType("KEY_ONLY"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.TagFilterType("KEY_ONLY"),
					},
				},
				{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.TagFilterType("KEY_ONLY"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.TagFilterType("KEY_ONLY"),
					},
				},
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		TerminationHookEnabled: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateDeploymentGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateDeploymentGroup"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteApplication(t *testing.T) {
	input := &DeleteApplicationInput{
		ApplicationName: ptr.String("__ApplicationName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteApplication(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteApplication"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteDeploymentConfig(t *testing.T) {
	input := &DeleteDeploymentConfigInput{
		DeploymentConfigName: ptr.String("__DeploymentConfigName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteDeploymentConfig(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteDeploymentConfig"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteDeploymentGroup(t *testing.T) {
	input := &DeleteDeploymentGroupInput{
		ApplicationName:     ptr.String("__ApplicationName__"),
		DeploymentGroupName: ptr.String("__DeploymentGroupName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteDeploymentGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteDeploymentGroup"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteGitHubAccountToken(t *testing.T) {
	input := &DeleteGitHubAccountTokenInput{
		TokenName: ptr.String("__TokenName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteGitHubAccountToken(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteGitHubAccountToken"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeleteResourcesByExternalId(t *testing.T) {
	input := &DeleteResourcesByExternalIdInput{
		ExternalId: ptr.String("__ExternalId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteResourcesByExternalId(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeleteResourcesByExternalId"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DeregisterOnPremisesInstance(t *testing.T) {
	input := &DeregisterOnPremisesInstanceInput{
		InstanceName: ptr.String("__InstanceName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeregisterOnPremisesInstance(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DeregisterOnPremisesInstance"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetApplication(t *testing.T) {
	input := &GetApplicationInput{
		ApplicationName: ptr.String("__ApplicationName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetApplication(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetApplication"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetApplicationRevision(t *testing.T) {
	input := &GetApplicationRevisionInput{
		ApplicationName: ptr.String("__ApplicationName__"),
		Revision: &types.RevisionLocation{
			RevisionType: types.RevisionLocationType("S3"),
			S3Location: &types.S3Location{
				Bucket:     ptr.String("__Bucket__"),
				Key:        ptr.String("__Key__"),
				BundleType: types.BundleType("tar"),
				Version:    ptr.String("__Version__"),
				ETag:       ptr.String("__ETag__"),
			},
			GitHubLocation: &types.GitHubLocation{
				Repository: ptr.String("__Repository__"),
				CommitId:   ptr.String("__CommitId__"),
			},
			String_: &types.RawString{
				Content: ptr.String("__Content__"),
				Sha256:  ptr.String("__Sha256__"),
			},
			AppSpecContent: &types.AppSpecContent{
				Content: ptr.String("__Content__"),
				Sha256:  ptr.String("__Sha256__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetApplicationRevision(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetApplicationRevision"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetDeployment(t *testing.T) {
	input := &GetDeploymentInput{
		DeploymentId: ptr.String("__DeploymentId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetDeployment(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetDeployment"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetDeploymentConfig(t *testing.T) {
	input := &GetDeploymentConfigInput{
		DeploymentConfigName: ptr.String("__DeploymentConfigName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetDeploymentConfig(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetDeploymentConfig"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetDeploymentGroup(t *testing.T) {
	input := &GetDeploymentGroupInput{
		ApplicationName:     ptr.String("__ApplicationName__"),
		DeploymentGroupName: ptr.String("__DeploymentGroupName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetDeploymentGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetDeploymentGroup"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetDeploymentInstance(t *testing.T) {
	input := &GetDeploymentInstanceInput{
		DeploymentId: ptr.String("__DeploymentId__"),
		InstanceId:   ptr.String("__InstanceId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetDeploymentInstance(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetDeploymentInstance"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetDeploymentTarget(t *testing.T) {
	input := &GetDeploymentTargetInput{
		DeploymentId: ptr.String("__DeploymentId__"),
		TargetId:     ptr.String("__TargetId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetDeploymentTarget(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetDeploymentTarget"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetOnPremisesInstance(t *testing.T) {
	input := &GetOnPremisesInstanceInput{
		InstanceName: ptr.String("__InstanceName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetOnPremisesInstance(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetOnPremisesInstance"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListApplicationRevisions(t *testing.T) {
	input := &ListApplicationRevisionsInput{
		ApplicationName: ptr.String("__ApplicationName__"),
		SortBy:          types.ApplicationRevisionSortBy("registerTime"),
		SortOrder:       types.SortOrder("ascending"),
		S3Bucket:        ptr.String("__S3Bucket__"),
		S3KeyPrefix:     ptr.String("__S3KeyPrefix__"),
		Deployed:        types.ListStateFilterAction("include"),
		NextToken:       ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListApplicationRevisions(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListApplicationRevisions"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListApplications(t *testing.T) {
	input := &ListApplicationsInput{
		NextToken: ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListApplications(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListApplications"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListDeploymentConfigs(t *testing.T) {
	input := &ListDeploymentConfigsInput{
		NextToken: ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListDeploymentConfigs(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListDeploymentConfigs"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListDeploymentGroups(t *testing.T) {
	input := &ListDeploymentGroupsInput{
		ApplicationName: ptr.String("__ApplicationName__"),
		NextToken:       ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListDeploymentGroups(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListDeploymentGroups"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListDeploymentInstances(t *testing.T) {
	input := &ListDeploymentInstancesInput{
		DeploymentId: ptr.String("__DeploymentId__"),
		NextToken:    ptr.String("__NextToken__"),
		InstanceStatusFilter: []types.InstanceStatus{
			types.InstanceStatus("Pending"),
			types.InstanceStatus("Pending"),
		},
		InstanceTypeFilter: []types.InstanceType{
			types.InstanceType("Blue"),
			types.InstanceType("Blue"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListDeploymentInstances(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListDeploymentInstances"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListDeployments(t *testing.T) {
	input := &ListDeploymentsInput{
		ApplicationName:     ptr.String("__ApplicationName__"),
		DeploymentGroupName: ptr.String("__DeploymentGroupName__"),
		ExternalId:          ptr.String("__ExternalId__"),
		IncludeOnlyStatuses: []types.DeploymentStatus{
			types.DeploymentStatus("Created"),
			types.DeploymentStatus("Created"),
		},
		CreateTimeRange: &types.TimeRange{
			Start: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			End:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken: ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListDeployments(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListDeployments"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListDeploymentTargets(t *testing.T) {
	input := &ListDeploymentTargetsInput{
		DeploymentId: ptr.String("__DeploymentId__"),
		NextToken:    ptr.String("__NextToken__"),
		TargetFilters: map[string][]string{
			"key0": {
				"__Member__",
				"__Member__",
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListDeploymentTargets(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListDeploymentTargets"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListGitHubAccountTokenNames(t *testing.T) {
	input := &ListGitHubAccountTokenNamesInput{
		NextToken: ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListGitHubAccountTokenNames(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListGitHubAccountTokenNames"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListOnPremisesInstances(t *testing.T) {
	input := &ListOnPremisesInstancesInput{
		RegistrationStatus: types.RegistrationStatus("Registered"),
		TagFilters: []types.TagFilter{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
				Type:  types.TagFilterType("KEY_ONLY"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
				Type:  types.TagFilterType("KEY_ONLY"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListOnPremisesInstances(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListOnPremisesInstances"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListTagsForResource(t *testing.T) {
	input := &ListTagsForResourceInput{
		ResourceArn: ptr.String("__ResourceArn__"),
		NextToken:   ptr.String("__NextToken__"),
	}
	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_PutLifecycleEventHookExecutionStatus(t *testing.T) {
	input := &PutLifecycleEventHookExecutionStatusInput{
		DeploymentId:                  ptr.String("__DeploymentId__"),
		LifecycleEventHookExecutionId: ptr.String("__LifecycleEventHookExecutionId__"),
		Status:                        types.LifecycleEventStatus("Pending"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutLifecycleEventHookExecutionStatus(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutLifecycleEventHookExecutionStatus"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_RegisterApplicationRevision(t *testing.T) {
	input := &RegisterApplicationRevisionInput{
		ApplicationName: ptr.String("__ApplicationName__"),
		Description:     ptr.String("__Description__"),
		Revision: &types.RevisionLocation{
			RevisionType: types.RevisionLocationType("S3"),
			S3Location: &types.S3Location{
				Bucket:     ptr.String("__Bucket__"),
				Key:        ptr.String("__Key__"),
				BundleType: types.BundleType("tar"),
				Version:    ptr.String("__Version__"),
				ETag:       ptr.String("__ETag__"),
			},
			GitHubLocation: &types.GitHubLocation{
				Repository: ptr.String("__Repository__"),
				CommitId:   ptr.String("__CommitId__"),
			},
			String_: &types.RawString{
				Content: ptr.String("__Content__"),
				Sha256:  ptr.String("__Sha256__"),
			},
			AppSpecContent: &types.AppSpecContent{
				Content: ptr.String("__Content__"),
				Sha256:  ptr.String("__Sha256__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.RegisterApplicationRevision(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "RegisterApplicationRevision"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_RegisterOnPremisesInstance(t *testing.T) {
	input := &RegisterOnPremisesInstanceInput{
		InstanceName:  ptr.String("__InstanceName__"),
		IamSessionArn: ptr.String("__IamSessionArn__"),
		IamUserArn:    ptr.String("__IamUserArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.RegisterOnPremisesInstance(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "RegisterOnPremisesInstance"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_RemoveTagsFromOnPremisesInstances(t *testing.T) {
	input := &RemoveTagsFromOnPremisesInstancesInput{
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		InstanceNames: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.RemoveTagsFromOnPremisesInstances(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "RemoveTagsFromOnPremisesInstances"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_SkipWaitTimeForInstanceTermination(t *testing.T) {
	input := &SkipWaitTimeForInstanceTerminationInput{
		DeploymentId: ptr.String("__DeploymentId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.SkipWaitTimeForInstanceTermination(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "SkipWaitTimeForInstanceTermination"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_StopDeployment(t *testing.T) {
	input := &StopDeploymentInput{
		DeploymentId:        ptr.String("__DeploymentId__"),
		AutoRollbackEnabled: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopDeployment(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "StopDeployment"); 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_UpdateApplication(t *testing.T) {
	input := &UpdateApplicationInput{
		ApplicationName:    ptr.String("__ApplicationName__"),
		NewApplicationName: ptr.String("__NewApplicationName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateApplication(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UpdateApplication"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateDeploymentGroup(t *testing.T) {
	input := &UpdateDeploymentGroupInput{
		ApplicationName:            ptr.String("__ApplicationName__"),
		CurrentDeploymentGroupName: ptr.String("__CurrentDeploymentGroupName__"),
		NewDeploymentGroupName:     ptr.String("__NewDeploymentGroupName__"),
		DeploymentConfigName:       ptr.String("__DeploymentConfigName__"),
		Ec2TagFilters: []types.EC2TagFilter{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
				Type:  types.EC2TagFilterType("KEY_ONLY"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
				Type:  types.EC2TagFilterType("KEY_ONLY"),
			},
		},
		OnPremisesInstanceTagFilters: []types.TagFilter{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
				Type:  types.TagFilterType("KEY_ONLY"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
				Type:  types.TagFilterType("KEY_ONLY"),
			},
		},
		AutoScalingGroups: []string{
			"__Member__",
			"__Member__",
		},
		ServiceRoleArn: ptr.String("__ServiceRoleArn__"),
		TriggerConfigurations: []types.TriggerConfig{
			{
				TriggerName:      ptr.String("__TriggerName__"),
				TriggerTargetArn: ptr.String("__TriggerTargetArn__"),
				TriggerEvents: []types.TriggerEventType{
					types.TriggerEventType("DeploymentStart"),
					types.TriggerEventType("DeploymentStart"),
				},
			},
			{
				TriggerName:      ptr.String("__TriggerName__"),
				TriggerTargetArn: ptr.String("__TriggerTargetArn__"),
				TriggerEvents: []types.TriggerEventType{
					types.TriggerEventType("DeploymentStart"),
					types.TriggerEventType("DeploymentStart"),
				},
			},
		},
		AlarmConfiguration: &types.AlarmConfiguration{
			Enabled:                true,
			IgnorePollAlarmFailure: true,
			Alarms: []types.Alarm{
				{
					Name: ptr.String("__Name__"),
				},
				{
					Name: ptr.String("__Name__"),
				},
			},
		},
		AutoRollbackConfiguration: &types.AutoRollbackConfiguration{
			Enabled: true,
			Events: []types.AutoRollbackEvent{
				types.AutoRollbackEvent("DEPLOYMENT_FAILURE"),
				types.AutoRollbackEvent("DEPLOYMENT_FAILURE"),
			},
		},
		OutdatedInstancesStrategy: types.OutdatedInstancesStrategy("UPDATE"),
		DeploymentStyle: &types.DeploymentStyle{
			DeploymentType:   types.DeploymentType("IN_PLACE"),
			DeploymentOption: types.DeploymentOption("WITH_TRAFFIC_CONTROL"),
		},
		BlueGreenDeploymentConfiguration: &types.BlueGreenDeploymentConfiguration{
			TerminateBlueInstancesOnDeploymentSuccess: &types.BlueInstanceTerminationOption{
				Action:                       types.InstanceAction("TERMINATE"),
				TerminationWaitTimeInMinutes: 1,
			},
			DeploymentReadyOption: &types.DeploymentReadyOption{
				ActionOnTimeout:   types.DeploymentReadyAction("CONTINUE_DEPLOYMENT"),
				WaitTimeInMinutes: 1,
			},
			GreenFleetProvisioningOption: &types.GreenFleetProvisioningOption{
				Action: types.GreenFleetProvisioningAction("DISCOVER_EXISTING"),
			},
		},
		LoadBalancerInfo: &types.LoadBalancerInfo{
			ElbInfoList: []types.ELBInfo{
				{
					Name: ptr.String("__Name__"),
				},
				{
					Name: ptr.String("__Name__"),
				},
			},
			TargetGroupInfoList: []types.TargetGroupInfo{
				{
					Name: ptr.String("__Name__"),
				},
				{
					Name: ptr.String("__Name__"),
				},
			},
			TargetGroupPairInfoList: []types.TargetGroupPairInfo{
				{
					TargetGroups: []types.TargetGroupInfo{
						{
							Name: ptr.String("__Name__"),
						},
						{
							Name: ptr.String("__Name__"),
						},
					},
					ProdTrafficRoute: &types.TrafficRoute{
						ListenerArns: []string{
							"__Member__",
							"__Member__",
						},
					},
					TestTrafficRoute: &types.TrafficRoute{
						ListenerArns: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
				{
					TargetGroups: []types.TargetGroupInfo{
						{
							Name: ptr.String("__Name__"),
						},
						{
							Name: ptr.String("__Name__"),
						},
					},
					ProdTrafficRoute: &types.TrafficRoute{
						ListenerArns: []string{
							"__Member__",
							"__Member__",
						},
					},
					TestTrafficRoute: &types.TrafficRoute{
						ListenerArns: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
			},
		},
		Ec2TagSet: &types.EC2TagSet{
			Ec2TagSetList: [][]types.EC2TagFilter{
				{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.EC2TagFilterType("KEY_ONLY"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.EC2TagFilterType("KEY_ONLY"),
					},
				},
				{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.EC2TagFilterType("KEY_ONLY"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.EC2TagFilterType("KEY_ONLY"),
					},
				},
			},
		},
		EcsServices: []types.ECSService{
			{
				ServiceName: ptr.String("__ServiceName__"),
				ClusterName: ptr.String("__ClusterName__"),
			},
			{
				ServiceName: ptr.String("__ServiceName__"),
				ClusterName: ptr.String("__ClusterName__"),
			},
		},
		OnPremisesTagSet: &types.OnPremisesTagSet{
			OnPremisesTagSetList: [][]types.TagFilter{
				{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.TagFilterType("KEY_ONLY"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.TagFilterType("KEY_ONLY"),
					},
				},
				{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.TagFilterType("KEY_ONLY"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
						Type:  types.TagFilterType("KEY_ONLY"),
					},
				},
			},
		},
		TerminationHookEnabled: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateDeploymentGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UpdateDeploymentGroup"); err != nil {
		t.Fatal(err)
	}
}
