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

//go:build request_snapshot

package codebuild

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/codebuild/types"
	smithyendpoints "github.com/aws/smithy-go/endpoints"
	"github.com/aws/smithy-go/middleware"
	"github.com/aws/smithy-go/ptr"
	smithyhttp "github.com/aws/smithy-go/transport/http"
	"io"
	"io/fs"
	"net/url"
	"os"
	"slices"
	"strings"
	"testing"
)

const serdeSSPrefix = "request_snapshot"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type serdeEndpointResolver struct{}

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

func serdeNewClient() *Client {
	return New(Options{
		Region:             "us-east-1",
		EndpointResolverV2: &serdeEndpointResolver{},
	})
}
func serdeBodyEqual(got, expected []byte) bool {
	return bytes.Equal(got, expected)
}
func TestCheckRequestSnapshot_BatchDeleteBuilds(t *testing.T) {
	input := &BatchDeleteBuildsInput{
		Ids: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchDeleteBuilds(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "BatchDeleteBuilds"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

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

func TestCheckRequestSnapshot_CreateFleet(t *testing.T) {
	input := &CreateFleetInput{
		Name:            ptr.String("__Name__"),
		BaseCapacity:    ptr.Int32(1),
		EnvironmentType: types.EnvironmentType("WINDOWS_CONTAINER"),
		ComputeType:     types.ComputeType("BUILD_GENERAL1_SMALL"),
		ComputeConfiguration: &types.ComputeConfiguration{
			VCpu:         ptr.Int64(1),
			Memory:       ptr.Int64(1),
			Disk:         ptr.Int64(1),
			MachineType:  types.MachineType("GENERAL"),
			InstanceType: ptr.String("__InstanceType__"),
		},
		ScalingConfiguration: &types.ScalingConfigurationInput{
			ScalingType: types.FleetScalingType("TARGET_TRACKING_SCALING"),
			TargetTrackingScalingConfigs: []types.TargetTrackingScalingConfiguration{
				{
					MetricType:  types.FleetScalingMetricType("FLEET_UTILIZATION_RATE"),
					TargetValue: ptr.Float64(1.0),
				},
				{
					MetricType:  types.FleetScalingMetricType("FLEET_UTILIZATION_RATE"),
					TargetValue: ptr.Float64(1.0),
				},
			},
			MaxCapacity: ptr.Int32(1),
		},
		OverflowBehavior: types.FleetOverflowBehavior("QUEUE"),
		VpcConfig: &types.VpcConfig{
			VpcId: ptr.String("__VpcId__"),
			Subnets: []string{
				"__Member__",
				"__Member__",
			},
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
		},
		ProxyConfiguration: &types.ProxyConfiguration{
			DefaultBehavior: types.FleetProxyRuleBehavior("ALLOW_ALL"),
			OrderedProxyRules: []types.FleetProxyRule{
				{
					Type:   types.FleetProxyRuleType("DOMAIN"),
					Effect: types.FleetProxyRuleEffectType("ALLOW"),
					Entities: []string{
						"__Member__",
						"__Member__",
					},
				},
				{
					Type:   types.FleetProxyRuleType("DOMAIN"),
					Effect: types.FleetProxyRuleEffectType("ALLOW"),
					Entities: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
		},
		ImageId:          ptr.String("__ImageId__"),
		FleetServiceRole: ptr.String("__FleetServiceRole__"),
		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.CreateFleet(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateFleet"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateProject(t *testing.T) {
	input := &CreateProjectInput{
		Name:        ptr.String("__Name__"),
		Description: ptr.String("__Description__"),
		Source: &types.ProjectSource{
			Type:          types.SourceType("CODECOMMIT"),
			Location:      ptr.String("__Location__"),
			GitCloneDepth: ptr.Int32(1),
			GitSubmodulesConfig: &types.GitSubmodulesConfig{
				FetchSubmodules: ptr.Bool(true),
			},
			Buildspec: ptr.String("__Buildspec__"),
			Auth: &types.SourceAuth{
				Type:     types.SourceAuthType("OAUTH"),
				Resource: ptr.String("__Resource__"),
			},
			ReportBuildStatus: ptr.Bool(true),
			BuildStatusConfig: &types.BuildStatusConfig{
				Context:   ptr.String("__Context__"),
				TargetUrl: ptr.String("__TargetUrl__"),
			},
			InsecureSsl:      ptr.Bool(true),
			SourceIdentifier: ptr.String("__SourceIdentifier__"),
		},
		SecondarySources: []types.ProjectSource{
			{
				Type:          types.SourceType("CODECOMMIT"),
				Location:      ptr.String("__Location__"),
				GitCloneDepth: ptr.Int32(1),
				GitSubmodulesConfig: &types.GitSubmodulesConfig{
					FetchSubmodules: ptr.Bool(true),
				},
				Buildspec: ptr.String("__Buildspec__"),
				Auth: &types.SourceAuth{
					Type:     types.SourceAuthType("OAUTH"),
					Resource: ptr.String("__Resource__"),
				},
				ReportBuildStatus: ptr.Bool(true),
				BuildStatusConfig: &types.BuildStatusConfig{
					Context:   ptr.String("__Context__"),
					TargetUrl: ptr.String("__TargetUrl__"),
				},
				InsecureSsl:      ptr.Bool(true),
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
			},
			{
				Type:          types.SourceType("CODECOMMIT"),
				Location:      ptr.String("__Location__"),
				GitCloneDepth: ptr.Int32(1),
				GitSubmodulesConfig: &types.GitSubmodulesConfig{
					FetchSubmodules: ptr.Bool(true),
				},
				Buildspec: ptr.String("__Buildspec__"),
				Auth: &types.SourceAuth{
					Type:     types.SourceAuthType("OAUTH"),
					Resource: ptr.String("__Resource__"),
				},
				ReportBuildStatus: ptr.Bool(true),
				BuildStatusConfig: &types.BuildStatusConfig{
					Context:   ptr.String("__Context__"),
					TargetUrl: ptr.String("__TargetUrl__"),
				},
				InsecureSsl:      ptr.Bool(true),
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
			},
		},
		SourceVersion: ptr.String("__SourceVersion__"),
		SecondarySourceVersions: []types.ProjectSourceVersion{
			{
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
				SourceVersion:    ptr.String("__SourceVersion__"),
			},
			{
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
				SourceVersion:    ptr.String("__SourceVersion__"),
			},
		},
		Artifacts: &types.ProjectArtifacts{
			Type:                 types.ArtifactsType("CODEPIPELINE"),
			Location:             ptr.String("__Location__"),
			Path:                 ptr.String("__Path__"),
			NamespaceType:        types.ArtifactNamespace("NONE"),
			Name:                 ptr.String("__Name__"),
			Packaging:            types.ArtifactPackaging("NONE"),
			OverrideArtifactName: ptr.Bool(true),
			EncryptionDisabled:   ptr.Bool(true),
			ArtifactIdentifier:   ptr.String("__ArtifactIdentifier__"),
			BucketOwnerAccess:    types.BucketOwnerAccess("NONE"),
		},
		SecondaryArtifacts: []types.ProjectArtifacts{
			{
				Type:                 types.ArtifactsType("CODEPIPELINE"),
				Location:             ptr.String("__Location__"),
				Path:                 ptr.String("__Path__"),
				NamespaceType:        types.ArtifactNamespace("NONE"),
				Name:                 ptr.String("__Name__"),
				Packaging:            types.ArtifactPackaging("NONE"),
				OverrideArtifactName: ptr.Bool(true),
				EncryptionDisabled:   ptr.Bool(true),
				ArtifactIdentifier:   ptr.String("__ArtifactIdentifier__"),
				BucketOwnerAccess:    types.BucketOwnerAccess("NONE"),
			},
			{
				Type:                 types.ArtifactsType("CODEPIPELINE"),
				Location:             ptr.String("__Location__"),
				Path:                 ptr.String("__Path__"),
				NamespaceType:        types.ArtifactNamespace("NONE"),
				Name:                 ptr.String("__Name__"),
				Packaging:            types.ArtifactPackaging("NONE"),
				OverrideArtifactName: ptr.Bool(true),
				EncryptionDisabled:   ptr.Bool(true),
				ArtifactIdentifier:   ptr.String("__ArtifactIdentifier__"),
				BucketOwnerAccess:    types.BucketOwnerAccess("NONE"),
			},
		},
		Cache: &types.ProjectCache{
			Type:     types.CacheType("NO_CACHE"),
			Location: ptr.String("__Location__"),
			Modes: []types.CacheMode{
				types.CacheMode("LOCAL_DOCKER_LAYER_CACHE"),
				types.CacheMode("LOCAL_DOCKER_LAYER_CACHE"),
			},
			CacheNamespace: ptr.String("__CacheNamespace__"),
		},
		Environment: &types.ProjectEnvironment{
			Type:        types.EnvironmentType("WINDOWS_CONTAINER"),
			Image:       ptr.String("__Image__"),
			ComputeType: types.ComputeType("BUILD_GENERAL1_SMALL"),
			ComputeConfiguration: &types.ComputeConfiguration{
				VCpu:         ptr.Int64(1),
				Memory:       ptr.Int64(1),
				Disk:         ptr.Int64(1),
				MachineType:  types.MachineType("GENERAL"),
				InstanceType: ptr.String("__InstanceType__"),
			},
			Fleet: &types.ProjectFleet{
				FleetArn: ptr.String("__FleetArn__"),
			},
			EnvironmentVariables: []types.EnvironmentVariable{
				{
					Name:  ptr.String("__Name__"),
					Value: ptr.String("__Value__"),
					Type:  types.EnvironmentVariableType("PLAINTEXT"),
				},
				{
					Name:  ptr.String("__Name__"),
					Value: ptr.String("__Value__"),
					Type:  types.EnvironmentVariableType("PLAINTEXT"),
				},
			},
			PrivilegedMode: ptr.Bool(true),
			Certificate:    ptr.String("__Certificate__"),
			RegistryCredential: &types.RegistryCredential{
				Credential:         ptr.String("__Credential__"),
				CredentialProvider: types.CredentialProviderType("SECRETS_MANAGER"),
			},
			ImagePullCredentialsType: types.ImagePullCredentialsType("CODEBUILD"),
			DockerServer: &types.DockerServer{
				ComputeType: types.ComputeType("BUILD_GENERAL1_SMALL"),
				SecurityGroupIds: []string{
					"__Member__",
					"__Member__",
				},
				Status: &types.DockerServerStatus{
					Status:  ptr.String("__Status__"),
					Message: ptr.String("__Message__"),
				},
			},
			HostKernel: types.HostKernel("LINUX_KERNEL_4"),
		},
		ServiceRole:            ptr.String("__ServiceRole__"),
		TimeoutInMinutes:       ptr.Int32(1),
		QueuedTimeoutInMinutes: ptr.Int32(1),
		EncryptionKey:          ptr.String("__EncryptionKey__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		VpcConfig: &types.VpcConfig{
			VpcId: ptr.String("__VpcId__"),
			Subnets: []string{
				"__Member__",
				"__Member__",
			},
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
		},
		BadgeEnabled: ptr.Bool(true),
		LogsConfig: &types.LogsConfig{
			CloudWatchLogs: &types.CloudWatchLogsConfig{
				Status:     types.LogsConfigStatusType("ENABLED"),
				GroupName:  ptr.String("__GroupName__"),
				StreamName: ptr.String("__StreamName__"),
			},
			S3Logs: &types.S3LogsConfig{
				Status:             types.LogsConfigStatusType("ENABLED"),
				Location:           ptr.String("__Location__"),
				EncryptionDisabled: ptr.Bool(true),
				BucketOwnerAccess:  types.BucketOwnerAccess("NONE"),
			},
		},
		FileSystemLocations: []types.ProjectFileSystemLocation{
			{
				Type:         types.FileSystemType("EFS"),
				Location:     ptr.String("__Location__"),
				MountPoint:   ptr.String("__MountPoint__"),
				Identifier:   ptr.String("__Identifier__"),
				MountOptions: ptr.String("__MountOptions__"),
			},
			{
				Type:         types.FileSystemType("EFS"),
				Location:     ptr.String("__Location__"),
				MountPoint:   ptr.String("__MountPoint__"),
				Identifier:   ptr.String("__Identifier__"),
				MountOptions: ptr.String("__MountOptions__"),
			},
		},
		BuildBatchConfig: &types.ProjectBuildBatchConfig{
			ServiceRole:      ptr.String("__ServiceRole__"),
			CombineArtifacts: ptr.Bool(true),
			Restrictions: &types.BatchRestrictions{
				MaximumBuildsAllowed: ptr.Int32(1),
				ComputeTypesAllowed: []string{
					"__Member__",
					"__Member__",
				},
				FleetsAllowed: []string{
					"__Member__",
					"__Member__",
				},
			},
			TimeoutInMins:   ptr.Int32(1),
			BatchReportMode: types.BatchReportModeType("REPORT_INDIVIDUAL_BUILDS"),
		},
		ConcurrentBuildLimit: ptr.Int32(1),
		AutoRetryLimit:       ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateProject(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateProject"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateReportGroup(t *testing.T) {
	input := &CreateReportGroupInput{
		Name: ptr.String("__Name__"),
		Type: types.ReportType("TEST"),
		ExportConfig: &types.ReportExportConfig{
			ExportConfigType: types.ReportExportConfigType("S3"),
			S3Destination: &types.S3ReportExportConfig{
				Bucket:             ptr.String("__Bucket__"),
				BucketOwner:        ptr.String("__BucketOwner__"),
				Path:               ptr.String("__Path__"),
				Packaging:          types.ReportPackagingType("ZIP"),
				EncryptionKey:      ptr.String("__EncryptionKey__"),
				EncryptionDisabled: ptr.Bool(true),
			},
		},
		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.CreateReportGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateReportGroup"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateWebhook(t *testing.T) {
	input := &CreateWebhookInput{
		ProjectName:  ptr.String("__ProjectName__"),
		BranchFilter: ptr.String("__BranchFilter__"),
		FilterGroups: [][]types.WebhookFilter{
			{
				{
					Type:                  types.WebhookFilterType("EVENT"),
					Pattern:               ptr.String("__Pattern__"),
					ExcludeMatchedPattern: ptr.Bool(true),
				},
				{
					Type:                  types.WebhookFilterType("EVENT"),
					Pattern:               ptr.String("__Pattern__"),
					ExcludeMatchedPattern: ptr.Bool(true),
				},
			},
			{
				{
					Type:                  types.WebhookFilterType("EVENT"),
					Pattern:               ptr.String("__Pattern__"),
					ExcludeMatchedPattern: ptr.Bool(true),
				},
				{
					Type:                  types.WebhookFilterType("EVENT"),
					Pattern:               ptr.String("__Pattern__"),
					ExcludeMatchedPattern: ptr.Bool(true),
				},
			},
		},
		BuildType:      types.WebhookBuildType("BUILD"),
		ManualCreation: ptr.Bool(true),
		ScopeConfiguration: &types.ScopeConfiguration{
			Name:   ptr.String("__Name__"),
			Domain: ptr.String("__Domain__"),
			Scope:  types.WebhookScopeType("GITHUB_ORGANIZATION"),
		},
		PullRequestBuildPolicy: &types.PullRequestBuildPolicy{
			RequiresCommentApproval: types.PullRequestBuildCommentApproval("DISABLED"),
			ApproverRoles: []types.PullRequestBuildApproverRole{
				types.PullRequestBuildApproverRole("GITHUB_READ"),
				types.PullRequestBuildApproverRole("GITHUB_READ"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateWebhook(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateWebhook"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

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

func TestCheckRequestSnapshot_DescribeCodeCoverages(t *testing.T) {
	input := &DescribeCodeCoveragesInput{
		ReportArn:                 ptr.String("__ReportArn__"),
		NextToken:                 ptr.String("__NextToken__"),
		MaxResults:                ptr.Int32(1),
		SortOrder:                 types.SortOrderType("ASCENDING"),
		SortBy:                    types.ReportCodeCoverageSortByType("LINE_COVERAGE_PERCENTAGE"),
		MinLineCoveragePercentage: ptr.Float64(1.0),
		MaxLineCoveragePercentage: ptr.Float64(1.0),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeCodeCoverages(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DescribeCodeCoverages"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeTestCases(t *testing.T) {
	input := &DescribeTestCasesInput{
		ReportArn:  ptr.String("__ReportArn__"),
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
		Filter: &types.TestCaseFilter{
			Status:  ptr.String("__Status__"),
			Keyword: ptr.String("__Keyword__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeTestCases(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DescribeTestCases"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_GetReportGroupTrend(t *testing.T) {
	input := &GetReportGroupTrendInput{
		ReportGroupArn: ptr.String("__ReportGroupArn__"),
		NumOfReports:   ptr.Int32(1),
		TrendField:     types.ReportGroupTrendFieldType("PASS_RATE"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetReportGroupTrend(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetReportGroupTrend"); err != nil {
		t.Fatal(err)
	}
}

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

func TestCheckRequestSnapshot_ImportSourceCredentials(t *testing.T) {
	input := &ImportSourceCredentialsInput{
		Username:        ptr.String("__Username__"),
		Token:           ptr.String("__Token__"),
		ServerType:      types.ServerType("GITHUB"),
		AuthType:        types.AuthType("OAUTH"),
		ShouldOverwrite: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ImportSourceCredentials(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ImportSourceCredentials"); err != nil {
		t.Fatal(err)
	}
}

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

func TestCheckRequestSnapshot_ListBuildBatches(t *testing.T) {
	input := &ListBuildBatchesInput{
		Filter: &types.BuildBatchFilter{
			Status: types.StatusType("SUCCEEDED"),
		},
		MaxResults: ptr.Int32(1),
		SortOrder:  types.SortOrderType("ASCENDING"),
		NextToken:  ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBuildBatches(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListBuildBatches"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListBuildBatchesForProject(t *testing.T) {
	input := &ListBuildBatchesForProjectInput{
		ProjectName: ptr.String("__ProjectName__"),
		Filter: &types.BuildBatchFilter{
			Status: types.StatusType("SUCCEEDED"),
		},
		MaxResults: ptr.Int32(1),
		SortOrder:  types.SortOrderType("ASCENDING"),
		NextToken:  ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBuildBatchesForProject(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListBuildBatchesForProject"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

func TestCheckRequestSnapshot_ListReports(t *testing.T) {
	input := &ListReportsInput{
		SortOrder:  types.SortOrderType("ASCENDING"),
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
		Filter: &types.ReportFilter{
			Status: types.ReportStatusType("GENERATING"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListReports(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListReports"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListReportsForReportGroup(t *testing.T) {
	input := &ListReportsForReportGroupInput{
		ReportGroupArn: ptr.String("__ReportGroupArn__"),
		NextToken:      ptr.String("__NextToken__"),
		SortOrder:      types.SortOrderType("ASCENDING"),
		MaxResults:     ptr.Int32(1),
		Filter: &types.ReportFilter{
			Status: types.ReportStatusType("GENERATING"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListReportsForReportGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListReportsForReportGroup"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

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

func TestCheckRequestSnapshot_StartBuild(t *testing.T) {
	input := &StartBuildInput{
		ProjectName: ptr.String("__ProjectName__"),
		SecondarySourcesOverride: []types.ProjectSource{
			{
				Type:          types.SourceType("CODECOMMIT"),
				Location:      ptr.String("__Location__"),
				GitCloneDepth: ptr.Int32(1),
				GitSubmodulesConfig: &types.GitSubmodulesConfig{
					FetchSubmodules: ptr.Bool(true),
				},
				Buildspec: ptr.String("__Buildspec__"),
				Auth: &types.SourceAuth{
					Type:     types.SourceAuthType("OAUTH"),
					Resource: ptr.String("__Resource__"),
				},
				ReportBuildStatus: ptr.Bool(true),
				BuildStatusConfig: &types.BuildStatusConfig{
					Context:   ptr.String("__Context__"),
					TargetUrl: ptr.String("__TargetUrl__"),
				},
				InsecureSsl:      ptr.Bool(true),
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
			},
			{
				Type:          types.SourceType("CODECOMMIT"),
				Location:      ptr.String("__Location__"),
				GitCloneDepth: ptr.Int32(1),
				GitSubmodulesConfig: &types.GitSubmodulesConfig{
					FetchSubmodules: ptr.Bool(true),
				},
				Buildspec: ptr.String("__Buildspec__"),
				Auth: &types.SourceAuth{
					Type:     types.SourceAuthType("OAUTH"),
					Resource: ptr.String("__Resource__"),
				},
				ReportBuildStatus: ptr.Bool(true),
				BuildStatusConfig: &types.BuildStatusConfig{
					Context:   ptr.String("__Context__"),
					TargetUrl: ptr.String("__TargetUrl__"),
				},
				InsecureSsl:      ptr.Bool(true),
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
			},
		},
		SecondarySourcesVersionOverride: []types.ProjectSourceVersion{
			{
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
				SourceVersion:    ptr.String("__SourceVersion__"),
			},
			{
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
				SourceVersion:    ptr.String("__SourceVersion__"),
			},
		},
		SourceVersion: ptr.String("__SourceVersion__"),
		ArtifactsOverride: &types.ProjectArtifacts{
			Type:                 types.ArtifactsType("CODEPIPELINE"),
			Location:             ptr.String("__Location__"),
			Path:                 ptr.String("__Path__"),
			NamespaceType:        types.ArtifactNamespace("NONE"),
			Name:                 ptr.String("__Name__"),
			Packaging:            types.ArtifactPackaging("NONE"),
			OverrideArtifactName: ptr.Bool(true),
			EncryptionDisabled:   ptr.Bool(true),
			ArtifactIdentifier:   ptr.String("__ArtifactIdentifier__"),
			BucketOwnerAccess:    types.BucketOwnerAccess("NONE"),
		},
		SecondaryArtifactsOverride: []types.ProjectArtifacts{
			{
				Type:                 types.ArtifactsType("CODEPIPELINE"),
				Location:             ptr.String("__Location__"),
				Path:                 ptr.String("__Path__"),
				NamespaceType:        types.ArtifactNamespace("NONE"),
				Name:                 ptr.String("__Name__"),
				Packaging:            types.ArtifactPackaging("NONE"),
				OverrideArtifactName: ptr.Bool(true),
				EncryptionDisabled:   ptr.Bool(true),
				ArtifactIdentifier:   ptr.String("__ArtifactIdentifier__"),
				BucketOwnerAccess:    types.BucketOwnerAccess("NONE"),
			},
			{
				Type:                 types.ArtifactsType("CODEPIPELINE"),
				Location:             ptr.String("__Location__"),
				Path:                 ptr.String("__Path__"),
				NamespaceType:        types.ArtifactNamespace("NONE"),
				Name:                 ptr.String("__Name__"),
				Packaging:            types.ArtifactPackaging("NONE"),
				OverrideArtifactName: ptr.Bool(true),
				EncryptionDisabled:   ptr.Bool(true),
				ArtifactIdentifier:   ptr.String("__ArtifactIdentifier__"),
				BucketOwnerAccess:    types.BucketOwnerAccess("NONE"),
			},
		},
		EnvironmentVariablesOverride: []types.EnvironmentVariable{
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
				Type:  types.EnvironmentVariableType("PLAINTEXT"),
			},
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
				Type:  types.EnvironmentVariableType("PLAINTEXT"),
			},
		},
		SourceTypeOverride:     types.SourceType("CODECOMMIT"),
		SourceLocationOverride: ptr.String("__SourceLocationOverride__"),
		SourceAuthOverride: &types.SourceAuth{
			Type:     types.SourceAuthType("OAUTH"),
			Resource: ptr.String("__Resource__"),
		},
		GitCloneDepthOverride: ptr.Int32(1),
		GitSubmodulesConfigOverride: &types.GitSubmodulesConfig{
			FetchSubmodules: ptr.Bool(true),
		},
		BuildspecOverride:         ptr.String("__BuildspecOverride__"),
		InsecureSslOverride:       ptr.Bool(true),
		ReportBuildStatusOverride: ptr.Bool(true),
		BuildStatusConfigOverride: &types.BuildStatusConfig{
			Context:   ptr.String("__Context__"),
			TargetUrl: ptr.String("__TargetUrl__"),
		},
		EnvironmentTypeOverride: types.EnvironmentType("WINDOWS_CONTAINER"),
		ImageOverride:           ptr.String("__ImageOverride__"),
		ComputeTypeOverride:     types.ComputeType("BUILD_GENERAL1_SMALL"),
		CertificateOverride:     ptr.String("__CertificateOverride__"),
		CacheOverride: &types.ProjectCache{
			Type:     types.CacheType("NO_CACHE"),
			Location: ptr.String("__Location__"),
			Modes: []types.CacheMode{
				types.CacheMode("LOCAL_DOCKER_LAYER_CACHE"),
				types.CacheMode("LOCAL_DOCKER_LAYER_CACHE"),
			},
			CacheNamespace: ptr.String("__CacheNamespace__"),
		},
		ServiceRoleOverride:            ptr.String("__ServiceRoleOverride__"),
		PrivilegedModeOverride:         ptr.Bool(true),
		TimeoutInMinutesOverride:       ptr.Int32(1),
		QueuedTimeoutInMinutesOverride: ptr.Int32(1),
		EncryptionKeyOverride:          ptr.String("__EncryptionKeyOverride__"),
		IdempotencyToken:               ptr.String("__IdempotencyToken__"),
		LogsConfigOverride: &types.LogsConfig{
			CloudWatchLogs: &types.CloudWatchLogsConfig{
				Status:     types.LogsConfigStatusType("ENABLED"),
				GroupName:  ptr.String("__GroupName__"),
				StreamName: ptr.String("__StreamName__"),
			},
			S3Logs: &types.S3LogsConfig{
				Status:             types.LogsConfigStatusType("ENABLED"),
				Location:           ptr.String("__Location__"),
				EncryptionDisabled: ptr.Bool(true),
				BucketOwnerAccess:  types.BucketOwnerAccess("NONE"),
			},
		},
		RegistryCredentialOverride: &types.RegistryCredential{
			Credential:         ptr.String("__Credential__"),
			CredentialProvider: types.CredentialProviderType("SECRETS_MANAGER"),
		},
		ImagePullCredentialsTypeOverride: types.ImagePullCredentialsType("CODEBUILD"),
		DebugSessionEnabled:              ptr.Bool(true),
		FleetOverride: &types.ProjectFleet{
			FleetArn: ptr.String("__FleetArn__"),
		},
		AutoRetryLimitOverride: ptr.Int32(1),
		HostKernelOverride:     types.HostKernel("LINUX_KERNEL_4"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartBuild(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "StartBuild"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_StartBuildBatch(t *testing.T) {
	input := &StartBuildBatchInput{
		ProjectName: ptr.String("__ProjectName__"),
		SecondarySourcesOverride: []types.ProjectSource{
			{
				Type:          types.SourceType("CODECOMMIT"),
				Location:      ptr.String("__Location__"),
				GitCloneDepth: ptr.Int32(1),
				GitSubmodulesConfig: &types.GitSubmodulesConfig{
					FetchSubmodules: ptr.Bool(true),
				},
				Buildspec: ptr.String("__Buildspec__"),
				Auth: &types.SourceAuth{
					Type:     types.SourceAuthType("OAUTH"),
					Resource: ptr.String("__Resource__"),
				},
				ReportBuildStatus: ptr.Bool(true),
				BuildStatusConfig: &types.BuildStatusConfig{
					Context:   ptr.String("__Context__"),
					TargetUrl: ptr.String("__TargetUrl__"),
				},
				InsecureSsl:      ptr.Bool(true),
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
			},
			{
				Type:          types.SourceType("CODECOMMIT"),
				Location:      ptr.String("__Location__"),
				GitCloneDepth: ptr.Int32(1),
				GitSubmodulesConfig: &types.GitSubmodulesConfig{
					FetchSubmodules: ptr.Bool(true),
				},
				Buildspec: ptr.String("__Buildspec__"),
				Auth: &types.SourceAuth{
					Type:     types.SourceAuthType("OAUTH"),
					Resource: ptr.String("__Resource__"),
				},
				ReportBuildStatus: ptr.Bool(true),
				BuildStatusConfig: &types.BuildStatusConfig{
					Context:   ptr.String("__Context__"),
					TargetUrl: ptr.String("__TargetUrl__"),
				},
				InsecureSsl:      ptr.Bool(true),
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
			},
		},
		SecondarySourcesVersionOverride: []types.ProjectSourceVersion{
			{
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
				SourceVersion:    ptr.String("__SourceVersion__"),
			},
			{
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
				SourceVersion:    ptr.String("__SourceVersion__"),
			},
		},
		SourceVersion: ptr.String("__SourceVersion__"),
		ArtifactsOverride: &types.ProjectArtifacts{
			Type:                 types.ArtifactsType("CODEPIPELINE"),
			Location:             ptr.String("__Location__"),
			Path:                 ptr.String("__Path__"),
			NamespaceType:        types.ArtifactNamespace("NONE"),
			Name:                 ptr.String("__Name__"),
			Packaging:            types.ArtifactPackaging("NONE"),
			OverrideArtifactName: ptr.Bool(true),
			EncryptionDisabled:   ptr.Bool(true),
			ArtifactIdentifier:   ptr.String("__ArtifactIdentifier__"),
			BucketOwnerAccess:    types.BucketOwnerAccess("NONE"),
		},
		SecondaryArtifactsOverride: []types.ProjectArtifacts{
			{
				Type:                 types.ArtifactsType("CODEPIPELINE"),
				Location:             ptr.String("__Location__"),
				Path:                 ptr.String("__Path__"),
				NamespaceType:        types.ArtifactNamespace("NONE"),
				Name:                 ptr.String("__Name__"),
				Packaging:            types.ArtifactPackaging("NONE"),
				OverrideArtifactName: ptr.Bool(true),
				EncryptionDisabled:   ptr.Bool(true),
				ArtifactIdentifier:   ptr.String("__ArtifactIdentifier__"),
				BucketOwnerAccess:    types.BucketOwnerAccess("NONE"),
			},
			{
				Type:                 types.ArtifactsType("CODEPIPELINE"),
				Location:             ptr.String("__Location__"),
				Path:                 ptr.String("__Path__"),
				NamespaceType:        types.ArtifactNamespace("NONE"),
				Name:                 ptr.String("__Name__"),
				Packaging:            types.ArtifactPackaging("NONE"),
				OverrideArtifactName: ptr.Bool(true),
				EncryptionDisabled:   ptr.Bool(true),
				ArtifactIdentifier:   ptr.String("__ArtifactIdentifier__"),
				BucketOwnerAccess:    types.BucketOwnerAccess("NONE"),
			},
		},
		EnvironmentVariablesOverride: []types.EnvironmentVariable{
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
				Type:  types.EnvironmentVariableType("PLAINTEXT"),
			},
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
				Type:  types.EnvironmentVariableType("PLAINTEXT"),
			},
		},
		SourceTypeOverride:     types.SourceType("CODECOMMIT"),
		SourceLocationOverride: ptr.String("__SourceLocationOverride__"),
		SourceAuthOverride: &types.SourceAuth{
			Type:     types.SourceAuthType("OAUTH"),
			Resource: ptr.String("__Resource__"),
		},
		GitCloneDepthOverride: ptr.Int32(1),
		GitSubmodulesConfigOverride: &types.GitSubmodulesConfig{
			FetchSubmodules: ptr.Bool(true),
		},
		BuildspecOverride:              ptr.String("__BuildspecOverride__"),
		InsecureSslOverride:            ptr.Bool(true),
		ReportBuildBatchStatusOverride: ptr.Bool(true),
		EnvironmentTypeOverride:        types.EnvironmentType("WINDOWS_CONTAINER"),
		ImageOverride:                  ptr.String("__ImageOverride__"),
		ComputeTypeOverride:            types.ComputeType("BUILD_GENERAL1_SMALL"),
		CertificateOverride:            ptr.String("__CertificateOverride__"),
		CacheOverride: &types.ProjectCache{
			Type:     types.CacheType("NO_CACHE"),
			Location: ptr.String("__Location__"),
			Modes: []types.CacheMode{
				types.CacheMode("LOCAL_DOCKER_LAYER_CACHE"),
				types.CacheMode("LOCAL_DOCKER_LAYER_CACHE"),
			},
			CacheNamespace: ptr.String("__CacheNamespace__"),
		},
		ServiceRoleOverride:            ptr.String("__ServiceRoleOverride__"),
		PrivilegedModeOverride:         ptr.Bool(true),
		BuildTimeoutInMinutesOverride:  ptr.Int32(1),
		QueuedTimeoutInMinutesOverride: ptr.Int32(1),
		EncryptionKeyOverride:          ptr.String("__EncryptionKeyOverride__"),
		IdempotencyToken:               ptr.String("__IdempotencyToken__"),
		LogsConfigOverride: &types.LogsConfig{
			CloudWatchLogs: &types.CloudWatchLogsConfig{
				Status:     types.LogsConfigStatusType("ENABLED"),
				GroupName:  ptr.String("__GroupName__"),
				StreamName: ptr.String("__StreamName__"),
			},
			S3Logs: &types.S3LogsConfig{
				Status:             types.LogsConfigStatusType("ENABLED"),
				Location:           ptr.String("__Location__"),
				EncryptionDisabled: ptr.Bool(true),
				BucketOwnerAccess:  types.BucketOwnerAccess("NONE"),
			},
		},
		RegistryCredentialOverride: &types.RegistryCredential{
			Credential:         ptr.String("__Credential__"),
			CredentialProvider: types.CredentialProviderType("SECRETS_MANAGER"),
		},
		ImagePullCredentialsTypeOverride: types.ImagePullCredentialsType("CODEBUILD"),
		BuildBatchConfigOverride: &types.ProjectBuildBatchConfig{
			ServiceRole:      ptr.String("__ServiceRole__"),
			CombineArtifacts: ptr.Bool(true),
			Restrictions: &types.BatchRestrictions{
				MaximumBuildsAllowed: ptr.Int32(1),
				ComputeTypesAllowed: []string{
					"__Member__",
					"__Member__",
				},
				FleetsAllowed: []string{
					"__Member__",
					"__Member__",
				},
			},
			TimeoutInMins:   ptr.Int32(1),
			BatchReportMode: types.BatchReportModeType("REPORT_INDIVIDUAL_BUILDS"),
		},
		DebugSessionEnabled: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartBuildBatch(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "StartBuildBatch"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

func TestCheckRequestSnapshot_UpdateFleet(t *testing.T) {
	input := &UpdateFleetInput{
		Arn:             ptr.String("__Arn__"),
		BaseCapacity:    ptr.Int32(1),
		EnvironmentType: types.EnvironmentType("WINDOWS_CONTAINER"),
		ComputeType:     types.ComputeType("BUILD_GENERAL1_SMALL"),
		ComputeConfiguration: &types.ComputeConfiguration{
			VCpu:         ptr.Int64(1),
			Memory:       ptr.Int64(1),
			Disk:         ptr.Int64(1),
			MachineType:  types.MachineType("GENERAL"),
			InstanceType: ptr.String("__InstanceType__"),
		},
		ScalingConfiguration: &types.ScalingConfigurationInput{
			ScalingType: types.FleetScalingType("TARGET_TRACKING_SCALING"),
			TargetTrackingScalingConfigs: []types.TargetTrackingScalingConfiguration{
				{
					MetricType:  types.FleetScalingMetricType("FLEET_UTILIZATION_RATE"),
					TargetValue: ptr.Float64(1.0),
				},
				{
					MetricType:  types.FleetScalingMetricType("FLEET_UTILIZATION_RATE"),
					TargetValue: ptr.Float64(1.0),
				},
			},
			MaxCapacity: ptr.Int32(1),
		},
		OverflowBehavior: types.FleetOverflowBehavior("QUEUE"),
		VpcConfig: &types.VpcConfig{
			VpcId: ptr.String("__VpcId__"),
			Subnets: []string{
				"__Member__",
				"__Member__",
			},
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
		},
		ProxyConfiguration: &types.ProxyConfiguration{
			DefaultBehavior: types.FleetProxyRuleBehavior("ALLOW_ALL"),
			OrderedProxyRules: []types.FleetProxyRule{
				{
					Type:   types.FleetProxyRuleType("DOMAIN"),
					Effect: types.FleetProxyRuleEffectType("ALLOW"),
					Entities: []string{
						"__Member__",
						"__Member__",
					},
				},
				{
					Type:   types.FleetProxyRuleType("DOMAIN"),
					Effect: types.FleetProxyRuleEffectType("ALLOW"),
					Entities: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
		},
		ImageId:          ptr.String("__ImageId__"),
		FleetServiceRole: ptr.String("__FleetServiceRole__"),
		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.UpdateFleet(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UpdateFleet"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateProject(t *testing.T) {
	input := &UpdateProjectInput{
		Name:        ptr.String("__Name__"),
		Description: ptr.String("__Description__"),
		Source: &types.ProjectSource{
			Type:          types.SourceType("CODECOMMIT"),
			Location:      ptr.String("__Location__"),
			GitCloneDepth: ptr.Int32(1),
			GitSubmodulesConfig: &types.GitSubmodulesConfig{
				FetchSubmodules: ptr.Bool(true),
			},
			Buildspec: ptr.String("__Buildspec__"),
			Auth: &types.SourceAuth{
				Type:     types.SourceAuthType("OAUTH"),
				Resource: ptr.String("__Resource__"),
			},
			ReportBuildStatus: ptr.Bool(true),
			BuildStatusConfig: &types.BuildStatusConfig{
				Context:   ptr.String("__Context__"),
				TargetUrl: ptr.String("__TargetUrl__"),
			},
			InsecureSsl:      ptr.Bool(true),
			SourceIdentifier: ptr.String("__SourceIdentifier__"),
		},
		SecondarySources: []types.ProjectSource{
			{
				Type:          types.SourceType("CODECOMMIT"),
				Location:      ptr.String("__Location__"),
				GitCloneDepth: ptr.Int32(1),
				GitSubmodulesConfig: &types.GitSubmodulesConfig{
					FetchSubmodules: ptr.Bool(true),
				},
				Buildspec: ptr.String("__Buildspec__"),
				Auth: &types.SourceAuth{
					Type:     types.SourceAuthType("OAUTH"),
					Resource: ptr.String("__Resource__"),
				},
				ReportBuildStatus: ptr.Bool(true),
				BuildStatusConfig: &types.BuildStatusConfig{
					Context:   ptr.String("__Context__"),
					TargetUrl: ptr.String("__TargetUrl__"),
				},
				InsecureSsl:      ptr.Bool(true),
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
			},
			{
				Type:          types.SourceType("CODECOMMIT"),
				Location:      ptr.String("__Location__"),
				GitCloneDepth: ptr.Int32(1),
				GitSubmodulesConfig: &types.GitSubmodulesConfig{
					FetchSubmodules: ptr.Bool(true),
				},
				Buildspec: ptr.String("__Buildspec__"),
				Auth: &types.SourceAuth{
					Type:     types.SourceAuthType("OAUTH"),
					Resource: ptr.String("__Resource__"),
				},
				ReportBuildStatus: ptr.Bool(true),
				BuildStatusConfig: &types.BuildStatusConfig{
					Context:   ptr.String("__Context__"),
					TargetUrl: ptr.String("__TargetUrl__"),
				},
				InsecureSsl:      ptr.Bool(true),
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
			},
		},
		SourceVersion: ptr.String("__SourceVersion__"),
		SecondarySourceVersions: []types.ProjectSourceVersion{
			{
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
				SourceVersion:    ptr.String("__SourceVersion__"),
			},
			{
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
				SourceVersion:    ptr.String("__SourceVersion__"),
			},
		},
		Artifacts: &types.ProjectArtifacts{
			Type:                 types.ArtifactsType("CODEPIPELINE"),
			Location:             ptr.String("__Location__"),
			Path:                 ptr.String("__Path__"),
			NamespaceType:        types.ArtifactNamespace("NONE"),
			Name:                 ptr.String("__Name__"),
			Packaging:            types.ArtifactPackaging("NONE"),
			OverrideArtifactName: ptr.Bool(true),
			EncryptionDisabled:   ptr.Bool(true),
			ArtifactIdentifier:   ptr.String("__ArtifactIdentifier__"),
			BucketOwnerAccess:    types.BucketOwnerAccess("NONE"),
		},
		SecondaryArtifacts: []types.ProjectArtifacts{
			{
				Type:                 types.ArtifactsType("CODEPIPELINE"),
				Location:             ptr.String("__Location__"),
				Path:                 ptr.String("__Path__"),
				NamespaceType:        types.ArtifactNamespace("NONE"),
				Name:                 ptr.String("__Name__"),
				Packaging:            types.ArtifactPackaging("NONE"),
				OverrideArtifactName: ptr.Bool(true),
				EncryptionDisabled:   ptr.Bool(true),
				ArtifactIdentifier:   ptr.String("__ArtifactIdentifier__"),
				BucketOwnerAccess:    types.BucketOwnerAccess("NONE"),
			},
			{
				Type:                 types.ArtifactsType("CODEPIPELINE"),
				Location:             ptr.String("__Location__"),
				Path:                 ptr.String("__Path__"),
				NamespaceType:        types.ArtifactNamespace("NONE"),
				Name:                 ptr.String("__Name__"),
				Packaging:            types.ArtifactPackaging("NONE"),
				OverrideArtifactName: ptr.Bool(true),
				EncryptionDisabled:   ptr.Bool(true),
				ArtifactIdentifier:   ptr.String("__ArtifactIdentifier__"),
				BucketOwnerAccess:    types.BucketOwnerAccess("NONE"),
			},
		},
		Cache: &types.ProjectCache{
			Type:     types.CacheType("NO_CACHE"),
			Location: ptr.String("__Location__"),
			Modes: []types.CacheMode{
				types.CacheMode("LOCAL_DOCKER_LAYER_CACHE"),
				types.CacheMode("LOCAL_DOCKER_LAYER_CACHE"),
			},
			CacheNamespace: ptr.String("__CacheNamespace__"),
		},
		Environment: &types.ProjectEnvironment{
			Type:        types.EnvironmentType("WINDOWS_CONTAINER"),
			Image:       ptr.String("__Image__"),
			ComputeType: types.ComputeType("BUILD_GENERAL1_SMALL"),
			ComputeConfiguration: &types.ComputeConfiguration{
				VCpu:         ptr.Int64(1),
				Memory:       ptr.Int64(1),
				Disk:         ptr.Int64(1),
				MachineType:  types.MachineType("GENERAL"),
				InstanceType: ptr.String("__InstanceType__"),
			},
			Fleet: &types.ProjectFleet{
				FleetArn: ptr.String("__FleetArn__"),
			},
			EnvironmentVariables: []types.EnvironmentVariable{
				{
					Name:  ptr.String("__Name__"),
					Value: ptr.String("__Value__"),
					Type:  types.EnvironmentVariableType("PLAINTEXT"),
				},
				{
					Name:  ptr.String("__Name__"),
					Value: ptr.String("__Value__"),
					Type:  types.EnvironmentVariableType("PLAINTEXT"),
				},
			},
			PrivilegedMode: ptr.Bool(true),
			Certificate:    ptr.String("__Certificate__"),
			RegistryCredential: &types.RegistryCredential{
				Credential:         ptr.String("__Credential__"),
				CredentialProvider: types.CredentialProviderType("SECRETS_MANAGER"),
			},
			ImagePullCredentialsType: types.ImagePullCredentialsType("CODEBUILD"),
			DockerServer: &types.DockerServer{
				ComputeType: types.ComputeType("BUILD_GENERAL1_SMALL"),
				SecurityGroupIds: []string{
					"__Member__",
					"__Member__",
				},
				Status: &types.DockerServerStatus{
					Status:  ptr.String("__Status__"),
					Message: ptr.String("__Message__"),
				},
			},
			HostKernel: types.HostKernel("LINUX_KERNEL_4"),
		},
		ServiceRole:            ptr.String("__ServiceRole__"),
		TimeoutInMinutes:       ptr.Int32(1),
		QueuedTimeoutInMinutes: ptr.Int32(1),
		EncryptionKey:          ptr.String("__EncryptionKey__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		VpcConfig: &types.VpcConfig{
			VpcId: ptr.String("__VpcId__"),
			Subnets: []string{
				"__Member__",
				"__Member__",
			},
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
		},
		BadgeEnabled: ptr.Bool(true),
		LogsConfig: &types.LogsConfig{
			CloudWatchLogs: &types.CloudWatchLogsConfig{
				Status:     types.LogsConfigStatusType("ENABLED"),
				GroupName:  ptr.String("__GroupName__"),
				StreamName: ptr.String("__StreamName__"),
			},
			S3Logs: &types.S3LogsConfig{
				Status:             types.LogsConfigStatusType("ENABLED"),
				Location:           ptr.String("__Location__"),
				EncryptionDisabled: ptr.Bool(true),
				BucketOwnerAccess:  types.BucketOwnerAccess("NONE"),
			},
		},
		FileSystemLocations: []types.ProjectFileSystemLocation{
			{
				Type:         types.FileSystemType("EFS"),
				Location:     ptr.String("__Location__"),
				MountPoint:   ptr.String("__MountPoint__"),
				Identifier:   ptr.String("__Identifier__"),
				MountOptions: ptr.String("__MountOptions__"),
			},
			{
				Type:         types.FileSystemType("EFS"),
				Location:     ptr.String("__Location__"),
				MountPoint:   ptr.String("__MountPoint__"),
				Identifier:   ptr.String("__Identifier__"),
				MountOptions: ptr.String("__MountOptions__"),
			},
		},
		BuildBatchConfig: &types.ProjectBuildBatchConfig{
			ServiceRole:      ptr.String("__ServiceRole__"),
			CombineArtifacts: ptr.Bool(true),
			Restrictions: &types.BatchRestrictions{
				MaximumBuildsAllowed: ptr.Int32(1),
				ComputeTypesAllowed: []string{
					"__Member__",
					"__Member__",
				},
				FleetsAllowed: []string{
					"__Member__",
					"__Member__",
				},
			},
			TimeoutInMins:   ptr.Int32(1),
			BatchReportMode: types.BatchReportModeType("REPORT_INDIVIDUAL_BUILDS"),
		},
		ConcurrentBuildLimit: ptr.Int32(1),
		AutoRetryLimit:       ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateProject(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UpdateProject"); err != nil {
		t.Fatal(err)
	}
}

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

func TestCheckRequestSnapshot_UpdateReportGroup(t *testing.T) {
	input := &UpdateReportGroupInput{
		Arn: ptr.String("__Arn__"),
		ExportConfig: &types.ReportExportConfig{
			ExportConfigType: types.ReportExportConfigType("S3"),
			S3Destination: &types.S3ReportExportConfig{
				Bucket:             ptr.String("__Bucket__"),
				BucketOwner:        ptr.String("__BucketOwner__"),
				Path:               ptr.String("__Path__"),
				Packaging:          types.ReportPackagingType("ZIP"),
				EncryptionKey:      ptr.String("__EncryptionKey__"),
				EncryptionDisabled: ptr.Bool(true),
			},
		},
		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.UpdateReportGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UpdateReportGroup"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateWebhook(t *testing.T) {
	input := &UpdateWebhookInput{
		ProjectName:  ptr.String("__ProjectName__"),
		BranchFilter: ptr.String("__BranchFilter__"),
		RotateSecret: true,
		FilterGroups: [][]types.WebhookFilter{
			{
				{
					Type:                  types.WebhookFilterType("EVENT"),
					Pattern:               ptr.String("__Pattern__"),
					ExcludeMatchedPattern: ptr.Bool(true),
				},
				{
					Type:                  types.WebhookFilterType("EVENT"),
					Pattern:               ptr.String("__Pattern__"),
					ExcludeMatchedPattern: ptr.Bool(true),
				},
			},
			{
				{
					Type:                  types.WebhookFilterType("EVENT"),
					Pattern:               ptr.String("__Pattern__"),
					ExcludeMatchedPattern: ptr.Bool(true),
				},
				{
					Type:                  types.WebhookFilterType("EVENT"),
					Pattern:               ptr.String("__Pattern__"),
					ExcludeMatchedPattern: ptr.Bool(true),
				},
			},
		},
		BuildType: types.WebhookBuildType("BUILD"),
		PullRequestBuildPolicy: &types.PullRequestBuildPolicy{
			RequiresCommentApproval: types.PullRequestBuildCommentApproval("DISABLED"),
			ApproverRoles: []types.PullRequestBuildApproverRole{
				types.PullRequestBuildApproverRole("GITHUB_READ"),
				types.PullRequestBuildApproverRole("GITHUB_READ"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateWebhook(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UpdateWebhook"); err != nil {
		t.Fatal(err)
	}
}
func TestUpdateRequestSnapshot_BatchDeleteBuilds(t *testing.T) {
	input := &BatchDeleteBuildsInput{
		Ids: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchDeleteBuilds(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "BatchDeleteBuilds"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

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

func TestUpdateRequestSnapshot_CreateFleet(t *testing.T) {
	input := &CreateFleetInput{
		Name:            ptr.String("__Name__"),
		BaseCapacity:    ptr.Int32(1),
		EnvironmentType: types.EnvironmentType("WINDOWS_CONTAINER"),
		ComputeType:     types.ComputeType("BUILD_GENERAL1_SMALL"),
		ComputeConfiguration: &types.ComputeConfiguration{
			VCpu:         ptr.Int64(1),
			Memory:       ptr.Int64(1),
			Disk:         ptr.Int64(1),
			MachineType:  types.MachineType("GENERAL"),
			InstanceType: ptr.String("__InstanceType__"),
		},
		ScalingConfiguration: &types.ScalingConfigurationInput{
			ScalingType: types.FleetScalingType("TARGET_TRACKING_SCALING"),
			TargetTrackingScalingConfigs: []types.TargetTrackingScalingConfiguration{
				{
					MetricType:  types.FleetScalingMetricType("FLEET_UTILIZATION_RATE"),
					TargetValue: ptr.Float64(1.0),
				},
				{
					MetricType:  types.FleetScalingMetricType("FLEET_UTILIZATION_RATE"),
					TargetValue: ptr.Float64(1.0),
				},
			},
			MaxCapacity: ptr.Int32(1),
		},
		OverflowBehavior: types.FleetOverflowBehavior("QUEUE"),
		VpcConfig: &types.VpcConfig{
			VpcId: ptr.String("__VpcId__"),
			Subnets: []string{
				"__Member__",
				"__Member__",
			},
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
		},
		ProxyConfiguration: &types.ProxyConfiguration{
			DefaultBehavior: types.FleetProxyRuleBehavior("ALLOW_ALL"),
			OrderedProxyRules: []types.FleetProxyRule{
				{
					Type:   types.FleetProxyRuleType("DOMAIN"),
					Effect: types.FleetProxyRuleEffectType("ALLOW"),
					Entities: []string{
						"__Member__",
						"__Member__",
					},
				},
				{
					Type:   types.FleetProxyRuleType("DOMAIN"),
					Effect: types.FleetProxyRuleEffectType("ALLOW"),
					Entities: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
		},
		ImageId:          ptr.String("__ImageId__"),
		FleetServiceRole: ptr.String("__FleetServiceRole__"),
		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.CreateFleet(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateFleet"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateProject(t *testing.T) {
	input := &CreateProjectInput{
		Name:        ptr.String("__Name__"),
		Description: ptr.String("__Description__"),
		Source: &types.ProjectSource{
			Type:          types.SourceType("CODECOMMIT"),
			Location:      ptr.String("__Location__"),
			GitCloneDepth: ptr.Int32(1),
			GitSubmodulesConfig: &types.GitSubmodulesConfig{
				FetchSubmodules: ptr.Bool(true),
			},
			Buildspec: ptr.String("__Buildspec__"),
			Auth: &types.SourceAuth{
				Type:     types.SourceAuthType("OAUTH"),
				Resource: ptr.String("__Resource__"),
			},
			ReportBuildStatus: ptr.Bool(true),
			BuildStatusConfig: &types.BuildStatusConfig{
				Context:   ptr.String("__Context__"),
				TargetUrl: ptr.String("__TargetUrl__"),
			},
			InsecureSsl:      ptr.Bool(true),
			SourceIdentifier: ptr.String("__SourceIdentifier__"),
		},
		SecondarySources: []types.ProjectSource{
			{
				Type:          types.SourceType("CODECOMMIT"),
				Location:      ptr.String("__Location__"),
				GitCloneDepth: ptr.Int32(1),
				GitSubmodulesConfig: &types.GitSubmodulesConfig{
					FetchSubmodules: ptr.Bool(true),
				},
				Buildspec: ptr.String("__Buildspec__"),
				Auth: &types.SourceAuth{
					Type:     types.SourceAuthType("OAUTH"),
					Resource: ptr.String("__Resource__"),
				},
				ReportBuildStatus: ptr.Bool(true),
				BuildStatusConfig: &types.BuildStatusConfig{
					Context:   ptr.String("__Context__"),
					TargetUrl: ptr.String("__TargetUrl__"),
				},
				InsecureSsl:      ptr.Bool(true),
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
			},
			{
				Type:          types.SourceType("CODECOMMIT"),
				Location:      ptr.String("__Location__"),
				GitCloneDepth: ptr.Int32(1),
				GitSubmodulesConfig: &types.GitSubmodulesConfig{
					FetchSubmodules: ptr.Bool(true),
				},
				Buildspec: ptr.String("__Buildspec__"),
				Auth: &types.SourceAuth{
					Type:     types.SourceAuthType("OAUTH"),
					Resource: ptr.String("__Resource__"),
				},
				ReportBuildStatus: ptr.Bool(true),
				BuildStatusConfig: &types.BuildStatusConfig{
					Context:   ptr.String("__Context__"),
					TargetUrl: ptr.String("__TargetUrl__"),
				},
				InsecureSsl:      ptr.Bool(true),
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
			},
		},
		SourceVersion: ptr.String("__SourceVersion__"),
		SecondarySourceVersions: []types.ProjectSourceVersion{
			{
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
				SourceVersion:    ptr.String("__SourceVersion__"),
			},
			{
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
				SourceVersion:    ptr.String("__SourceVersion__"),
			},
		},
		Artifacts: &types.ProjectArtifacts{
			Type:                 types.ArtifactsType("CODEPIPELINE"),
			Location:             ptr.String("__Location__"),
			Path:                 ptr.String("__Path__"),
			NamespaceType:        types.ArtifactNamespace("NONE"),
			Name:                 ptr.String("__Name__"),
			Packaging:            types.ArtifactPackaging("NONE"),
			OverrideArtifactName: ptr.Bool(true),
			EncryptionDisabled:   ptr.Bool(true),
			ArtifactIdentifier:   ptr.String("__ArtifactIdentifier__"),
			BucketOwnerAccess:    types.BucketOwnerAccess("NONE"),
		},
		SecondaryArtifacts: []types.ProjectArtifacts{
			{
				Type:                 types.ArtifactsType("CODEPIPELINE"),
				Location:             ptr.String("__Location__"),
				Path:                 ptr.String("__Path__"),
				NamespaceType:        types.ArtifactNamespace("NONE"),
				Name:                 ptr.String("__Name__"),
				Packaging:            types.ArtifactPackaging("NONE"),
				OverrideArtifactName: ptr.Bool(true),
				EncryptionDisabled:   ptr.Bool(true),
				ArtifactIdentifier:   ptr.String("__ArtifactIdentifier__"),
				BucketOwnerAccess:    types.BucketOwnerAccess("NONE"),
			},
			{
				Type:                 types.ArtifactsType("CODEPIPELINE"),
				Location:             ptr.String("__Location__"),
				Path:                 ptr.String("__Path__"),
				NamespaceType:        types.ArtifactNamespace("NONE"),
				Name:                 ptr.String("__Name__"),
				Packaging:            types.ArtifactPackaging("NONE"),
				OverrideArtifactName: ptr.Bool(true),
				EncryptionDisabled:   ptr.Bool(true),
				ArtifactIdentifier:   ptr.String("__ArtifactIdentifier__"),
				BucketOwnerAccess:    types.BucketOwnerAccess("NONE"),
			},
		},
		Cache: &types.ProjectCache{
			Type:     types.CacheType("NO_CACHE"),
			Location: ptr.String("__Location__"),
			Modes: []types.CacheMode{
				types.CacheMode("LOCAL_DOCKER_LAYER_CACHE"),
				types.CacheMode("LOCAL_DOCKER_LAYER_CACHE"),
			},
			CacheNamespace: ptr.String("__CacheNamespace__"),
		},
		Environment: &types.ProjectEnvironment{
			Type:        types.EnvironmentType("WINDOWS_CONTAINER"),
			Image:       ptr.String("__Image__"),
			ComputeType: types.ComputeType("BUILD_GENERAL1_SMALL"),
			ComputeConfiguration: &types.ComputeConfiguration{
				VCpu:         ptr.Int64(1),
				Memory:       ptr.Int64(1),
				Disk:         ptr.Int64(1),
				MachineType:  types.MachineType("GENERAL"),
				InstanceType: ptr.String("__InstanceType__"),
			},
			Fleet: &types.ProjectFleet{
				FleetArn: ptr.String("__FleetArn__"),
			},
			EnvironmentVariables: []types.EnvironmentVariable{
				{
					Name:  ptr.String("__Name__"),
					Value: ptr.String("__Value__"),
					Type:  types.EnvironmentVariableType("PLAINTEXT"),
				},
				{
					Name:  ptr.String("__Name__"),
					Value: ptr.String("__Value__"),
					Type:  types.EnvironmentVariableType("PLAINTEXT"),
				},
			},
			PrivilegedMode: ptr.Bool(true),
			Certificate:    ptr.String("__Certificate__"),
			RegistryCredential: &types.RegistryCredential{
				Credential:         ptr.String("__Credential__"),
				CredentialProvider: types.CredentialProviderType("SECRETS_MANAGER"),
			},
			ImagePullCredentialsType: types.ImagePullCredentialsType("CODEBUILD"),
			DockerServer: &types.DockerServer{
				ComputeType: types.ComputeType("BUILD_GENERAL1_SMALL"),
				SecurityGroupIds: []string{
					"__Member__",
					"__Member__",
				},
				Status: &types.DockerServerStatus{
					Status:  ptr.String("__Status__"),
					Message: ptr.String("__Message__"),
				},
			},
			HostKernel: types.HostKernel("LINUX_KERNEL_4"),
		},
		ServiceRole:            ptr.String("__ServiceRole__"),
		TimeoutInMinutes:       ptr.Int32(1),
		QueuedTimeoutInMinutes: ptr.Int32(1),
		EncryptionKey:          ptr.String("__EncryptionKey__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		VpcConfig: &types.VpcConfig{
			VpcId: ptr.String("__VpcId__"),
			Subnets: []string{
				"__Member__",
				"__Member__",
			},
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
		},
		BadgeEnabled: ptr.Bool(true),
		LogsConfig: &types.LogsConfig{
			CloudWatchLogs: &types.CloudWatchLogsConfig{
				Status:     types.LogsConfigStatusType("ENABLED"),
				GroupName:  ptr.String("__GroupName__"),
				StreamName: ptr.String("__StreamName__"),
			},
			S3Logs: &types.S3LogsConfig{
				Status:             types.LogsConfigStatusType("ENABLED"),
				Location:           ptr.String("__Location__"),
				EncryptionDisabled: ptr.Bool(true),
				BucketOwnerAccess:  types.BucketOwnerAccess("NONE"),
			},
		},
		FileSystemLocations: []types.ProjectFileSystemLocation{
			{
				Type:         types.FileSystemType("EFS"),
				Location:     ptr.String("__Location__"),
				MountPoint:   ptr.String("__MountPoint__"),
				Identifier:   ptr.String("__Identifier__"),
				MountOptions: ptr.String("__MountOptions__"),
			},
			{
				Type:         types.FileSystemType("EFS"),
				Location:     ptr.String("__Location__"),
				MountPoint:   ptr.String("__MountPoint__"),
				Identifier:   ptr.String("__Identifier__"),
				MountOptions: ptr.String("__MountOptions__"),
			},
		},
		BuildBatchConfig: &types.ProjectBuildBatchConfig{
			ServiceRole:      ptr.String("__ServiceRole__"),
			CombineArtifacts: ptr.Bool(true),
			Restrictions: &types.BatchRestrictions{
				MaximumBuildsAllowed: ptr.Int32(1),
				ComputeTypesAllowed: []string{
					"__Member__",
					"__Member__",
				},
				FleetsAllowed: []string{
					"__Member__",
					"__Member__",
				},
			},
			TimeoutInMins:   ptr.Int32(1),
			BatchReportMode: types.BatchReportModeType("REPORT_INDIVIDUAL_BUILDS"),
		},
		ConcurrentBuildLimit: ptr.Int32(1),
		AutoRetryLimit:       ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateProject(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateProject"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateReportGroup(t *testing.T) {
	input := &CreateReportGroupInput{
		Name: ptr.String("__Name__"),
		Type: types.ReportType("TEST"),
		ExportConfig: &types.ReportExportConfig{
			ExportConfigType: types.ReportExportConfigType("S3"),
			S3Destination: &types.S3ReportExportConfig{
				Bucket:             ptr.String("__Bucket__"),
				BucketOwner:        ptr.String("__BucketOwner__"),
				Path:               ptr.String("__Path__"),
				Packaging:          types.ReportPackagingType("ZIP"),
				EncryptionKey:      ptr.String("__EncryptionKey__"),
				EncryptionDisabled: ptr.Bool(true),
			},
		},
		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.CreateReportGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateReportGroup"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateWebhook(t *testing.T) {
	input := &CreateWebhookInput{
		ProjectName:  ptr.String("__ProjectName__"),
		BranchFilter: ptr.String("__BranchFilter__"),
		FilterGroups: [][]types.WebhookFilter{
			{
				{
					Type:                  types.WebhookFilterType("EVENT"),
					Pattern:               ptr.String("__Pattern__"),
					ExcludeMatchedPattern: ptr.Bool(true),
				},
				{
					Type:                  types.WebhookFilterType("EVENT"),
					Pattern:               ptr.String("__Pattern__"),
					ExcludeMatchedPattern: ptr.Bool(true),
				},
			},
			{
				{
					Type:                  types.WebhookFilterType("EVENT"),
					Pattern:               ptr.String("__Pattern__"),
					ExcludeMatchedPattern: ptr.Bool(true),
				},
				{
					Type:                  types.WebhookFilterType("EVENT"),
					Pattern:               ptr.String("__Pattern__"),
					ExcludeMatchedPattern: ptr.Bool(true),
				},
			},
		},
		BuildType:      types.WebhookBuildType("BUILD"),
		ManualCreation: ptr.Bool(true),
		ScopeConfiguration: &types.ScopeConfiguration{
			Name:   ptr.String("__Name__"),
			Domain: ptr.String("__Domain__"),
			Scope:  types.WebhookScopeType("GITHUB_ORGANIZATION"),
		},
		PullRequestBuildPolicy: &types.PullRequestBuildPolicy{
			RequiresCommentApproval: types.PullRequestBuildCommentApproval("DISABLED"),
			ApproverRoles: []types.PullRequestBuildApproverRole{
				types.PullRequestBuildApproverRole("GITHUB_READ"),
				types.PullRequestBuildApproverRole("GITHUB_READ"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateWebhook(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateWebhook"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

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

func TestUpdateRequestSnapshot_DescribeCodeCoverages(t *testing.T) {
	input := &DescribeCodeCoveragesInput{
		ReportArn:                 ptr.String("__ReportArn__"),
		NextToken:                 ptr.String("__NextToken__"),
		MaxResults:                ptr.Int32(1),
		SortOrder:                 types.SortOrderType("ASCENDING"),
		SortBy:                    types.ReportCodeCoverageSortByType("LINE_COVERAGE_PERCENTAGE"),
		MinLineCoveragePercentage: ptr.Float64(1.0),
		MaxLineCoveragePercentage: ptr.Float64(1.0),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeCodeCoverages(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DescribeCodeCoverages"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeTestCases(t *testing.T) {
	input := &DescribeTestCasesInput{
		ReportArn:  ptr.String("__ReportArn__"),
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
		Filter: &types.TestCaseFilter{
			Status:  ptr.String("__Status__"),
			Keyword: ptr.String("__Keyword__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeTestCases(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DescribeTestCases"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_GetReportGroupTrend(t *testing.T) {
	input := &GetReportGroupTrendInput{
		ReportGroupArn: ptr.String("__ReportGroupArn__"),
		NumOfReports:   ptr.Int32(1),
		TrendField:     types.ReportGroupTrendFieldType("PASS_RATE"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetReportGroupTrend(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetReportGroupTrend"); err != nil {
		t.Fatal(err)
	}
}

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

func TestUpdateRequestSnapshot_ImportSourceCredentials(t *testing.T) {
	input := &ImportSourceCredentialsInput{
		Username:        ptr.String("__Username__"),
		Token:           ptr.String("__Token__"),
		ServerType:      types.ServerType("GITHUB"),
		AuthType:        types.AuthType("OAUTH"),
		ShouldOverwrite: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ImportSourceCredentials(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ImportSourceCredentials"); err != nil {
		t.Fatal(err)
	}
}

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

func TestUpdateRequestSnapshot_ListBuildBatches(t *testing.T) {
	input := &ListBuildBatchesInput{
		Filter: &types.BuildBatchFilter{
			Status: types.StatusType("SUCCEEDED"),
		},
		MaxResults: ptr.Int32(1),
		SortOrder:  types.SortOrderType("ASCENDING"),
		NextToken:  ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBuildBatches(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListBuildBatches"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListBuildBatchesForProject(t *testing.T) {
	input := &ListBuildBatchesForProjectInput{
		ProjectName: ptr.String("__ProjectName__"),
		Filter: &types.BuildBatchFilter{
			Status: types.StatusType("SUCCEEDED"),
		},
		MaxResults: ptr.Int32(1),
		SortOrder:  types.SortOrderType("ASCENDING"),
		NextToken:  ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBuildBatchesForProject(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListBuildBatchesForProject"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

func TestUpdateRequestSnapshot_ListReports(t *testing.T) {
	input := &ListReportsInput{
		SortOrder:  types.SortOrderType("ASCENDING"),
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
		Filter: &types.ReportFilter{
			Status: types.ReportStatusType("GENERATING"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListReports(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListReports"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListReportsForReportGroup(t *testing.T) {
	input := &ListReportsForReportGroupInput{
		ReportGroupArn: ptr.String("__ReportGroupArn__"),
		NextToken:      ptr.String("__NextToken__"),
		SortOrder:      types.SortOrderType("ASCENDING"),
		MaxResults:     ptr.Int32(1),
		Filter: &types.ReportFilter{
			Status: types.ReportStatusType("GENERATING"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListReportsForReportGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListReportsForReportGroup"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

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

func TestUpdateRequestSnapshot_StartBuild(t *testing.T) {
	input := &StartBuildInput{
		ProjectName: ptr.String("__ProjectName__"),
		SecondarySourcesOverride: []types.ProjectSource{
			{
				Type:          types.SourceType("CODECOMMIT"),
				Location:      ptr.String("__Location__"),
				GitCloneDepth: ptr.Int32(1),
				GitSubmodulesConfig: &types.GitSubmodulesConfig{
					FetchSubmodules: ptr.Bool(true),
				},
				Buildspec: ptr.String("__Buildspec__"),
				Auth: &types.SourceAuth{
					Type:     types.SourceAuthType("OAUTH"),
					Resource: ptr.String("__Resource__"),
				},
				ReportBuildStatus: ptr.Bool(true),
				BuildStatusConfig: &types.BuildStatusConfig{
					Context:   ptr.String("__Context__"),
					TargetUrl: ptr.String("__TargetUrl__"),
				},
				InsecureSsl:      ptr.Bool(true),
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
			},
			{
				Type:          types.SourceType("CODECOMMIT"),
				Location:      ptr.String("__Location__"),
				GitCloneDepth: ptr.Int32(1),
				GitSubmodulesConfig: &types.GitSubmodulesConfig{
					FetchSubmodules: ptr.Bool(true),
				},
				Buildspec: ptr.String("__Buildspec__"),
				Auth: &types.SourceAuth{
					Type:     types.SourceAuthType("OAUTH"),
					Resource: ptr.String("__Resource__"),
				},
				ReportBuildStatus: ptr.Bool(true),
				BuildStatusConfig: &types.BuildStatusConfig{
					Context:   ptr.String("__Context__"),
					TargetUrl: ptr.String("__TargetUrl__"),
				},
				InsecureSsl:      ptr.Bool(true),
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
			},
		},
		SecondarySourcesVersionOverride: []types.ProjectSourceVersion{
			{
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
				SourceVersion:    ptr.String("__SourceVersion__"),
			},
			{
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
				SourceVersion:    ptr.String("__SourceVersion__"),
			},
		},
		SourceVersion: ptr.String("__SourceVersion__"),
		ArtifactsOverride: &types.ProjectArtifacts{
			Type:                 types.ArtifactsType("CODEPIPELINE"),
			Location:             ptr.String("__Location__"),
			Path:                 ptr.String("__Path__"),
			NamespaceType:        types.ArtifactNamespace("NONE"),
			Name:                 ptr.String("__Name__"),
			Packaging:            types.ArtifactPackaging("NONE"),
			OverrideArtifactName: ptr.Bool(true),
			EncryptionDisabled:   ptr.Bool(true),
			ArtifactIdentifier:   ptr.String("__ArtifactIdentifier__"),
			BucketOwnerAccess:    types.BucketOwnerAccess("NONE"),
		},
		SecondaryArtifactsOverride: []types.ProjectArtifacts{
			{
				Type:                 types.ArtifactsType("CODEPIPELINE"),
				Location:             ptr.String("__Location__"),
				Path:                 ptr.String("__Path__"),
				NamespaceType:        types.ArtifactNamespace("NONE"),
				Name:                 ptr.String("__Name__"),
				Packaging:            types.ArtifactPackaging("NONE"),
				OverrideArtifactName: ptr.Bool(true),
				EncryptionDisabled:   ptr.Bool(true),
				ArtifactIdentifier:   ptr.String("__ArtifactIdentifier__"),
				BucketOwnerAccess:    types.BucketOwnerAccess("NONE"),
			},
			{
				Type:                 types.ArtifactsType("CODEPIPELINE"),
				Location:             ptr.String("__Location__"),
				Path:                 ptr.String("__Path__"),
				NamespaceType:        types.ArtifactNamespace("NONE"),
				Name:                 ptr.String("__Name__"),
				Packaging:            types.ArtifactPackaging("NONE"),
				OverrideArtifactName: ptr.Bool(true),
				EncryptionDisabled:   ptr.Bool(true),
				ArtifactIdentifier:   ptr.String("__ArtifactIdentifier__"),
				BucketOwnerAccess:    types.BucketOwnerAccess("NONE"),
			},
		},
		EnvironmentVariablesOverride: []types.EnvironmentVariable{
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
				Type:  types.EnvironmentVariableType("PLAINTEXT"),
			},
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
				Type:  types.EnvironmentVariableType("PLAINTEXT"),
			},
		},
		SourceTypeOverride:     types.SourceType("CODECOMMIT"),
		SourceLocationOverride: ptr.String("__SourceLocationOverride__"),
		SourceAuthOverride: &types.SourceAuth{
			Type:     types.SourceAuthType("OAUTH"),
			Resource: ptr.String("__Resource__"),
		},
		GitCloneDepthOverride: ptr.Int32(1),
		GitSubmodulesConfigOverride: &types.GitSubmodulesConfig{
			FetchSubmodules: ptr.Bool(true),
		},
		BuildspecOverride:         ptr.String("__BuildspecOverride__"),
		InsecureSslOverride:       ptr.Bool(true),
		ReportBuildStatusOverride: ptr.Bool(true),
		BuildStatusConfigOverride: &types.BuildStatusConfig{
			Context:   ptr.String("__Context__"),
			TargetUrl: ptr.String("__TargetUrl__"),
		},
		EnvironmentTypeOverride: types.EnvironmentType("WINDOWS_CONTAINER"),
		ImageOverride:           ptr.String("__ImageOverride__"),
		ComputeTypeOverride:     types.ComputeType("BUILD_GENERAL1_SMALL"),
		CertificateOverride:     ptr.String("__CertificateOverride__"),
		CacheOverride: &types.ProjectCache{
			Type:     types.CacheType("NO_CACHE"),
			Location: ptr.String("__Location__"),
			Modes: []types.CacheMode{
				types.CacheMode("LOCAL_DOCKER_LAYER_CACHE"),
				types.CacheMode("LOCAL_DOCKER_LAYER_CACHE"),
			},
			CacheNamespace: ptr.String("__CacheNamespace__"),
		},
		ServiceRoleOverride:            ptr.String("__ServiceRoleOverride__"),
		PrivilegedModeOverride:         ptr.Bool(true),
		TimeoutInMinutesOverride:       ptr.Int32(1),
		QueuedTimeoutInMinutesOverride: ptr.Int32(1),
		EncryptionKeyOverride:          ptr.String("__EncryptionKeyOverride__"),
		IdempotencyToken:               ptr.String("__IdempotencyToken__"),
		LogsConfigOverride: &types.LogsConfig{
			CloudWatchLogs: &types.CloudWatchLogsConfig{
				Status:     types.LogsConfigStatusType("ENABLED"),
				GroupName:  ptr.String("__GroupName__"),
				StreamName: ptr.String("__StreamName__"),
			},
			S3Logs: &types.S3LogsConfig{
				Status:             types.LogsConfigStatusType("ENABLED"),
				Location:           ptr.String("__Location__"),
				EncryptionDisabled: ptr.Bool(true),
				BucketOwnerAccess:  types.BucketOwnerAccess("NONE"),
			},
		},
		RegistryCredentialOverride: &types.RegistryCredential{
			Credential:         ptr.String("__Credential__"),
			CredentialProvider: types.CredentialProviderType("SECRETS_MANAGER"),
		},
		ImagePullCredentialsTypeOverride: types.ImagePullCredentialsType("CODEBUILD"),
		DebugSessionEnabled:              ptr.Bool(true),
		FleetOverride: &types.ProjectFleet{
			FleetArn: ptr.String("__FleetArn__"),
		},
		AutoRetryLimitOverride: ptr.Int32(1),
		HostKernelOverride:     types.HostKernel("LINUX_KERNEL_4"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartBuild(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "StartBuild"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_StartBuildBatch(t *testing.T) {
	input := &StartBuildBatchInput{
		ProjectName: ptr.String("__ProjectName__"),
		SecondarySourcesOverride: []types.ProjectSource{
			{
				Type:          types.SourceType("CODECOMMIT"),
				Location:      ptr.String("__Location__"),
				GitCloneDepth: ptr.Int32(1),
				GitSubmodulesConfig: &types.GitSubmodulesConfig{
					FetchSubmodules: ptr.Bool(true),
				},
				Buildspec: ptr.String("__Buildspec__"),
				Auth: &types.SourceAuth{
					Type:     types.SourceAuthType("OAUTH"),
					Resource: ptr.String("__Resource__"),
				},
				ReportBuildStatus: ptr.Bool(true),
				BuildStatusConfig: &types.BuildStatusConfig{
					Context:   ptr.String("__Context__"),
					TargetUrl: ptr.String("__TargetUrl__"),
				},
				InsecureSsl:      ptr.Bool(true),
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
			},
			{
				Type:          types.SourceType("CODECOMMIT"),
				Location:      ptr.String("__Location__"),
				GitCloneDepth: ptr.Int32(1),
				GitSubmodulesConfig: &types.GitSubmodulesConfig{
					FetchSubmodules: ptr.Bool(true),
				},
				Buildspec: ptr.String("__Buildspec__"),
				Auth: &types.SourceAuth{
					Type:     types.SourceAuthType("OAUTH"),
					Resource: ptr.String("__Resource__"),
				},
				ReportBuildStatus: ptr.Bool(true),
				BuildStatusConfig: &types.BuildStatusConfig{
					Context:   ptr.String("__Context__"),
					TargetUrl: ptr.String("__TargetUrl__"),
				},
				InsecureSsl:      ptr.Bool(true),
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
			},
		},
		SecondarySourcesVersionOverride: []types.ProjectSourceVersion{
			{
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
				SourceVersion:    ptr.String("__SourceVersion__"),
			},
			{
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
				SourceVersion:    ptr.String("__SourceVersion__"),
			},
		},
		SourceVersion: ptr.String("__SourceVersion__"),
		ArtifactsOverride: &types.ProjectArtifacts{
			Type:                 types.ArtifactsType("CODEPIPELINE"),
			Location:             ptr.String("__Location__"),
			Path:                 ptr.String("__Path__"),
			NamespaceType:        types.ArtifactNamespace("NONE"),
			Name:                 ptr.String("__Name__"),
			Packaging:            types.ArtifactPackaging("NONE"),
			OverrideArtifactName: ptr.Bool(true),
			EncryptionDisabled:   ptr.Bool(true),
			ArtifactIdentifier:   ptr.String("__ArtifactIdentifier__"),
			BucketOwnerAccess:    types.BucketOwnerAccess("NONE"),
		},
		SecondaryArtifactsOverride: []types.ProjectArtifacts{
			{
				Type:                 types.ArtifactsType("CODEPIPELINE"),
				Location:             ptr.String("__Location__"),
				Path:                 ptr.String("__Path__"),
				NamespaceType:        types.ArtifactNamespace("NONE"),
				Name:                 ptr.String("__Name__"),
				Packaging:            types.ArtifactPackaging("NONE"),
				OverrideArtifactName: ptr.Bool(true),
				EncryptionDisabled:   ptr.Bool(true),
				ArtifactIdentifier:   ptr.String("__ArtifactIdentifier__"),
				BucketOwnerAccess:    types.BucketOwnerAccess("NONE"),
			},
			{
				Type:                 types.ArtifactsType("CODEPIPELINE"),
				Location:             ptr.String("__Location__"),
				Path:                 ptr.String("__Path__"),
				NamespaceType:        types.ArtifactNamespace("NONE"),
				Name:                 ptr.String("__Name__"),
				Packaging:            types.ArtifactPackaging("NONE"),
				OverrideArtifactName: ptr.Bool(true),
				EncryptionDisabled:   ptr.Bool(true),
				ArtifactIdentifier:   ptr.String("__ArtifactIdentifier__"),
				BucketOwnerAccess:    types.BucketOwnerAccess("NONE"),
			},
		},
		EnvironmentVariablesOverride: []types.EnvironmentVariable{
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
				Type:  types.EnvironmentVariableType("PLAINTEXT"),
			},
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
				Type:  types.EnvironmentVariableType("PLAINTEXT"),
			},
		},
		SourceTypeOverride:     types.SourceType("CODECOMMIT"),
		SourceLocationOverride: ptr.String("__SourceLocationOverride__"),
		SourceAuthOverride: &types.SourceAuth{
			Type:     types.SourceAuthType("OAUTH"),
			Resource: ptr.String("__Resource__"),
		},
		GitCloneDepthOverride: ptr.Int32(1),
		GitSubmodulesConfigOverride: &types.GitSubmodulesConfig{
			FetchSubmodules: ptr.Bool(true),
		},
		BuildspecOverride:              ptr.String("__BuildspecOverride__"),
		InsecureSslOverride:            ptr.Bool(true),
		ReportBuildBatchStatusOverride: ptr.Bool(true),
		EnvironmentTypeOverride:        types.EnvironmentType("WINDOWS_CONTAINER"),
		ImageOverride:                  ptr.String("__ImageOverride__"),
		ComputeTypeOverride:            types.ComputeType("BUILD_GENERAL1_SMALL"),
		CertificateOverride:            ptr.String("__CertificateOverride__"),
		CacheOverride: &types.ProjectCache{
			Type:     types.CacheType("NO_CACHE"),
			Location: ptr.String("__Location__"),
			Modes: []types.CacheMode{
				types.CacheMode("LOCAL_DOCKER_LAYER_CACHE"),
				types.CacheMode("LOCAL_DOCKER_LAYER_CACHE"),
			},
			CacheNamespace: ptr.String("__CacheNamespace__"),
		},
		ServiceRoleOverride:            ptr.String("__ServiceRoleOverride__"),
		PrivilegedModeOverride:         ptr.Bool(true),
		BuildTimeoutInMinutesOverride:  ptr.Int32(1),
		QueuedTimeoutInMinutesOverride: ptr.Int32(1),
		EncryptionKeyOverride:          ptr.String("__EncryptionKeyOverride__"),
		IdempotencyToken:               ptr.String("__IdempotencyToken__"),
		LogsConfigOverride: &types.LogsConfig{
			CloudWatchLogs: &types.CloudWatchLogsConfig{
				Status:     types.LogsConfigStatusType("ENABLED"),
				GroupName:  ptr.String("__GroupName__"),
				StreamName: ptr.String("__StreamName__"),
			},
			S3Logs: &types.S3LogsConfig{
				Status:             types.LogsConfigStatusType("ENABLED"),
				Location:           ptr.String("__Location__"),
				EncryptionDisabled: ptr.Bool(true),
				BucketOwnerAccess:  types.BucketOwnerAccess("NONE"),
			},
		},
		RegistryCredentialOverride: &types.RegistryCredential{
			Credential:         ptr.String("__Credential__"),
			CredentialProvider: types.CredentialProviderType("SECRETS_MANAGER"),
		},
		ImagePullCredentialsTypeOverride: types.ImagePullCredentialsType("CODEBUILD"),
		BuildBatchConfigOverride: &types.ProjectBuildBatchConfig{
			ServiceRole:      ptr.String("__ServiceRole__"),
			CombineArtifacts: ptr.Bool(true),
			Restrictions: &types.BatchRestrictions{
				MaximumBuildsAllowed: ptr.Int32(1),
				ComputeTypesAllowed: []string{
					"__Member__",
					"__Member__",
				},
				FleetsAllowed: []string{
					"__Member__",
					"__Member__",
				},
			},
			TimeoutInMins:   ptr.Int32(1),
			BatchReportMode: types.BatchReportModeType("REPORT_INDIVIDUAL_BUILDS"),
		},
		DebugSessionEnabled: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartBuildBatch(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "StartBuildBatch"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

func TestUpdateRequestSnapshot_UpdateFleet(t *testing.T) {
	input := &UpdateFleetInput{
		Arn:             ptr.String("__Arn__"),
		BaseCapacity:    ptr.Int32(1),
		EnvironmentType: types.EnvironmentType("WINDOWS_CONTAINER"),
		ComputeType:     types.ComputeType("BUILD_GENERAL1_SMALL"),
		ComputeConfiguration: &types.ComputeConfiguration{
			VCpu:         ptr.Int64(1),
			Memory:       ptr.Int64(1),
			Disk:         ptr.Int64(1),
			MachineType:  types.MachineType("GENERAL"),
			InstanceType: ptr.String("__InstanceType__"),
		},
		ScalingConfiguration: &types.ScalingConfigurationInput{
			ScalingType: types.FleetScalingType("TARGET_TRACKING_SCALING"),
			TargetTrackingScalingConfigs: []types.TargetTrackingScalingConfiguration{
				{
					MetricType:  types.FleetScalingMetricType("FLEET_UTILIZATION_RATE"),
					TargetValue: ptr.Float64(1.0),
				},
				{
					MetricType:  types.FleetScalingMetricType("FLEET_UTILIZATION_RATE"),
					TargetValue: ptr.Float64(1.0),
				},
			},
			MaxCapacity: ptr.Int32(1),
		},
		OverflowBehavior: types.FleetOverflowBehavior("QUEUE"),
		VpcConfig: &types.VpcConfig{
			VpcId: ptr.String("__VpcId__"),
			Subnets: []string{
				"__Member__",
				"__Member__",
			},
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
		},
		ProxyConfiguration: &types.ProxyConfiguration{
			DefaultBehavior: types.FleetProxyRuleBehavior("ALLOW_ALL"),
			OrderedProxyRules: []types.FleetProxyRule{
				{
					Type:   types.FleetProxyRuleType("DOMAIN"),
					Effect: types.FleetProxyRuleEffectType("ALLOW"),
					Entities: []string{
						"__Member__",
						"__Member__",
					},
				},
				{
					Type:   types.FleetProxyRuleType("DOMAIN"),
					Effect: types.FleetProxyRuleEffectType("ALLOW"),
					Entities: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
		},
		ImageId:          ptr.String("__ImageId__"),
		FleetServiceRole: ptr.String("__FleetServiceRole__"),
		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.UpdateFleet(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UpdateFleet"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateProject(t *testing.T) {
	input := &UpdateProjectInput{
		Name:        ptr.String("__Name__"),
		Description: ptr.String("__Description__"),
		Source: &types.ProjectSource{
			Type:          types.SourceType("CODECOMMIT"),
			Location:      ptr.String("__Location__"),
			GitCloneDepth: ptr.Int32(1),
			GitSubmodulesConfig: &types.GitSubmodulesConfig{
				FetchSubmodules: ptr.Bool(true),
			},
			Buildspec: ptr.String("__Buildspec__"),
			Auth: &types.SourceAuth{
				Type:     types.SourceAuthType("OAUTH"),
				Resource: ptr.String("__Resource__"),
			},
			ReportBuildStatus: ptr.Bool(true),
			BuildStatusConfig: &types.BuildStatusConfig{
				Context:   ptr.String("__Context__"),
				TargetUrl: ptr.String("__TargetUrl__"),
			},
			InsecureSsl:      ptr.Bool(true),
			SourceIdentifier: ptr.String("__SourceIdentifier__"),
		},
		SecondarySources: []types.ProjectSource{
			{
				Type:          types.SourceType("CODECOMMIT"),
				Location:      ptr.String("__Location__"),
				GitCloneDepth: ptr.Int32(1),
				GitSubmodulesConfig: &types.GitSubmodulesConfig{
					FetchSubmodules: ptr.Bool(true),
				},
				Buildspec: ptr.String("__Buildspec__"),
				Auth: &types.SourceAuth{
					Type:     types.SourceAuthType("OAUTH"),
					Resource: ptr.String("__Resource__"),
				},
				ReportBuildStatus: ptr.Bool(true),
				BuildStatusConfig: &types.BuildStatusConfig{
					Context:   ptr.String("__Context__"),
					TargetUrl: ptr.String("__TargetUrl__"),
				},
				InsecureSsl:      ptr.Bool(true),
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
			},
			{
				Type:          types.SourceType("CODECOMMIT"),
				Location:      ptr.String("__Location__"),
				GitCloneDepth: ptr.Int32(1),
				GitSubmodulesConfig: &types.GitSubmodulesConfig{
					FetchSubmodules: ptr.Bool(true),
				},
				Buildspec: ptr.String("__Buildspec__"),
				Auth: &types.SourceAuth{
					Type:     types.SourceAuthType("OAUTH"),
					Resource: ptr.String("__Resource__"),
				},
				ReportBuildStatus: ptr.Bool(true),
				BuildStatusConfig: &types.BuildStatusConfig{
					Context:   ptr.String("__Context__"),
					TargetUrl: ptr.String("__TargetUrl__"),
				},
				InsecureSsl:      ptr.Bool(true),
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
			},
		},
		SourceVersion: ptr.String("__SourceVersion__"),
		SecondarySourceVersions: []types.ProjectSourceVersion{
			{
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
				SourceVersion:    ptr.String("__SourceVersion__"),
			},
			{
				SourceIdentifier: ptr.String("__SourceIdentifier__"),
				SourceVersion:    ptr.String("__SourceVersion__"),
			},
		},
		Artifacts: &types.ProjectArtifacts{
			Type:                 types.ArtifactsType("CODEPIPELINE"),
			Location:             ptr.String("__Location__"),
			Path:                 ptr.String("__Path__"),
			NamespaceType:        types.ArtifactNamespace("NONE"),
			Name:                 ptr.String("__Name__"),
			Packaging:            types.ArtifactPackaging("NONE"),
			OverrideArtifactName: ptr.Bool(true),
			EncryptionDisabled:   ptr.Bool(true),
			ArtifactIdentifier:   ptr.String("__ArtifactIdentifier__"),
			BucketOwnerAccess:    types.BucketOwnerAccess("NONE"),
		},
		SecondaryArtifacts: []types.ProjectArtifacts{
			{
				Type:                 types.ArtifactsType("CODEPIPELINE"),
				Location:             ptr.String("__Location__"),
				Path:                 ptr.String("__Path__"),
				NamespaceType:        types.ArtifactNamespace("NONE"),
				Name:                 ptr.String("__Name__"),
				Packaging:            types.ArtifactPackaging("NONE"),
				OverrideArtifactName: ptr.Bool(true),
				EncryptionDisabled:   ptr.Bool(true),
				ArtifactIdentifier:   ptr.String("__ArtifactIdentifier__"),
				BucketOwnerAccess:    types.BucketOwnerAccess("NONE"),
			},
			{
				Type:                 types.ArtifactsType("CODEPIPELINE"),
				Location:             ptr.String("__Location__"),
				Path:                 ptr.String("__Path__"),
				NamespaceType:        types.ArtifactNamespace("NONE"),
				Name:                 ptr.String("__Name__"),
				Packaging:            types.ArtifactPackaging("NONE"),
				OverrideArtifactName: ptr.Bool(true),
				EncryptionDisabled:   ptr.Bool(true),
				ArtifactIdentifier:   ptr.String("__ArtifactIdentifier__"),
				BucketOwnerAccess:    types.BucketOwnerAccess("NONE"),
			},
		},
		Cache: &types.ProjectCache{
			Type:     types.CacheType("NO_CACHE"),
			Location: ptr.String("__Location__"),
			Modes: []types.CacheMode{
				types.CacheMode("LOCAL_DOCKER_LAYER_CACHE"),
				types.CacheMode("LOCAL_DOCKER_LAYER_CACHE"),
			},
			CacheNamespace: ptr.String("__CacheNamespace__"),
		},
		Environment: &types.ProjectEnvironment{
			Type:        types.EnvironmentType("WINDOWS_CONTAINER"),
			Image:       ptr.String("__Image__"),
			ComputeType: types.ComputeType("BUILD_GENERAL1_SMALL"),
			ComputeConfiguration: &types.ComputeConfiguration{
				VCpu:         ptr.Int64(1),
				Memory:       ptr.Int64(1),
				Disk:         ptr.Int64(1),
				MachineType:  types.MachineType("GENERAL"),
				InstanceType: ptr.String("__InstanceType__"),
			},
			Fleet: &types.ProjectFleet{
				FleetArn: ptr.String("__FleetArn__"),
			},
			EnvironmentVariables: []types.EnvironmentVariable{
				{
					Name:  ptr.String("__Name__"),
					Value: ptr.String("__Value__"),
					Type:  types.EnvironmentVariableType("PLAINTEXT"),
				},
				{
					Name:  ptr.String("__Name__"),
					Value: ptr.String("__Value__"),
					Type:  types.EnvironmentVariableType("PLAINTEXT"),
				},
			},
			PrivilegedMode: ptr.Bool(true),
			Certificate:    ptr.String("__Certificate__"),
			RegistryCredential: &types.RegistryCredential{
				Credential:         ptr.String("__Credential__"),
				CredentialProvider: types.CredentialProviderType("SECRETS_MANAGER"),
			},
			ImagePullCredentialsType: types.ImagePullCredentialsType("CODEBUILD"),
			DockerServer: &types.DockerServer{
				ComputeType: types.ComputeType("BUILD_GENERAL1_SMALL"),
				SecurityGroupIds: []string{
					"__Member__",
					"__Member__",
				},
				Status: &types.DockerServerStatus{
					Status:  ptr.String("__Status__"),
					Message: ptr.String("__Message__"),
				},
			},
			HostKernel: types.HostKernel("LINUX_KERNEL_4"),
		},
		ServiceRole:            ptr.String("__ServiceRole__"),
		TimeoutInMinutes:       ptr.Int32(1),
		QueuedTimeoutInMinutes: ptr.Int32(1),
		EncryptionKey:          ptr.String("__EncryptionKey__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		VpcConfig: &types.VpcConfig{
			VpcId: ptr.String("__VpcId__"),
			Subnets: []string{
				"__Member__",
				"__Member__",
			},
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
		},
		BadgeEnabled: ptr.Bool(true),
		LogsConfig: &types.LogsConfig{
			CloudWatchLogs: &types.CloudWatchLogsConfig{
				Status:     types.LogsConfigStatusType("ENABLED"),
				GroupName:  ptr.String("__GroupName__"),
				StreamName: ptr.String("__StreamName__"),
			},
			S3Logs: &types.S3LogsConfig{
				Status:             types.LogsConfigStatusType("ENABLED"),
				Location:           ptr.String("__Location__"),
				EncryptionDisabled: ptr.Bool(true),
				BucketOwnerAccess:  types.BucketOwnerAccess("NONE"),
			},
		},
		FileSystemLocations: []types.ProjectFileSystemLocation{
			{
				Type:         types.FileSystemType("EFS"),
				Location:     ptr.String("__Location__"),
				MountPoint:   ptr.String("__MountPoint__"),
				Identifier:   ptr.String("__Identifier__"),
				MountOptions: ptr.String("__MountOptions__"),
			},
			{
				Type:         types.FileSystemType("EFS"),
				Location:     ptr.String("__Location__"),
				MountPoint:   ptr.String("__MountPoint__"),
				Identifier:   ptr.String("__Identifier__"),
				MountOptions: ptr.String("__MountOptions__"),
			},
		},
		BuildBatchConfig: &types.ProjectBuildBatchConfig{
			ServiceRole:      ptr.String("__ServiceRole__"),
			CombineArtifacts: ptr.Bool(true),
			Restrictions: &types.BatchRestrictions{
				MaximumBuildsAllowed: ptr.Int32(1),
				ComputeTypesAllowed: []string{
					"__Member__",
					"__Member__",
				},
				FleetsAllowed: []string{
					"__Member__",
					"__Member__",
				},
			},
			TimeoutInMins:   ptr.Int32(1),
			BatchReportMode: types.BatchReportModeType("REPORT_INDIVIDUAL_BUILDS"),
		},
		ConcurrentBuildLimit: ptr.Int32(1),
		AutoRetryLimit:       ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateProject(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UpdateProject"); err != nil {
		t.Fatal(err)
	}
}

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

func TestUpdateRequestSnapshot_UpdateReportGroup(t *testing.T) {
	input := &UpdateReportGroupInput{
		Arn: ptr.String("__Arn__"),
		ExportConfig: &types.ReportExportConfig{
			ExportConfigType: types.ReportExportConfigType("S3"),
			S3Destination: &types.S3ReportExportConfig{
				Bucket:             ptr.String("__Bucket__"),
				BucketOwner:        ptr.String("__BucketOwner__"),
				Path:               ptr.String("__Path__"),
				Packaging:          types.ReportPackagingType("ZIP"),
				EncryptionKey:      ptr.String("__EncryptionKey__"),
				EncryptionDisabled: ptr.Bool(true),
			},
		},
		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.UpdateReportGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UpdateReportGroup"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateWebhook(t *testing.T) {
	input := &UpdateWebhookInput{
		ProjectName:  ptr.String("__ProjectName__"),
		BranchFilter: ptr.String("__BranchFilter__"),
		RotateSecret: true,
		FilterGroups: [][]types.WebhookFilter{
			{
				{
					Type:                  types.WebhookFilterType("EVENT"),
					Pattern:               ptr.String("__Pattern__"),
					ExcludeMatchedPattern: ptr.Bool(true),
				},
				{
					Type:                  types.WebhookFilterType("EVENT"),
					Pattern:               ptr.String("__Pattern__"),
					ExcludeMatchedPattern: ptr.Bool(true),
				},
			},
			{
				{
					Type:                  types.WebhookFilterType("EVENT"),
					Pattern:               ptr.String("__Pattern__"),
					ExcludeMatchedPattern: ptr.Bool(true),
				},
				{
					Type:                  types.WebhookFilterType("EVENT"),
					Pattern:               ptr.String("__Pattern__"),
					ExcludeMatchedPattern: ptr.Bool(true),
				},
			},
		},
		BuildType: types.WebhookBuildType("BUILD"),
		PullRequestBuildPolicy: &types.PullRequestBuildPolicy{
			RequiresCommentApproval: types.PullRequestBuildCommentApproval("DISABLED"),
			ApproverRoles: []types.PullRequestBuildApproverRole{
				types.PullRequestBuildApproverRole("GITHUB_READ"),
				types.PullRequestBuildApproverRole("GITHUB_READ"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateWebhook(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UpdateWebhook"); err != nil {
		t.Fatal(err)
	}
}
