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

//go:build request_snapshot

package appstream

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/appstream/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_AssociateAppBlockBuilderAppBlock(t *testing.T) {
	input := &AssociateAppBlockBuilderAppBlockInput{
		AppBlockArn:         ptr.String("__AppBlockArn__"),
		AppBlockBuilderName: ptr.String("__AppBlockBuilderName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AssociateAppBlockBuilderAppBlock(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AssociateAppBlockBuilderAppBlock"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

func TestCheckRequestSnapshot_BatchAssociateUserStack(t *testing.T) {
	input := &BatchAssociateUserStackInput{
		UserStackAssociations: []types.UserStackAssociation{
			{
				StackName:             ptr.String("__StackName__"),
				UserName:              ptr.String("__UserName__"),
				AuthenticationType:    types.AuthenticationType("API"),
				SendEmailNotification: ptr.Bool(true),
			},
			{
				StackName:             ptr.String("__StackName__"),
				UserName:              ptr.String("__UserName__"),
				AuthenticationType:    types.AuthenticationType("API"),
				SendEmailNotification: ptr.Bool(true),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchAssociateUserStack(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchAssociateUserStack"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_BatchDisassociateUserStack(t *testing.T) {
	input := &BatchDisassociateUserStackInput{
		UserStackAssociations: []types.UserStackAssociation{
			{
				StackName:             ptr.String("__StackName__"),
				UserName:              ptr.String("__UserName__"),
				AuthenticationType:    types.AuthenticationType("API"),
				SendEmailNotification: ptr.Bool(true),
			},
			{
				StackName:             ptr.String("__StackName__"),
				UserName:              ptr.String("__UserName__"),
				AuthenticationType:    types.AuthenticationType("API"),
				SendEmailNotification: ptr.Bool(true),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchDisassociateUserStack(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchDisassociateUserStack"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CopyImage(t *testing.T) {
	input := &CopyImageInput{
		SourceImageName:             ptr.String("__SourceImageName__"),
		DestinationImageName:        ptr.String("__DestinationImageName__"),
		DestinationRegion:           ptr.String("__DestinationRegion__"),
		DestinationImageDescription: ptr.String("__DestinationImageDescription__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CopyImage(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CopyImage"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateAppBlock(t *testing.T) {
	input := &CreateAppBlockInput{
		Name:        ptr.String("__Name__"),
		Description: ptr.String("__Description__"),
		DisplayName: ptr.String("__DisplayName__"),
		SourceS3Location: &types.S3Location{
			S3Bucket: ptr.String("__S3Bucket__"),
			S3Key:    ptr.String("__S3Key__"),
		},
		SetupScriptDetails: &types.ScriptDetails{
			ScriptS3Location: &types.S3Location{
				S3Bucket: ptr.String("__S3Bucket__"),
				S3Key:    ptr.String("__S3Key__"),
			},
			ExecutablePath:       ptr.String("__ExecutablePath__"),
			ExecutableParameters: ptr.String("__ExecutableParameters__"),
			TimeoutInSeconds:     ptr.Int32(1),
		},
		Tags: map[string]string{
			"key0": "__Value__",
		},
		PostSetupScriptDetails: &types.ScriptDetails{
			ScriptS3Location: &types.S3Location{
				S3Bucket: ptr.String("__S3Bucket__"),
				S3Key:    ptr.String("__S3Key__"),
			},
			ExecutablePath:       ptr.String("__ExecutablePath__"),
			ExecutableParameters: ptr.String("__ExecutableParameters__"),
			TimeoutInSeconds:     ptr.Int32(1),
		},
		PackagingType: types.PackagingType("CUSTOM"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateAppBlock(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateAppBlock"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateAppBlockBuilder(t *testing.T) {
	input := &CreateAppBlockBuilderInput{
		Name:        ptr.String("__Name__"),
		Description: ptr.String("__Description__"),
		DisplayName: ptr.String("__DisplayName__"),
		Tags: map[string]string{
			"key0": "__Value__",
		},
		Platform:     types.AppBlockBuilderPlatformType("WINDOWS_SERVER_2019"),
		InstanceType: ptr.String("__InstanceType__"),
		VpcConfig: &types.VpcConfig{
			SubnetIds: []string{
				"__Member__",
				"__Member__",
			},
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
		},
		EnableDefaultInternetAccess: ptr.Bool(true),
		IamRoleArn:                  ptr.String("__IamRoleArn__"),
		AccessEndpoints: []types.AccessEndpoint{
			{
				EndpointType: types.AccessEndpointType("STREAMING"),
				VpceId:       ptr.String("__VpceId__"),
			},
			{
				EndpointType: types.AccessEndpointType("STREAMING"),
				VpceId:       ptr.String("__VpceId__"),
			},
		},
		DisableIMDSV1: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateAppBlockBuilder(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateAppBlockBuilder"); err != nil {
		t.Fatal(err)
	}
}

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

func TestCheckRequestSnapshot_CreateApplication(t *testing.T) {
	input := &CreateApplicationInput{
		Name:        ptr.String("__Name__"),
		DisplayName: ptr.String("__DisplayName__"),
		Description: ptr.String("__Description__"),
		IconS3Location: &types.S3Location{
			S3Bucket: ptr.String("__S3Bucket__"),
			S3Key:    ptr.String("__S3Key__"),
		},
		LaunchPath:       ptr.String("__LaunchPath__"),
		WorkingDirectory: ptr.String("__WorkingDirectory__"),
		LaunchParameters: ptr.String("__LaunchParameters__"),
		Platforms: []types.PlatformType{
			types.PlatformType("WINDOWS"),
			types.PlatformType("WINDOWS"),
		},
		InstanceFamilies: []string{
			"__Member__",
			"__Member__",
		},
		AppBlockArn: ptr.String("__AppBlockArn__"),
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateApplication(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateApplication"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateDirectoryConfig(t *testing.T) {
	input := &CreateDirectoryConfigInput{
		DirectoryName: ptr.String("__DirectoryName__"),
		OrganizationalUnitDistinguishedNames: []string{
			"__Member__",
			"__Member__",
		},
		ServiceAccountCredentials: &types.ServiceAccountCredentials{
			AccountName:     ptr.String("__AccountName__"),
			AccountPassword: ptr.String("__AccountPassword__"),
		},
		CertificateBasedAuthProperties: &types.CertificateBasedAuthProperties{
			Status:                  types.CertificateBasedAuthStatus("DISABLED"),
			CertificateAuthorityArn: ptr.String("__CertificateAuthorityArn__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateDirectoryConfig(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateDirectoryConfig"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateEntitlement(t *testing.T) {
	input := &CreateEntitlementInput{
		Name:          ptr.String("__Name__"),
		StackName:     ptr.String("__StackName__"),
		Description:   ptr.String("__Description__"),
		AppVisibility: types.AppVisibility("ALL"),
		Attributes: []types.EntitlementAttribute{
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateEntitlement(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateEntitlement"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateExportImageTask(t *testing.T) {
	input := &CreateExportImageTaskInput{
		ImageName:  ptr.String("__ImageName__"),
		AmiName:    ptr.String("__AmiName__"),
		IamRoleArn: ptr.String("__IamRoleArn__"),
		TagSpecifications: map[string]string{
			"key0": "__Value__",
		},
		AmiDescription: ptr.String("__AmiDescription__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateExportImageTask(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateExportImageTask"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateFleet(t *testing.T) {
	input := &CreateFleetInput{
		Name:         ptr.String("__Name__"),
		ImageName:    ptr.String("__ImageName__"),
		ImageArn:     ptr.String("__ImageArn__"),
		InstanceType: ptr.String("__InstanceType__"),
		FleetType:    types.FleetType("ALWAYS_ON"),
		ComputeCapacity: &types.ComputeCapacity{
			DesiredInstances: ptr.Int32(1),
			DesiredSessions:  ptr.Int32(1),
		},
		VpcConfig: &types.VpcConfig{
			SubnetIds: []string{
				"__Member__",
				"__Member__",
			},
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
		},
		MaxUserDurationInSeconds:    ptr.Int32(1),
		DisconnectTimeoutInSeconds:  ptr.Int32(1),
		Description:                 ptr.String("__Description__"),
		DisplayName:                 ptr.String("__DisplayName__"),
		EnableDefaultInternetAccess: ptr.Bool(true),
		DomainJoinInfo: &types.DomainJoinInfo{
			DirectoryName:                       ptr.String("__DirectoryName__"),
			OrganizationalUnitDistinguishedName: ptr.String("__OrganizationalUnitDistinguishedName__"),
		},
		Tags: map[string]string{
			"key0": "__Value__",
		},
		IdleDisconnectTimeoutInSeconds: ptr.Int32(1),
		IamRoleArn:                     ptr.String("__IamRoleArn__"),
		StreamView:                     types.StreamView("APP"),
		Platform:                       types.PlatformType("WINDOWS"),
		MaxConcurrentSessions:          ptr.Int32(1),
		UsbDeviceFilterStrings: []string{
			"__Member__",
			"__Member__",
		},
		SessionScriptS3Location: &types.S3Location{
			S3Bucket: ptr.String("__S3Bucket__"),
			S3Key:    ptr.String("__S3Key__"),
		},
		MaxSessionsPerInstance: ptr.Int32(1),
		RootVolumeConfig: &types.VolumeConfig{
			VolumeSizeInGb: ptr.Int32(1),
		},
		DisableIMDSV1: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateFleet(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateFleet"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateImageBuilder(t *testing.T) {
	input := &CreateImageBuilderInput{
		Name:         ptr.String("__Name__"),
		ImageName:    ptr.String("__ImageName__"),
		ImageArn:     ptr.String("__ImageArn__"),
		InstanceType: ptr.String("__InstanceType__"),
		Description:  ptr.String("__Description__"),
		DisplayName:  ptr.String("__DisplayName__"),
		VpcConfig: &types.VpcConfig{
			SubnetIds: []string{
				"__Member__",
				"__Member__",
			},
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
		},
		IamRoleArn:                  ptr.String("__IamRoleArn__"),
		EnableDefaultInternetAccess: ptr.Bool(true),
		DomainJoinInfo: &types.DomainJoinInfo{
			DirectoryName:                       ptr.String("__DirectoryName__"),
			OrganizationalUnitDistinguishedName: ptr.String("__OrganizationalUnitDistinguishedName__"),
		},
		AppstreamAgentVersion: ptr.String("__AppstreamAgentVersion__"),
		Tags: map[string]string{
			"key0": "__Value__",
		},
		AccessEndpoints: []types.AccessEndpoint{
			{
				EndpointType: types.AccessEndpointType("STREAMING"),
				VpceId:       ptr.String("__VpceId__"),
			},
			{
				EndpointType: types.AccessEndpointType("STREAMING"),
				VpceId:       ptr.String("__VpceId__"),
			},
		},
		RootVolumeConfig: &types.VolumeConfig{
			VolumeSizeInGb: ptr.Int32(1),
		},
		SoftwaresToInstall: []string{
			"__Member__",
			"__Member__",
		},
		SoftwaresToUninstall: []string{
			"__Member__",
			"__Member__",
		},
		DisableIMDSV1: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateImageBuilder(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateImageBuilder"); err != nil {
		t.Fatal(err)
	}
}

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

func TestCheckRequestSnapshot_CreateImportedImage(t *testing.T) {
	input := &CreateImportedImageInput{
		Name:             ptr.String("__Name__"),
		SourceAmiId:      ptr.String("__SourceAmiId__"),
		WorkspaceImageId: ptr.String("__WorkspaceImageId__"),
		IamRoleArn:       ptr.String("__IamRoleArn__"),
		Description:      ptr.String("__Description__"),
		DisplayName:      ptr.String("__DisplayName__"),
		Tags: map[string]string{
			"key0": "__Value__",
		},
		RuntimeValidationConfig: &types.RuntimeValidationConfig{
			IntendedInstanceType: ptr.String("__IntendedInstanceType__"),
		},
		AgentSoftwareVersion: types.AgentSoftwareVersion("CURRENT_LATEST"),
		AppCatalogConfig: []types.ApplicationConfig{
			{
				Name:                 ptr.String("__Name__"),
				DisplayName:          ptr.String("__DisplayName__"),
				AbsoluteAppPath:      ptr.String("__AbsoluteAppPath__"),
				AbsoluteIconPath:     ptr.String("__AbsoluteIconPath__"),
				AbsoluteManifestPath: ptr.String("__AbsoluteManifestPath__"),
				WorkingDirectory:     ptr.String("__WorkingDirectory__"),
				LaunchParameters:     ptr.String("__LaunchParameters__"),
			},
			{
				Name:                 ptr.String("__Name__"),
				DisplayName:          ptr.String("__DisplayName__"),
				AbsoluteAppPath:      ptr.String("__AbsoluteAppPath__"),
				AbsoluteIconPath:     ptr.String("__AbsoluteIconPath__"),
				AbsoluteManifestPath: ptr.String("__AbsoluteManifestPath__"),
				WorkingDirectory:     ptr.String("__WorkingDirectory__"),
				LaunchParameters:     ptr.String("__LaunchParameters__"),
			},
		},
		DryRun: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateImportedImage(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateImportedImage"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateStack(t *testing.T) {
	input := &CreateStackInput{
		Name:        ptr.String("__Name__"),
		Description: ptr.String("__Description__"),
		DisplayName: ptr.String("__DisplayName__"),
		StorageConnectors: []types.StorageConnector{
			{
				ConnectorType:      types.StorageConnectorType("HOMEFOLDERS"),
				ResourceIdentifier: ptr.String("__ResourceIdentifier__"),
				Domains: []string{
					"__Member__",
					"__Member__",
				},
				DomainsRequireAdminConsent: []string{
					"__Member__",
					"__Member__",
				},
			},
			{
				ConnectorType:      types.StorageConnectorType("HOMEFOLDERS"),
				ResourceIdentifier: ptr.String("__ResourceIdentifier__"),
				Domains: []string{
					"__Member__",
					"__Member__",
				},
				DomainsRequireAdminConsent: []string{
					"__Member__",
					"__Member__",
				},
			},
		},
		RedirectURL: ptr.String("__RedirectURL__"),
		FeedbackURL: ptr.String("__FeedbackURL__"),
		UserSettings: []types.UserSetting{
			{
				Action:        types.Action("CLIPBOARD_COPY_FROM_LOCAL_DEVICE"),
				Permission:    types.Permission("ENABLED"),
				MaximumLength: ptr.Int32(1),
			},
			{
				Action:        types.Action("CLIPBOARD_COPY_FROM_LOCAL_DEVICE"),
				Permission:    types.Permission("ENABLED"),
				MaximumLength: ptr.Int32(1),
			},
		},
		ApplicationSettings: &types.ApplicationSettings{
			Enabled:       ptr.Bool(true),
			SettingsGroup: ptr.String("__SettingsGroup__"),
		},
		Tags: map[string]string{
			"key0": "__Value__",
		},
		AccessEndpoints: []types.AccessEndpoint{
			{
				EndpointType: types.AccessEndpointType("STREAMING"),
				VpceId:       ptr.String("__VpceId__"),
			},
			{
				EndpointType: types.AccessEndpointType("STREAMING"),
				VpceId:       ptr.String("__VpceId__"),
			},
		},
		EmbedHostDomains: []string{
			"__Member__",
			"__Member__",
		},
		StreamingExperienceSettings: &types.StreamingExperienceSettings{
			PreferredProtocol: types.PreferredProtocol("TCP"),
		},
		ContentRedirection: &types.ContentRedirection{
			HostToClient: &types.UrlRedirectionConfig{
				Enabled: ptr.Bool(true),
				AllowedUrls: []string{
					"__Member__",
					"__Member__",
				},
				DeniedUrls: []string{
					"__Member__",
					"__Member__",
				},
			},
		},
		AgentAccessConfig: &types.AgentAccessConfig{
			Settings: []types.AgentAccessSetting{
				{
					AgentAction: types.AgentAction("COMPUTER_VISION"),
					Permission:  types.Permission("ENABLED"),
				},
				{
					AgentAction: types.AgentAction("COMPUTER_VISION"),
					Permission:  types.Permission("ENABLED"),
				},
			},
			S3BucketArn:              ptr.String("__S3BucketArn__"),
			ScreenshotsUploadEnabled: ptr.Bool(true),
			ScreenResolution:         types.ScreenResolution("W_1280xH_720"),
			ScreenImageFormat:        types.ScreenImageFormat("PNG"),
			UserControlMode:          types.UserControlMode("VIEW_ONLY"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateStack(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateStack"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateStreamingURL(t *testing.T) {
	input := &CreateStreamingURLInput{
		StackName:      ptr.String("__StackName__"),
		FleetName:      ptr.String("__FleetName__"),
		UserId:         ptr.String("__UserId__"),
		ApplicationId:  ptr.String("__ApplicationId__"),
		Validity:       ptr.Int64(1),
		SessionContext: ptr.String("__SessionContext__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateStreamingURL(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateStreamingURL"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateThemeForStack(t *testing.T) {
	input := &CreateThemeForStackInput{
		StackName: ptr.String("__StackName__"),
		FooterLinks: []types.ThemeFooterLink{
			{
				DisplayName:   ptr.String("__DisplayName__"),
				FooterLinkURL: ptr.String("__FooterLinkURL__"),
			},
			{
				DisplayName:   ptr.String("__DisplayName__"),
				FooterLinkURL: ptr.String("__FooterLinkURL__"),
			},
		},
		TitleText:    ptr.String("__TitleText__"),
		ThemeStyling: types.ThemeStyling("LIGHT_BLUE"),
		OrganizationLogoS3Location: &types.S3Location{
			S3Bucket: ptr.String("__S3Bucket__"),
			S3Key:    ptr.String("__S3Key__"),
		},
		FaviconS3Location: &types.S3Location{
			S3Bucket: ptr.String("__S3Bucket__"),
			S3Key:    ptr.String("__S3Key__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateThemeForStack(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateThemeForStack"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateUpdatedImage(t *testing.T) {
	input := &CreateUpdatedImageInput{
		ExistingImageName:   ptr.String("__ExistingImageName__"),
		NewImageName:        ptr.String("__NewImageName__"),
		NewImageDescription: ptr.String("__NewImageDescription__"),
		NewImageDisplayName: ptr.String("__NewImageDisplayName__"),
		NewImageTags: map[string]string{
			"key0": "__Value__",
		},
		DryRun: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateUpdatedImage(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateUpdatedImage"); err != nil {
		t.Fatal(err)
	}
}

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

func TestCheckRequestSnapshot_CreateUser(t *testing.T) {
	input := &CreateUserInput{
		UserName:           ptr.String("__UserName__"),
		MessageAction:      types.MessageAction("SUPPRESS"),
		FirstName:          ptr.String("__FirstName__"),
		LastName:           ptr.String("__LastName__"),
		AuthenticationType: types.AuthenticationType("API"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateUser(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateUser"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func TestCheckRequestSnapshot_DescribeSessions(t *testing.T) {
	input := &DescribeSessionsInput{
		StackName:          ptr.String("__StackName__"),
		FleetName:          ptr.String("__FleetName__"),
		UserId:             ptr.String("__UserId__"),
		NextToken:          ptr.String("__NextToken__"),
		Limit:              ptr.Int32(1),
		AuthenticationType: types.AuthenticationType("API"),
		InstanceId:         ptr.String("__InstanceId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeSessions(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeSessions"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func TestCheckRequestSnapshot_ListExportImageTasks(t *testing.T) {
	input := &ListExportImageTasksInput{
		Filters: []types.Filter{
			{
				Name: ptr.String("__Name__"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
			},
			{
				Name: ptr.String("__Name__"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
			},
		},
		MaxResults: ptr.Int32(1),
		NextToken:  ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListExportImageTasks(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListExportImageTasks"); 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_StartAppBlockBuilder(t *testing.T) {
	input := &StartAppBlockBuilderInput{
		Name: ptr.String("__Name__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartAppBlockBuilder(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartAppBlockBuilder"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

func TestCheckRequestSnapshot_StopImageBuilder(t *testing.T) {
	input := &StopImageBuilderInput{
		Name: ptr.String("__Name__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopImageBuilder(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StopImageBuilder"); 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_UpdateAppBlockBuilder(t *testing.T) {
	input := &UpdateAppBlockBuilderInput{
		Name:         ptr.String("__Name__"),
		Description:  ptr.String("__Description__"),
		DisplayName:  ptr.String("__DisplayName__"),
		Platform:     types.PlatformType("WINDOWS"),
		InstanceType: ptr.String("__InstanceType__"),
		VpcConfig: &types.VpcConfig{
			SubnetIds: []string{
				"__Member__",
				"__Member__",
			},
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
		},
		EnableDefaultInternetAccess: ptr.Bool(true),
		IamRoleArn:                  ptr.String("__IamRoleArn__"),
		AccessEndpoints: []types.AccessEndpoint{
			{
				EndpointType: types.AccessEndpointType("STREAMING"),
				VpceId:       ptr.String("__VpceId__"),
			},
			{
				EndpointType: types.AccessEndpointType("STREAMING"),
				VpceId:       ptr.String("__VpceId__"),
			},
		},
		AttributesToDelete: []types.AppBlockBuilderAttribute{
			types.AppBlockBuilderAttribute("IAM_ROLE_ARN"),
			types.AppBlockBuilderAttribute("IAM_ROLE_ARN"),
		},
		DisableIMDSV1: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateAppBlockBuilder(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateAppBlockBuilder"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateApplication(t *testing.T) {
	input := &UpdateApplicationInput{
		Name:        ptr.String("__Name__"),
		DisplayName: ptr.String("__DisplayName__"),
		Description: ptr.String("__Description__"),
		IconS3Location: &types.S3Location{
			S3Bucket: ptr.String("__S3Bucket__"),
			S3Key:    ptr.String("__S3Key__"),
		},
		LaunchPath:       ptr.String("__LaunchPath__"),
		WorkingDirectory: ptr.String("__WorkingDirectory__"),
		LaunchParameters: ptr.String("__LaunchParameters__"),
		AppBlockArn:      ptr.String("__AppBlockArn__"),
		AttributesToDelete: []types.ApplicationAttribute{
			types.ApplicationAttribute("LAUNCH_PARAMETERS"),
			types.ApplicationAttribute("LAUNCH_PARAMETERS"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateApplication(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateApplication"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateDirectoryConfig(t *testing.T) {
	input := &UpdateDirectoryConfigInput{
		DirectoryName: ptr.String("__DirectoryName__"),
		OrganizationalUnitDistinguishedNames: []string{
			"__Member__",
			"__Member__",
		},
		ServiceAccountCredentials: &types.ServiceAccountCredentials{
			AccountName:     ptr.String("__AccountName__"),
			AccountPassword: ptr.String("__AccountPassword__"),
		},
		CertificateBasedAuthProperties: &types.CertificateBasedAuthProperties{
			Status:                  types.CertificateBasedAuthStatus("DISABLED"),
			CertificateAuthorityArn: ptr.String("__CertificateAuthorityArn__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateDirectoryConfig(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateDirectoryConfig"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateEntitlement(t *testing.T) {
	input := &UpdateEntitlementInput{
		Name:          ptr.String("__Name__"),
		StackName:     ptr.String("__StackName__"),
		Description:   ptr.String("__Description__"),
		AppVisibility: types.AppVisibility("ALL"),
		Attributes: []types.EntitlementAttribute{
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateEntitlement(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateEntitlement"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateFleet(t *testing.T) {
	input := &UpdateFleetInput{
		ImageName:    ptr.String("__ImageName__"),
		ImageArn:     ptr.String("__ImageArn__"),
		Name:         ptr.String("__Name__"),
		InstanceType: ptr.String("__InstanceType__"),
		ComputeCapacity: &types.ComputeCapacity{
			DesiredInstances: ptr.Int32(1),
			DesiredSessions:  ptr.Int32(1),
		},
		VpcConfig: &types.VpcConfig{
			SubnetIds: []string{
				"__Member__",
				"__Member__",
			},
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
		},
		MaxUserDurationInSeconds:    ptr.Int32(1),
		DisconnectTimeoutInSeconds:  ptr.Int32(1),
		DeleteVpcConfig:             ptr.Bool(true),
		Description:                 ptr.String("__Description__"),
		DisplayName:                 ptr.String("__DisplayName__"),
		EnableDefaultInternetAccess: ptr.Bool(true),
		DomainJoinInfo: &types.DomainJoinInfo{
			DirectoryName:                       ptr.String("__DirectoryName__"),
			OrganizationalUnitDistinguishedName: ptr.String("__OrganizationalUnitDistinguishedName__"),
		},
		IdleDisconnectTimeoutInSeconds: ptr.Int32(1),
		AttributesToDelete: []types.FleetAttribute{
			types.FleetAttribute("VPC_CONFIGURATION"),
			types.FleetAttribute("VPC_CONFIGURATION"),
		},
		IamRoleArn:            ptr.String("__IamRoleArn__"),
		StreamView:            types.StreamView("APP"),
		Platform:              types.PlatformType("WINDOWS"),
		MaxConcurrentSessions: ptr.Int32(1),
		UsbDeviceFilterStrings: []string{
			"__Member__",
			"__Member__",
		},
		SessionScriptS3Location: &types.S3Location{
			S3Bucket: ptr.String("__S3Bucket__"),
			S3Key:    ptr.String("__S3Key__"),
		},
		MaxSessionsPerInstance: ptr.Int32(1),
		RootVolumeConfig: &types.VolumeConfig{
			VolumeSizeInGb: ptr.Int32(1),
		},
		DisableIMDSV1: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateFleet(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateFleet"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateImagePermissions(t *testing.T) {
	input := &UpdateImagePermissionsInput{
		Name:            ptr.String("__Name__"),
		SharedAccountId: ptr.String("__SharedAccountId__"),
		ImagePermissions: &types.ImagePermissions{
			AllowFleet:        ptr.Bool(true),
			AllowImageBuilder: ptr.Bool(true),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateImagePermissions(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateImagePermissions"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateStack(t *testing.T) {
	input := &UpdateStackInput{
		DisplayName: ptr.String("__DisplayName__"),
		Description: ptr.String("__Description__"),
		Name:        ptr.String("__Name__"),
		StorageConnectors: []types.StorageConnector{
			{
				ConnectorType:      types.StorageConnectorType("HOMEFOLDERS"),
				ResourceIdentifier: ptr.String("__ResourceIdentifier__"),
				Domains: []string{
					"__Member__",
					"__Member__",
				},
				DomainsRequireAdminConsent: []string{
					"__Member__",
					"__Member__",
				},
			},
			{
				ConnectorType:      types.StorageConnectorType("HOMEFOLDERS"),
				ResourceIdentifier: ptr.String("__ResourceIdentifier__"),
				Domains: []string{
					"__Member__",
					"__Member__",
				},
				DomainsRequireAdminConsent: []string{
					"__Member__",
					"__Member__",
				},
			},
		},
		DeleteStorageConnectors: ptr.Bool(true),
		RedirectURL:             ptr.String("__RedirectURL__"),
		FeedbackURL:             ptr.String("__FeedbackURL__"),
		AttributesToDelete: []types.StackAttribute{
			types.StackAttribute("STORAGE_CONNECTORS"),
			types.StackAttribute("STORAGE_CONNECTORS"),
		},
		UserSettings: []types.UserSetting{
			{
				Action:        types.Action("CLIPBOARD_COPY_FROM_LOCAL_DEVICE"),
				Permission:    types.Permission("ENABLED"),
				MaximumLength: ptr.Int32(1),
			},
			{
				Action:        types.Action("CLIPBOARD_COPY_FROM_LOCAL_DEVICE"),
				Permission:    types.Permission("ENABLED"),
				MaximumLength: ptr.Int32(1),
			},
		},
		ApplicationSettings: &types.ApplicationSettings{
			Enabled:       ptr.Bool(true),
			SettingsGroup: ptr.String("__SettingsGroup__"),
		},
		AccessEndpoints: []types.AccessEndpoint{
			{
				EndpointType: types.AccessEndpointType("STREAMING"),
				VpceId:       ptr.String("__VpceId__"),
			},
			{
				EndpointType: types.AccessEndpointType("STREAMING"),
				VpceId:       ptr.String("__VpceId__"),
			},
		},
		EmbedHostDomains: []string{
			"__Member__",
			"__Member__",
		},
		StreamingExperienceSettings: &types.StreamingExperienceSettings{
			PreferredProtocol: types.PreferredProtocol("TCP"),
		},
		ContentRedirection: &types.ContentRedirection{
			HostToClient: &types.UrlRedirectionConfig{
				Enabled: ptr.Bool(true),
				AllowedUrls: []string{
					"__Member__",
					"__Member__",
				},
				DeniedUrls: []string{
					"__Member__",
					"__Member__",
				},
			},
		},
		AgentAccessConfig: &types.AgentAccessConfigForUpdate{
			Settings: []types.AgentAccessSetting{
				{
					AgentAction: types.AgentAction("COMPUTER_VISION"),
					Permission:  types.Permission("ENABLED"),
				},
				{
					AgentAction: types.AgentAction("COMPUTER_VISION"),
					Permission:  types.Permission("ENABLED"),
				},
			},
			S3BucketArn:              ptr.String("__S3BucketArn__"),
			ScreenshotsUploadEnabled: ptr.Bool(true),
			ScreenResolution:         types.ScreenResolution("W_1280xH_720"),
			ScreenImageFormat:        types.ScreenImageFormat("PNG"),
			UserControlMode:          types.UserControlMode("VIEW_ONLY"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateStack(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateStack"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateThemeForStack(t *testing.T) {
	input := &UpdateThemeForStackInput{
		StackName: ptr.String("__StackName__"),
		FooterLinks: []types.ThemeFooterLink{
			{
				DisplayName:   ptr.String("__DisplayName__"),
				FooterLinkURL: ptr.String("__FooterLinkURL__"),
			},
			{
				DisplayName:   ptr.String("__DisplayName__"),
				FooterLinkURL: ptr.String("__FooterLinkURL__"),
			},
		},
		TitleText:    ptr.String("__TitleText__"),
		ThemeStyling: types.ThemeStyling("LIGHT_BLUE"),
		OrganizationLogoS3Location: &types.S3Location{
			S3Bucket: ptr.String("__S3Bucket__"),
			S3Key:    ptr.String("__S3Key__"),
		},
		FaviconS3Location: &types.S3Location{
			S3Bucket: ptr.String("__S3Bucket__"),
			S3Key:    ptr.String("__S3Key__"),
		},
		State: types.ThemeState("ENABLED"),
		AttributesToDelete: []types.ThemeAttribute{
			types.ThemeAttribute("FOOTER_LINKS"),
			types.ThemeAttribute("FOOTER_LINKS"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateThemeForStack(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateThemeForStack"); err != nil {
		t.Fatal(err)
	}
}
func TestUpdateRequestSnapshot_AssociateAppBlockBuilderAppBlock(t *testing.T) {
	input := &AssociateAppBlockBuilderAppBlockInput{
		AppBlockArn:         ptr.String("__AppBlockArn__"),
		AppBlockBuilderName: ptr.String("__AppBlockBuilderName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AssociateAppBlockBuilderAppBlock(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AssociateAppBlockBuilderAppBlock"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

func TestUpdateRequestSnapshot_BatchAssociateUserStack(t *testing.T) {
	input := &BatchAssociateUserStackInput{
		UserStackAssociations: []types.UserStackAssociation{
			{
				StackName:             ptr.String("__StackName__"),
				UserName:              ptr.String("__UserName__"),
				AuthenticationType:    types.AuthenticationType("API"),
				SendEmailNotification: ptr.Bool(true),
			},
			{
				StackName:             ptr.String("__StackName__"),
				UserName:              ptr.String("__UserName__"),
				AuthenticationType:    types.AuthenticationType("API"),
				SendEmailNotification: ptr.Bool(true),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchAssociateUserStack(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchAssociateUserStack"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_BatchDisassociateUserStack(t *testing.T) {
	input := &BatchDisassociateUserStackInput{
		UserStackAssociations: []types.UserStackAssociation{
			{
				StackName:             ptr.String("__StackName__"),
				UserName:              ptr.String("__UserName__"),
				AuthenticationType:    types.AuthenticationType("API"),
				SendEmailNotification: ptr.Bool(true),
			},
			{
				StackName:             ptr.String("__StackName__"),
				UserName:              ptr.String("__UserName__"),
				AuthenticationType:    types.AuthenticationType("API"),
				SendEmailNotification: ptr.Bool(true),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchDisassociateUserStack(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchDisassociateUserStack"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CopyImage(t *testing.T) {
	input := &CopyImageInput{
		SourceImageName:             ptr.String("__SourceImageName__"),
		DestinationImageName:        ptr.String("__DestinationImageName__"),
		DestinationRegion:           ptr.String("__DestinationRegion__"),
		DestinationImageDescription: ptr.String("__DestinationImageDescription__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CopyImage(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CopyImage"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateAppBlock(t *testing.T) {
	input := &CreateAppBlockInput{
		Name:        ptr.String("__Name__"),
		Description: ptr.String("__Description__"),
		DisplayName: ptr.String("__DisplayName__"),
		SourceS3Location: &types.S3Location{
			S3Bucket: ptr.String("__S3Bucket__"),
			S3Key:    ptr.String("__S3Key__"),
		},
		SetupScriptDetails: &types.ScriptDetails{
			ScriptS3Location: &types.S3Location{
				S3Bucket: ptr.String("__S3Bucket__"),
				S3Key:    ptr.String("__S3Key__"),
			},
			ExecutablePath:       ptr.String("__ExecutablePath__"),
			ExecutableParameters: ptr.String("__ExecutableParameters__"),
			TimeoutInSeconds:     ptr.Int32(1),
		},
		Tags: map[string]string{
			"key0": "__Value__",
		},
		PostSetupScriptDetails: &types.ScriptDetails{
			ScriptS3Location: &types.S3Location{
				S3Bucket: ptr.String("__S3Bucket__"),
				S3Key:    ptr.String("__S3Key__"),
			},
			ExecutablePath:       ptr.String("__ExecutablePath__"),
			ExecutableParameters: ptr.String("__ExecutableParameters__"),
			TimeoutInSeconds:     ptr.Int32(1),
		},
		PackagingType: types.PackagingType("CUSTOM"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateAppBlock(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateAppBlock"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateAppBlockBuilder(t *testing.T) {
	input := &CreateAppBlockBuilderInput{
		Name:        ptr.String("__Name__"),
		Description: ptr.String("__Description__"),
		DisplayName: ptr.String("__DisplayName__"),
		Tags: map[string]string{
			"key0": "__Value__",
		},
		Platform:     types.AppBlockBuilderPlatformType("WINDOWS_SERVER_2019"),
		InstanceType: ptr.String("__InstanceType__"),
		VpcConfig: &types.VpcConfig{
			SubnetIds: []string{
				"__Member__",
				"__Member__",
			},
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
		},
		EnableDefaultInternetAccess: ptr.Bool(true),
		IamRoleArn:                  ptr.String("__IamRoleArn__"),
		AccessEndpoints: []types.AccessEndpoint{
			{
				EndpointType: types.AccessEndpointType("STREAMING"),
				VpceId:       ptr.String("__VpceId__"),
			},
			{
				EndpointType: types.AccessEndpointType("STREAMING"),
				VpceId:       ptr.String("__VpceId__"),
			},
		},
		DisableIMDSV1: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateAppBlockBuilder(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateAppBlockBuilder"); err != nil {
		t.Fatal(err)
	}
}

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

func TestUpdateRequestSnapshot_CreateApplication(t *testing.T) {
	input := &CreateApplicationInput{
		Name:        ptr.String("__Name__"),
		DisplayName: ptr.String("__DisplayName__"),
		Description: ptr.String("__Description__"),
		IconS3Location: &types.S3Location{
			S3Bucket: ptr.String("__S3Bucket__"),
			S3Key:    ptr.String("__S3Key__"),
		},
		LaunchPath:       ptr.String("__LaunchPath__"),
		WorkingDirectory: ptr.String("__WorkingDirectory__"),
		LaunchParameters: ptr.String("__LaunchParameters__"),
		Platforms: []types.PlatformType{
			types.PlatformType("WINDOWS"),
			types.PlatformType("WINDOWS"),
		},
		InstanceFamilies: []string{
			"__Member__",
			"__Member__",
		},
		AppBlockArn: ptr.String("__AppBlockArn__"),
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateApplication(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateApplication"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateDirectoryConfig(t *testing.T) {
	input := &CreateDirectoryConfigInput{
		DirectoryName: ptr.String("__DirectoryName__"),
		OrganizationalUnitDistinguishedNames: []string{
			"__Member__",
			"__Member__",
		},
		ServiceAccountCredentials: &types.ServiceAccountCredentials{
			AccountName:     ptr.String("__AccountName__"),
			AccountPassword: ptr.String("__AccountPassword__"),
		},
		CertificateBasedAuthProperties: &types.CertificateBasedAuthProperties{
			Status:                  types.CertificateBasedAuthStatus("DISABLED"),
			CertificateAuthorityArn: ptr.String("__CertificateAuthorityArn__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateDirectoryConfig(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateDirectoryConfig"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateEntitlement(t *testing.T) {
	input := &CreateEntitlementInput{
		Name:          ptr.String("__Name__"),
		StackName:     ptr.String("__StackName__"),
		Description:   ptr.String("__Description__"),
		AppVisibility: types.AppVisibility("ALL"),
		Attributes: []types.EntitlementAttribute{
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateEntitlement(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateEntitlement"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateExportImageTask(t *testing.T) {
	input := &CreateExportImageTaskInput{
		ImageName:  ptr.String("__ImageName__"),
		AmiName:    ptr.String("__AmiName__"),
		IamRoleArn: ptr.String("__IamRoleArn__"),
		TagSpecifications: map[string]string{
			"key0": "__Value__",
		},
		AmiDescription: ptr.String("__AmiDescription__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateExportImageTask(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateExportImageTask"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateFleet(t *testing.T) {
	input := &CreateFleetInput{
		Name:         ptr.String("__Name__"),
		ImageName:    ptr.String("__ImageName__"),
		ImageArn:     ptr.String("__ImageArn__"),
		InstanceType: ptr.String("__InstanceType__"),
		FleetType:    types.FleetType("ALWAYS_ON"),
		ComputeCapacity: &types.ComputeCapacity{
			DesiredInstances: ptr.Int32(1),
			DesiredSessions:  ptr.Int32(1),
		},
		VpcConfig: &types.VpcConfig{
			SubnetIds: []string{
				"__Member__",
				"__Member__",
			},
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
		},
		MaxUserDurationInSeconds:    ptr.Int32(1),
		DisconnectTimeoutInSeconds:  ptr.Int32(1),
		Description:                 ptr.String("__Description__"),
		DisplayName:                 ptr.String("__DisplayName__"),
		EnableDefaultInternetAccess: ptr.Bool(true),
		DomainJoinInfo: &types.DomainJoinInfo{
			DirectoryName:                       ptr.String("__DirectoryName__"),
			OrganizationalUnitDistinguishedName: ptr.String("__OrganizationalUnitDistinguishedName__"),
		},
		Tags: map[string]string{
			"key0": "__Value__",
		},
		IdleDisconnectTimeoutInSeconds: ptr.Int32(1),
		IamRoleArn:                     ptr.String("__IamRoleArn__"),
		StreamView:                     types.StreamView("APP"),
		Platform:                       types.PlatformType("WINDOWS"),
		MaxConcurrentSessions:          ptr.Int32(1),
		UsbDeviceFilterStrings: []string{
			"__Member__",
			"__Member__",
		},
		SessionScriptS3Location: &types.S3Location{
			S3Bucket: ptr.String("__S3Bucket__"),
			S3Key:    ptr.String("__S3Key__"),
		},
		MaxSessionsPerInstance: ptr.Int32(1),
		RootVolumeConfig: &types.VolumeConfig{
			VolumeSizeInGb: ptr.Int32(1),
		},
		DisableIMDSV1: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateFleet(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateFleet"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateImageBuilder(t *testing.T) {
	input := &CreateImageBuilderInput{
		Name:         ptr.String("__Name__"),
		ImageName:    ptr.String("__ImageName__"),
		ImageArn:     ptr.String("__ImageArn__"),
		InstanceType: ptr.String("__InstanceType__"),
		Description:  ptr.String("__Description__"),
		DisplayName:  ptr.String("__DisplayName__"),
		VpcConfig: &types.VpcConfig{
			SubnetIds: []string{
				"__Member__",
				"__Member__",
			},
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
		},
		IamRoleArn:                  ptr.String("__IamRoleArn__"),
		EnableDefaultInternetAccess: ptr.Bool(true),
		DomainJoinInfo: &types.DomainJoinInfo{
			DirectoryName:                       ptr.String("__DirectoryName__"),
			OrganizationalUnitDistinguishedName: ptr.String("__OrganizationalUnitDistinguishedName__"),
		},
		AppstreamAgentVersion: ptr.String("__AppstreamAgentVersion__"),
		Tags: map[string]string{
			"key0": "__Value__",
		},
		AccessEndpoints: []types.AccessEndpoint{
			{
				EndpointType: types.AccessEndpointType("STREAMING"),
				VpceId:       ptr.String("__VpceId__"),
			},
			{
				EndpointType: types.AccessEndpointType("STREAMING"),
				VpceId:       ptr.String("__VpceId__"),
			},
		},
		RootVolumeConfig: &types.VolumeConfig{
			VolumeSizeInGb: ptr.Int32(1),
		},
		SoftwaresToInstall: []string{
			"__Member__",
			"__Member__",
		},
		SoftwaresToUninstall: []string{
			"__Member__",
			"__Member__",
		},
		DisableIMDSV1: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateImageBuilder(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateImageBuilder"); err != nil {
		t.Fatal(err)
	}
}

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

func TestUpdateRequestSnapshot_CreateImportedImage(t *testing.T) {
	input := &CreateImportedImageInput{
		Name:             ptr.String("__Name__"),
		SourceAmiId:      ptr.String("__SourceAmiId__"),
		WorkspaceImageId: ptr.String("__WorkspaceImageId__"),
		IamRoleArn:       ptr.String("__IamRoleArn__"),
		Description:      ptr.String("__Description__"),
		DisplayName:      ptr.String("__DisplayName__"),
		Tags: map[string]string{
			"key0": "__Value__",
		},
		RuntimeValidationConfig: &types.RuntimeValidationConfig{
			IntendedInstanceType: ptr.String("__IntendedInstanceType__"),
		},
		AgentSoftwareVersion: types.AgentSoftwareVersion("CURRENT_LATEST"),
		AppCatalogConfig: []types.ApplicationConfig{
			{
				Name:                 ptr.String("__Name__"),
				DisplayName:          ptr.String("__DisplayName__"),
				AbsoluteAppPath:      ptr.String("__AbsoluteAppPath__"),
				AbsoluteIconPath:     ptr.String("__AbsoluteIconPath__"),
				AbsoluteManifestPath: ptr.String("__AbsoluteManifestPath__"),
				WorkingDirectory:     ptr.String("__WorkingDirectory__"),
				LaunchParameters:     ptr.String("__LaunchParameters__"),
			},
			{
				Name:                 ptr.String("__Name__"),
				DisplayName:          ptr.String("__DisplayName__"),
				AbsoluteAppPath:      ptr.String("__AbsoluteAppPath__"),
				AbsoluteIconPath:     ptr.String("__AbsoluteIconPath__"),
				AbsoluteManifestPath: ptr.String("__AbsoluteManifestPath__"),
				WorkingDirectory:     ptr.String("__WorkingDirectory__"),
				LaunchParameters:     ptr.String("__LaunchParameters__"),
			},
		},
		DryRun: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateImportedImage(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateImportedImage"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateStack(t *testing.T) {
	input := &CreateStackInput{
		Name:        ptr.String("__Name__"),
		Description: ptr.String("__Description__"),
		DisplayName: ptr.String("__DisplayName__"),
		StorageConnectors: []types.StorageConnector{
			{
				ConnectorType:      types.StorageConnectorType("HOMEFOLDERS"),
				ResourceIdentifier: ptr.String("__ResourceIdentifier__"),
				Domains: []string{
					"__Member__",
					"__Member__",
				},
				DomainsRequireAdminConsent: []string{
					"__Member__",
					"__Member__",
				},
			},
			{
				ConnectorType:      types.StorageConnectorType("HOMEFOLDERS"),
				ResourceIdentifier: ptr.String("__ResourceIdentifier__"),
				Domains: []string{
					"__Member__",
					"__Member__",
				},
				DomainsRequireAdminConsent: []string{
					"__Member__",
					"__Member__",
				},
			},
		},
		RedirectURL: ptr.String("__RedirectURL__"),
		FeedbackURL: ptr.String("__FeedbackURL__"),
		UserSettings: []types.UserSetting{
			{
				Action:        types.Action("CLIPBOARD_COPY_FROM_LOCAL_DEVICE"),
				Permission:    types.Permission("ENABLED"),
				MaximumLength: ptr.Int32(1),
			},
			{
				Action:        types.Action("CLIPBOARD_COPY_FROM_LOCAL_DEVICE"),
				Permission:    types.Permission("ENABLED"),
				MaximumLength: ptr.Int32(1),
			},
		},
		ApplicationSettings: &types.ApplicationSettings{
			Enabled:       ptr.Bool(true),
			SettingsGroup: ptr.String("__SettingsGroup__"),
		},
		Tags: map[string]string{
			"key0": "__Value__",
		},
		AccessEndpoints: []types.AccessEndpoint{
			{
				EndpointType: types.AccessEndpointType("STREAMING"),
				VpceId:       ptr.String("__VpceId__"),
			},
			{
				EndpointType: types.AccessEndpointType("STREAMING"),
				VpceId:       ptr.String("__VpceId__"),
			},
		},
		EmbedHostDomains: []string{
			"__Member__",
			"__Member__",
		},
		StreamingExperienceSettings: &types.StreamingExperienceSettings{
			PreferredProtocol: types.PreferredProtocol("TCP"),
		},
		ContentRedirection: &types.ContentRedirection{
			HostToClient: &types.UrlRedirectionConfig{
				Enabled: ptr.Bool(true),
				AllowedUrls: []string{
					"__Member__",
					"__Member__",
				},
				DeniedUrls: []string{
					"__Member__",
					"__Member__",
				},
			},
		},
		AgentAccessConfig: &types.AgentAccessConfig{
			Settings: []types.AgentAccessSetting{
				{
					AgentAction: types.AgentAction("COMPUTER_VISION"),
					Permission:  types.Permission("ENABLED"),
				},
				{
					AgentAction: types.AgentAction("COMPUTER_VISION"),
					Permission:  types.Permission("ENABLED"),
				},
			},
			S3BucketArn:              ptr.String("__S3BucketArn__"),
			ScreenshotsUploadEnabled: ptr.Bool(true),
			ScreenResolution:         types.ScreenResolution("W_1280xH_720"),
			ScreenImageFormat:        types.ScreenImageFormat("PNG"),
			UserControlMode:          types.UserControlMode("VIEW_ONLY"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateStack(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateStack"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateStreamingURL(t *testing.T) {
	input := &CreateStreamingURLInput{
		StackName:      ptr.String("__StackName__"),
		FleetName:      ptr.String("__FleetName__"),
		UserId:         ptr.String("__UserId__"),
		ApplicationId:  ptr.String("__ApplicationId__"),
		Validity:       ptr.Int64(1),
		SessionContext: ptr.String("__SessionContext__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateStreamingURL(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateStreamingURL"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateThemeForStack(t *testing.T) {
	input := &CreateThemeForStackInput{
		StackName: ptr.String("__StackName__"),
		FooterLinks: []types.ThemeFooterLink{
			{
				DisplayName:   ptr.String("__DisplayName__"),
				FooterLinkURL: ptr.String("__FooterLinkURL__"),
			},
			{
				DisplayName:   ptr.String("__DisplayName__"),
				FooterLinkURL: ptr.String("__FooterLinkURL__"),
			},
		},
		TitleText:    ptr.String("__TitleText__"),
		ThemeStyling: types.ThemeStyling("LIGHT_BLUE"),
		OrganizationLogoS3Location: &types.S3Location{
			S3Bucket: ptr.String("__S3Bucket__"),
			S3Key:    ptr.String("__S3Key__"),
		},
		FaviconS3Location: &types.S3Location{
			S3Bucket: ptr.String("__S3Bucket__"),
			S3Key:    ptr.String("__S3Key__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateThemeForStack(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateThemeForStack"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateUpdatedImage(t *testing.T) {
	input := &CreateUpdatedImageInput{
		ExistingImageName:   ptr.String("__ExistingImageName__"),
		NewImageName:        ptr.String("__NewImageName__"),
		NewImageDescription: ptr.String("__NewImageDescription__"),
		NewImageDisplayName: ptr.String("__NewImageDisplayName__"),
		NewImageTags: map[string]string{
			"key0": "__Value__",
		},
		DryRun: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateUpdatedImage(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateUpdatedImage"); err != nil {
		t.Fatal(err)
	}
}

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

func TestUpdateRequestSnapshot_CreateUser(t *testing.T) {
	input := &CreateUserInput{
		UserName:           ptr.String("__UserName__"),
		MessageAction:      types.MessageAction("SUPPRESS"),
		FirstName:          ptr.String("__FirstName__"),
		LastName:           ptr.String("__LastName__"),
		AuthenticationType: types.AuthenticationType("API"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateUser(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateUser"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func TestUpdateRequestSnapshot_DescribeSessions(t *testing.T) {
	input := &DescribeSessionsInput{
		StackName:          ptr.String("__StackName__"),
		FleetName:          ptr.String("__FleetName__"),
		UserId:             ptr.String("__UserId__"),
		NextToken:          ptr.String("__NextToken__"),
		Limit:              ptr.Int32(1),
		AuthenticationType: types.AuthenticationType("API"),
		InstanceId:         ptr.String("__InstanceId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DescribeSessions(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DescribeSessions"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func TestUpdateRequestSnapshot_ListExportImageTasks(t *testing.T) {
	input := &ListExportImageTasksInput{
		Filters: []types.Filter{
			{
				Name: ptr.String("__Name__"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
			},
			{
				Name: ptr.String("__Name__"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
			},
		},
		MaxResults: ptr.Int32(1),
		NextToken:  ptr.String("__NextToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListExportImageTasks(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListExportImageTasks"); 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_StartAppBlockBuilder(t *testing.T) {
	input := &StartAppBlockBuilderInput{
		Name: ptr.String("__Name__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StartAppBlockBuilder(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StartAppBlockBuilder"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

func TestUpdateRequestSnapshot_StopImageBuilder(t *testing.T) {
	input := &StopImageBuilderInput{
		Name: ptr.String("__Name__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopImageBuilder(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StopImageBuilder"); 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_UpdateAppBlockBuilder(t *testing.T) {
	input := &UpdateAppBlockBuilderInput{
		Name:         ptr.String("__Name__"),
		Description:  ptr.String("__Description__"),
		DisplayName:  ptr.String("__DisplayName__"),
		Platform:     types.PlatformType("WINDOWS"),
		InstanceType: ptr.String("__InstanceType__"),
		VpcConfig: &types.VpcConfig{
			SubnetIds: []string{
				"__Member__",
				"__Member__",
			},
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
		},
		EnableDefaultInternetAccess: ptr.Bool(true),
		IamRoleArn:                  ptr.String("__IamRoleArn__"),
		AccessEndpoints: []types.AccessEndpoint{
			{
				EndpointType: types.AccessEndpointType("STREAMING"),
				VpceId:       ptr.String("__VpceId__"),
			},
			{
				EndpointType: types.AccessEndpointType("STREAMING"),
				VpceId:       ptr.String("__VpceId__"),
			},
		},
		AttributesToDelete: []types.AppBlockBuilderAttribute{
			types.AppBlockBuilderAttribute("IAM_ROLE_ARN"),
			types.AppBlockBuilderAttribute("IAM_ROLE_ARN"),
		},
		DisableIMDSV1: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateAppBlockBuilder(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateAppBlockBuilder"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateApplication(t *testing.T) {
	input := &UpdateApplicationInput{
		Name:        ptr.String("__Name__"),
		DisplayName: ptr.String("__DisplayName__"),
		Description: ptr.String("__Description__"),
		IconS3Location: &types.S3Location{
			S3Bucket: ptr.String("__S3Bucket__"),
			S3Key:    ptr.String("__S3Key__"),
		},
		LaunchPath:       ptr.String("__LaunchPath__"),
		WorkingDirectory: ptr.String("__WorkingDirectory__"),
		LaunchParameters: ptr.String("__LaunchParameters__"),
		AppBlockArn:      ptr.String("__AppBlockArn__"),
		AttributesToDelete: []types.ApplicationAttribute{
			types.ApplicationAttribute("LAUNCH_PARAMETERS"),
			types.ApplicationAttribute("LAUNCH_PARAMETERS"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateApplication(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateApplication"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateDirectoryConfig(t *testing.T) {
	input := &UpdateDirectoryConfigInput{
		DirectoryName: ptr.String("__DirectoryName__"),
		OrganizationalUnitDistinguishedNames: []string{
			"__Member__",
			"__Member__",
		},
		ServiceAccountCredentials: &types.ServiceAccountCredentials{
			AccountName:     ptr.String("__AccountName__"),
			AccountPassword: ptr.String("__AccountPassword__"),
		},
		CertificateBasedAuthProperties: &types.CertificateBasedAuthProperties{
			Status:                  types.CertificateBasedAuthStatus("DISABLED"),
			CertificateAuthorityArn: ptr.String("__CertificateAuthorityArn__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateDirectoryConfig(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateDirectoryConfig"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateEntitlement(t *testing.T) {
	input := &UpdateEntitlementInput{
		Name:          ptr.String("__Name__"),
		StackName:     ptr.String("__StackName__"),
		Description:   ptr.String("__Description__"),
		AppVisibility: types.AppVisibility("ALL"),
		Attributes: []types.EntitlementAttribute{
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateEntitlement(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateEntitlement"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateFleet(t *testing.T) {
	input := &UpdateFleetInput{
		ImageName:    ptr.String("__ImageName__"),
		ImageArn:     ptr.String("__ImageArn__"),
		Name:         ptr.String("__Name__"),
		InstanceType: ptr.String("__InstanceType__"),
		ComputeCapacity: &types.ComputeCapacity{
			DesiredInstances: ptr.Int32(1),
			DesiredSessions:  ptr.Int32(1),
		},
		VpcConfig: &types.VpcConfig{
			SubnetIds: []string{
				"__Member__",
				"__Member__",
			},
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
		},
		MaxUserDurationInSeconds:    ptr.Int32(1),
		DisconnectTimeoutInSeconds:  ptr.Int32(1),
		DeleteVpcConfig:             ptr.Bool(true),
		Description:                 ptr.String("__Description__"),
		DisplayName:                 ptr.String("__DisplayName__"),
		EnableDefaultInternetAccess: ptr.Bool(true),
		DomainJoinInfo: &types.DomainJoinInfo{
			DirectoryName:                       ptr.String("__DirectoryName__"),
			OrganizationalUnitDistinguishedName: ptr.String("__OrganizationalUnitDistinguishedName__"),
		},
		IdleDisconnectTimeoutInSeconds: ptr.Int32(1),
		AttributesToDelete: []types.FleetAttribute{
			types.FleetAttribute("VPC_CONFIGURATION"),
			types.FleetAttribute("VPC_CONFIGURATION"),
		},
		IamRoleArn:            ptr.String("__IamRoleArn__"),
		StreamView:            types.StreamView("APP"),
		Platform:              types.PlatformType("WINDOWS"),
		MaxConcurrentSessions: ptr.Int32(1),
		UsbDeviceFilterStrings: []string{
			"__Member__",
			"__Member__",
		},
		SessionScriptS3Location: &types.S3Location{
			S3Bucket: ptr.String("__S3Bucket__"),
			S3Key:    ptr.String("__S3Key__"),
		},
		MaxSessionsPerInstance: ptr.Int32(1),
		RootVolumeConfig: &types.VolumeConfig{
			VolumeSizeInGb: ptr.Int32(1),
		},
		DisableIMDSV1: ptr.Bool(true),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateFleet(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateFleet"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateImagePermissions(t *testing.T) {
	input := &UpdateImagePermissionsInput{
		Name:            ptr.String("__Name__"),
		SharedAccountId: ptr.String("__SharedAccountId__"),
		ImagePermissions: &types.ImagePermissions{
			AllowFleet:        ptr.Bool(true),
			AllowImageBuilder: ptr.Bool(true),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateImagePermissions(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateImagePermissions"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateStack(t *testing.T) {
	input := &UpdateStackInput{
		DisplayName: ptr.String("__DisplayName__"),
		Description: ptr.String("__Description__"),
		Name:        ptr.String("__Name__"),
		StorageConnectors: []types.StorageConnector{
			{
				ConnectorType:      types.StorageConnectorType("HOMEFOLDERS"),
				ResourceIdentifier: ptr.String("__ResourceIdentifier__"),
				Domains: []string{
					"__Member__",
					"__Member__",
				},
				DomainsRequireAdminConsent: []string{
					"__Member__",
					"__Member__",
				},
			},
			{
				ConnectorType:      types.StorageConnectorType("HOMEFOLDERS"),
				ResourceIdentifier: ptr.String("__ResourceIdentifier__"),
				Domains: []string{
					"__Member__",
					"__Member__",
				},
				DomainsRequireAdminConsent: []string{
					"__Member__",
					"__Member__",
				},
			},
		},
		DeleteStorageConnectors: ptr.Bool(true),
		RedirectURL:             ptr.String("__RedirectURL__"),
		FeedbackURL:             ptr.String("__FeedbackURL__"),
		AttributesToDelete: []types.StackAttribute{
			types.StackAttribute("STORAGE_CONNECTORS"),
			types.StackAttribute("STORAGE_CONNECTORS"),
		},
		UserSettings: []types.UserSetting{
			{
				Action:        types.Action("CLIPBOARD_COPY_FROM_LOCAL_DEVICE"),
				Permission:    types.Permission("ENABLED"),
				MaximumLength: ptr.Int32(1),
			},
			{
				Action:        types.Action("CLIPBOARD_COPY_FROM_LOCAL_DEVICE"),
				Permission:    types.Permission("ENABLED"),
				MaximumLength: ptr.Int32(1),
			},
		},
		ApplicationSettings: &types.ApplicationSettings{
			Enabled:       ptr.Bool(true),
			SettingsGroup: ptr.String("__SettingsGroup__"),
		},
		AccessEndpoints: []types.AccessEndpoint{
			{
				EndpointType: types.AccessEndpointType("STREAMING"),
				VpceId:       ptr.String("__VpceId__"),
			},
			{
				EndpointType: types.AccessEndpointType("STREAMING"),
				VpceId:       ptr.String("__VpceId__"),
			},
		},
		EmbedHostDomains: []string{
			"__Member__",
			"__Member__",
		},
		StreamingExperienceSettings: &types.StreamingExperienceSettings{
			PreferredProtocol: types.PreferredProtocol("TCP"),
		},
		ContentRedirection: &types.ContentRedirection{
			HostToClient: &types.UrlRedirectionConfig{
				Enabled: ptr.Bool(true),
				AllowedUrls: []string{
					"__Member__",
					"__Member__",
				},
				DeniedUrls: []string{
					"__Member__",
					"__Member__",
				},
			},
		},
		AgentAccessConfig: &types.AgentAccessConfigForUpdate{
			Settings: []types.AgentAccessSetting{
				{
					AgentAction: types.AgentAction("COMPUTER_VISION"),
					Permission:  types.Permission("ENABLED"),
				},
				{
					AgentAction: types.AgentAction("COMPUTER_VISION"),
					Permission:  types.Permission("ENABLED"),
				},
			},
			S3BucketArn:              ptr.String("__S3BucketArn__"),
			ScreenshotsUploadEnabled: ptr.Bool(true),
			ScreenResolution:         types.ScreenResolution("W_1280xH_720"),
			ScreenImageFormat:        types.ScreenImageFormat("PNG"),
			UserControlMode:          types.UserControlMode("VIEW_ONLY"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateStack(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateStack"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateThemeForStack(t *testing.T) {
	input := &UpdateThemeForStackInput{
		StackName: ptr.String("__StackName__"),
		FooterLinks: []types.ThemeFooterLink{
			{
				DisplayName:   ptr.String("__DisplayName__"),
				FooterLinkURL: ptr.String("__FooterLinkURL__"),
			},
			{
				DisplayName:   ptr.String("__DisplayName__"),
				FooterLinkURL: ptr.String("__FooterLinkURL__"),
			},
		},
		TitleText:    ptr.String("__TitleText__"),
		ThemeStyling: types.ThemeStyling("LIGHT_BLUE"),
		OrganizationLogoS3Location: &types.S3Location{
			S3Bucket: ptr.String("__S3Bucket__"),
			S3Key:    ptr.String("__S3Key__"),
		},
		FaviconS3Location: &types.S3Location{
			S3Bucket: ptr.String("__S3Bucket__"),
			S3Key:    ptr.String("__S3Key__"),
		},
		State: types.ThemeState("ENABLED"),
		AttributesToDelete: []types.ThemeAttribute{
			types.ThemeAttribute("FOOTER_LINKS"),
			types.ThemeAttribute("FOOTER_LINKS"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateThemeForStack(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateThemeForStack"); err != nil {
		t.Fatal(err)
	}
}
