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

//go:build request_snapshot

package auditmanager

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

const serdeSSPrefix = "request_snapshot"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type serdeEndpointResolver struct{}

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

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

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

func TestCheckRequestSnapshot_BatchCreateDelegationByAssessment(t *testing.T) {
	input := &BatchCreateDelegationByAssessmentInput{
		CreateDelegationRequests: []types.CreateDelegationRequest{
			{
				Comment:      ptr.String("__Comment__"),
				ControlSetId: ptr.String("__ControlSetId__"),
				RoleArn:      ptr.String("__RoleArn__"),
				RoleType:     types.RoleType("PROCESS_OWNER"),
			},
			{
				Comment:      ptr.String("__Comment__"),
				ControlSetId: ptr.String("__ControlSetId__"),
				RoleArn:      ptr.String("__RoleArn__"),
				RoleType:     types.RoleType("PROCESS_OWNER"),
			},
		},
		AssessmentId: ptr.String("__AssessmentId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchCreateDelegationByAssessment(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchCreateDelegationByAssessment"); err != nil {
		t.Fatal(err)
	}
}

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

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

func TestCheckRequestSnapshot_BatchImportEvidenceToAssessmentControl(t *testing.T) {
	input := &BatchImportEvidenceToAssessmentControlInput{
		AssessmentId: ptr.String("__AssessmentId__"),
		ControlSetId: ptr.String("__ControlSetId__"),
		ControlId:    ptr.String("__ControlId__"),
		ManualEvidence: []types.ManualEvidence{
			{
				S3ResourcePath:   ptr.String("__S3ResourcePath__"),
				TextResponse:     ptr.String("__TextResponse__"),
				EvidenceFileName: ptr.String("__EvidenceFileName__"),
			},
			{
				S3ResourcePath:   ptr.String("__S3ResourcePath__"),
				TextResponse:     ptr.String("__TextResponse__"),
				EvidenceFileName: ptr.String("__EvidenceFileName__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchImportEvidenceToAssessmentControl(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchImportEvidenceToAssessmentControl"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateAssessment(t *testing.T) {
	input := &CreateAssessmentInput{
		Name:        ptr.String("__Name__"),
		Description: ptr.String("__Description__"),
		AssessmentReportsDestination: &types.AssessmentReportsDestination{
			DestinationType: types.AssessmentReportDestinationType("S3"),
			Destination:     ptr.String("__Destination__"),
		},
		Scope: &types.Scope{
			AwsAccounts: []types.AWSAccount{
				{
					Id:           ptr.String("__Id__"),
					EmailAddress: ptr.String("__EmailAddress__"),
					Name:         ptr.String("__Name__"),
				},
				{
					Id:           ptr.String("__Id__"),
					EmailAddress: ptr.String("__EmailAddress__"),
					Name:         ptr.String("__Name__"),
				},
			},
			AwsServices: []types.AWSService{
				{
					ServiceName: ptr.String("__ServiceName__"),
				},
				{
					ServiceName: ptr.String("__ServiceName__"),
				},
			},
		},
		Roles: []types.Role{
			{
				RoleType: types.RoleType("PROCESS_OWNER"),
				RoleArn:  ptr.String("__RoleArn__"),
			},
			{
				RoleType: types.RoleType("PROCESS_OWNER"),
				RoleArn:  ptr.String("__RoleArn__"),
			},
		},
		FrameworkId: ptr.String("__FrameworkId__"),
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateAssessment(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateAssessment"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateAssessmentFramework(t *testing.T) {
	input := &CreateAssessmentFrameworkInput{
		Name:           ptr.String("__Name__"),
		Description:    ptr.String("__Description__"),
		ComplianceType: ptr.String("__ComplianceType__"),
		ControlSets: []types.CreateAssessmentFrameworkControlSet{
			{
				Name: ptr.String("__Name__"),
				Controls: []types.CreateAssessmentFrameworkControl{
					{
						Id: ptr.String("__Id__"),
					},
					{
						Id: ptr.String("__Id__"),
					},
				},
			},
			{
				Name: ptr.String("__Name__"),
				Controls: []types.CreateAssessmentFrameworkControl{
					{
						Id: ptr.String("__Id__"),
					},
					{
						Id: ptr.String("__Id__"),
					},
				},
			},
		},
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateAssessmentFramework(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateAssessmentFramework"); err != nil {
		t.Fatal(err)
	}
}

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

func TestCheckRequestSnapshot_CreateControl(t *testing.T) {
	input := &CreateControlInput{
		Name:                   ptr.String("__Name__"),
		Description:            ptr.String("__Description__"),
		TestingInformation:     ptr.String("__TestingInformation__"),
		ActionPlanTitle:        ptr.String("__ActionPlanTitle__"),
		ActionPlanInstructions: ptr.String("__ActionPlanInstructions__"),
		ControlMappingSources: []types.CreateControlMappingSource{
			{
				SourceName:        ptr.String("__SourceName__"),
				SourceDescription: ptr.String("__SourceDescription__"),
				SourceSetUpOption: types.SourceSetUpOption("System_Controls_Mapping"),
				SourceType:        types.SourceType("AWS_Cloudtrail"),
				SourceKeyword: &types.SourceKeyword{
					KeywordInputType: types.KeywordInputType("SELECT_FROM_LIST"),
					KeywordValue:     ptr.String("__KeywordValue__"),
				},
				SourceFrequency:     types.SourceFrequency("DAILY"),
				TroubleshootingText: ptr.String("__TroubleshootingText__"),
			},
			{
				SourceName:        ptr.String("__SourceName__"),
				SourceDescription: ptr.String("__SourceDescription__"),
				SourceSetUpOption: types.SourceSetUpOption("System_Controls_Mapping"),
				SourceType:        types.SourceType("AWS_Cloudtrail"),
				SourceKeyword: &types.SourceKeyword{
					KeywordInputType: types.KeywordInputType("SELECT_FROM_LIST"),
					KeywordValue:     ptr.String("__KeywordValue__"),
				},
				SourceFrequency:     types.SourceFrequency("DAILY"),
				TroubleshootingText: ptr.String("__TroubleshootingText__"),
			},
		},
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateControl(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateControl"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func TestCheckRequestSnapshot_GetEvidence(t *testing.T) {
	input := &GetEvidenceInput{
		AssessmentId:     ptr.String("__AssessmentId__"),
		ControlSetId:     ptr.String("__ControlSetId__"),
		EvidenceFolderId: ptr.String("__EvidenceFolderId__"),
		EvidenceId:       ptr.String("__EvidenceId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetEvidence(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetEvidence"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func TestCheckRequestSnapshot_ListNotifications(t *testing.T) {
	input := &ListNotificationsInput{
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListNotifications(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListNotifications"); 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_RegisterAccount(t *testing.T) {
	input := &RegisterAccountInput{
		KmsKey:                ptr.String("__KmsKey__"),
		DelegatedAdminAccount: ptr.String("__DelegatedAdminAccount__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.RegisterAccount(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "RegisterAccount"); err != nil {
		t.Fatal(err)
	}
}

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

func TestCheckRequestSnapshot_StartAssessmentFrameworkShare(t *testing.T) {
	input := &StartAssessmentFrameworkShareInput{
		FrameworkId:        ptr.String("__FrameworkId__"),
		DestinationAccount: ptr.String("__DestinationAccount__"),
		DestinationRegion:  ptr.String("__DestinationRegion__"),
		Comment:            ptr.String("__Comment__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartAssessmentFrameworkShare(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartAssessmentFrameworkShare"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_TagResource(t *testing.T) {
	input := &TagResourceInput{
		ResourceArn: ptr.String("__ResourceArn__"),
		Tags: map[string]string{
			"key0": "__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_UpdateAssessment(t *testing.T) {
	input := &UpdateAssessmentInput{
		AssessmentId:          ptr.String("__AssessmentId__"),
		AssessmentName:        ptr.String("__AssessmentName__"),
		AssessmentDescription: ptr.String("__AssessmentDescription__"),
		Scope: &types.Scope{
			AwsAccounts: []types.AWSAccount{
				{
					Id:           ptr.String("__Id__"),
					EmailAddress: ptr.String("__EmailAddress__"),
					Name:         ptr.String("__Name__"),
				},
				{
					Id:           ptr.String("__Id__"),
					EmailAddress: ptr.String("__EmailAddress__"),
					Name:         ptr.String("__Name__"),
				},
			},
			AwsServices: []types.AWSService{
				{
					ServiceName: ptr.String("__ServiceName__"),
				},
				{
					ServiceName: ptr.String("__ServiceName__"),
				},
			},
		},
		AssessmentReportsDestination: &types.AssessmentReportsDestination{
			DestinationType: types.AssessmentReportDestinationType("S3"),
			Destination:     ptr.String("__Destination__"),
		},
		Roles: []types.Role{
			{
				RoleType: types.RoleType("PROCESS_OWNER"),
				RoleArn:  ptr.String("__RoleArn__"),
			},
			{
				RoleType: types.RoleType("PROCESS_OWNER"),
				RoleArn:  ptr.String("__RoleArn__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateAssessment(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateAssessment"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateAssessmentControl(t *testing.T) {
	input := &UpdateAssessmentControlInput{
		AssessmentId:  ptr.String("__AssessmentId__"),
		ControlSetId:  ptr.String("__ControlSetId__"),
		ControlId:     ptr.String("__ControlId__"),
		ControlStatus: types.ControlStatus("UNDER_REVIEW"),
		CommentBody:   ptr.String("__CommentBody__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateAssessmentControl(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateAssessmentControl"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateAssessmentControlSetStatus(t *testing.T) {
	input := &UpdateAssessmentControlSetStatusInput{
		AssessmentId: ptr.String("__AssessmentId__"),
		ControlSetId: ptr.String("__ControlSetId__"),
		Status:       types.ControlSetStatus("ACTIVE"),
		Comment:      ptr.String("__Comment__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateAssessmentControlSetStatus(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateAssessmentControlSetStatus"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateAssessmentFramework(t *testing.T) {
	input := &UpdateAssessmentFrameworkInput{
		FrameworkId:    ptr.String("__FrameworkId__"),
		Name:           ptr.String("__Name__"),
		Description:    ptr.String("__Description__"),
		ComplianceType: ptr.String("__ComplianceType__"),
		ControlSets: []types.UpdateAssessmentFrameworkControlSet{
			{
				Id:   ptr.String("__Id__"),
				Name: ptr.String("__Name__"),
				Controls: []types.CreateAssessmentFrameworkControl{
					{
						Id: ptr.String("__Id__"),
					},
					{
						Id: ptr.String("__Id__"),
					},
				},
			},
			{
				Id:   ptr.String("__Id__"),
				Name: ptr.String("__Name__"),
				Controls: []types.CreateAssessmentFrameworkControl{
					{
						Id: ptr.String("__Id__"),
					},
					{
						Id: ptr.String("__Id__"),
					},
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateAssessmentFramework(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateAssessmentFramework"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateAssessmentFrameworkShare(t *testing.T) {
	input := &UpdateAssessmentFrameworkShareInput{
		RequestId:   ptr.String("__RequestId__"),
		RequestType: types.ShareRequestType("SENT"),
		Action:      types.ShareRequestAction("ACCEPT"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateAssessmentFrameworkShare(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateAssessmentFrameworkShare"); err != nil {
		t.Fatal(err)
	}
}

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

func TestCheckRequestSnapshot_UpdateControl(t *testing.T) {
	input := &UpdateControlInput{
		ControlId:              ptr.String("__ControlId__"),
		Name:                   ptr.String("__Name__"),
		Description:            ptr.String("__Description__"),
		TestingInformation:     ptr.String("__TestingInformation__"),
		ActionPlanTitle:        ptr.String("__ActionPlanTitle__"),
		ActionPlanInstructions: ptr.String("__ActionPlanInstructions__"),
		ControlMappingSources: []types.ControlMappingSource{
			{
				SourceId:          ptr.String("__SourceId__"),
				SourceName:        ptr.String("__SourceName__"),
				SourceDescription: ptr.String("__SourceDescription__"),
				SourceSetUpOption: types.SourceSetUpOption("System_Controls_Mapping"),
				SourceType:        types.SourceType("AWS_Cloudtrail"),
				SourceKeyword: &types.SourceKeyword{
					KeywordInputType: types.KeywordInputType("SELECT_FROM_LIST"),
					KeywordValue:     ptr.String("__KeywordValue__"),
				},
				SourceFrequency:     types.SourceFrequency("DAILY"),
				TroubleshootingText: ptr.String("__TroubleshootingText__"),
			},
			{
				SourceId:          ptr.String("__SourceId__"),
				SourceName:        ptr.String("__SourceName__"),
				SourceDescription: ptr.String("__SourceDescription__"),
				SourceSetUpOption: types.SourceSetUpOption("System_Controls_Mapping"),
				SourceType:        types.SourceType("AWS_Cloudtrail"),
				SourceKeyword: &types.SourceKeyword{
					KeywordInputType: types.KeywordInputType("SELECT_FROM_LIST"),
					KeywordValue:     ptr.String("__KeywordValue__"),
				},
				SourceFrequency:     types.SourceFrequency("DAILY"),
				TroubleshootingText: ptr.String("__TroubleshootingText__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateControl(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateControl"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateSettings(t *testing.T) {
	input := &UpdateSettingsInput{
		SnsTopic: ptr.String("__SnsTopic__"),
		DefaultAssessmentReportsDestination: &types.AssessmentReportsDestination{
			DestinationType: types.AssessmentReportDestinationType("S3"),
			Destination:     ptr.String("__Destination__"),
		},
		DefaultProcessOwners: []types.Role{
			{
				RoleType: types.RoleType("PROCESS_OWNER"),
				RoleArn:  ptr.String("__RoleArn__"),
			},
			{
				RoleType: types.RoleType("PROCESS_OWNER"),
				RoleArn:  ptr.String("__RoleArn__"),
			},
		},
		KmsKey:                ptr.String("__KmsKey__"),
		EvidenceFinderEnabled: ptr.Bool(true),
		DeregistrationPolicy: &types.DeregistrationPolicy{
			DeleteResources: types.DeleteResources("ALL"),
		},
		DefaultExportDestination: &types.DefaultExportDestination{
			DestinationType: types.ExportDestinationType("S3"),
			Destination:     ptr.String("__Destination__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateSettings(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateSettings"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ValidateAssessmentReportIntegrity(t *testing.T) {
	input := &ValidateAssessmentReportIntegrityInput{
		S3RelativePath: ptr.String("__S3RelativePath__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ValidateAssessmentReportIntegrity(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ValidateAssessmentReportIntegrity"); err != nil {
		t.Fatal(err)
	}
}
func TestUpdateRequestSnapshot_AssociateAssessmentReportEvidenceFolder(t *testing.T) {
	input := &AssociateAssessmentReportEvidenceFolderInput{
		AssessmentId:     ptr.String("__AssessmentId__"),
		EvidenceFolderId: ptr.String("__EvidenceFolderId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AssociateAssessmentReportEvidenceFolder(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AssociateAssessmentReportEvidenceFolder"); err != nil {
		t.Fatal(err)
	}
}

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

func TestUpdateRequestSnapshot_BatchCreateDelegationByAssessment(t *testing.T) {
	input := &BatchCreateDelegationByAssessmentInput{
		CreateDelegationRequests: []types.CreateDelegationRequest{
			{
				Comment:      ptr.String("__Comment__"),
				ControlSetId: ptr.String("__ControlSetId__"),
				RoleArn:      ptr.String("__RoleArn__"),
				RoleType:     types.RoleType("PROCESS_OWNER"),
			},
			{
				Comment:      ptr.String("__Comment__"),
				ControlSetId: ptr.String("__ControlSetId__"),
				RoleArn:      ptr.String("__RoleArn__"),
				RoleType:     types.RoleType("PROCESS_OWNER"),
			},
		},
		AssessmentId: ptr.String("__AssessmentId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchCreateDelegationByAssessment(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchCreateDelegationByAssessment"); err != nil {
		t.Fatal(err)
	}
}

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

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

func TestUpdateRequestSnapshot_BatchImportEvidenceToAssessmentControl(t *testing.T) {
	input := &BatchImportEvidenceToAssessmentControlInput{
		AssessmentId: ptr.String("__AssessmentId__"),
		ControlSetId: ptr.String("__ControlSetId__"),
		ControlId:    ptr.String("__ControlId__"),
		ManualEvidence: []types.ManualEvidence{
			{
				S3ResourcePath:   ptr.String("__S3ResourcePath__"),
				TextResponse:     ptr.String("__TextResponse__"),
				EvidenceFileName: ptr.String("__EvidenceFileName__"),
			},
			{
				S3ResourcePath:   ptr.String("__S3ResourcePath__"),
				TextResponse:     ptr.String("__TextResponse__"),
				EvidenceFileName: ptr.String("__EvidenceFileName__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchImportEvidenceToAssessmentControl(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchImportEvidenceToAssessmentControl"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateAssessment(t *testing.T) {
	input := &CreateAssessmentInput{
		Name:        ptr.String("__Name__"),
		Description: ptr.String("__Description__"),
		AssessmentReportsDestination: &types.AssessmentReportsDestination{
			DestinationType: types.AssessmentReportDestinationType("S3"),
			Destination:     ptr.String("__Destination__"),
		},
		Scope: &types.Scope{
			AwsAccounts: []types.AWSAccount{
				{
					Id:           ptr.String("__Id__"),
					EmailAddress: ptr.String("__EmailAddress__"),
					Name:         ptr.String("__Name__"),
				},
				{
					Id:           ptr.String("__Id__"),
					EmailAddress: ptr.String("__EmailAddress__"),
					Name:         ptr.String("__Name__"),
				},
			},
			AwsServices: []types.AWSService{
				{
					ServiceName: ptr.String("__ServiceName__"),
				},
				{
					ServiceName: ptr.String("__ServiceName__"),
				},
			},
		},
		Roles: []types.Role{
			{
				RoleType: types.RoleType("PROCESS_OWNER"),
				RoleArn:  ptr.String("__RoleArn__"),
			},
			{
				RoleType: types.RoleType("PROCESS_OWNER"),
				RoleArn:  ptr.String("__RoleArn__"),
			},
		},
		FrameworkId: ptr.String("__FrameworkId__"),
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateAssessment(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateAssessment"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateAssessmentFramework(t *testing.T) {
	input := &CreateAssessmentFrameworkInput{
		Name:           ptr.String("__Name__"),
		Description:    ptr.String("__Description__"),
		ComplianceType: ptr.String("__ComplianceType__"),
		ControlSets: []types.CreateAssessmentFrameworkControlSet{
			{
				Name: ptr.String("__Name__"),
				Controls: []types.CreateAssessmentFrameworkControl{
					{
						Id: ptr.String("__Id__"),
					},
					{
						Id: ptr.String("__Id__"),
					},
				},
			},
			{
				Name: ptr.String("__Name__"),
				Controls: []types.CreateAssessmentFrameworkControl{
					{
						Id: ptr.String("__Id__"),
					},
					{
						Id: ptr.String("__Id__"),
					},
				},
			},
		},
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateAssessmentFramework(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateAssessmentFramework"); err != nil {
		t.Fatal(err)
	}
}

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

func TestUpdateRequestSnapshot_CreateControl(t *testing.T) {
	input := &CreateControlInput{
		Name:                   ptr.String("__Name__"),
		Description:            ptr.String("__Description__"),
		TestingInformation:     ptr.String("__TestingInformation__"),
		ActionPlanTitle:        ptr.String("__ActionPlanTitle__"),
		ActionPlanInstructions: ptr.String("__ActionPlanInstructions__"),
		ControlMappingSources: []types.CreateControlMappingSource{
			{
				SourceName:        ptr.String("__SourceName__"),
				SourceDescription: ptr.String("__SourceDescription__"),
				SourceSetUpOption: types.SourceSetUpOption("System_Controls_Mapping"),
				SourceType:        types.SourceType("AWS_Cloudtrail"),
				SourceKeyword: &types.SourceKeyword{
					KeywordInputType: types.KeywordInputType("SELECT_FROM_LIST"),
					KeywordValue:     ptr.String("__KeywordValue__"),
				},
				SourceFrequency:     types.SourceFrequency("DAILY"),
				TroubleshootingText: ptr.String("__TroubleshootingText__"),
			},
			{
				SourceName:        ptr.String("__SourceName__"),
				SourceDescription: ptr.String("__SourceDescription__"),
				SourceSetUpOption: types.SourceSetUpOption("System_Controls_Mapping"),
				SourceType:        types.SourceType("AWS_Cloudtrail"),
				SourceKeyword: &types.SourceKeyword{
					KeywordInputType: types.KeywordInputType("SELECT_FROM_LIST"),
					KeywordValue:     ptr.String("__KeywordValue__"),
				},
				SourceFrequency:     types.SourceFrequency("DAILY"),
				TroubleshootingText: ptr.String("__TroubleshootingText__"),
			},
		},
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateControl(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateControl"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func TestUpdateRequestSnapshot_GetEvidence(t *testing.T) {
	input := &GetEvidenceInput{
		AssessmentId:     ptr.String("__AssessmentId__"),
		ControlSetId:     ptr.String("__ControlSetId__"),
		EvidenceFolderId: ptr.String("__EvidenceFolderId__"),
		EvidenceId:       ptr.String("__EvidenceId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetEvidence(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetEvidence"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func TestUpdateRequestSnapshot_ListNotifications(t *testing.T) {
	input := &ListNotificationsInput{
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListNotifications(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListNotifications"); 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_RegisterAccount(t *testing.T) {
	input := &RegisterAccountInput{
		KmsKey:                ptr.String("__KmsKey__"),
		DelegatedAdminAccount: ptr.String("__DelegatedAdminAccount__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.RegisterAccount(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "RegisterAccount"); err != nil {
		t.Fatal(err)
	}
}

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

func TestUpdateRequestSnapshot_StartAssessmentFrameworkShare(t *testing.T) {
	input := &StartAssessmentFrameworkShareInput{
		FrameworkId:        ptr.String("__FrameworkId__"),
		DestinationAccount: ptr.String("__DestinationAccount__"),
		DestinationRegion:  ptr.String("__DestinationRegion__"),
		Comment:            ptr.String("__Comment__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartAssessmentFrameworkShare(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartAssessmentFrameworkShare"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_TagResource(t *testing.T) {
	input := &TagResourceInput{
		ResourceArn: ptr.String("__ResourceArn__"),
		Tags: map[string]string{
			"key0": "__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_UpdateAssessment(t *testing.T) {
	input := &UpdateAssessmentInput{
		AssessmentId:          ptr.String("__AssessmentId__"),
		AssessmentName:        ptr.String("__AssessmentName__"),
		AssessmentDescription: ptr.String("__AssessmentDescription__"),
		Scope: &types.Scope{
			AwsAccounts: []types.AWSAccount{
				{
					Id:           ptr.String("__Id__"),
					EmailAddress: ptr.String("__EmailAddress__"),
					Name:         ptr.String("__Name__"),
				},
				{
					Id:           ptr.String("__Id__"),
					EmailAddress: ptr.String("__EmailAddress__"),
					Name:         ptr.String("__Name__"),
				},
			},
			AwsServices: []types.AWSService{
				{
					ServiceName: ptr.String("__ServiceName__"),
				},
				{
					ServiceName: ptr.String("__ServiceName__"),
				},
			},
		},
		AssessmentReportsDestination: &types.AssessmentReportsDestination{
			DestinationType: types.AssessmentReportDestinationType("S3"),
			Destination:     ptr.String("__Destination__"),
		},
		Roles: []types.Role{
			{
				RoleType: types.RoleType("PROCESS_OWNER"),
				RoleArn:  ptr.String("__RoleArn__"),
			},
			{
				RoleType: types.RoleType("PROCESS_OWNER"),
				RoleArn:  ptr.String("__RoleArn__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateAssessment(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateAssessment"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateAssessmentControl(t *testing.T) {
	input := &UpdateAssessmentControlInput{
		AssessmentId:  ptr.String("__AssessmentId__"),
		ControlSetId:  ptr.String("__ControlSetId__"),
		ControlId:     ptr.String("__ControlId__"),
		ControlStatus: types.ControlStatus("UNDER_REVIEW"),
		CommentBody:   ptr.String("__CommentBody__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateAssessmentControl(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateAssessmentControl"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateAssessmentControlSetStatus(t *testing.T) {
	input := &UpdateAssessmentControlSetStatusInput{
		AssessmentId: ptr.String("__AssessmentId__"),
		ControlSetId: ptr.String("__ControlSetId__"),
		Status:       types.ControlSetStatus("ACTIVE"),
		Comment:      ptr.String("__Comment__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateAssessmentControlSetStatus(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateAssessmentControlSetStatus"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateAssessmentFramework(t *testing.T) {
	input := &UpdateAssessmentFrameworkInput{
		FrameworkId:    ptr.String("__FrameworkId__"),
		Name:           ptr.String("__Name__"),
		Description:    ptr.String("__Description__"),
		ComplianceType: ptr.String("__ComplianceType__"),
		ControlSets: []types.UpdateAssessmentFrameworkControlSet{
			{
				Id:   ptr.String("__Id__"),
				Name: ptr.String("__Name__"),
				Controls: []types.CreateAssessmentFrameworkControl{
					{
						Id: ptr.String("__Id__"),
					},
					{
						Id: ptr.String("__Id__"),
					},
				},
			},
			{
				Id:   ptr.String("__Id__"),
				Name: ptr.String("__Name__"),
				Controls: []types.CreateAssessmentFrameworkControl{
					{
						Id: ptr.String("__Id__"),
					},
					{
						Id: ptr.String("__Id__"),
					},
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateAssessmentFramework(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateAssessmentFramework"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateAssessmentFrameworkShare(t *testing.T) {
	input := &UpdateAssessmentFrameworkShareInput{
		RequestId:   ptr.String("__RequestId__"),
		RequestType: types.ShareRequestType("SENT"),
		Action:      types.ShareRequestAction("ACCEPT"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateAssessmentFrameworkShare(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateAssessmentFrameworkShare"); err != nil {
		t.Fatal(err)
	}
}

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

func TestUpdateRequestSnapshot_UpdateControl(t *testing.T) {
	input := &UpdateControlInput{
		ControlId:              ptr.String("__ControlId__"),
		Name:                   ptr.String("__Name__"),
		Description:            ptr.String("__Description__"),
		TestingInformation:     ptr.String("__TestingInformation__"),
		ActionPlanTitle:        ptr.String("__ActionPlanTitle__"),
		ActionPlanInstructions: ptr.String("__ActionPlanInstructions__"),
		ControlMappingSources: []types.ControlMappingSource{
			{
				SourceId:          ptr.String("__SourceId__"),
				SourceName:        ptr.String("__SourceName__"),
				SourceDescription: ptr.String("__SourceDescription__"),
				SourceSetUpOption: types.SourceSetUpOption("System_Controls_Mapping"),
				SourceType:        types.SourceType("AWS_Cloudtrail"),
				SourceKeyword: &types.SourceKeyword{
					KeywordInputType: types.KeywordInputType("SELECT_FROM_LIST"),
					KeywordValue:     ptr.String("__KeywordValue__"),
				},
				SourceFrequency:     types.SourceFrequency("DAILY"),
				TroubleshootingText: ptr.String("__TroubleshootingText__"),
			},
			{
				SourceId:          ptr.String("__SourceId__"),
				SourceName:        ptr.String("__SourceName__"),
				SourceDescription: ptr.String("__SourceDescription__"),
				SourceSetUpOption: types.SourceSetUpOption("System_Controls_Mapping"),
				SourceType:        types.SourceType("AWS_Cloudtrail"),
				SourceKeyword: &types.SourceKeyword{
					KeywordInputType: types.KeywordInputType("SELECT_FROM_LIST"),
					KeywordValue:     ptr.String("__KeywordValue__"),
				},
				SourceFrequency:     types.SourceFrequency("DAILY"),
				TroubleshootingText: ptr.String("__TroubleshootingText__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateControl(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateControl"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateSettings(t *testing.T) {
	input := &UpdateSettingsInput{
		SnsTopic: ptr.String("__SnsTopic__"),
		DefaultAssessmentReportsDestination: &types.AssessmentReportsDestination{
			DestinationType: types.AssessmentReportDestinationType("S3"),
			Destination:     ptr.String("__Destination__"),
		},
		DefaultProcessOwners: []types.Role{
			{
				RoleType: types.RoleType("PROCESS_OWNER"),
				RoleArn:  ptr.String("__RoleArn__"),
			},
			{
				RoleType: types.RoleType("PROCESS_OWNER"),
				RoleArn:  ptr.String("__RoleArn__"),
			},
		},
		KmsKey:                ptr.String("__KmsKey__"),
		EvidenceFinderEnabled: ptr.Bool(true),
		DeregistrationPolicy: &types.DeregistrationPolicy{
			DeleteResources: types.DeleteResources("ALL"),
		},
		DefaultExportDestination: &types.DefaultExportDestination{
			DestinationType: types.ExportDestinationType("S3"),
			Destination:     ptr.String("__Destination__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateSettings(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateSettings"); err != nil {
		t.Fatal(err)
	}
}

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