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

//go:build request_snapshot

package cognitoidentityprovider

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/cognitoidentityprovider/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_AddCustomAttributes(t *testing.T) {
	input := &AddCustomAttributesInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		CustomAttributes: []types.SchemaAttributeType{
			{
				Name:                   ptr.String("__Name__"),
				AttributeDataType:      types.AttributeDataType("String"),
				DeveloperOnlyAttribute: ptr.Bool(true),
				Mutable:                ptr.Bool(true),
				Required:               ptr.Bool(true),
				NumberAttributeConstraints: &types.NumberAttributeConstraintsType{
					MinValue: ptr.String("__MinValue__"),
					MaxValue: ptr.String("__MaxValue__"),
				},
				StringAttributeConstraints: &types.StringAttributeConstraintsType{
					MinLength: ptr.String("__MinLength__"),
					MaxLength: ptr.String("__MaxLength__"),
				},
			},
			{
				Name:                   ptr.String("__Name__"),
				AttributeDataType:      types.AttributeDataType("String"),
				DeveloperOnlyAttribute: ptr.Bool(true),
				Mutable:                ptr.Bool(true),
				Required:               ptr.Bool(true),
				NumberAttributeConstraints: &types.NumberAttributeConstraintsType{
					MinValue: ptr.String("__MinValue__"),
					MaxValue: ptr.String("__MaxValue__"),
				},
				StringAttributeConstraints: &types.StringAttributeConstraintsType{
					MinLength: ptr.String("__MinLength__"),
					MaxLength: ptr.String("__MaxLength__"),
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AddCustomAttributes(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AddCustomAttributes"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

func TestCheckRequestSnapshot_AdminCreateUser(t *testing.T) {
	input := &AdminCreateUserInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		Username:   ptr.String("__Username__"),
		UserAttributes: []types.AttributeType{
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
		},
		ValidationData: []types.AttributeType{
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
		},
		TemporaryPassword:  ptr.String("__TemporaryPassword__"),
		ForceAliasCreation: true,
		MessageAction:      types.MessageActionType("RESEND"),
		DesiredDeliveryMediums: []types.DeliveryMediumType{
			types.DeliveryMediumType("SMS"),
			types.DeliveryMediumType("SMS"),
		},
		ClientMetadata: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AdminCreateUser(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AdminCreateUser"); err != nil {
		t.Fatal(err)
	}
}

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

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

func TestCheckRequestSnapshot_AdminDisableProviderForUser(t *testing.T) {
	input := &AdminDisableProviderForUserInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		User: &types.ProviderUserIdentifierType{
			ProviderName:           ptr.String("__ProviderName__"),
			ProviderAttributeName:  ptr.String("__ProviderAttributeName__"),
			ProviderAttributeValue: ptr.String("__ProviderAttributeValue__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AdminDisableProviderForUser(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AdminDisableProviderForUser"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

func TestCheckRequestSnapshot_AdminInitiateAuth(t *testing.T) {
	input := &AdminInitiateAuthInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		ClientId:   ptr.String("__ClientId__"),
		AuthFlow:   types.AuthFlowType("USER_SRP_AUTH"),
		AuthParameters: map[string]string{
			"key0": "__Value__",
		},
		ClientMetadata: map[string]string{
			"key0": "__Value__",
		},
		AnalyticsMetadata: &types.AnalyticsMetadataType{
			AnalyticsEndpointId: ptr.String("__AnalyticsEndpointId__"),
		},
		ContextData: &types.ContextDataType{
			IpAddress:  ptr.String("__IpAddress__"),
			ServerName: ptr.String("__ServerName__"),
			ServerPath: ptr.String("__ServerPath__"),
			HttpHeaders: []types.HttpHeader{
				{
					HeaderName:  ptr.String("__HeaderName__"),
					HeaderValue: ptr.String("__HeaderValue__"),
				},
				{
					HeaderName:  ptr.String("__HeaderName__"),
					HeaderValue: ptr.String("__HeaderValue__"),
				},
			},
			EncodedData: ptr.String("__EncodedData__"),
		},
		Session: ptr.String("__Session__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AdminInitiateAuth(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AdminInitiateAuth"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_AdminLinkProviderForUser(t *testing.T) {
	input := &AdminLinkProviderForUserInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		DestinationUser: &types.ProviderUserIdentifierType{
			ProviderName:           ptr.String("__ProviderName__"),
			ProviderAttributeName:  ptr.String("__ProviderAttributeName__"),
			ProviderAttributeValue: ptr.String("__ProviderAttributeValue__"),
		},
		SourceUser: &types.ProviderUserIdentifierType{
			ProviderName:           ptr.String("__ProviderName__"),
			ProviderAttributeName:  ptr.String("__ProviderAttributeName__"),
			ProviderAttributeValue: ptr.String("__ProviderAttributeValue__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AdminLinkProviderForUser(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AdminLinkProviderForUser"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

func TestCheckRequestSnapshot_AdminRespondToAuthChallenge(t *testing.T) {
	input := &AdminRespondToAuthChallengeInput{
		UserPoolId:    ptr.String("__UserPoolId__"),
		ClientId:      ptr.String("__ClientId__"),
		ChallengeName: types.ChallengeNameType("SMS_MFA"),
		ChallengeResponses: map[string]string{
			"key0": "__Value__",
		},
		Session: ptr.String("__Session__"),
		AnalyticsMetadata: &types.AnalyticsMetadataType{
			AnalyticsEndpointId: ptr.String("__AnalyticsEndpointId__"),
		},
		ContextData: &types.ContextDataType{
			IpAddress:  ptr.String("__IpAddress__"),
			ServerName: ptr.String("__ServerName__"),
			ServerPath: ptr.String("__ServerPath__"),
			HttpHeaders: []types.HttpHeader{
				{
					HeaderName:  ptr.String("__HeaderName__"),
					HeaderValue: ptr.String("__HeaderValue__"),
				},
				{
					HeaderName:  ptr.String("__HeaderName__"),
					HeaderValue: ptr.String("__HeaderValue__"),
				},
			},
			EncodedData: ptr.String("__EncodedData__"),
		},
		ClientMetadata: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AdminRespondToAuthChallenge(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AdminRespondToAuthChallenge"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_AdminSetUserMFAPreference(t *testing.T) {
	input := &AdminSetUserMFAPreferenceInput{
		SMSMfaSettings: &types.SMSMfaSettingsType{
			Enabled:      true,
			PreferredMfa: true,
		},
		SoftwareTokenMfaSettings: &types.SoftwareTokenMfaSettingsType{
			Enabled:      true,
			PreferredMfa: true,
		},
		EmailMfaSettings: &types.EmailMfaSettingsType{
			Enabled:      true,
			PreferredMfa: true,
		},
		WebAuthnMfaSettings: &types.WebAuthnMfaSettingsType{
			Enabled: true,
		},
		Username:   ptr.String("__Username__"),
		UserPoolId: ptr.String("__UserPoolId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AdminSetUserMFAPreference(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AdminSetUserMFAPreference"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_AdminSetUserPassword(t *testing.T) {
	input := &AdminSetUserPasswordInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		Username:   ptr.String("__Username__"),
		Password:   ptr.String("__Password__"),
		Permanent:  true,
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AdminSetUserPassword(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AdminSetUserPassword"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_AdminSetUserSettings(t *testing.T) {
	input := &AdminSetUserSettingsInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		Username:   ptr.String("__Username__"),
		MFAOptions: []types.MFAOptionType{
			{
				DeliveryMedium: types.DeliveryMediumType("SMS"),
				AttributeName:  ptr.String("__AttributeName__"),
			},
			{
				DeliveryMedium: types.DeliveryMediumType("SMS"),
				AttributeName:  ptr.String("__AttributeName__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AdminSetUserSettings(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AdminSetUserSettings"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_AdminUpdateAuthEventFeedback(t *testing.T) {
	input := &AdminUpdateAuthEventFeedbackInput{
		UserPoolId:    ptr.String("__UserPoolId__"),
		Username:      ptr.String("__Username__"),
		EventId:       ptr.String("__EventId__"),
		FeedbackValue: types.FeedbackValueType("Valid"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AdminUpdateAuthEventFeedback(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AdminUpdateAuthEventFeedback"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_AdminUpdateDeviceStatus(t *testing.T) {
	input := &AdminUpdateDeviceStatusInput{
		UserPoolId:             ptr.String("__UserPoolId__"),
		Username:               ptr.String("__Username__"),
		DeviceKey:              ptr.String("__DeviceKey__"),
		DeviceRememberedStatus: types.DeviceRememberedStatusType("remembered"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AdminUpdateDeviceStatus(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AdminUpdateDeviceStatus"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_AdminUpdateUserAttributes(t *testing.T) {
	input := &AdminUpdateUserAttributesInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		Username:   ptr.String("__Username__"),
		UserAttributes: []types.AttributeType{
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
		},
		ClientMetadata: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AdminUpdateUserAttributes(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AdminUpdateUserAttributes"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

func TestCheckRequestSnapshot_ConfirmDevice(t *testing.T) {
	input := &ConfirmDeviceInput{
		AccessToken: ptr.String("__AccessToken__"),
		DeviceKey:   ptr.String("__DeviceKey__"),
		DeviceSecretVerifierConfig: &types.DeviceSecretVerifierConfigType{
			PasswordVerifier: ptr.String("__PasswordVerifier__"),
			Salt:             ptr.String("__Salt__"),
		},
		DeviceName: ptr.String("__DeviceName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ConfirmDevice(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ConfirmDevice"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ConfirmForgotPassword(t *testing.T) {
	input := &ConfirmForgotPasswordInput{
		ClientId:         ptr.String("__ClientId__"),
		SecretHash:       ptr.String("__SecretHash__"),
		Username:         ptr.String("__Username__"),
		ConfirmationCode: ptr.String("__ConfirmationCode__"),
		Password:         ptr.String("__Password__"),
		AnalyticsMetadata: &types.AnalyticsMetadataType{
			AnalyticsEndpointId: ptr.String("__AnalyticsEndpointId__"),
		},
		UserContextData: &types.UserContextDataType{
			IpAddress:   ptr.String("__IpAddress__"),
			EncodedData: ptr.String("__EncodedData__"),
		},
		ClientMetadata: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ConfirmForgotPassword(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ConfirmForgotPassword"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ConfirmSignUp(t *testing.T) {
	input := &ConfirmSignUpInput{
		ClientId:           ptr.String("__ClientId__"),
		SecretHash:         ptr.String("__SecretHash__"),
		Username:           ptr.String("__Username__"),
		ConfirmationCode:   ptr.String("__ConfirmationCode__"),
		ForceAliasCreation: true,
		AnalyticsMetadata: &types.AnalyticsMetadataType{
			AnalyticsEndpointId: ptr.String("__AnalyticsEndpointId__"),
		},
		UserContextData: &types.UserContextDataType{
			IpAddress:   ptr.String("__IpAddress__"),
			EncodedData: ptr.String("__EncodedData__"),
		},
		ClientMetadata: map[string]string{
			"key0": "__Value__",
		},
		Session: ptr.String("__Session__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ConfirmSignUp(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ConfirmSignUp"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateGroup(t *testing.T) {
	input := &CreateGroupInput{
		GroupName:   ptr.String("__GroupName__"),
		UserPoolId:  ptr.String("__UserPoolId__"),
		Description: ptr.String("__Description__"),
		RoleArn:     ptr.String("__RoleArn__"),
		Precedence:  ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateGroup"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateIdentityProvider(t *testing.T) {
	input := &CreateIdentityProviderInput{
		UserPoolId:   ptr.String("__UserPoolId__"),
		ProviderName: ptr.String("__ProviderName__"),
		ProviderType: types.IdentityProviderTypeType("SAML"),
		ProviderDetails: map[string]string{
			"key0": "__Value__",
		},
		AttributeMapping: map[string]string{
			"key0": "__Value__",
		},
		IdpIdentifiers: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateIdentityProvider(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateIdentityProvider"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateManagedLoginBranding(t *testing.T) {
	input := &CreateManagedLoginBrandingInput{
		UserPoolId:               ptr.String("__UserPoolId__"),
		ClientId:                 ptr.String("__ClientId__"),
		UseCognitoProvidedValues: true,
		Settings:                 nil,
		Assets: []types.AssetType{
			{
				Category:   types.AssetCategoryType("FAVICON_ICO"),
				ColorMode:  types.ColorSchemeModeType("LIGHT"),
				Extension:  types.AssetExtensionType("ICO"),
				Bytes:      []byte("blob"),
				ResourceId: ptr.String("__ResourceId__"),
			},
			{
				Category:   types.AssetCategoryType("FAVICON_ICO"),
				ColorMode:  types.ColorSchemeModeType("LIGHT"),
				Extension:  types.AssetExtensionType("ICO"),
				Bytes:      []byte("blob"),
				ResourceId: ptr.String("__ResourceId__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateManagedLoginBranding(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateManagedLoginBranding"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateResourceServer(t *testing.T) {
	input := &CreateResourceServerInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		Identifier: ptr.String("__Identifier__"),
		Name:       ptr.String("__Name__"),
		Scopes: []types.ResourceServerScopeType{
			{
				ScopeName:        ptr.String("__ScopeName__"),
				ScopeDescription: ptr.String("__ScopeDescription__"),
			},
			{
				ScopeName:        ptr.String("__ScopeName__"),
				ScopeDescription: ptr.String("__ScopeDescription__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateResourceServer(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateResourceServer"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateTerms(t *testing.T) {
	input := &CreateTermsInput{
		UserPoolId:  ptr.String("__UserPoolId__"),
		ClientId:    ptr.String("__ClientId__"),
		TermsName:   ptr.String("__TermsName__"),
		TermsSource: types.TermsSourceType("LINK"),
		Enforcement: types.TermsEnforcementType("NONE"),
		Links: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateTerms(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateTerms"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateUserImportJob(t *testing.T) {
	input := &CreateUserImportJobInput{
		JobName:                  ptr.String("__JobName__"),
		UserPoolId:               ptr.String("__UserPoolId__"),
		CloudWatchLogsRoleArn:    ptr.String("__CloudWatchLogsRoleArn__"),
		PasswordHashingAlgorithm: types.PasswordHashingAlgorithmType("BCRYPT"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateUserImportJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateUserImportJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateUserPool(t *testing.T) {
	input := &CreateUserPoolInput{
		PoolName: ptr.String("__PoolName__"),
		Policies: &types.UserPoolPolicyType{
			PasswordPolicy: &types.PasswordPolicyType{
				MinimumLength:                 ptr.Int32(1),
				RequireUppercase:              true,
				RequireLowercase:              true,
				RequireNumbers:                true,
				RequireSymbols:                true,
				PasswordHistorySize:           ptr.Int32(1),
				TemporaryPasswordValidityDays: 1,
			},
			SignInPolicy: &types.SignInPolicyType{
				AllowedFirstAuthFactors: []types.AuthFactorType{
					types.AuthFactorType("PASSWORD"),
					types.AuthFactorType("PASSWORD"),
				},
			},
		},
		DeletionProtection: types.DeletionProtectionType("ACTIVE"),
		LambdaConfig: &types.LambdaConfigType{
			PreSignUp:                   ptr.String("__PreSignUp__"),
			CustomMessage:               ptr.String("__CustomMessage__"),
			PostConfirmation:            ptr.String("__PostConfirmation__"),
			PreAuthentication:           ptr.String("__PreAuthentication__"),
			PostAuthentication:          ptr.String("__PostAuthentication__"),
			DefineAuthChallenge:         ptr.String("__DefineAuthChallenge__"),
			CreateAuthChallenge:         ptr.String("__CreateAuthChallenge__"),
			VerifyAuthChallengeResponse: ptr.String("__VerifyAuthChallengeResponse__"),
			PreTokenGeneration:          ptr.String("__PreTokenGeneration__"),
			UserMigration:               ptr.String("__UserMigration__"),
			PreTokenGenerationConfig: &types.PreTokenGenerationVersionConfigType{
				LambdaVersion: types.PreTokenGenerationLambdaVersionType("V1_0"),
				LambdaArn:     ptr.String("__LambdaArn__"),
			},
			CustomSMSSender: &types.CustomSMSLambdaVersionConfigType{
				LambdaVersion: types.CustomSMSSenderLambdaVersionType("V1_0"),
				LambdaArn:     ptr.String("__LambdaArn__"),
			},
			CustomEmailSender: &types.CustomEmailLambdaVersionConfigType{
				LambdaVersion: types.CustomEmailSenderLambdaVersionType("V1_0"),
				LambdaArn:     ptr.String("__LambdaArn__"),
			},
			KMSKeyID: ptr.String("__KMSKeyID__"),
			InboundFederation: &types.InboundFederationLambdaType{
				LambdaVersion: types.InboundFederationLambdaVersionType("V1_0"),
				LambdaArn:     ptr.String("__LambdaArn__"),
			},
		},
		AutoVerifiedAttributes: []types.VerifiedAttributeType{
			types.VerifiedAttributeType("phone_number"),
			types.VerifiedAttributeType("phone_number"),
		},
		AliasAttributes: []types.AliasAttributeType{
			types.AliasAttributeType("phone_number"),
			types.AliasAttributeType("phone_number"),
		},
		UsernameAttributes: []types.UsernameAttributeType{
			types.UsernameAttributeType("phone_number"),
			types.UsernameAttributeType("phone_number"),
		},
		SmsVerificationMessage:   ptr.String("__SmsVerificationMessage__"),
		EmailVerificationMessage: ptr.String("__EmailVerificationMessage__"),
		EmailVerificationSubject: ptr.String("__EmailVerificationSubject__"),
		VerificationMessageTemplate: &types.VerificationMessageTemplateType{
			SmsMessage:         ptr.String("__SmsMessage__"),
			EmailMessage:       ptr.String("__EmailMessage__"),
			EmailSubject:       ptr.String("__EmailSubject__"),
			EmailMessageByLink: ptr.String("__EmailMessageByLink__"),
			EmailSubjectByLink: ptr.String("__EmailSubjectByLink__"),
			DefaultEmailOption: types.DefaultEmailOptionType("CONFIRM_WITH_LINK"),
		},
		SmsAuthenticationMessage: ptr.String("__SmsAuthenticationMessage__"),
		MfaConfiguration:         types.UserPoolMfaType("OFF"),
		UserAttributeUpdateSettings: &types.UserAttributeUpdateSettingsType{
			AttributesRequireVerificationBeforeUpdate: []types.VerifiedAttributeType{
				types.VerifiedAttributeType("phone_number"),
				types.VerifiedAttributeType("phone_number"),
			},
		},
		DeviceConfiguration: &types.DeviceConfigurationType{
			ChallengeRequiredOnNewDevice:     true,
			DeviceOnlyRememberedOnUserPrompt: true,
		},
		EmailConfiguration: &types.EmailConfigurationType{
			SourceArn:           ptr.String("__SourceArn__"),
			ReplyToEmailAddress: ptr.String("__ReplyToEmailAddress__"),
			EmailSendingAccount: types.EmailSendingAccountType("COGNITO_DEFAULT"),
			From:                ptr.String("__From__"),
			ConfigurationSet:    ptr.String("__ConfigurationSet__"),
		},
		SmsConfiguration: &types.SmsConfigurationType{
			SnsCallerArn: ptr.String("__SnsCallerArn__"),
			ExternalId:   ptr.String("__ExternalId__"),
			SnsRegion:    ptr.String("__SnsRegion__"),
			EumsSms: &types.EumsSmsConfigurationType{
				CallerArn:            ptr.String("__CallerArn__"),
				ExternalId:           ptr.String("__ExternalId__"),
				OriginationIdentity:  ptr.String("__OriginationIdentity__"),
				ConfigurationSetName: ptr.String("__ConfigurationSetName__"),
				InEntityId:           ptr.String("__InEntityId__"),
				InTemplateId:         ptr.String("__InTemplateId__"),
				Region:               ptr.String("__Region__"),
			},
		},
		UserPoolTags: map[string]string{
			"key0": "__Value__",
		},
		AdminCreateUserConfig: &types.AdminCreateUserConfigType{
			AllowAdminCreateUserOnly:  true,
			UnusedAccountValidityDays: 1,
			InviteMessageTemplate: &types.MessageTemplateType{
				SMSMessage:   ptr.String("__SMSMessage__"),
				EmailMessage: ptr.String("__EmailMessage__"),
				EmailSubject: ptr.String("__EmailSubject__"),
			},
		},
		Schema: []types.SchemaAttributeType{
			{
				Name:                   ptr.String("__Name__"),
				AttributeDataType:      types.AttributeDataType("String"),
				DeveloperOnlyAttribute: ptr.Bool(true),
				Mutable:                ptr.Bool(true),
				Required:               ptr.Bool(true),
				NumberAttributeConstraints: &types.NumberAttributeConstraintsType{
					MinValue: ptr.String("__MinValue__"),
					MaxValue: ptr.String("__MaxValue__"),
				},
				StringAttributeConstraints: &types.StringAttributeConstraintsType{
					MinLength: ptr.String("__MinLength__"),
					MaxLength: ptr.String("__MaxLength__"),
				},
			},
			{
				Name:                   ptr.String("__Name__"),
				AttributeDataType:      types.AttributeDataType("String"),
				DeveloperOnlyAttribute: ptr.Bool(true),
				Mutable:                ptr.Bool(true),
				Required:               ptr.Bool(true),
				NumberAttributeConstraints: &types.NumberAttributeConstraintsType{
					MinValue: ptr.String("__MinValue__"),
					MaxValue: ptr.String("__MaxValue__"),
				},
				StringAttributeConstraints: &types.StringAttributeConstraintsType{
					MinLength: ptr.String("__MinLength__"),
					MaxLength: ptr.String("__MaxLength__"),
				},
			},
		},
		UserPoolAddOns: &types.UserPoolAddOnsType{
			AdvancedSecurityMode: types.AdvancedSecurityModeType("OFF"),
			AdvancedSecurityAdditionalFlows: &types.AdvancedSecurityAdditionalFlowsType{
				CustomAuthMode: types.AdvancedSecurityEnabledModeType("AUDIT"),
			},
		},
		UsernameConfiguration: &types.UsernameConfigurationType{
			CaseSensitive: ptr.Bool(true),
		},
		AccountRecoverySetting: &types.AccountRecoverySettingType{
			RecoveryMechanisms: []types.RecoveryOptionType{
				{
					Priority: ptr.Int32(1),
					Name:     types.RecoveryOptionNameType("verified_email"),
				},
				{
					Priority: ptr.Int32(1),
					Name:     types.RecoveryOptionNameType("verified_email"),
				},
			},
		},
		UserPoolTier: types.UserPoolTierType("LITE"),
		KeyConfiguration: &types.KeyConfigurationType{
			KeyType:   types.EncryptionKeyType("AWS_OWNED_KEY"),
			KmsKeyArn: ptr.String("__KmsKeyArn__"),
		},
		IssuerConfiguration: &types.IssuerConfigurationType{
			Type: types.IssuerType("ORIGINAL"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateUserPool(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateUserPool"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateUserPoolClient(t *testing.T) {
	input := &CreateUserPoolClientInput{
		UserPoolId:           ptr.String("__UserPoolId__"),
		ClientName:           ptr.String("__ClientName__"),
		GenerateSecret:       true,
		ClientSecret:         ptr.String("__ClientSecret__"),
		RefreshTokenValidity: 1,
		AccessTokenValidity:  ptr.Int32(1),
		IdTokenValidity:      ptr.Int32(1),
		TokenValidityUnits: &types.TokenValidityUnitsType{
			AccessToken:  types.TimeUnitsType("seconds"),
			IdToken:      types.TimeUnitsType("seconds"),
			RefreshToken: types.TimeUnitsType("seconds"),
		},
		ReadAttributes: []string{
			"__Member__",
			"__Member__",
		},
		WriteAttributes: []string{
			"__Member__",
			"__Member__",
		},
		ExplicitAuthFlows: []types.ExplicitAuthFlowsType{
			types.ExplicitAuthFlowsType("ADMIN_NO_SRP_AUTH"),
			types.ExplicitAuthFlowsType("ADMIN_NO_SRP_AUTH"),
		},
		SupportedIdentityProviders: []string{
			"__Member__",
			"__Member__",
		},
		CallbackURLs: []string{
			"__Member__",
			"__Member__",
		},
		LogoutURLs: []string{
			"__Member__",
			"__Member__",
		},
		DefaultRedirectURI: ptr.String("__DefaultRedirectURI__"),
		AllowedOAuthFlows: []types.OAuthFlowType{
			types.OAuthFlowType("code"),
			types.OAuthFlowType("code"),
		},
		AllowedOAuthScopes: []string{
			"__Member__",
			"__Member__",
		},
		AllowedOAuthFlowsUserPoolClient: true,
		AnalyticsConfiguration: &types.AnalyticsConfigurationType{
			ApplicationId:  ptr.String("__ApplicationId__"),
			ApplicationArn: ptr.String("__ApplicationArn__"),
			RoleArn:        ptr.String("__RoleArn__"),
			ExternalId:     ptr.String("__ExternalId__"),
			UserDataShared: true,
		},
		PreventUserExistenceErrors:               types.PreventUserExistenceErrorTypes("LEGACY"),
		EnableTokenRevocation:                    ptr.Bool(true),
		EnablePropagateAdditionalUserContextData: ptr.Bool(true),
		AuthSessionValidity:                      ptr.Int32(1),
		RefreshTokenRotation: &types.RefreshTokenRotationType{
			Feature:                 types.FeatureType("ENABLED"),
			RetryGracePeriodSeconds: ptr.Int32(1),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateUserPoolClient(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateUserPoolClient"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateUserPoolDomain(t *testing.T) {
	input := &CreateUserPoolDomainInput{
		Domain:              ptr.String("__Domain__"),
		UserPoolId:          ptr.String("__UserPoolId__"),
		ManagedLoginVersion: ptr.Int32(1),
		CustomDomainConfig: &types.CustomDomainConfigType{
			CertificateArn: ptr.String("__CertificateArn__"),
			SecurityPolicy: types.SecurityPolicyType("TLS_V1"),
		},
		Routing: &types.RoutingType{
			Failover: &types.FailoverType{
				SecondaryRegion:             ptr.String("__SecondaryRegion__"),
				PrimaryRoute53HealthCheckId: ptr.String("__PrimaryRoute53HealthCheckId__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateUserPoolDomain(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateUserPoolDomain"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

func TestCheckRequestSnapshot_DeleteUser(t *testing.T) {
	input := &DeleteUserInput{
		AccessToken: ptr.String("__AccessToken__"),
	}
	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_DeleteUserAttributes(t *testing.T) {
	input := &DeleteUserAttributesInput{
		UserAttributeNames: []string{
			"__Member__",
			"__Member__",
		},
		AccessToken: ptr.String("__AccessToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteUserAttributes(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteUserAttributes"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func TestCheckRequestSnapshot_ForgotPassword(t *testing.T) {
	input := &ForgotPasswordInput{
		ClientId:   ptr.String("__ClientId__"),
		SecretHash: ptr.String("__SecretHash__"),
		UserContextData: &types.UserContextDataType{
			IpAddress:   ptr.String("__IpAddress__"),
			EncodedData: ptr.String("__EncodedData__"),
		},
		Username: ptr.String("__Username__"),
		AnalyticsMetadata: &types.AnalyticsMetadataType{
			AnalyticsEndpointId: ptr.String("__AnalyticsEndpointId__"),
		},
		ClientMetadata: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ForgotPassword(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ForgotPassword"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

func TestCheckRequestSnapshot_GetTokensFromRefreshToken(t *testing.T) {
	input := &GetTokensFromRefreshTokenInput{
		RefreshToken: ptr.String("__RefreshToken__"),
		ClientId:     ptr.String("__ClientId__"),
		ClientSecret: ptr.String("__ClientSecret__"),
		DeviceKey:    ptr.String("__DeviceKey__"),
		ClientMetadata: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetTokensFromRefreshToken(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetTokensFromRefreshToken"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

func TestCheckRequestSnapshot_InitiateAuth(t *testing.T) {
	input := &InitiateAuthInput{
		AuthFlow: types.AuthFlowType("USER_SRP_AUTH"),
		AuthParameters: map[string]string{
			"key0": "__Value__",
		},
		ClientMetadata: map[string]string{
			"key0": "__Value__",
		},
		ClientId: ptr.String("__ClientId__"),
		AnalyticsMetadata: &types.AnalyticsMetadataType{
			AnalyticsEndpointId: ptr.String("__AnalyticsEndpointId__"),
		},
		UserContextData: &types.UserContextDataType{
			IpAddress:   ptr.String("__IpAddress__"),
			EncodedData: ptr.String("__EncodedData__"),
		},
		Session: ptr.String("__Session__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.InitiateAuth(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "InitiateAuth"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

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

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

func TestCheckRequestSnapshot_ListUsers(t *testing.T) {
	input := &ListUsersInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		AttributesToGet: []string{
			"__Member__",
			"__Member__",
		},
		Limit:           ptr.Int32(1),
		PaginationToken: ptr.String("__PaginationToken__"),
		Filter:          ptr.String("__Filter__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListUsers(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListUsers"); err != nil {
		t.Fatal(err)
	}
}

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

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

func TestCheckRequestSnapshot_ResendConfirmationCode(t *testing.T) {
	input := &ResendConfirmationCodeInput{
		ClientId:   ptr.String("__ClientId__"),
		SecretHash: ptr.String("__SecretHash__"),
		UserContextData: &types.UserContextDataType{
			IpAddress:   ptr.String("__IpAddress__"),
			EncodedData: ptr.String("__EncodedData__"),
		},
		Username: ptr.String("__Username__"),
		AnalyticsMetadata: &types.AnalyticsMetadataType{
			AnalyticsEndpointId: ptr.String("__AnalyticsEndpointId__"),
		},
		ClientMetadata: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ResendConfirmationCode(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ResendConfirmationCode"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_RespondToAuthChallenge(t *testing.T) {
	input := &RespondToAuthChallengeInput{
		ClientId:      ptr.String("__ClientId__"),
		ChallengeName: types.ChallengeNameType("SMS_MFA"),
		Session:       ptr.String("__Session__"),
		ChallengeResponses: map[string]string{
			"key0": "__Value__",
		},
		AnalyticsMetadata: &types.AnalyticsMetadataType{
			AnalyticsEndpointId: ptr.String("__AnalyticsEndpointId__"),
		},
		UserContextData: &types.UserContextDataType{
			IpAddress:   ptr.String("__IpAddress__"),
			EncodedData: ptr.String("__EncodedData__"),
		},
		ClientMetadata: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.RespondToAuthChallenge(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "RespondToAuthChallenge"); err != nil {
		t.Fatal(err)
	}
}

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

func TestCheckRequestSnapshot_SetLogDeliveryConfiguration(t *testing.T) {
	input := &SetLogDeliveryConfigurationInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		LogConfigurations: []types.LogConfigurationType{
			{
				LogLevel:    types.LogLevel("ERROR"),
				EventSource: types.EventSourceName("userNotification"),
				CloudWatchLogsConfiguration: &types.CloudWatchLogsConfigurationType{
					LogGroupArn: ptr.String("__LogGroupArn__"),
				},
				S3Configuration: &types.S3ConfigurationType{
					BucketArn: ptr.String("__BucketArn__"),
				},
				FirehoseConfiguration: &types.FirehoseConfigurationType{
					StreamArn: ptr.String("__StreamArn__"),
				},
			},
			{
				LogLevel:    types.LogLevel("ERROR"),
				EventSource: types.EventSourceName("userNotification"),
				CloudWatchLogsConfiguration: &types.CloudWatchLogsConfigurationType{
					LogGroupArn: ptr.String("__LogGroupArn__"),
				},
				S3Configuration: &types.S3ConfigurationType{
					BucketArn: ptr.String("__BucketArn__"),
				},
				FirehoseConfiguration: &types.FirehoseConfigurationType{
					StreamArn: ptr.String("__StreamArn__"),
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.SetLogDeliveryConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "SetLogDeliveryConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_SetRiskConfiguration(t *testing.T) {
	input := &SetRiskConfigurationInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		ClientId:   ptr.String("__ClientId__"),
		CompromisedCredentialsRiskConfiguration: &types.CompromisedCredentialsRiskConfigurationType{
			EventFilter: []types.EventFilterType{
				types.EventFilterType("SIGN_IN"),
				types.EventFilterType("SIGN_IN"),
			},
			Actions: &types.CompromisedCredentialsActionsType{
				EventAction: types.CompromisedCredentialsEventActionType("BLOCK"),
			},
		},
		AccountTakeoverRiskConfiguration: &types.AccountTakeoverRiskConfigurationType{
			NotifyConfiguration: &types.NotifyConfigurationType{
				From:      ptr.String("__From__"),
				ReplyTo:   ptr.String("__ReplyTo__"),
				SourceArn: ptr.String("__SourceArn__"),
				BlockEmail: &types.NotifyEmailType{
					Subject:  ptr.String("__Subject__"),
					HtmlBody: ptr.String("__HtmlBody__"),
					TextBody: ptr.String("__TextBody__"),
				},
				NoActionEmail: &types.NotifyEmailType{
					Subject:  ptr.String("__Subject__"),
					HtmlBody: ptr.String("__HtmlBody__"),
					TextBody: ptr.String("__TextBody__"),
				},
				MfaEmail: &types.NotifyEmailType{
					Subject:  ptr.String("__Subject__"),
					HtmlBody: ptr.String("__HtmlBody__"),
					TextBody: ptr.String("__TextBody__"),
				},
			},
			Actions: &types.AccountTakeoverActionsType{
				LowAction: &types.AccountTakeoverActionType{
					Notify:      true,
					EventAction: types.AccountTakeoverEventActionType("BLOCK"),
				},
				MediumAction: &types.AccountTakeoverActionType{
					Notify:      true,
					EventAction: types.AccountTakeoverEventActionType("BLOCK"),
				},
				HighAction: &types.AccountTakeoverActionType{
					Notify:      true,
					EventAction: types.AccountTakeoverEventActionType("BLOCK"),
				},
			},
		},
		RiskExceptionConfiguration: &types.RiskExceptionConfigurationType{
			BlockedIPRangeList: []string{
				"__Member__",
				"__Member__",
			},
			SkippedIPRangeList: []string{
				"__Member__",
				"__Member__",
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.SetRiskConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "SetRiskConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_SetUICustomization(t *testing.T) {
	input := &SetUICustomizationInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		ClientId:   ptr.String("__ClientId__"),
		CSS:        ptr.String("__CSS__"),
		ImageFile:  []byte("blob"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.SetUICustomization(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "SetUICustomization"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_SetUserMFAPreference(t *testing.T) {
	input := &SetUserMFAPreferenceInput{
		SMSMfaSettings: &types.SMSMfaSettingsType{
			Enabled:      true,
			PreferredMfa: true,
		},
		SoftwareTokenMfaSettings: &types.SoftwareTokenMfaSettingsType{
			Enabled:      true,
			PreferredMfa: true,
		},
		EmailMfaSettings: &types.EmailMfaSettingsType{
			Enabled:      true,
			PreferredMfa: true,
		},
		WebAuthnMfaSettings: &types.WebAuthnMfaSettingsType{
			Enabled: true,
		},
		AccessToken: ptr.String("__AccessToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.SetUserMFAPreference(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "SetUserMFAPreference"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_SetUserPoolMfaConfig(t *testing.T) {
	input := &SetUserPoolMfaConfigInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		SmsMfaConfiguration: &types.SmsMfaConfigType{
			SmsAuthenticationMessage: ptr.String("__SmsAuthenticationMessage__"),
			SmsConfiguration: &types.SmsConfigurationType{
				SnsCallerArn: ptr.String("__SnsCallerArn__"),
				ExternalId:   ptr.String("__ExternalId__"),
				SnsRegion:    ptr.String("__SnsRegion__"),
				EumsSms: &types.EumsSmsConfigurationType{
					CallerArn:            ptr.String("__CallerArn__"),
					ExternalId:           ptr.String("__ExternalId__"),
					OriginationIdentity:  ptr.String("__OriginationIdentity__"),
					ConfigurationSetName: ptr.String("__ConfigurationSetName__"),
					InEntityId:           ptr.String("__InEntityId__"),
					InTemplateId:         ptr.String("__InTemplateId__"),
					Region:               ptr.String("__Region__"),
				},
			},
		},
		SoftwareTokenMfaConfiguration: &types.SoftwareTokenMfaConfigType{
			Enabled: true,
		},
		EmailMfaConfiguration: &types.EmailMfaConfigType{
			Message: ptr.String("__Message__"),
			Subject: ptr.String("__Subject__"),
		},
		MfaConfiguration: types.UserPoolMfaType("OFF"),
		WebAuthnConfiguration: &types.WebAuthnConfigurationType{
			RelyingPartyId:      ptr.String("__RelyingPartyId__"),
			UserVerification:    types.UserVerificationType("required"),
			FactorConfiguration: types.WebAuthnFactorConfigurationType("SINGLE_FACTOR"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.SetUserPoolMfaConfig(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "SetUserPoolMfaConfig"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_SetUserSettings(t *testing.T) {
	input := &SetUserSettingsInput{
		AccessToken: ptr.String("__AccessToken__"),
		MFAOptions: []types.MFAOptionType{
			{
				DeliveryMedium: types.DeliveryMediumType("SMS"),
				AttributeName:  ptr.String("__AttributeName__"),
			},
			{
				DeliveryMedium: types.DeliveryMediumType("SMS"),
				AttributeName:  ptr.String("__AttributeName__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.SetUserSettings(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "SetUserSettings"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_SignUp(t *testing.T) {
	input := &SignUpInput{
		ClientId:   ptr.String("__ClientId__"),
		SecretHash: ptr.String("__SecretHash__"),
		Username:   ptr.String("__Username__"),
		Password:   ptr.String("__Password__"),
		UserAttributes: []types.AttributeType{
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
		},
		ValidationData: []types.AttributeType{
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
		},
		AnalyticsMetadata: &types.AnalyticsMetadataType{
			AnalyticsEndpointId: ptr.String("__AnalyticsEndpointId__"),
		},
		UserContextData: &types.UserContextDataType{
			IpAddress:   ptr.String("__IpAddress__"),
			EncodedData: ptr.String("__EncodedData__"),
		},
		ClientMetadata: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.SignUp(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "SignUp"); err != nil {
		t.Fatal(err)
	}
}

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

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

func TestCheckRequestSnapshot_StopUserImportJob(t *testing.T) {
	input := &StopUserImportJobInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		JobId:      ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopUserImportJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StopUserImportJob"); 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_UpdateAuthEventFeedback(t *testing.T) {
	input := &UpdateAuthEventFeedbackInput{
		UserPoolId:    ptr.String("__UserPoolId__"),
		Username:      ptr.String("__Username__"),
		EventId:       ptr.String("__EventId__"),
		FeedbackToken: ptr.String("__FeedbackToken__"),
		FeedbackValue: types.FeedbackValueType("Valid"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateAuthEventFeedback(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateAuthEventFeedback"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateDeviceStatus(t *testing.T) {
	input := &UpdateDeviceStatusInput{
		AccessToken:            ptr.String("__AccessToken__"),
		DeviceKey:              ptr.String("__DeviceKey__"),
		DeviceRememberedStatus: types.DeviceRememberedStatusType("remembered"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateDeviceStatus(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateDeviceStatus"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateGroup(t *testing.T) {
	input := &UpdateGroupInput{
		GroupName:   ptr.String("__GroupName__"),
		UserPoolId:  ptr.String("__UserPoolId__"),
		Description: ptr.String("__Description__"),
		RoleArn:     ptr.String("__RoleArn__"),
		Precedence:  ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateGroup"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateIdentityProvider(t *testing.T) {
	input := &UpdateIdentityProviderInput{
		UserPoolId:   ptr.String("__UserPoolId__"),
		ProviderName: ptr.String("__ProviderName__"),
		ProviderDetails: map[string]string{
			"key0": "__Value__",
		},
		AttributeMapping: map[string]string{
			"key0": "__Value__",
		},
		IdpIdentifiers: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateIdentityProvider(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateIdentityProvider"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateManagedLoginBranding(t *testing.T) {
	input := &UpdateManagedLoginBrandingInput{
		UserPoolId:               ptr.String("__UserPoolId__"),
		ManagedLoginBrandingId:   ptr.String("__ManagedLoginBrandingId__"),
		UseCognitoProvidedValues: true,
		Settings:                 nil,
		Assets: []types.AssetType{
			{
				Category:   types.AssetCategoryType("FAVICON_ICO"),
				ColorMode:  types.ColorSchemeModeType("LIGHT"),
				Extension:  types.AssetExtensionType("ICO"),
				Bytes:      []byte("blob"),
				ResourceId: ptr.String("__ResourceId__"),
			},
			{
				Category:   types.AssetCategoryType("FAVICON_ICO"),
				ColorMode:  types.ColorSchemeModeType("LIGHT"),
				Extension:  types.AssetExtensionType("ICO"),
				Bytes:      []byte("blob"),
				ResourceId: ptr.String("__ResourceId__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateManagedLoginBranding(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateManagedLoginBranding"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateProvisionedLimit(t *testing.T) {
	input := &UpdateProvisionedLimitInput{
		LimitDefinition: &types.LimitDefinitionType{
			LimitClass: types.LimitClass("API_CATEGORY"),
			Attributes: map[string]string{
				"key0": "__Value__",
			},
		},
		RequestedLimitValue: 1,
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateProvisionedLimit(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateProvisionedLimit"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateResourceServer(t *testing.T) {
	input := &UpdateResourceServerInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		Identifier: ptr.String("__Identifier__"),
		Name:       ptr.String("__Name__"),
		Scopes: []types.ResourceServerScopeType{
			{
				ScopeName:        ptr.String("__ScopeName__"),
				ScopeDescription: ptr.String("__ScopeDescription__"),
			},
			{
				ScopeName:        ptr.String("__ScopeName__"),
				ScopeDescription: ptr.String("__ScopeDescription__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateResourceServer(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateResourceServer"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateTerms(t *testing.T) {
	input := &UpdateTermsInput{
		TermsId:     ptr.String("__TermsId__"),
		UserPoolId:  ptr.String("__UserPoolId__"),
		TermsName:   ptr.String("__TermsName__"),
		TermsSource: types.TermsSourceType("LINK"),
		Enforcement: types.TermsEnforcementType("NONE"),
		Links: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateTerms(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateTerms"); err != nil {
		t.Fatal(err)
	}
}

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

func TestCheckRequestSnapshot_UpdateUserPool(t *testing.T) {
	input := &UpdateUserPoolInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		Policies: &types.UserPoolPolicyType{
			PasswordPolicy: &types.PasswordPolicyType{
				MinimumLength:                 ptr.Int32(1),
				RequireUppercase:              true,
				RequireLowercase:              true,
				RequireNumbers:                true,
				RequireSymbols:                true,
				PasswordHistorySize:           ptr.Int32(1),
				TemporaryPasswordValidityDays: 1,
			},
			SignInPolicy: &types.SignInPolicyType{
				AllowedFirstAuthFactors: []types.AuthFactorType{
					types.AuthFactorType("PASSWORD"),
					types.AuthFactorType("PASSWORD"),
				},
			},
		},
		DeletionProtection: types.DeletionProtectionType("ACTIVE"),
		LambdaConfig: &types.LambdaConfigType{
			PreSignUp:                   ptr.String("__PreSignUp__"),
			CustomMessage:               ptr.String("__CustomMessage__"),
			PostConfirmation:            ptr.String("__PostConfirmation__"),
			PreAuthentication:           ptr.String("__PreAuthentication__"),
			PostAuthentication:          ptr.String("__PostAuthentication__"),
			DefineAuthChallenge:         ptr.String("__DefineAuthChallenge__"),
			CreateAuthChallenge:         ptr.String("__CreateAuthChallenge__"),
			VerifyAuthChallengeResponse: ptr.String("__VerifyAuthChallengeResponse__"),
			PreTokenGeneration:          ptr.String("__PreTokenGeneration__"),
			UserMigration:               ptr.String("__UserMigration__"),
			PreTokenGenerationConfig: &types.PreTokenGenerationVersionConfigType{
				LambdaVersion: types.PreTokenGenerationLambdaVersionType("V1_0"),
				LambdaArn:     ptr.String("__LambdaArn__"),
			},
			CustomSMSSender: &types.CustomSMSLambdaVersionConfigType{
				LambdaVersion: types.CustomSMSSenderLambdaVersionType("V1_0"),
				LambdaArn:     ptr.String("__LambdaArn__"),
			},
			CustomEmailSender: &types.CustomEmailLambdaVersionConfigType{
				LambdaVersion: types.CustomEmailSenderLambdaVersionType("V1_0"),
				LambdaArn:     ptr.String("__LambdaArn__"),
			},
			KMSKeyID: ptr.String("__KMSKeyID__"),
			InboundFederation: &types.InboundFederationLambdaType{
				LambdaVersion: types.InboundFederationLambdaVersionType("V1_0"),
				LambdaArn:     ptr.String("__LambdaArn__"),
			},
		},
		AutoVerifiedAttributes: []types.VerifiedAttributeType{
			types.VerifiedAttributeType("phone_number"),
			types.VerifiedAttributeType("phone_number"),
		},
		SmsVerificationMessage:   ptr.String("__SmsVerificationMessage__"),
		EmailVerificationMessage: ptr.String("__EmailVerificationMessage__"),
		EmailVerificationSubject: ptr.String("__EmailVerificationSubject__"),
		VerificationMessageTemplate: &types.VerificationMessageTemplateType{
			SmsMessage:         ptr.String("__SmsMessage__"),
			EmailMessage:       ptr.String("__EmailMessage__"),
			EmailSubject:       ptr.String("__EmailSubject__"),
			EmailMessageByLink: ptr.String("__EmailMessageByLink__"),
			EmailSubjectByLink: ptr.String("__EmailSubjectByLink__"),
			DefaultEmailOption: types.DefaultEmailOptionType("CONFIRM_WITH_LINK"),
		},
		SmsAuthenticationMessage: ptr.String("__SmsAuthenticationMessage__"),
		UserAttributeUpdateSettings: &types.UserAttributeUpdateSettingsType{
			AttributesRequireVerificationBeforeUpdate: []types.VerifiedAttributeType{
				types.VerifiedAttributeType("phone_number"),
				types.VerifiedAttributeType("phone_number"),
			},
		},
		MfaConfiguration: types.UserPoolMfaType("OFF"),
		DeviceConfiguration: &types.DeviceConfigurationType{
			ChallengeRequiredOnNewDevice:     true,
			DeviceOnlyRememberedOnUserPrompt: true,
		},
		EmailConfiguration: &types.EmailConfigurationType{
			SourceArn:           ptr.String("__SourceArn__"),
			ReplyToEmailAddress: ptr.String("__ReplyToEmailAddress__"),
			EmailSendingAccount: types.EmailSendingAccountType("COGNITO_DEFAULT"),
			From:                ptr.String("__From__"),
			ConfigurationSet:    ptr.String("__ConfigurationSet__"),
		},
		SmsConfiguration: &types.SmsConfigurationType{
			SnsCallerArn: ptr.String("__SnsCallerArn__"),
			ExternalId:   ptr.String("__ExternalId__"),
			SnsRegion:    ptr.String("__SnsRegion__"),
			EumsSms: &types.EumsSmsConfigurationType{
				CallerArn:            ptr.String("__CallerArn__"),
				ExternalId:           ptr.String("__ExternalId__"),
				OriginationIdentity:  ptr.String("__OriginationIdentity__"),
				ConfigurationSetName: ptr.String("__ConfigurationSetName__"),
				InEntityId:           ptr.String("__InEntityId__"),
				InTemplateId:         ptr.String("__InTemplateId__"),
				Region:               ptr.String("__Region__"),
			},
		},
		UserPoolTags: map[string]string{
			"key0": "__Value__",
		},
		AdminCreateUserConfig: &types.AdminCreateUserConfigType{
			AllowAdminCreateUserOnly:  true,
			UnusedAccountValidityDays: 1,
			InviteMessageTemplate: &types.MessageTemplateType{
				SMSMessage:   ptr.String("__SMSMessage__"),
				EmailMessage: ptr.String("__EmailMessage__"),
				EmailSubject: ptr.String("__EmailSubject__"),
			},
		},
		UserPoolAddOns: &types.UserPoolAddOnsType{
			AdvancedSecurityMode: types.AdvancedSecurityModeType("OFF"),
			AdvancedSecurityAdditionalFlows: &types.AdvancedSecurityAdditionalFlowsType{
				CustomAuthMode: types.AdvancedSecurityEnabledModeType("AUDIT"),
			},
		},
		AccountRecoverySetting: &types.AccountRecoverySettingType{
			RecoveryMechanisms: []types.RecoveryOptionType{
				{
					Priority: ptr.Int32(1),
					Name:     types.RecoveryOptionNameType("verified_email"),
				},
				{
					Priority: ptr.Int32(1),
					Name:     types.RecoveryOptionNameType("verified_email"),
				},
			},
		},
		PoolName:     ptr.String("__PoolName__"),
		UserPoolTier: types.UserPoolTierType("LITE"),
		KeyConfiguration: &types.KeyConfigurationType{
			KeyType:   types.EncryptionKeyType("AWS_OWNED_KEY"),
			KmsKeyArn: ptr.String("__KmsKeyArn__"),
		},
		IssuerConfiguration: &types.IssuerConfigurationType{
			Type: types.IssuerType("ORIGINAL"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateUserPool(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateUserPool"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateUserPoolClient(t *testing.T) {
	input := &UpdateUserPoolClientInput{
		UserPoolId:           ptr.String("__UserPoolId__"),
		ClientId:             ptr.String("__ClientId__"),
		ClientName:           ptr.String("__ClientName__"),
		RefreshTokenValidity: 1,
		AccessTokenValidity:  ptr.Int32(1),
		IdTokenValidity:      ptr.Int32(1),
		TokenValidityUnits: &types.TokenValidityUnitsType{
			AccessToken:  types.TimeUnitsType("seconds"),
			IdToken:      types.TimeUnitsType("seconds"),
			RefreshToken: types.TimeUnitsType("seconds"),
		},
		ReadAttributes: []string{
			"__Member__",
			"__Member__",
		},
		WriteAttributes: []string{
			"__Member__",
			"__Member__",
		},
		ExplicitAuthFlows: []types.ExplicitAuthFlowsType{
			types.ExplicitAuthFlowsType("ADMIN_NO_SRP_AUTH"),
			types.ExplicitAuthFlowsType("ADMIN_NO_SRP_AUTH"),
		},
		SupportedIdentityProviders: []string{
			"__Member__",
			"__Member__",
		},
		CallbackURLs: []string{
			"__Member__",
			"__Member__",
		},
		LogoutURLs: []string{
			"__Member__",
			"__Member__",
		},
		DefaultRedirectURI: ptr.String("__DefaultRedirectURI__"),
		AllowedOAuthFlows: []types.OAuthFlowType{
			types.OAuthFlowType("code"),
			types.OAuthFlowType("code"),
		},
		AllowedOAuthScopes: []string{
			"__Member__",
			"__Member__",
		},
		AllowedOAuthFlowsUserPoolClient: true,
		AnalyticsConfiguration: &types.AnalyticsConfigurationType{
			ApplicationId:  ptr.String("__ApplicationId__"),
			ApplicationArn: ptr.String("__ApplicationArn__"),
			RoleArn:        ptr.String("__RoleArn__"),
			ExternalId:     ptr.String("__ExternalId__"),
			UserDataShared: true,
		},
		PreventUserExistenceErrors:               types.PreventUserExistenceErrorTypes("LEGACY"),
		EnableTokenRevocation:                    ptr.Bool(true),
		EnablePropagateAdditionalUserContextData: ptr.Bool(true),
		AuthSessionValidity:                      ptr.Int32(1),
		RefreshTokenRotation: &types.RefreshTokenRotationType{
			Feature:                 types.FeatureType("ENABLED"),
			RetryGracePeriodSeconds: ptr.Int32(1),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateUserPoolClient(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateUserPoolClient"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateUserPoolDomain(t *testing.T) {
	input := &UpdateUserPoolDomainInput{
		Domain:              ptr.String("__Domain__"),
		UserPoolId:          ptr.String("__UserPoolId__"),
		ManagedLoginVersion: ptr.Int32(1),
		CustomDomainConfig: &types.CustomDomainConfigType{
			CertificateArn: ptr.String("__CertificateArn__"),
			SecurityPolicy: types.SecurityPolicyType("TLS_V1"),
		},
		Routing: &types.RoutingType{
			Failover: &types.FailoverType{
				SecondaryRegion:             ptr.String("__SecondaryRegion__"),
				PrimaryRoute53HealthCheckId: ptr.String("__PrimaryRoute53HealthCheckId__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateUserPoolDomain(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateUserPoolDomain"); err != nil {
		t.Fatal(err)
	}
}

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

func TestCheckRequestSnapshot_VerifySoftwareToken(t *testing.T) {
	input := &VerifySoftwareTokenInput{
		AccessToken:        ptr.String("__AccessToken__"),
		Session:            ptr.String("__Session__"),
		UserCode:           ptr.String("__UserCode__"),
		FriendlyDeviceName: ptr.String("__FriendlyDeviceName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.VerifySoftwareToken(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "VerifySoftwareToken"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_VerifyUserAttribute(t *testing.T) {
	input := &VerifyUserAttributeInput{
		AccessToken:   ptr.String("__AccessToken__"),
		AttributeName: ptr.String("__AttributeName__"),
		Code:          ptr.String("__Code__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.VerifyUserAttribute(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "VerifyUserAttribute"); err != nil {
		t.Fatal(err)
	}
}
func TestUpdateRequestSnapshot_AddCustomAttributes(t *testing.T) {
	input := &AddCustomAttributesInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		CustomAttributes: []types.SchemaAttributeType{
			{
				Name:                   ptr.String("__Name__"),
				AttributeDataType:      types.AttributeDataType("String"),
				DeveloperOnlyAttribute: ptr.Bool(true),
				Mutable:                ptr.Bool(true),
				Required:               ptr.Bool(true),
				NumberAttributeConstraints: &types.NumberAttributeConstraintsType{
					MinValue: ptr.String("__MinValue__"),
					MaxValue: ptr.String("__MaxValue__"),
				},
				StringAttributeConstraints: &types.StringAttributeConstraintsType{
					MinLength: ptr.String("__MinLength__"),
					MaxLength: ptr.String("__MaxLength__"),
				},
			},
			{
				Name:                   ptr.String("__Name__"),
				AttributeDataType:      types.AttributeDataType("String"),
				DeveloperOnlyAttribute: ptr.Bool(true),
				Mutable:                ptr.Bool(true),
				Required:               ptr.Bool(true),
				NumberAttributeConstraints: &types.NumberAttributeConstraintsType{
					MinValue: ptr.String("__MinValue__"),
					MaxValue: ptr.String("__MaxValue__"),
				},
				StringAttributeConstraints: &types.StringAttributeConstraintsType{
					MinLength: ptr.String("__MinLength__"),
					MaxLength: ptr.String("__MaxLength__"),
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AddCustomAttributes(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AddCustomAttributes"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

func TestUpdateRequestSnapshot_AdminCreateUser(t *testing.T) {
	input := &AdminCreateUserInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		Username:   ptr.String("__Username__"),
		UserAttributes: []types.AttributeType{
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
		},
		ValidationData: []types.AttributeType{
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
		},
		TemporaryPassword:  ptr.String("__TemporaryPassword__"),
		ForceAliasCreation: true,
		MessageAction:      types.MessageActionType("RESEND"),
		DesiredDeliveryMediums: []types.DeliveryMediumType{
			types.DeliveryMediumType("SMS"),
			types.DeliveryMediumType("SMS"),
		},
		ClientMetadata: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AdminCreateUser(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AdminCreateUser"); err != nil {
		t.Fatal(err)
	}
}

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

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

func TestUpdateRequestSnapshot_AdminDisableProviderForUser(t *testing.T) {
	input := &AdminDisableProviderForUserInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		User: &types.ProviderUserIdentifierType{
			ProviderName:           ptr.String("__ProviderName__"),
			ProviderAttributeName:  ptr.String("__ProviderAttributeName__"),
			ProviderAttributeValue: ptr.String("__ProviderAttributeValue__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AdminDisableProviderForUser(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AdminDisableProviderForUser"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

func TestUpdateRequestSnapshot_AdminInitiateAuth(t *testing.T) {
	input := &AdminInitiateAuthInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		ClientId:   ptr.String("__ClientId__"),
		AuthFlow:   types.AuthFlowType("USER_SRP_AUTH"),
		AuthParameters: map[string]string{
			"key0": "__Value__",
		},
		ClientMetadata: map[string]string{
			"key0": "__Value__",
		},
		AnalyticsMetadata: &types.AnalyticsMetadataType{
			AnalyticsEndpointId: ptr.String("__AnalyticsEndpointId__"),
		},
		ContextData: &types.ContextDataType{
			IpAddress:  ptr.String("__IpAddress__"),
			ServerName: ptr.String("__ServerName__"),
			ServerPath: ptr.String("__ServerPath__"),
			HttpHeaders: []types.HttpHeader{
				{
					HeaderName:  ptr.String("__HeaderName__"),
					HeaderValue: ptr.String("__HeaderValue__"),
				},
				{
					HeaderName:  ptr.String("__HeaderName__"),
					HeaderValue: ptr.String("__HeaderValue__"),
				},
			},
			EncodedData: ptr.String("__EncodedData__"),
		},
		Session: ptr.String("__Session__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AdminInitiateAuth(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AdminInitiateAuth"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_AdminLinkProviderForUser(t *testing.T) {
	input := &AdminLinkProviderForUserInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		DestinationUser: &types.ProviderUserIdentifierType{
			ProviderName:           ptr.String("__ProviderName__"),
			ProviderAttributeName:  ptr.String("__ProviderAttributeName__"),
			ProviderAttributeValue: ptr.String("__ProviderAttributeValue__"),
		},
		SourceUser: &types.ProviderUserIdentifierType{
			ProviderName:           ptr.String("__ProviderName__"),
			ProviderAttributeName:  ptr.String("__ProviderAttributeName__"),
			ProviderAttributeValue: ptr.String("__ProviderAttributeValue__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AdminLinkProviderForUser(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AdminLinkProviderForUser"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

func TestUpdateRequestSnapshot_AdminRespondToAuthChallenge(t *testing.T) {
	input := &AdminRespondToAuthChallengeInput{
		UserPoolId:    ptr.String("__UserPoolId__"),
		ClientId:      ptr.String("__ClientId__"),
		ChallengeName: types.ChallengeNameType("SMS_MFA"),
		ChallengeResponses: map[string]string{
			"key0": "__Value__",
		},
		Session: ptr.String("__Session__"),
		AnalyticsMetadata: &types.AnalyticsMetadataType{
			AnalyticsEndpointId: ptr.String("__AnalyticsEndpointId__"),
		},
		ContextData: &types.ContextDataType{
			IpAddress:  ptr.String("__IpAddress__"),
			ServerName: ptr.String("__ServerName__"),
			ServerPath: ptr.String("__ServerPath__"),
			HttpHeaders: []types.HttpHeader{
				{
					HeaderName:  ptr.String("__HeaderName__"),
					HeaderValue: ptr.String("__HeaderValue__"),
				},
				{
					HeaderName:  ptr.String("__HeaderName__"),
					HeaderValue: ptr.String("__HeaderValue__"),
				},
			},
			EncodedData: ptr.String("__EncodedData__"),
		},
		ClientMetadata: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AdminRespondToAuthChallenge(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AdminRespondToAuthChallenge"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_AdminSetUserMFAPreference(t *testing.T) {
	input := &AdminSetUserMFAPreferenceInput{
		SMSMfaSettings: &types.SMSMfaSettingsType{
			Enabled:      true,
			PreferredMfa: true,
		},
		SoftwareTokenMfaSettings: &types.SoftwareTokenMfaSettingsType{
			Enabled:      true,
			PreferredMfa: true,
		},
		EmailMfaSettings: &types.EmailMfaSettingsType{
			Enabled:      true,
			PreferredMfa: true,
		},
		WebAuthnMfaSettings: &types.WebAuthnMfaSettingsType{
			Enabled: true,
		},
		Username:   ptr.String("__Username__"),
		UserPoolId: ptr.String("__UserPoolId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AdminSetUserMFAPreference(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AdminSetUserMFAPreference"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_AdminSetUserPassword(t *testing.T) {
	input := &AdminSetUserPasswordInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		Username:   ptr.String("__Username__"),
		Password:   ptr.String("__Password__"),
		Permanent:  true,
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AdminSetUserPassword(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AdminSetUserPassword"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_AdminSetUserSettings(t *testing.T) {
	input := &AdminSetUserSettingsInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		Username:   ptr.String("__Username__"),
		MFAOptions: []types.MFAOptionType{
			{
				DeliveryMedium: types.DeliveryMediumType("SMS"),
				AttributeName:  ptr.String("__AttributeName__"),
			},
			{
				DeliveryMedium: types.DeliveryMediumType("SMS"),
				AttributeName:  ptr.String("__AttributeName__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AdminSetUserSettings(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AdminSetUserSettings"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_AdminUpdateAuthEventFeedback(t *testing.T) {
	input := &AdminUpdateAuthEventFeedbackInput{
		UserPoolId:    ptr.String("__UserPoolId__"),
		Username:      ptr.String("__Username__"),
		EventId:       ptr.String("__EventId__"),
		FeedbackValue: types.FeedbackValueType("Valid"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AdminUpdateAuthEventFeedback(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AdminUpdateAuthEventFeedback"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_AdminUpdateDeviceStatus(t *testing.T) {
	input := &AdminUpdateDeviceStatusInput{
		UserPoolId:             ptr.String("__UserPoolId__"),
		Username:               ptr.String("__Username__"),
		DeviceKey:              ptr.String("__DeviceKey__"),
		DeviceRememberedStatus: types.DeviceRememberedStatusType("remembered"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AdminUpdateDeviceStatus(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AdminUpdateDeviceStatus"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_AdminUpdateUserAttributes(t *testing.T) {
	input := &AdminUpdateUserAttributesInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		Username:   ptr.String("__Username__"),
		UserAttributes: []types.AttributeType{
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
		},
		ClientMetadata: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.AdminUpdateUserAttributes(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "AdminUpdateUserAttributes"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

func TestUpdateRequestSnapshot_ConfirmDevice(t *testing.T) {
	input := &ConfirmDeviceInput{
		AccessToken: ptr.String("__AccessToken__"),
		DeviceKey:   ptr.String("__DeviceKey__"),
		DeviceSecretVerifierConfig: &types.DeviceSecretVerifierConfigType{
			PasswordVerifier: ptr.String("__PasswordVerifier__"),
			Salt:             ptr.String("__Salt__"),
		},
		DeviceName: ptr.String("__DeviceName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ConfirmDevice(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ConfirmDevice"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ConfirmForgotPassword(t *testing.T) {
	input := &ConfirmForgotPasswordInput{
		ClientId:         ptr.String("__ClientId__"),
		SecretHash:       ptr.String("__SecretHash__"),
		Username:         ptr.String("__Username__"),
		ConfirmationCode: ptr.String("__ConfirmationCode__"),
		Password:         ptr.String("__Password__"),
		AnalyticsMetadata: &types.AnalyticsMetadataType{
			AnalyticsEndpointId: ptr.String("__AnalyticsEndpointId__"),
		},
		UserContextData: &types.UserContextDataType{
			IpAddress:   ptr.String("__IpAddress__"),
			EncodedData: ptr.String("__EncodedData__"),
		},
		ClientMetadata: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ConfirmForgotPassword(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ConfirmForgotPassword"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ConfirmSignUp(t *testing.T) {
	input := &ConfirmSignUpInput{
		ClientId:           ptr.String("__ClientId__"),
		SecretHash:         ptr.String("__SecretHash__"),
		Username:           ptr.String("__Username__"),
		ConfirmationCode:   ptr.String("__ConfirmationCode__"),
		ForceAliasCreation: true,
		AnalyticsMetadata: &types.AnalyticsMetadataType{
			AnalyticsEndpointId: ptr.String("__AnalyticsEndpointId__"),
		},
		UserContextData: &types.UserContextDataType{
			IpAddress:   ptr.String("__IpAddress__"),
			EncodedData: ptr.String("__EncodedData__"),
		},
		ClientMetadata: map[string]string{
			"key0": "__Value__",
		},
		Session: ptr.String("__Session__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ConfirmSignUp(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ConfirmSignUp"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateGroup(t *testing.T) {
	input := &CreateGroupInput{
		GroupName:   ptr.String("__GroupName__"),
		UserPoolId:  ptr.String("__UserPoolId__"),
		Description: ptr.String("__Description__"),
		RoleArn:     ptr.String("__RoleArn__"),
		Precedence:  ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateGroup"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateIdentityProvider(t *testing.T) {
	input := &CreateIdentityProviderInput{
		UserPoolId:   ptr.String("__UserPoolId__"),
		ProviderName: ptr.String("__ProviderName__"),
		ProviderType: types.IdentityProviderTypeType("SAML"),
		ProviderDetails: map[string]string{
			"key0": "__Value__",
		},
		AttributeMapping: map[string]string{
			"key0": "__Value__",
		},
		IdpIdentifiers: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateIdentityProvider(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateIdentityProvider"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateManagedLoginBranding(t *testing.T) {
	input := &CreateManagedLoginBrandingInput{
		UserPoolId:               ptr.String("__UserPoolId__"),
		ClientId:                 ptr.String("__ClientId__"),
		UseCognitoProvidedValues: true,
		Settings:                 nil,
		Assets: []types.AssetType{
			{
				Category:   types.AssetCategoryType("FAVICON_ICO"),
				ColorMode:  types.ColorSchemeModeType("LIGHT"),
				Extension:  types.AssetExtensionType("ICO"),
				Bytes:      []byte("blob"),
				ResourceId: ptr.String("__ResourceId__"),
			},
			{
				Category:   types.AssetCategoryType("FAVICON_ICO"),
				ColorMode:  types.ColorSchemeModeType("LIGHT"),
				Extension:  types.AssetExtensionType("ICO"),
				Bytes:      []byte("blob"),
				ResourceId: ptr.String("__ResourceId__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateManagedLoginBranding(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateManagedLoginBranding"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateResourceServer(t *testing.T) {
	input := &CreateResourceServerInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		Identifier: ptr.String("__Identifier__"),
		Name:       ptr.String("__Name__"),
		Scopes: []types.ResourceServerScopeType{
			{
				ScopeName:        ptr.String("__ScopeName__"),
				ScopeDescription: ptr.String("__ScopeDescription__"),
			},
			{
				ScopeName:        ptr.String("__ScopeName__"),
				ScopeDescription: ptr.String("__ScopeDescription__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateResourceServer(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateResourceServer"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateTerms(t *testing.T) {
	input := &CreateTermsInput{
		UserPoolId:  ptr.String("__UserPoolId__"),
		ClientId:    ptr.String("__ClientId__"),
		TermsName:   ptr.String("__TermsName__"),
		TermsSource: types.TermsSourceType("LINK"),
		Enforcement: types.TermsEnforcementType("NONE"),
		Links: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateTerms(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateTerms"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateUserImportJob(t *testing.T) {
	input := &CreateUserImportJobInput{
		JobName:                  ptr.String("__JobName__"),
		UserPoolId:               ptr.String("__UserPoolId__"),
		CloudWatchLogsRoleArn:    ptr.String("__CloudWatchLogsRoleArn__"),
		PasswordHashingAlgorithm: types.PasswordHashingAlgorithmType("BCRYPT"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateUserImportJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateUserImportJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateUserPool(t *testing.T) {
	input := &CreateUserPoolInput{
		PoolName: ptr.String("__PoolName__"),
		Policies: &types.UserPoolPolicyType{
			PasswordPolicy: &types.PasswordPolicyType{
				MinimumLength:                 ptr.Int32(1),
				RequireUppercase:              true,
				RequireLowercase:              true,
				RequireNumbers:                true,
				RequireSymbols:                true,
				PasswordHistorySize:           ptr.Int32(1),
				TemporaryPasswordValidityDays: 1,
			},
			SignInPolicy: &types.SignInPolicyType{
				AllowedFirstAuthFactors: []types.AuthFactorType{
					types.AuthFactorType("PASSWORD"),
					types.AuthFactorType("PASSWORD"),
				},
			},
		},
		DeletionProtection: types.DeletionProtectionType("ACTIVE"),
		LambdaConfig: &types.LambdaConfigType{
			PreSignUp:                   ptr.String("__PreSignUp__"),
			CustomMessage:               ptr.String("__CustomMessage__"),
			PostConfirmation:            ptr.String("__PostConfirmation__"),
			PreAuthentication:           ptr.String("__PreAuthentication__"),
			PostAuthentication:          ptr.String("__PostAuthentication__"),
			DefineAuthChallenge:         ptr.String("__DefineAuthChallenge__"),
			CreateAuthChallenge:         ptr.String("__CreateAuthChallenge__"),
			VerifyAuthChallengeResponse: ptr.String("__VerifyAuthChallengeResponse__"),
			PreTokenGeneration:          ptr.String("__PreTokenGeneration__"),
			UserMigration:               ptr.String("__UserMigration__"),
			PreTokenGenerationConfig: &types.PreTokenGenerationVersionConfigType{
				LambdaVersion: types.PreTokenGenerationLambdaVersionType("V1_0"),
				LambdaArn:     ptr.String("__LambdaArn__"),
			},
			CustomSMSSender: &types.CustomSMSLambdaVersionConfigType{
				LambdaVersion: types.CustomSMSSenderLambdaVersionType("V1_0"),
				LambdaArn:     ptr.String("__LambdaArn__"),
			},
			CustomEmailSender: &types.CustomEmailLambdaVersionConfigType{
				LambdaVersion: types.CustomEmailSenderLambdaVersionType("V1_0"),
				LambdaArn:     ptr.String("__LambdaArn__"),
			},
			KMSKeyID: ptr.String("__KMSKeyID__"),
			InboundFederation: &types.InboundFederationLambdaType{
				LambdaVersion: types.InboundFederationLambdaVersionType("V1_0"),
				LambdaArn:     ptr.String("__LambdaArn__"),
			},
		},
		AutoVerifiedAttributes: []types.VerifiedAttributeType{
			types.VerifiedAttributeType("phone_number"),
			types.VerifiedAttributeType("phone_number"),
		},
		AliasAttributes: []types.AliasAttributeType{
			types.AliasAttributeType("phone_number"),
			types.AliasAttributeType("phone_number"),
		},
		UsernameAttributes: []types.UsernameAttributeType{
			types.UsernameAttributeType("phone_number"),
			types.UsernameAttributeType("phone_number"),
		},
		SmsVerificationMessage:   ptr.String("__SmsVerificationMessage__"),
		EmailVerificationMessage: ptr.String("__EmailVerificationMessage__"),
		EmailVerificationSubject: ptr.String("__EmailVerificationSubject__"),
		VerificationMessageTemplate: &types.VerificationMessageTemplateType{
			SmsMessage:         ptr.String("__SmsMessage__"),
			EmailMessage:       ptr.String("__EmailMessage__"),
			EmailSubject:       ptr.String("__EmailSubject__"),
			EmailMessageByLink: ptr.String("__EmailMessageByLink__"),
			EmailSubjectByLink: ptr.String("__EmailSubjectByLink__"),
			DefaultEmailOption: types.DefaultEmailOptionType("CONFIRM_WITH_LINK"),
		},
		SmsAuthenticationMessage: ptr.String("__SmsAuthenticationMessage__"),
		MfaConfiguration:         types.UserPoolMfaType("OFF"),
		UserAttributeUpdateSettings: &types.UserAttributeUpdateSettingsType{
			AttributesRequireVerificationBeforeUpdate: []types.VerifiedAttributeType{
				types.VerifiedAttributeType("phone_number"),
				types.VerifiedAttributeType("phone_number"),
			},
		},
		DeviceConfiguration: &types.DeviceConfigurationType{
			ChallengeRequiredOnNewDevice:     true,
			DeviceOnlyRememberedOnUserPrompt: true,
		},
		EmailConfiguration: &types.EmailConfigurationType{
			SourceArn:           ptr.String("__SourceArn__"),
			ReplyToEmailAddress: ptr.String("__ReplyToEmailAddress__"),
			EmailSendingAccount: types.EmailSendingAccountType("COGNITO_DEFAULT"),
			From:                ptr.String("__From__"),
			ConfigurationSet:    ptr.String("__ConfigurationSet__"),
		},
		SmsConfiguration: &types.SmsConfigurationType{
			SnsCallerArn: ptr.String("__SnsCallerArn__"),
			ExternalId:   ptr.String("__ExternalId__"),
			SnsRegion:    ptr.String("__SnsRegion__"),
			EumsSms: &types.EumsSmsConfigurationType{
				CallerArn:            ptr.String("__CallerArn__"),
				ExternalId:           ptr.String("__ExternalId__"),
				OriginationIdentity:  ptr.String("__OriginationIdentity__"),
				ConfigurationSetName: ptr.String("__ConfigurationSetName__"),
				InEntityId:           ptr.String("__InEntityId__"),
				InTemplateId:         ptr.String("__InTemplateId__"),
				Region:               ptr.String("__Region__"),
			},
		},
		UserPoolTags: map[string]string{
			"key0": "__Value__",
		},
		AdminCreateUserConfig: &types.AdminCreateUserConfigType{
			AllowAdminCreateUserOnly:  true,
			UnusedAccountValidityDays: 1,
			InviteMessageTemplate: &types.MessageTemplateType{
				SMSMessage:   ptr.String("__SMSMessage__"),
				EmailMessage: ptr.String("__EmailMessage__"),
				EmailSubject: ptr.String("__EmailSubject__"),
			},
		},
		Schema: []types.SchemaAttributeType{
			{
				Name:                   ptr.String("__Name__"),
				AttributeDataType:      types.AttributeDataType("String"),
				DeveloperOnlyAttribute: ptr.Bool(true),
				Mutable:                ptr.Bool(true),
				Required:               ptr.Bool(true),
				NumberAttributeConstraints: &types.NumberAttributeConstraintsType{
					MinValue: ptr.String("__MinValue__"),
					MaxValue: ptr.String("__MaxValue__"),
				},
				StringAttributeConstraints: &types.StringAttributeConstraintsType{
					MinLength: ptr.String("__MinLength__"),
					MaxLength: ptr.String("__MaxLength__"),
				},
			},
			{
				Name:                   ptr.String("__Name__"),
				AttributeDataType:      types.AttributeDataType("String"),
				DeveloperOnlyAttribute: ptr.Bool(true),
				Mutable:                ptr.Bool(true),
				Required:               ptr.Bool(true),
				NumberAttributeConstraints: &types.NumberAttributeConstraintsType{
					MinValue: ptr.String("__MinValue__"),
					MaxValue: ptr.String("__MaxValue__"),
				},
				StringAttributeConstraints: &types.StringAttributeConstraintsType{
					MinLength: ptr.String("__MinLength__"),
					MaxLength: ptr.String("__MaxLength__"),
				},
			},
		},
		UserPoolAddOns: &types.UserPoolAddOnsType{
			AdvancedSecurityMode: types.AdvancedSecurityModeType("OFF"),
			AdvancedSecurityAdditionalFlows: &types.AdvancedSecurityAdditionalFlowsType{
				CustomAuthMode: types.AdvancedSecurityEnabledModeType("AUDIT"),
			},
		},
		UsernameConfiguration: &types.UsernameConfigurationType{
			CaseSensitive: ptr.Bool(true),
		},
		AccountRecoverySetting: &types.AccountRecoverySettingType{
			RecoveryMechanisms: []types.RecoveryOptionType{
				{
					Priority: ptr.Int32(1),
					Name:     types.RecoveryOptionNameType("verified_email"),
				},
				{
					Priority: ptr.Int32(1),
					Name:     types.RecoveryOptionNameType("verified_email"),
				},
			},
		},
		UserPoolTier: types.UserPoolTierType("LITE"),
		KeyConfiguration: &types.KeyConfigurationType{
			KeyType:   types.EncryptionKeyType("AWS_OWNED_KEY"),
			KmsKeyArn: ptr.String("__KmsKeyArn__"),
		},
		IssuerConfiguration: &types.IssuerConfigurationType{
			Type: types.IssuerType("ORIGINAL"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateUserPool(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateUserPool"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateUserPoolClient(t *testing.T) {
	input := &CreateUserPoolClientInput{
		UserPoolId:           ptr.String("__UserPoolId__"),
		ClientName:           ptr.String("__ClientName__"),
		GenerateSecret:       true,
		ClientSecret:         ptr.String("__ClientSecret__"),
		RefreshTokenValidity: 1,
		AccessTokenValidity:  ptr.Int32(1),
		IdTokenValidity:      ptr.Int32(1),
		TokenValidityUnits: &types.TokenValidityUnitsType{
			AccessToken:  types.TimeUnitsType("seconds"),
			IdToken:      types.TimeUnitsType("seconds"),
			RefreshToken: types.TimeUnitsType("seconds"),
		},
		ReadAttributes: []string{
			"__Member__",
			"__Member__",
		},
		WriteAttributes: []string{
			"__Member__",
			"__Member__",
		},
		ExplicitAuthFlows: []types.ExplicitAuthFlowsType{
			types.ExplicitAuthFlowsType("ADMIN_NO_SRP_AUTH"),
			types.ExplicitAuthFlowsType("ADMIN_NO_SRP_AUTH"),
		},
		SupportedIdentityProviders: []string{
			"__Member__",
			"__Member__",
		},
		CallbackURLs: []string{
			"__Member__",
			"__Member__",
		},
		LogoutURLs: []string{
			"__Member__",
			"__Member__",
		},
		DefaultRedirectURI: ptr.String("__DefaultRedirectURI__"),
		AllowedOAuthFlows: []types.OAuthFlowType{
			types.OAuthFlowType("code"),
			types.OAuthFlowType("code"),
		},
		AllowedOAuthScopes: []string{
			"__Member__",
			"__Member__",
		},
		AllowedOAuthFlowsUserPoolClient: true,
		AnalyticsConfiguration: &types.AnalyticsConfigurationType{
			ApplicationId:  ptr.String("__ApplicationId__"),
			ApplicationArn: ptr.String("__ApplicationArn__"),
			RoleArn:        ptr.String("__RoleArn__"),
			ExternalId:     ptr.String("__ExternalId__"),
			UserDataShared: true,
		},
		PreventUserExistenceErrors:               types.PreventUserExistenceErrorTypes("LEGACY"),
		EnableTokenRevocation:                    ptr.Bool(true),
		EnablePropagateAdditionalUserContextData: ptr.Bool(true),
		AuthSessionValidity:                      ptr.Int32(1),
		RefreshTokenRotation: &types.RefreshTokenRotationType{
			Feature:                 types.FeatureType("ENABLED"),
			RetryGracePeriodSeconds: ptr.Int32(1),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateUserPoolClient(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateUserPoolClient"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateUserPoolDomain(t *testing.T) {
	input := &CreateUserPoolDomainInput{
		Domain:              ptr.String("__Domain__"),
		UserPoolId:          ptr.String("__UserPoolId__"),
		ManagedLoginVersion: ptr.Int32(1),
		CustomDomainConfig: &types.CustomDomainConfigType{
			CertificateArn: ptr.String("__CertificateArn__"),
			SecurityPolicy: types.SecurityPolicyType("TLS_V1"),
		},
		Routing: &types.RoutingType{
			Failover: &types.FailoverType{
				SecondaryRegion:             ptr.String("__SecondaryRegion__"),
				PrimaryRoute53HealthCheckId: ptr.String("__PrimaryRoute53HealthCheckId__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateUserPoolDomain(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateUserPoolDomain"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

func TestUpdateRequestSnapshot_DeleteUser(t *testing.T) {
	input := &DeleteUserInput{
		AccessToken: ptr.String("__AccessToken__"),
	}
	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_DeleteUserAttributes(t *testing.T) {
	input := &DeleteUserAttributesInput{
		UserAttributeNames: []string{
			"__Member__",
			"__Member__",
		},
		AccessToken: ptr.String("__AccessToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.DeleteUserAttributes(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "DeleteUserAttributes"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func TestUpdateRequestSnapshot_ForgotPassword(t *testing.T) {
	input := &ForgotPasswordInput{
		ClientId:   ptr.String("__ClientId__"),
		SecretHash: ptr.String("__SecretHash__"),
		UserContextData: &types.UserContextDataType{
			IpAddress:   ptr.String("__IpAddress__"),
			EncodedData: ptr.String("__EncodedData__"),
		},
		Username: ptr.String("__Username__"),
		AnalyticsMetadata: &types.AnalyticsMetadataType{
			AnalyticsEndpointId: ptr.String("__AnalyticsEndpointId__"),
		},
		ClientMetadata: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ForgotPassword(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ForgotPassword"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

func TestUpdateRequestSnapshot_GetTokensFromRefreshToken(t *testing.T) {
	input := &GetTokensFromRefreshTokenInput{
		RefreshToken: ptr.String("__RefreshToken__"),
		ClientId:     ptr.String("__ClientId__"),
		ClientSecret: ptr.String("__ClientSecret__"),
		DeviceKey:    ptr.String("__DeviceKey__"),
		ClientMetadata: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.GetTokensFromRefreshToken(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "GetTokensFromRefreshToken"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

func TestUpdateRequestSnapshot_InitiateAuth(t *testing.T) {
	input := &InitiateAuthInput{
		AuthFlow: types.AuthFlowType("USER_SRP_AUTH"),
		AuthParameters: map[string]string{
			"key0": "__Value__",
		},
		ClientMetadata: map[string]string{
			"key0": "__Value__",
		},
		ClientId: ptr.String("__ClientId__"),
		AnalyticsMetadata: &types.AnalyticsMetadataType{
			AnalyticsEndpointId: ptr.String("__AnalyticsEndpointId__"),
		},
		UserContextData: &types.UserContextDataType{
			IpAddress:   ptr.String("__IpAddress__"),
			EncodedData: ptr.String("__EncodedData__"),
		},
		Session: ptr.String("__Session__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.InitiateAuth(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "InitiateAuth"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

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

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

func TestUpdateRequestSnapshot_ListUsers(t *testing.T) {
	input := &ListUsersInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		AttributesToGet: []string{
			"__Member__",
			"__Member__",
		},
		Limit:           ptr.Int32(1),
		PaginationToken: ptr.String("__PaginationToken__"),
		Filter:          ptr.String("__Filter__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListUsers(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListUsers"); err != nil {
		t.Fatal(err)
	}
}

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

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

func TestUpdateRequestSnapshot_ResendConfirmationCode(t *testing.T) {
	input := &ResendConfirmationCodeInput{
		ClientId:   ptr.String("__ClientId__"),
		SecretHash: ptr.String("__SecretHash__"),
		UserContextData: &types.UserContextDataType{
			IpAddress:   ptr.String("__IpAddress__"),
			EncodedData: ptr.String("__EncodedData__"),
		},
		Username: ptr.String("__Username__"),
		AnalyticsMetadata: &types.AnalyticsMetadataType{
			AnalyticsEndpointId: ptr.String("__AnalyticsEndpointId__"),
		},
		ClientMetadata: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ResendConfirmationCode(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ResendConfirmationCode"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_RespondToAuthChallenge(t *testing.T) {
	input := &RespondToAuthChallengeInput{
		ClientId:      ptr.String("__ClientId__"),
		ChallengeName: types.ChallengeNameType("SMS_MFA"),
		Session:       ptr.String("__Session__"),
		ChallengeResponses: map[string]string{
			"key0": "__Value__",
		},
		AnalyticsMetadata: &types.AnalyticsMetadataType{
			AnalyticsEndpointId: ptr.String("__AnalyticsEndpointId__"),
		},
		UserContextData: &types.UserContextDataType{
			IpAddress:   ptr.String("__IpAddress__"),
			EncodedData: ptr.String("__EncodedData__"),
		},
		ClientMetadata: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.RespondToAuthChallenge(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "RespondToAuthChallenge"); err != nil {
		t.Fatal(err)
	}
}

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

func TestUpdateRequestSnapshot_SetLogDeliveryConfiguration(t *testing.T) {
	input := &SetLogDeliveryConfigurationInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		LogConfigurations: []types.LogConfigurationType{
			{
				LogLevel:    types.LogLevel("ERROR"),
				EventSource: types.EventSourceName("userNotification"),
				CloudWatchLogsConfiguration: &types.CloudWatchLogsConfigurationType{
					LogGroupArn: ptr.String("__LogGroupArn__"),
				},
				S3Configuration: &types.S3ConfigurationType{
					BucketArn: ptr.String("__BucketArn__"),
				},
				FirehoseConfiguration: &types.FirehoseConfigurationType{
					StreamArn: ptr.String("__StreamArn__"),
				},
			},
			{
				LogLevel:    types.LogLevel("ERROR"),
				EventSource: types.EventSourceName("userNotification"),
				CloudWatchLogsConfiguration: &types.CloudWatchLogsConfigurationType{
					LogGroupArn: ptr.String("__LogGroupArn__"),
				},
				S3Configuration: &types.S3ConfigurationType{
					BucketArn: ptr.String("__BucketArn__"),
				},
				FirehoseConfiguration: &types.FirehoseConfigurationType{
					StreamArn: ptr.String("__StreamArn__"),
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.SetLogDeliveryConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "SetLogDeliveryConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_SetRiskConfiguration(t *testing.T) {
	input := &SetRiskConfigurationInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		ClientId:   ptr.String("__ClientId__"),
		CompromisedCredentialsRiskConfiguration: &types.CompromisedCredentialsRiskConfigurationType{
			EventFilter: []types.EventFilterType{
				types.EventFilterType("SIGN_IN"),
				types.EventFilterType("SIGN_IN"),
			},
			Actions: &types.CompromisedCredentialsActionsType{
				EventAction: types.CompromisedCredentialsEventActionType("BLOCK"),
			},
		},
		AccountTakeoverRiskConfiguration: &types.AccountTakeoverRiskConfigurationType{
			NotifyConfiguration: &types.NotifyConfigurationType{
				From:      ptr.String("__From__"),
				ReplyTo:   ptr.String("__ReplyTo__"),
				SourceArn: ptr.String("__SourceArn__"),
				BlockEmail: &types.NotifyEmailType{
					Subject:  ptr.String("__Subject__"),
					HtmlBody: ptr.String("__HtmlBody__"),
					TextBody: ptr.String("__TextBody__"),
				},
				NoActionEmail: &types.NotifyEmailType{
					Subject:  ptr.String("__Subject__"),
					HtmlBody: ptr.String("__HtmlBody__"),
					TextBody: ptr.String("__TextBody__"),
				},
				MfaEmail: &types.NotifyEmailType{
					Subject:  ptr.String("__Subject__"),
					HtmlBody: ptr.String("__HtmlBody__"),
					TextBody: ptr.String("__TextBody__"),
				},
			},
			Actions: &types.AccountTakeoverActionsType{
				LowAction: &types.AccountTakeoverActionType{
					Notify:      true,
					EventAction: types.AccountTakeoverEventActionType("BLOCK"),
				},
				MediumAction: &types.AccountTakeoverActionType{
					Notify:      true,
					EventAction: types.AccountTakeoverEventActionType("BLOCK"),
				},
				HighAction: &types.AccountTakeoverActionType{
					Notify:      true,
					EventAction: types.AccountTakeoverEventActionType("BLOCK"),
				},
			},
		},
		RiskExceptionConfiguration: &types.RiskExceptionConfigurationType{
			BlockedIPRangeList: []string{
				"__Member__",
				"__Member__",
			},
			SkippedIPRangeList: []string{
				"__Member__",
				"__Member__",
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.SetRiskConfiguration(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "SetRiskConfiguration"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_SetUICustomization(t *testing.T) {
	input := &SetUICustomizationInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		ClientId:   ptr.String("__ClientId__"),
		CSS:        ptr.String("__CSS__"),
		ImageFile:  []byte("blob"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.SetUICustomization(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "SetUICustomization"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_SetUserMFAPreference(t *testing.T) {
	input := &SetUserMFAPreferenceInput{
		SMSMfaSettings: &types.SMSMfaSettingsType{
			Enabled:      true,
			PreferredMfa: true,
		},
		SoftwareTokenMfaSettings: &types.SoftwareTokenMfaSettingsType{
			Enabled:      true,
			PreferredMfa: true,
		},
		EmailMfaSettings: &types.EmailMfaSettingsType{
			Enabled:      true,
			PreferredMfa: true,
		},
		WebAuthnMfaSettings: &types.WebAuthnMfaSettingsType{
			Enabled: true,
		},
		AccessToken: ptr.String("__AccessToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.SetUserMFAPreference(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "SetUserMFAPreference"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_SetUserPoolMfaConfig(t *testing.T) {
	input := &SetUserPoolMfaConfigInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		SmsMfaConfiguration: &types.SmsMfaConfigType{
			SmsAuthenticationMessage: ptr.String("__SmsAuthenticationMessage__"),
			SmsConfiguration: &types.SmsConfigurationType{
				SnsCallerArn: ptr.String("__SnsCallerArn__"),
				ExternalId:   ptr.String("__ExternalId__"),
				SnsRegion:    ptr.String("__SnsRegion__"),
				EumsSms: &types.EumsSmsConfigurationType{
					CallerArn:            ptr.String("__CallerArn__"),
					ExternalId:           ptr.String("__ExternalId__"),
					OriginationIdentity:  ptr.String("__OriginationIdentity__"),
					ConfigurationSetName: ptr.String("__ConfigurationSetName__"),
					InEntityId:           ptr.String("__InEntityId__"),
					InTemplateId:         ptr.String("__InTemplateId__"),
					Region:               ptr.String("__Region__"),
				},
			},
		},
		SoftwareTokenMfaConfiguration: &types.SoftwareTokenMfaConfigType{
			Enabled: true,
		},
		EmailMfaConfiguration: &types.EmailMfaConfigType{
			Message: ptr.String("__Message__"),
			Subject: ptr.String("__Subject__"),
		},
		MfaConfiguration: types.UserPoolMfaType("OFF"),
		WebAuthnConfiguration: &types.WebAuthnConfigurationType{
			RelyingPartyId:      ptr.String("__RelyingPartyId__"),
			UserVerification:    types.UserVerificationType("required"),
			FactorConfiguration: types.WebAuthnFactorConfigurationType("SINGLE_FACTOR"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.SetUserPoolMfaConfig(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "SetUserPoolMfaConfig"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_SetUserSettings(t *testing.T) {
	input := &SetUserSettingsInput{
		AccessToken: ptr.String("__AccessToken__"),
		MFAOptions: []types.MFAOptionType{
			{
				DeliveryMedium: types.DeliveryMediumType("SMS"),
				AttributeName:  ptr.String("__AttributeName__"),
			},
			{
				DeliveryMedium: types.DeliveryMediumType("SMS"),
				AttributeName:  ptr.String("__AttributeName__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.SetUserSettings(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "SetUserSettings"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_SignUp(t *testing.T) {
	input := &SignUpInput{
		ClientId:   ptr.String("__ClientId__"),
		SecretHash: ptr.String("__SecretHash__"),
		Username:   ptr.String("__Username__"),
		Password:   ptr.String("__Password__"),
		UserAttributes: []types.AttributeType{
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
		},
		ValidationData: []types.AttributeType{
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
			{
				Name:  ptr.String("__Name__"),
				Value: ptr.String("__Value__"),
			},
		},
		AnalyticsMetadata: &types.AnalyticsMetadataType{
			AnalyticsEndpointId: ptr.String("__AnalyticsEndpointId__"),
		},
		UserContextData: &types.UserContextDataType{
			IpAddress:   ptr.String("__IpAddress__"),
			EncodedData: ptr.String("__EncodedData__"),
		},
		ClientMetadata: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.SignUp(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "SignUp"); err != nil {
		t.Fatal(err)
	}
}

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

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

func TestUpdateRequestSnapshot_StopUserImportJob(t *testing.T) {
	input := &StopUserImportJobInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		JobId:      ptr.String("__JobId__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.StopUserImportJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "StopUserImportJob"); 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_UpdateAuthEventFeedback(t *testing.T) {
	input := &UpdateAuthEventFeedbackInput{
		UserPoolId:    ptr.String("__UserPoolId__"),
		Username:      ptr.String("__Username__"),
		EventId:       ptr.String("__EventId__"),
		FeedbackToken: ptr.String("__FeedbackToken__"),
		FeedbackValue: types.FeedbackValueType("Valid"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateAuthEventFeedback(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateAuthEventFeedback"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateDeviceStatus(t *testing.T) {
	input := &UpdateDeviceStatusInput{
		AccessToken:            ptr.String("__AccessToken__"),
		DeviceKey:              ptr.String("__DeviceKey__"),
		DeviceRememberedStatus: types.DeviceRememberedStatusType("remembered"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateDeviceStatus(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateDeviceStatus"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateGroup(t *testing.T) {
	input := &UpdateGroupInput{
		GroupName:   ptr.String("__GroupName__"),
		UserPoolId:  ptr.String("__UserPoolId__"),
		Description: ptr.String("__Description__"),
		RoleArn:     ptr.String("__RoleArn__"),
		Precedence:  ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateGroup(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateGroup"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateIdentityProvider(t *testing.T) {
	input := &UpdateIdentityProviderInput{
		UserPoolId:   ptr.String("__UserPoolId__"),
		ProviderName: ptr.String("__ProviderName__"),
		ProviderDetails: map[string]string{
			"key0": "__Value__",
		},
		AttributeMapping: map[string]string{
			"key0": "__Value__",
		},
		IdpIdentifiers: []string{
			"__Member__",
			"__Member__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateIdentityProvider(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateIdentityProvider"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateManagedLoginBranding(t *testing.T) {
	input := &UpdateManagedLoginBrandingInput{
		UserPoolId:               ptr.String("__UserPoolId__"),
		ManagedLoginBrandingId:   ptr.String("__ManagedLoginBrandingId__"),
		UseCognitoProvidedValues: true,
		Settings:                 nil,
		Assets: []types.AssetType{
			{
				Category:   types.AssetCategoryType("FAVICON_ICO"),
				ColorMode:  types.ColorSchemeModeType("LIGHT"),
				Extension:  types.AssetExtensionType("ICO"),
				Bytes:      []byte("blob"),
				ResourceId: ptr.String("__ResourceId__"),
			},
			{
				Category:   types.AssetCategoryType("FAVICON_ICO"),
				ColorMode:  types.ColorSchemeModeType("LIGHT"),
				Extension:  types.AssetExtensionType("ICO"),
				Bytes:      []byte("blob"),
				ResourceId: ptr.String("__ResourceId__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateManagedLoginBranding(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateManagedLoginBranding"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateProvisionedLimit(t *testing.T) {
	input := &UpdateProvisionedLimitInput{
		LimitDefinition: &types.LimitDefinitionType{
			LimitClass: types.LimitClass("API_CATEGORY"),
			Attributes: map[string]string{
				"key0": "__Value__",
			},
		},
		RequestedLimitValue: 1,
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateProvisionedLimit(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateProvisionedLimit"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateResourceServer(t *testing.T) {
	input := &UpdateResourceServerInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		Identifier: ptr.String("__Identifier__"),
		Name:       ptr.String("__Name__"),
		Scopes: []types.ResourceServerScopeType{
			{
				ScopeName:        ptr.String("__ScopeName__"),
				ScopeDescription: ptr.String("__ScopeDescription__"),
			},
			{
				ScopeName:        ptr.String("__ScopeName__"),
				ScopeDescription: ptr.String("__ScopeDescription__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateResourceServer(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateResourceServer"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateTerms(t *testing.T) {
	input := &UpdateTermsInput{
		TermsId:     ptr.String("__TermsId__"),
		UserPoolId:  ptr.String("__UserPoolId__"),
		TermsName:   ptr.String("__TermsName__"),
		TermsSource: types.TermsSourceType("LINK"),
		Enforcement: types.TermsEnforcementType("NONE"),
		Links: map[string]string{
			"key0": "__Value__",
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateTerms(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateTerms"); err != nil {
		t.Fatal(err)
	}
}

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

func TestUpdateRequestSnapshot_UpdateUserPool(t *testing.T) {
	input := &UpdateUserPoolInput{
		UserPoolId: ptr.String("__UserPoolId__"),
		Policies: &types.UserPoolPolicyType{
			PasswordPolicy: &types.PasswordPolicyType{
				MinimumLength:                 ptr.Int32(1),
				RequireUppercase:              true,
				RequireLowercase:              true,
				RequireNumbers:                true,
				RequireSymbols:                true,
				PasswordHistorySize:           ptr.Int32(1),
				TemporaryPasswordValidityDays: 1,
			},
			SignInPolicy: &types.SignInPolicyType{
				AllowedFirstAuthFactors: []types.AuthFactorType{
					types.AuthFactorType("PASSWORD"),
					types.AuthFactorType("PASSWORD"),
				},
			},
		},
		DeletionProtection: types.DeletionProtectionType("ACTIVE"),
		LambdaConfig: &types.LambdaConfigType{
			PreSignUp:                   ptr.String("__PreSignUp__"),
			CustomMessage:               ptr.String("__CustomMessage__"),
			PostConfirmation:            ptr.String("__PostConfirmation__"),
			PreAuthentication:           ptr.String("__PreAuthentication__"),
			PostAuthentication:          ptr.String("__PostAuthentication__"),
			DefineAuthChallenge:         ptr.String("__DefineAuthChallenge__"),
			CreateAuthChallenge:         ptr.String("__CreateAuthChallenge__"),
			VerifyAuthChallengeResponse: ptr.String("__VerifyAuthChallengeResponse__"),
			PreTokenGeneration:          ptr.String("__PreTokenGeneration__"),
			UserMigration:               ptr.String("__UserMigration__"),
			PreTokenGenerationConfig: &types.PreTokenGenerationVersionConfigType{
				LambdaVersion: types.PreTokenGenerationLambdaVersionType("V1_0"),
				LambdaArn:     ptr.String("__LambdaArn__"),
			},
			CustomSMSSender: &types.CustomSMSLambdaVersionConfigType{
				LambdaVersion: types.CustomSMSSenderLambdaVersionType("V1_0"),
				LambdaArn:     ptr.String("__LambdaArn__"),
			},
			CustomEmailSender: &types.CustomEmailLambdaVersionConfigType{
				LambdaVersion: types.CustomEmailSenderLambdaVersionType("V1_0"),
				LambdaArn:     ptr.String("__LambdaArn__"),
			},
			KMSKeyID: ptr.String("__KMSKeyID__"),
			InboundFederation: &types.InboundFederationLambdaType{
				LambdaVersion: types.InboundFederationLambdaVersionType("V1_0"),
				LambdaArn:     ptr.String("__LambdaArn__"),
			},
		},
		AutoVerifiedAttributes: []types.VerifiedAttributeType{
			types.VerifiedAttributeType("phone_number"),
			types.VerifiedAttributeType("phone_number"),
		},
		SmsVerificationMessage:   ptr.String("__SmsVerificationMessage__"),
		EmailVerificationMessage: ptr.String("__EmailVerificationMessage__"),
		EmailVerificationSubject: ptr.String("__EmailVerificationSubject__"),
		VerificationMessageTemplate: &types.VerificationMessageTemplateType{
			SmsMessage:         ptr.String("__SmsMessage__"),
			EmailMessage:       ptr.String("__EmailMessage__"),
			EmailSubject:       ptr.String("__EmailSubject__"),
			EmailMessageByLink: ptr.String("__EmailMessageByLink__"),
			EmailSubjectByLink: ptr.String("__EmailSubjectByLink__"),
			DefaultEmailOption: types.DefaultEmailOptionType("CONFIRM_WITH_LINK"),
		},
		SmsAuthenticationMessage: ptr.String("__SmsAuthenticationMessage__"),
		UserAttributeUpdateSettings: &types.UserAttributeUpdateSettingsType{
			AttributesRequireVerificationBeforeUpdate: []types.VerifiedAttributeType{
				types.VerifiedAttributeType("phone_number"),
				types.VerifiedAttributeType("phone_number"),
			},
		},
		MfaConfiguration: types.UserPoolMfaType("OFF"),
		DeviceConfiguration: &types.DeviceConfigurationType{
			ChallengeRequiredOnNewDevice:     true,
			DeviceOnlyRememberedOnUserPrompt: true,
		},
		EmailConfiguration: &types.EmailConfigurationType{
			SourceArn:           ptr.String("__SourceArn__"),
			ReplyToEmailAddress: ptr.String("__ReplyToEmailAddress__"),
			EmailSendingAccount: types.EmailSendingAccountType("COGNITO_DEFAULT"),
			From:                ptr.String("__From__"),
			ConfigurationSet:    ptr.String("__ConfigurationSet__"),
		},
		SmsConfiguration: &types.SmsConfigurationType{
			SnsCallerArn: ptr.String("__SnsCallerArn__"),
			ExternalId:   ptr.String("__ExternalId__"),
			SnsRegion:    ptr.String("__SnsRegion__"),
			EumsSms: &types.EumsSmsConfigurationType{
				CallerArn:            ptr.String("__CallerArn__"),
				ExternalId:           ptr.String("__ExternalId__"),
				OriginationIdentity:  ptr.String("__OriginationIdentity__"),
				ConfigurationSetName: ptr.String("__ConfigurationSetName__"),
				InEntityId:           ptr.String("__InEntityId__"),
				InTemplateId:         ptr.String("__InTemplateId__"),
				Region:               ptr.String("__Region__"),
			},
		},
		UserPoolTags: map[string]string{
			"key0": "__Value__",
		},
		AdminCreateUserConfig: &types.AdminCreateUserConfigType{
			AllowAdminCreateUserOnly:  true,
			UnusedAccountValidityDays: 1,
			InviteMessageTemplate: &types.MessageTemplateType{
				SMSMessage:   ptr.String("__SMSMessage__"),
				EmailMessage: ptr.String("__EmailMessage__"),
				EmailSubject: ptr.String("__EmailSubject__"),
			},
		},
		UserPoolAddOns: &types.UserPoolAddOnsType{
			AdvancedSecurityMode: types.AdvancedSecurityModeType("OFF"),
			AdvancedSecurityAdditionalFlows: &types.AdvancedSecurityAdditionalFlowsType{
				CustomAuthMode: types.AdvancedSecurityEnabledModeType("AUDIT"),
			},
		},
		AccountRecoverySetting: &types.AccountRecoverySettingType{
			RecoveryMechanisms: []types.RecoveryOptionType{
				{
					Priority: ptr.Int32(1),
					Name:     types.RecoveryOptionNameType("verified_email"),
				},
				{
					Priority: ptr.Int32(1),
					Name:     types.RecoveryOptionNameType("verified_email"),
				},
			},
		},
		PoolName:     ptr.String("__PoolName__"),
		UserPoolTier: types.UserPoolTierType("LITE"),
		KeyConfiguration: &types.KeyConfigurationType{
			KeyType:   types.EncryptionKeyType("AWS_OWNED_KEY"),
			KmsKeyArn: ptr.String("__KmsKeyArn__"),
		},
		IssuerConfiguration: &types.IssuerConfigurationType{
			Type: types.IssuerType("ORIGINAL"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateUserPool(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateUserPool"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateUserPoolClient(t *testing.T) {
	input := &UpdateUserPoolClientInput{
		UserPoolId:           ptr.String("__UserPoolId__"),
		ClientId:             ptr.String("__ClientId__"),
		ClientName:           ptr.String("__ClientName__"),
		RefreshTokenValidity: 1,
		AccessTokenValidity:  ptr.Int32(1),
		IdTokenValidity:      ptr.Int32(1),
		TokenValidityUnits: &types.TokenValidityUnitsType{
			AccessToken:  types.TimeUnitsType("seconds"),
			IdToken:      types.TimeUnitsType("seconds"),
			RefreshToken: types.TimeUnitsType("seconds"),
		},
		ReadAttributes: []string{
			"__Member__",
			"__Member__",
		},
		WriteAttributes: []string{
			"__Member__",
			"__Member__",
		},
		ExplicitAuthFlows: []types.ExplicitAuthFlowsType{
			types.ExplicitAuthFlowsType("ADMIN_NO_SRP_AUTH"),
			types.ExplicitAuthFlowsType("ADMIN_NO_SRP_AUTH"),
		},
		SupportedIdentityProviders: []string{
			"__Member__",
			"__Member__",
		},
		CallbackURLs: []string{
			"__Member__",
			"__Member__",
		},
		LogoutURLs: []string{
			"__Member__",
			"__Member__",
		},
		DefaultRedirectURI: ptr.String("__DefaultRedirectURI__"),
		AllowedOAuthFlows: []types.OAuthFlowType{
			types.OAuthFlowType("code"),
			types.OAuthFlowType("code"),
		},
		AllowedOAuthScopes: []string{
			"__Member__",
			"__Member__",
		},
		AllowedOAuthFlowsUserPoolClient: true,
		AnalyticsConfiguration: &types.AnalyticsConfigurationType{
			ApplicationId:  ptr.String("__ApplicationId__"),
			ApplicationArn: ptr.String("__ApplicationArn__"),
			RoleArn:        ptr.String("__RoleArn__"),
			ExternalId:     ptr.String("__ExternalId__"),
			UserDataShared: true,
		},
		PreventUserExistenceErrors:               types.PreventUserExistenceErrorTypes("LEGACY"),
		EnableTokenRevocation:                    ptr.Bool(true),
		EnablePropagateAdditionalUserContextData: ptr.Bool(true),
		AuthSessionValidity:                      ptr.Int32(1),
		RefreshTokenRotation: &types.RefreshTokenRotationType{
			Feature:                 types.FeatureType("ENABLED"),
			RetryGracePeriodSeconds: ptr.Int32(1),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateUserPoolClient(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateUserPoolClient"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateUserPoolDomain(t *testing.T) {
	input := &UpdateUserPoolDomainInput{
		Domain:              ptr.String("__Domain__"),
		UserPoolId:          ptr.String("__UserPoolId__"),
		ManagedLoginVersion: ptr.Int32(1),
		CustomDomainConfig: &types.CustomDomainConfigType{
			CertificateArn: ptr.String("__CertificateArn__"),
			SecurityPolicy: types.SecurityPolicyType("TLS_V1"),
		},
		Routing: &types.RoutingType{
			Failover: &types.FailoverType{
				SecondaryRegion:             ptr.String("__SecondaryRegion__"),
				PrimaryRoute53HealthCheckId: ptr.String("__PrimaryRoute53HealthCheckId__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateUserPoolDomain(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateUserPoolDomain"); err != nil {
		t.Fatal(err)
	}
}

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

func TestUpdateRequestSnapshot_VerifySoftwareToken(t *testing.T) {
	input := &VerifySoftwareTokenInput{
		AccessToken:        ptr.String("__AccessToken__"),
		Session:            ptr.String("__Session__"),
		UserCode:           ptr.String("__UserCode__"),
		FriendlyDeviceName: ptr.String("__FriendlyDeviceName__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.VerifySoftwareToken(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "VerifySoftwareToken"); err != nil {
		t.Fatal(err)
	}
}

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