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

//go:build request_snapshot

package ecr

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/ecr/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"
	"reflect"
	"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 {
	if len(got) == 0 || len(expected) == 0 {
		return bytes.Equal(got, expected)
	}
	gv, gok := serdeDecodeJSON(got)
	ev, eok := serdeDecodeJSON(expected)
	if !gok || !eok {
		return bytes.Equal(got, expected)
	}
	return reflect.DeepEqual(gv, ev)
}

// serdeDecodeJSON decodes a body for structural comparison. Numbers are kept as
// json.Number rather than float64 so a large int64 doesn't lose precision (which would
// mask a real difference) and so numeric formatting differences still show up.
func serdeDecodeJSON(b []byte) (any, bool) {
	d := json.NewDecoder(bytes.NewReader(b))
	d.UseNumber()
	var v any
	if err := d.Decode(&v); err != nil {
		return nil, false
	}
	return v, true
}
func TestCheckRequestSnapshot_BatchCheckLayerAvailability(t *testing.T) {
	input := &BatchCheckLayerAvailabilityInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		LayerDigests: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchCheckLayerAvailability(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "BatchCheckLayerAvailability"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_BatchDeleteImage(t *testing.T) {
	input := &BatchDeleteImageInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageIds: []types.ImageIdentifier{
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchDeleteImage(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "BatchDeleteImage"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_BatchGetImage(t *testing.T) {
	input := &BatchGetImageInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageIds: []types.ImageIdentifier{
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
		},
		AcceptedMediaTypes: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchGetImage(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "BatchGetImage"); err != nil {
		t.Fatal(err)
	}
}

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

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

func TestCheckRequestSnapshot_CreatePullThroughCacheRule(t *testing.T) {
	input := &CreatePullThroughCacheRuleInput{
		EcrRepositoryPrefix:      ptr.String("__EcrRepositoryPrefix__"),
		UpstreamRegistryUrl:      ptr.String("__UpstreamRegistryUrl__"),
		RegistryId:               ptr.String("__RegistryId__"),
		UpstreamRegistry:         types.UpstreamRegistry("ecr"),
		CredentialArn:            ptr.String("__CredentialArn__"),
		CustomRoleArn:            ptr.String("__CustomRoleArn__"),
		UpstreamRepositoryPrefix: ptr.String("__UpstreamRepositoryPrefix__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreatePullThroughCacheRule(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreatePullThroughCacheRule"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateRepository(t *testing.T) {
	input := &CreateRepositoryInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		ImageTagMutability: types.ImageTagMutability("MUTABLE"),
		ImageTagMutabilityExclusionFilters: []types.ImageTagMutabilityExclusionFilter{
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
		},
		ImageScanningConfiguration: &types.ImageScanningConfiguration{
			ScanOnPush: true,
		},
		EncryptionConfiguration: &types.EncryptionConfiguration{
			EncryptionType: types.EncryptionType("AES256"),
			KmsKey:         ptr.String("__KmsKey__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateRepository(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateRepository"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateRepositoryCreationTemplate(t *testing.T) {
	input := &CreateRepositoryCreationTemplateInput{
		Prefix:      ptr.String("__Prefix__"),
		Description: ptr.String("__Description__"),
		EncryptionConfiguration: &types.EncryptionConfigurationForRepositoryCreationTemplate{
			EncryptionType: types.EncryptionType("AES256"),
			KmsKey:         ptr.String("__KmsKey__"),
		},
		ResourceTags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		ImageTagMutability: types.ImageTagMutability("MUTABLE"),
		ImageTagMutabilityExclusionFilters: []types.ImageTagMutabilityExclusionFilter{
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
		},
		RepositoryPolicy: ptr.String("__RepositoryPolicy__"),
		LifecyclePolicy:  ptr.String("__LifecyclePolicy__"),
		AppliedFor: []types.RCTAppliedFor{
			types.RCTAppliedFor("REPLICATION"),
			types.RCTAppliedFor("REPLICATION"),
		},
		CustomRoleArn: ptr.String("__CustomRoleArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateRepositoryCreationTemplate(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateRepositoryCreationTemplate"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

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

func TestCheckRequestSnapshot_DescribeImageReplicationStatus(t *testing.T) {
	input := &DescribeImageReplicationStatusInput{
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageId: &types.ImageIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
			ImageTag:    ptr.String("__ImageTag__"),
		},
		RegistryId: ptr.String("__RegistryId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeImageReplicationStatus(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DescribeImageReplicationStatus"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeImages(t *testing.T) {
	input := &DescribeImagesInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageIds: []types.ImageIdentifier{
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
		Filter: &types.DescribeImagesFilter{
			TagStatus:   types.TagStatus("TAGGED"),
			ImageStatus: types.ImageStatusFilter("ACTIVE"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeImages(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DescribeImages"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeImageScanFindings(t *testing.T) {
	input := &DescribeImageScanFindingsInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageId: &types.ImageIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
			ImageTag:    ptr.String("__ImageTag__"),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeImageScanFindings(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DescribeImageScanFindings"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_DescribeImageSigningStatus(t *testing.T) {
	input := &DescribeImageSigningStatusInput{
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageId: &types.ImageIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
			ImageTag:    ptr.String("__ImageTag__"),
		},
		RegistryId: ptr.String("__RegistryId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeImageSigningStatus(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DescribeImageSigningStatus"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

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

func TestCheckRequestSnapshot_GetLifecyclePolicyPreview(t *testing.T) {
	input := &GetLifecyclePolicyPreviewInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageIds: []types.ImageIdentifier{
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
		Filter: &types.LifecyclePolicyPreviewFilter{
			TagStatus: types.TagStatus("TAGGED"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetLifecyclePolicyPreview(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetLifecyclePolicyPreview"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

func TestCheckRequestSnapshot_ListImageReferrers(t *testing.T) {
	input := &ListImageReferrersInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		SubjectId: &types.SubjectIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
		},
		Filter: &types.ListImageReferrersFilter{
			ArtifactTypes: []string{
				"__Member__",
				"__Member__",
			},
			ArtifactStatus: types.ArtifactStatusFilter("ACTIVE"),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListImageReferrers(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListImageReferrers"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListImages(t *testing.T) {
	input := &ListImagesInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		NextToken:      ptr.String("__NextToken__"),
		MaxResults:     ptr.Int32(1),
		Filter: &types.ListImagesFilter{
			TagStatus:   types.TagStatus("TAGGED"),
			ImageStatus: types.ImageStatusFilter("ACTIVE"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListImages(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListImages"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

func TestCheckRequestSnapshot_PutImage(t *testing.T) {
	input := &PutImageInput{
		RegistryId:             ptr.String("__RegistryId__"),
		RepositoryName:         ptr.String("__RepositoryName__"),
		ImageManifest:          ptr.String("__ImageManifest__"),
		ImageManifestMediaType: ptr.String("__ImageManifestMediaType__"),
		ImageTag:               ptr.String("__ImageTag__"),
		ImageDigest:            ptr.String("__ImageDigest__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutImage(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutImage"); err != nil {
		t.Fatal(err)
	}
}

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

func TestCheckRequestSnapshot_PutImageTagMutability(t *testing.T) {
	input := &PutImageTagMutabilityInput{
		RegistryId:         ptr.String("__RegistryId__"),
		RepositoryName:     ptr.String("__RepositoryName__"),
		ImageTagMutability: types.ImageTagMutability("MUTABLE"),
		ImageTagMutabilityExclusionFilters: []types.ImageTagMutabilityExclusionFilter{
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutImageTagMutability(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutImageTagMutability"); err != nil {
		t.Fatal(err)
	}
}

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

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

func TestCheckRequestSnapshot_PutRegistryScanningConfiguration(t *testing.T) {
	input := &PutRegistryScanningConfigurationInput{
		ScanType: types.ScanType("BASIC"),
		Rules: []types.RegistryScanningRule{
			{
				ScanFrequency: types.ScanFrequency("SCAN_ON_PUSH"),
				RepositoryFilters: []types.ScanningRepositoryFilter{
					{
						Filter:     ptr.String("__Filter__"),
						FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
					},
					{
						Filter:     ptr.String("__Filter__"),
						FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
					},
				},
			},
			{
				ScanFrequency: types.ScanFrequency("SCAN_ON_PUSH"),
				RepositoryFilters: []types.ScanningRepositoryFilter{
					{
						Filter:     ptr.String("__Filter__"),
						FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
					},
					{
						Filter:     ptr.String("__Filter__"),
						FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
					},
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutRegistryScanningConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutRegistryScanningConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutReplicationConfiguration(t *testing.T) {
	input := &PutReplicationConfigurationInput{
		ReplicationConfiguration: &types.ReplicationConfiguration{
			Rules: []types.ReplicationRule{
				{
					Destinations: []types.ReplicationDestination{
						{
							Region:     ptr.String("__Region__"),
							RegistryId: ptr.String("__RegistryId__"),
						},
						{
							Region:     ptr.String("__Region__"),
							RegistryId: ptr.String("__RegistryId__"),
						},
					},
					RepositoryFilters: []types.RepositoryFilter{
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.RepositoryFilterType("PREFIX_MATCH"),
						},
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.RepositoryFilterType("PREFIX_MATCH"),
						},
					},
				},
				{
					Destinations: []types.ReplicationDestination{
						{
							Region:     ptr.String("__Region__"),
							RegistryId: ptr.String("__RegistryId__"),
						},
						{
							Region:     ptr.String("__Region__"),
							RegistryId: ptr.String("__RegistryId__"),
						},
					},
					RepositoryFilters: []types.RepositoryFilter{
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.RepositoryFilterType("PREFIX_MATCH"),
						},
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.RepositoryFilterType("PREFIX_MATCH"),
						},
					},
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutReplicationConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutReplicationConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_PutSigningConfiguration(t *testing.T) {
	input := &PutSigningConfigurationInput{
		SigningConfiguration: &types.SigningConfiguration{
			Rules: []types.SigningRule{
				{
					SigningProfileArn: ptr.String("__SigningProfileArn__"),
					RepositoryFilters: []types.SigningRepositoryFilter{
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.SigningRepositoryFilterType("WILDCARD_MATCH"),
						},
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.SigningRepositoryFilterType("WILDCARD_MATCH"),
						},
					},
				},
				{
					SigningProfileArn: ptr.String("__SigningProfileArn__"),
					RepositoryFilters: []types.SigningRepositoryFilter{
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.SigningRepositoryFilterType("WILDCARD_MATCH"),
						},
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.SigningRepositoryFilterType("WILDCARD_MATCH"),
						},
					},
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutSigningConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutSigningConfiguration"); err != nil {
		t.Fatal(err)
	}
}

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

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

func TestCheckRequestSnapshot_StartImageScan(t *testing.T) {
	input := &StartImageScanInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageId: &types.ImageIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
			ImageTag:    ptr.String("__ImageTag__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartImageScan(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "StartImageScan"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

func TestCheckRequestSnapshot_UpdateImageStorageClass(t *testing.T) {
	input := &UpdateImageStorageClassInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageId: &types.ImageIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
			ImageTag:    ptr.String("__ImageTag__"),
		},
		TargetStorageClass: types.TargetStorageClass("STANDARD"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateImageStorageClass(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UpdateImageStorageClass"); err != nil {
		t.Fatal(err)
	}
}

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

func TestCheckRequestSnapshot_UpdateRepositoryCreationTemplate(t *testing.T) {
	input := &UpdateRepositoryCreationTemplateInput{
		Prefix:      ptr.String("__Prefix__"),
		Description: ptr.String("__Description__"),
		EncryptionConfiguration: &types.EncryptionConfigurationForRepositoryCreationTemplate{
			EncryptionType: types.EncryptionType("AES256"),
			KmsKey:         ptr.String("__KmsKey__"),
		},
		ResourceTags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		ImageTagMutability: types.ImageTagMutability("MUTABLE"),
		ImageTagMutabilityExclusionFilters: []types.ImageTagMutabilityExclusionFilter{
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
		},
		RepositoryPolicy: ptr.String("__RepositoryPolicy__"),
		LifecyclePolicy:  ptr.String("__LifecyclePolicy__"),
		AppliedFor: []types.RCTAppliedFor{
			types.RCTAppliedFor("REPLICATION"),
			types.RCTAppliedFor("REPLICATION"),
		},
		CustomRoleArn: ptr.String("__CustomRoleArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateRepositoryCreationTemplate(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UpdateRepositoryCreationTemplate"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UploadLayerPart(t *testing.T) {
	input := &UploadLayerPartInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		UploadId:       ptr.String("__UploadId__"),
		PartFirstByte:  ptr.Int64(1),
		PartLastByte:   ptr.Int64(1),
		LayerPartBlob:  []byte("blob"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UploadLayerPart(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UploadLayerPart"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ValidatePullThroughCacheRule(t *testing.T) {
	input := &ValidatePullThroughCacheRuleInput{
		EcrRepositoryPrefix: ptr.String("__EcrRepositoryPrefix__"),
		RegistryId:          ptr.String("__RegistryId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ValidatePullThroughCacheRule(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ValidatePullThroughCacheRule"); err != nil {
		t.Fatal(err)
	}
}
func TestUpdateRequestSnapshot_BatchCheckLayerAvailability(t *testing.T) {
	input := &BatchCheckLayerAvailabilityInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		LayerDigests: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchCheckLayerAvailability(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "BatchCheckLayerAvailability"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_BatchDeleteImage(t *testing.T) {
	input := &BatchDeleteImageInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageIds: []types.ImageIdentifier{
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchDeleteImage(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "BatchDeleteImage"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_BatchGetImage(t *testing.T) {
	input := &BatchGetImageInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageIds: []types.ImageIdentifier{
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
		},
		AcceptedMediaTypes: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchGetImage(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "BatchGetImage"); err != nil {
		t.Fatal(err)
	}
}

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

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

func TestUpdateRequestSnapshot_CreatePullThroughCacheRule(t *testing.T) {
	input := &CreatePullThroughCacheRuleInput{
		EcrRepositoryPrefix:      ptr.String("__EcrRepositoryPrefix__"),
		UpstreamRegistryUrl:      ptr.String("__UpstreamRegistryUrl__"),
		RegistryId:               ptr.String("__RegistryId__"),
		UpstreamRegistry:         types.UpstreamRegistry("ecr"),
		CredentialArn:            ptr.String("__CredentialArn__"),
		CustomRoleArn:            ptr.String("__CustomRoleArn__"),
		UpstreamRepositoryPrefix: ptr.String("__UpstreamRepositoryPrefix__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreatePullThroughCacheRule(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreatePullThroughCacheRule"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateRepository(t *testing.T) {
	input := &CreateRepositoryInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		ImageTagMutability: types.ImageTagMutability("MUTABLE"),
		ImageTagMutabilityExclusionFilters: []types.ImageTagMutabilityExclusionFilter{
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
		},
		ImageScanningConfiguration: &types.ImageScanningConfiguration{
			ScanOnPush: true,
		},
		EncryptionConfiguration: &types.EncryptionConfiguration{
			EncryptionType: types.EncryptionType("AES256"),
			KmsKey:         ptr.String("__KmsKey__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateRepository(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateRepository"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateRepositoryCreationTemplate(t *testing.T) {
	input := &CreateRepositoryCreationTemplateInput{
		Prefix:      ptr.String("__Prefix__"),
		Description: ptr.String("__Description__"),
		EncryptionConfiguration: &types.EncryptionConfigurationForRepositoryCreationTemplate{
			EncryptionType: types.EncryptionType("AES256"),
			KmsKey:         ptr.String("__KmsKey__"),
		},
		ResourceTags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		ImageTagMutability: types.ImageTagMutability("MUTABLE"),
		ImageTagMutabilityExclusionFilters: []types.ImageTagMutabilityExclusionFilter{
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
		},
		RepositoryPolicy: ptr.String("__RepositoryPolicy__"),
		LifecyclePolicy:  ptr.String("__LifecyclePolicy__"),
		AppliedFor: []types.RCTAppliedFor{
			types.RCTAppliedFor("REPLICATION"),
			types.RCTAppliedFor("REPLICATION"),
		},
		CustomRoleArn: ptr.String("__CustomRoleArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateRepositoryCreationTemplate(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "CreateRepositoryCreationTemplate"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

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

func TestUpdateRequestSnapshot_DescribeImageReplicationStatus(t *testing.T) {
	input := &DescribeImageReplicationStatusInput{
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageId: &types.ImageIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
			ImageTag:    ptr.String("__ImageTag__"),
		},
		RegistryId: ptr.String("__RegistryId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeImageReplicationStatus(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DescribeImageReplicationStatus"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeImages(t *testing.T) {
	input := &DescribeImagesInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageIds: []types.ImageIdentifier{
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
		Filter: &types.DescribeImagesFilter{
			TagStatus:   types.TagStatus("TAGGED"),
			ImageStatus: types.ImageStatusFilter("ACTIVE"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeImages(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DescribeImages"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeImageScanFindings(t *testing.T) {
	input := &DescribeImageScanFindingsInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageId: &types.ImageIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
			ImageTag:    ptr.String("__ImageTag__"),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeImageScanFindings(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DescribeImageScanFindings"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_DescribeImageSigningStatus(t *testing.T) {
	input := &DescribeImageSigningStatusInput{
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageId: &types.ImageIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
			ImageTag:    ptr.String("__ImageTag__"),
		},
		RegistryId: ptr.String("__RegistryId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeImageSigningStatus(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "DescribeImageSigningStatus"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

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

func TestUpdateRequestSnapshot_GetLifecyclePolicyPreview(t *testing.T) {
	input := &GetLifecyclePolicyPreviewInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageIds: []types.ImageIdentifier{
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
			{
				ImageDigest: ptr.String("__ImageDigest__"),
				ImageTag:    ptr.String("__ImageTag__"),
			},
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
		Filter: &types.LifecyclePolicyPreviewFilter{
			TagStatus: types.TagStatus("TAGGED"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetLifecyclePolicyPreview(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "GetLifecyclePolicyPreview"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

func TestUpdateRequestSnapshot_ListImageReferrers(t *testing.T) {
	input := &ListImageReferrersInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		SubjectId: &types.SubjectIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
		},
		Filter: &types.ListImageReferrersFilter{
			ArtifactTypes: []string{
				"__Member__",
				"__Member__",
			},
			ArtifactStatus: types.ArtifactStatusFilter("ACTIVE"),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListImageReferrers(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListImageReferrers"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListImages(t *testing.T) {
	input := &ListImagesInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		NextToken:      ptr.String("__NextToken__"),
		MaxResults:     ptr.Int32(1),
		Filter: &types.ListImagesFilter{
			TagStatus:   types.TagStatus("TAGGED"),
			ImageStatus: types.ImageStatusFilter("ACTIVE"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListImages(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "ListImages"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

func TestUpdateRequestSnapshot_PutImage(t *testing.T) {
	input := &PutImageInput{
		RegistryId:             ptr.String("__RegistryId__"),
		RepositoryName:         ptr.String("__RepositoryName__"),
		ImageManifest:          ptr.String("__ImageManifest__"),
		ImageManifestMediaType: ptr.String("__ImageManifestMediaType__"),
		ImageTag:               ptr.String("__ImageTag__"),
		ImageDigest:            ptr.String("__ImageDigest__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutImage(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutImage"); err != nil {
		t.Fatal(err)
	}
}

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

func TestUpdateRequestSnapshot_PutImageTagMutability(t *testing.T) {
	input := &PutImageTagMutabilityInput{
		RegistryId:         ptr.String("__RegistryId__"),
		RepositoryName:     ptr.String("__RepositoryName__"),
		ImageTagMutability: types.ImageTagMutability("MUTABLE"),
		ImageTagMutabilityExclusionFilters: []types.ImageTagMutabilityExclusionFilter{
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutImageTagMutability(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutImageTagMutability"); err != nil {
		t.Fatal(err)
	}
}

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

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

func TestUpdateRequestSnapshot_PutRegistryScanningConfiguration(t *testing.T) {
	input := &PutRegistryScanningConfigurationInput{
		ScanType: types.ScanType("BASIC"),
		Rules: []types.RegistryScanningRule{
			{
				ScanFrequency: types.ScanFrequency("SCAN_ON_PUSH"),
				RepositoryFilters: []types.ScanningRepositoryFilter{
					{
						Filter:     ptr.String("__Filter__"),
						FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
					},
					{
						Filter:     ptr.String("__Filter__"),
						FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
					},
				},
			},
			{
				ScanFrequency: types.ScanFrequency("SCAN_ON_PUSH"),
				RepositoryFilters: []types.ScanningRepositoryFilter{
					{
						Filter:     ptr.String("__Filter__"),
						FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
					},
					{
						Filter:     ptr.String("__Filter__"),
						FilterType: types.ScanningRepositoryFilterType("WILDCARD"),
					},
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutRegistryScanningConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutRegistryScanningConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutReplicationConfiguration(t *testing.T) {
	input := &PutReplicationConfigurationInput{
		ReplicationConfiguration: &types.ReplicationConfiguration{
			Rules: []types.ReplicationRule{
				{
					Destinations: []types.ReplicationDestination{
						{
							Region:     ptr.String("__Region__"),
							RegistryId: ptr.String("__RegistryId__"),
						},
						{
							Region:     ptr.String("__Region__"),
							RegistryId: ptr.String("__RegistryId__"),
						},
					},
					RepositoryFilters: []types.RepositoryFilter{
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.RepositoryFilterType("PREFIX_MATCH"),
						},
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.RepositoryFilterType("PREFIX_MATCH"),
						},
					},
				},
				{
					Destinations: []types.ReplicationDestination{
						{
							Region:     ptr.String("__Region__"),
							RegistryId: ptr.String("__RegistryId__"),
						},
						{
							Region:     ptr.String("__Region__"),
							RegistryId: ptr.String("__RegistryId__"),
						},
					},
					RepositoryFilters: []types.RepositoryFilter{
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.RepositoryFilterType("PREFIX_MATCH"),
						},
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.RepositoryFilterType("PREFIX_MATCH"),
						},
					},
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutReplicationConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutReplicationConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_PutSigningConfiguration(t *testing.T) {
	input := &PutSigningConfigurationInput{
		SigningConfiguration: &types.SigningConfiguration{
			Rules: []types.SigningRule{
				{
					SigningProfileArn: ptr.String("__SigningProfileArn__"),
					RepositoryFilters: []types.SigningRepositoryFilter{
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.SigningRepositoryFilterType("WILDCARD_MATCH"),
						},
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.SigningRepositoryFilterType("WILDCARD_MATCH"),
						},
					},
				},
				{
					SigningProfileArn: ptr.String("__SigningProfileArn__"),
					RepositoryFilters: []types.SigningRepositoryFilter{
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.SigningRepositoryFilterType("WILDCARD_MATCH"),
						},
						{
							Filter:     ptr.String("__Filter__"),
							FilterType: types.SigningRepositoryFilterType("WILDCARD_MATCH"),
						},
					},
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.PutSigningConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "PutSigningConfiguration"); err != nil {
		t.Fatal(err)
	}
}

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

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

func TestUpdateRequestSnapshot_StartImageScan(t *testing.T) {
	input := &StartImageScanInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageId: &types.ImageIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
			ImageTag:    ptr.String("__ImageTag__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartImageScan(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "StartImageScan"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

func TestUpdateRequestSnapshot_UpdateImageStorageClass(t *testing.T) {
	input := &UpdateImageStorageClassInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		ImageId: &types.ImageIdentifier{
			ImageDigest: ptr.String("__ImageDigest__"),
			ImageTag:    ptr.String("__ImageTag__"),
		},
		TargetStorageClass: types.TargetStorageClass("STANDARD"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateImageStorageClass(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UpdateImageStorageClass"); err != nil {
		t.Fatal(err)
	}
}

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

func TestUpdateRequestSnapshot_UpdateRepositoryCreationTemplate(t *testing.T) {
	input := &UpdateRepositoryCreationTemplateInput{
		Prefix:      ptr.String("__Prefix__"),
		Description: ptr.String("__Description__"),
		EncryptionConfiguration: &types.EncryptionConfigurationForRepositoryCreationTemplate{
			EncryptionType: types.EncryptionType("AES256"),
			KmsKey:         ptr.String("__KmsKey__"),
		},
		ResourceTags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		ImageTagMutability: types.ImageTagMutability("MUTABLE"),
		ImageTagMutabilityExclusionFilters: []types.ImageTagMutabilityExclusionFilter{
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
			{
				FilterType: types.ImageTagMutabilityExclusionFilterType("WILDCARD"),
				Filter:     ptr.String("__Filter__"),
			},
		},
		RepositoryPolicy: ptr.String("__RepositoryPolicy__"),
		LifecyclePolicy:  ptr.String("__LifecyclePolicy__"),
		AppliedFor: []types.RCTAppliedFor{
			types.RCTAppliedFor("REPLICATION"),
			types.RCTAppliedFor("REPLICATION"),
		},
		CustomRoleArn: ptr.String("__CustomRoleArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateRepositoryCreationTemplate(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UpdateRepositoryCreationTemplate"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UploadLayerPart(t *testing.T) {
	input := &UploadLayerPartInput{
		RegistryId:     ptr.String("__RegistryId__"),
		RepositoryName: ptr.String("__RepositoryName__"),
		UploadId:       ptr.String("__UploadId__"),
		PartFirstByte:  ptr.Int64(1),
		PartLastByte:   ptr.Int64(1),
		LayerPartBlob:  []byte("blob"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UploadLayerPart(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				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(), "UploadLayerPart"); err != nil {
		t.Fatal(err)
	}
}

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