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

//go:build request_snapshot

package bcmpricingcalculator

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/bcmpricingcalculator/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"
	"time"
)

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_BatchCreateBillScenarioCommitmentModification(t *testing.T) {
	input := &BatchCreateBillScenarioCommitmentModificationInput{
		BillScenarioId: ptr.String("__BillScenarioId__"),
		CommitmentModifications: []types.BatchCreateBillScenarioCommitmentModificationEntry{
			{
				Key:            ptr.String("__Key__"),
				Group:          ptr.String("__Group__"),
				UsageAccountId: ptr.String("__UsageAccountId__"),
				CommitmentAction: &types.BillScenarioCommitmentModificationActionMemberAddReservedInstanceAction{
					Value: types.AddReservedInstanceAction{
						ReservedInstancesOfferingId: ptr.String("__ReservedInstancesOfferingId__"),
						InstanceCount:               ptr.Int32(1),
					},
				},
			},
			{
				Key:            ptr.String("__Key__"),
				Group:          ptr.String("__Group__"),
				UsageAccountId: ptr.String("__UsageAccountId__"),
				CommitmentAction: &types.BillScenarioCommitmentModificationActionMemberAddReservedInstanceAction{
					Value: types.AddReservedInstanceAction{
						ReservedInstancesOfferingId: ptr.String("__ReservedInstancesOfferingId__"),
						InstanceCount:               ptr.Int32(1),
					},
				},
			},
		},
		ClientToken: ptr.String("__ClientToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchCreateBillScenarioCommitmentModification(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchCreateBillScenarioCommitmentModification"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_BatchCreateBillScenarioUsageModification(t *testing.T) {
	input := &BatchCreateBillScenarioUsageModificationInput{
		BillScenarioId: ptr.String("__BillScenarioId__"),
		UsageModifications: []types.BatchCreateBillScenarioUsageModificationEntry{
			{
				ServiceCode:      ptr.String("__ServiceCode__"),
				UsageType:        ptr.String("__UsageType__"),
				Operation:        ptr.String("__Operation__"),
				AvailabilityZone: ptr.String("__AvailabilityZone__"),
				Key:              ptr.String("__Key__"),
				Group:            ptr.String("__Group__"),
				UsageAccountId:   ptr.String("__UsageAccountId__"),
				Amounts: []types.UsageAmount{
					{
						StartHour: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Amount:    ptr.Float64(1.0),
					},
					{
						StartHour: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Amount:    ptr.Float64(1.0),
					},
				},
				HistoricalUsage: &types.HistoricalUsageEntity{
					ServiceCode:    ptr.String("__ServiceCode__"),
					UsageType:      ptr.String("__UsageType__"),
					Operation:      ptr.String("__Operation__"),
					Location:       ptr.String("__Location__"),
					UsageAccountId: ptr.String("__UsageAccountId__"),
					BillInterval: &types.BillInterval{
						Start: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						End:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
					FilterExpression: &types.Expression{
						And: []types.Expression{
							{},
							{},
						},
						Or: []types.Expression{
							{},
							{},
						},
						Not: nil,
						CostCategories: &types.ExpressionFilter{
							Key: ptr.String("__Key__"),
							MatchOptions: []string{
								"__Member__",
								"__Member__",
							},
							Values: []string{
								"__Member__",
								"__Member__",
							},
						},
						Dimensions: &types.ExpressionFilter{
							Key: ptr.String("__Key__"),
							MatchOptions: []string{
								"__Member__",
								"__Member__",
							},
							Values: []string{
								"__Member__",
								"__Member__",
							},
						},
						Tags: &types.ExpressionFilter{
							Key: ptr.String("__Key__"),
							MatchOptions: []string{
								"__Member__",
								"__Member__",
							},
							Values: []string{
								"__Member__",
								"__Member__",
							},
						},
					},
				},
			},
			{
				ServiceCode:      ptr.String("__ServiceCode__"),
				UsageType:        ptr.String("__UsageType__"),
				Operation:        ptr.String("__Operation__"),
				AvailabilityZone: ptr.String("__AvailabilityZone__"),
				Key:              ptr.String("__Key__"),
				Group:            ptr.String("__Group__"),
				UsageAccountId:   ptr.String("__UsageAccountId__"),
				Amounts: []types.UsageAmount{
					{
						StartHour: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Amount:    ptr.Float64(1.0),
					},
					{
						StartHour: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Amount:    ptr.Float64(1.0),
					},
				},
				HistoricalUsage: &types.HistoricalUsageEntity{
					ServiceCode:    ptr.String("__ServiceCode__"),
					UsageType:      ptr.String("__UsageType__"),
					Operation:      ptr.String("__Operation__"),
					Location:       ptr.String("__Location__"),
					UsageAccountId: ptr.String("__UsageAccountId__"),
					BillInterval: &types.BillInterval{
						Start: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						End:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
					FilterExpression: &types.Expression{
						And: []types.Expression{
							{},
							{},
						},
						Or: []types.Expression{
							{},
							{},
						},
						Not: nil,
						CostCategories: &types.ExpressionFilter{
							Key: ptr.String("__Key__"),
							MatchOptions: []string{
								"__Member__",
								"__Member__",
							},
							Values: []string{
								"__Member__",
								"__Member__",
							},
						},
						Dimensions: &types.ExpressionFilter{
							Key: ptr.String("__Key__"),
							MatchOptions: []string{
								"__Member__",
								"__Member__",
							},
							Values: []string{
								"__Member__",
								"__Member__",
							},
						},
						Tags: &types.ExpressionFilter{
							Key: ptr.String("__Key__"),
							MatchOptions: []string{
								"__Member__",
								"__Member__",
							},
							Values: []string{
								"__Member__",
								"__Member__",
							},
						},
					},
				},
			},
		},
		ClientToken: ptr.String("__ClientToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchCreateBillScenarioUsageModification(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchCreateBillScenarioUsageModification"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_BatchCreateWorkloadEstimateUsage(t *testing.T) {
	input := &BatchCreateWorkloadEstimateUsageInput{
		WorkloadEstimateId: ptr.String("__WorkloadEstimateId__"),
		Usage: []types.BatchCreateWorkloadEstimateUsageEntry{
			{
				ServiceCode:    ptr.String("__ServiceCode__"),
				UsageType:      ptr.String("__UsageType__"),
				Operation:      ptr.String("__Operation__"),
				Key:            ptr.String("__Key__"),
				Group:          ptr.String("__Group__"),
				UsageAccountId: ptr.String("__UsageAccountId__"),
				Amount:         ptr.Float64(1.0),
				HistoricalUsage: &types.HistoricalUsageEntity{
					ServiceCode:    ptr.String("__ServiceCode__"),
					UsageType:      ptr.String("__UsageType__"),
					Operation:      ptr.String("__Operation__"),
					Location:       ptr.String("__Location__"),
					UsageAccountId: ptr.String("__UsageAccountId__"),
					BillInterval: &types.BillInterval{
						Start: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						End:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
					FilterExpression: &types.Expression{
						And: []types.Expression{
							{},
							{},
						},
						Or: []types.Expression{
							{},
							{},
						},
						Not: nil,
						CostCategories: &types.ExpressionFilter{
							Key: ptr.String("__Key__"),
							MatchOptions: []string{
								"__Member__",
								"__Member__",
							},
							Values: []string{
								"__Member__",
								"__Member__",
							},
						},
						Dimensions: &types.ExpressionFilter{
							Key: ptr.String("__Key__"),
							MatchOptions: []string{
								"__Member__",
								"__Member__",
							},
							Values: []string{
								"__Member__",
								"__Member__",
							},
						},
						Tags: &types.ExpressionFilter{
							Key: ptr.String("__Key__"),
							MatchOptions: []string{
								"__Member__",
								"__Member__",
							},
							Values: []string{
								"__Member__",
								"__Member__",
							},
						},
					},
				},
			},
			{
				ServiceCode:    ptr.String("__ServiceCode__"),
				UsageType:      ptr.String("__UsageType__"),
				Operation:      ptr.String("__Operation__"),
				Key:            ptr.String("__Key__"),
				Group:          ptr.String("__Group__"),
				UsageAccountId: ptr.String("__UsageAccountId__"),
				Amount:         ptr.Float64(1.0),
				HistoricalUsage: &types.HistoricalUsageEntity{
					ServiceCode:    ptr.String("__ServiceCode__"),
					UsageType:      ptr.String("__UsageType__"),
					Operation:      ptr.String("__Operation__"),
					Location:       ptr.String("__Location__"),
					UsageAccountId: ptr.String("__UsageAccountId__"),
					BillInterval: &types.BillInterval{
						Start: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						End:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
					FilterExpression: &types.Expression{
						And: []types.Expression{
							{},
							{},
						},
						Or: []types.Expression{
							{},
							{},
						},
						Not: nil,
						CostCategories: &types.ExpressionFilter{
							Key: ptr.String("__Key__"),
							MatchOptions: []string{
								"__Member__",
								"__Member__",
							},
							Values: []string{
								"__Member__",
								"__Member__",
							},
						},
						Dimensions: &types.ExpressionFilter{
							Key: ptr.String("__Key__"),
							MatchOptions: []string{
								"__Member__",
								"__Member__",
							},
							Values: []string{
								"__Member__",
								"__Member__",
							},
						},
						Tags: &types.ExpressionFilter{
							Key: ptr.String("__Key__"),
							MatchOptions: []string{
								"__Member__",
								"__Member__",
							},
							Values: []string{
								"__Member__",
								"__Member__",
							},
						},
					},
				},
			},
		},
		ClientToken: ptr.String("__ClientToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchCreateWorkloadEstimateUsage(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchCreateWorkloadEstimateUsage"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

func TestCheckRequestSnapshot_BatchUpdateBillScenarioCommitmentModification(t *testing.T) {
	input := &BatchUpdateBillScenarioCommitmentModificationInput{
		BillScenarioId: ptr.String("__BillScenarioId__"),
		CommitmentModifications: []types.BatchUpdateBillScenarioCommitmentModificationEntry{
			{
				Id:    ptr.String("__Id__"),
				Group: ptr.String("__Group__"),
			},
			{
				Id:    ptr.String("__Id__"),
				Group: ptr.String("__Group__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchUpdateBillScenarioCommitmentModification(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchUpdateBillScenarioCommitmentModification"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_BatchUpdateBillScenarioUsageModification(t *testing.T) {
	input := &BatchUpdateBillScenarioUsageModificationInput{
		BillScenarioId: ptr.String("__BillScenarioId__"),
		UsageModifications: []types.BatchUpdateBillScenarioUsageModificationEntry{
			{
				Id:    ptr.String("__Id__"),
				Group: ptr.String("__Group__"),
				Amounts: []types.UsageAmount{
					{
						StartHour: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Amount:    ptr.Float64(1.0),
					},
					{
						StartHour: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Amount:    ptr.Float64(1.0),
					},
				},
			},
			{
				Id:    ptr.String("__Id__"),
				Group: ptr.String("__Group__"),
				Amounts: []types.UsageAmount{
					{
						StartHour: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Amount:    ptr.Float64(1.0),
					},
					{
						StartHour: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Amount:    ptr.Float64(1.0),
					},
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchUpdateBillScenarioUsageModification(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchUpdateBillScenarioUsageModification"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_BatchUpdateWorkloadEstimateUsage(t *testing.T) {
	input := &BatchUpdateWorkloadEstimateUsageInput{
		WorkloadEstimateId: ptr.String("__WorkloadEstimateId__"),
		Usage: []types.BatchUpdateWorkloadEstimateUsageEntry{
			{
				Id:     ptr.String("__Id__"),
				Group:  ptr.String("__Group__"),
				Amount: ptr.Float64(1.0),
			},
			{
				Id:     ptr.String("__Id__"),
				Group:  ptr.String("__Group__"),
				Amount: ptr.Float64(1.0),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchUpdateWorkloadEstimateUsage(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchUpdateWorkloadEstimateUsage"); err != nil {
		t.Fatal(err)
	}
}

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

func TestCheckRequestSnapshot_CreateBillScenario(t *testing.T) {
	input := &CreateBillScenarioInput{
		Name:        ptr.String("__Name__"),
		ClientToken: ptr.String("__ClientToken__"),
		Tags: map[string]string{
			"key0": "__Value__",
		},
		GroupSharingPreference:                types.GroupSharingPreferenceEnum("OPEN"),
		CostCategoryGroupSharingPreferenceArn: ptr.String("__CostCategoryGroupSharingPreferenceArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateBillScenario(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateBillScenario"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

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

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

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

func TestCheckRequestSnapshot_ListBillEstimateInputUsageModifications(t *testing.T) {
	input := &ListBillEstimateInputUsageModificationsInput{
		BillEstimateId: ptr.String("__BillEstimateId__"),
		Filters: []types.ListUsageFilter{
			{
				Name: types.ListUsageFilterName("USAGE_ACCOUNT_ID"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
			{
				Name: types.ListUsageFilterName("USAGE_ACCOUNT_ID"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBillEstimateInputUsageModifications(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListBillEstimateInputUsageModifications"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListBillEstimateLineItems(t *testing.T) {
	input := &ListBillEstimateLineItemsInput{
		BillEstimateId: ptr.String("__BillEstimateId__"),
		Filters: []types.ListBillEstimateLineItemsFilter{
			{
				Name: types.ListBillEstimateLineItemsFilterName("USAGE_ACCOUNT_ID"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
			{
				Name: types.ListBillEstimateLineItemsFilterName("USAGE_ACCOUNT_ID"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBillEstimateLineItems(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListBillEstimateLineItems"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListBillEstimates(t *testing.T) {
	input := &ListBillEstimatesInput{
		Filters: []types.ListBillEstimatesFilter{
			{
				Name: types.ListBillEstimatesFilterName("STATUS"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
			{
				Name: types.ListBillEstimatesFilterName("STATUS"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
		},
		CreatedAtFilter: &types.FilterTimestamp{
			AfterTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			BeforeTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		ExpiresAtFilter: &types.FilterTimestamp{
			AfterTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			BeforeTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBillEstimates(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListBillEstimates"); err != nil {
		t.Fatal(err)
	}
}

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

func TestCheckRequestSnapshot_ListBillScenarios(t *testing.T) {
	input := &ListBillScenariosInput{
		Filters: []types.ListBillScenariosFilter{
			{
				Name: types.ListBillScenariosFilterName("STATUS"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
			{
				Name: types.ListBillScenariosFilterName("STATUS"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
		},
		CreatedAtFilter: &types.FilterTimestamp{
			AfterTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			BeforeTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		ExpiresAtFilter: &types.FilterTimestamp{
			AfterTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			BeforeTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBillScenarios(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListBillScenarios"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListBillScenarioUsageModifications(t *testing.T) {
	input := &ListBillScenarioUsageModificationsInput{
		BillScenarioId: ptr.String("__BillScenarioId__"),
		Filters: []types.ListUsageFilter{
			{
				Name: types.ListUsageFilterName("USAGE_ACCOUNT_ID"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
			{
				Name: types.ListUsageFilterName("USAGE_ACCOUNT_ID"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBillScenarioUsageModifications(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListBillScenarioUsageModifications"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListTagsForResource(t *testing.T) {
	input := &ListTagsForResourceInput{
		Arn: ptr.String("__Arn__"),
	}
	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_ListWorkloadEstimates(t *testing.T) {
	input := &ListWorkloadEstimatesInput{
		CreatedAtFilter: &types.FilterTimestamp{
			AfterTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			BeforeTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		ExpiresAtFilter: &types.FilterTimestamp{
			AfterTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			BeforeTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		Filters: []types.ListWorkloadEstimatesFilter{
			{
				Name: types.ListWorkloadEstimatesFilterName("STATUS"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
			{
				Name: types.ListWorkloadEstimatesFilterName("STATUS"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListWorkloadEstimates(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListWorkloadEstimates"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListWorkloadEstimateUsage(t *testing.T) {
	input := &ListWorkloadEstimateUsageInput{
		WorkloadEstimateId: ptr.String("__WorkloadEstimateId__"),
		Filters: []types.ListUsageFilter{
			{
				Name: types.ListUsageFilterName("USAGE_ACCOUNT_ID"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
			{
				Name: types.ListUsageFilterName("USAGE_ACCOUNT_ID"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListWorkloadEstimateUsage(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListWorkloadEstimateUsage"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_TagResource(t *testing.T) {
	input := &TagResourceInput{
		Arn: ptr.String("__Arn__"),
		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{
		Arn: ptr.String("__Arn__"),
		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_UpdateBillEstimate(t *testing.T) {
	input := &UpdateBillEstimateInput{
		Identifier: ptr.String("__Identifier__"),
		Name:       ptr.String("__Name__"),
		ExpiresAt:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateBillEstimate(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateBillEstimate"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_UpdateBillScenario(t *testing.T) {
	input := &UpdateBillScenarioInput{
		Identifier:                            ptr.String("__Identifier__"),
		Name:                                  ptr.String("__Name__"),
		ExpiresAt:                             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		GroupSharingPreference:                types.GroupSharingPreferenceEnum("OPEN"),
		CostCategoryGroupSharingPreferenceArn: ptr.String("__CostCategoryGroupSharingPreferenceArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateBillScenario(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateBillScenario"); err != nil {
		t.Fatal(err)
	}
}

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

func TestCheckRequestSnapshot_UpdateWorkloadEstimate(t *testing.T) {
	input := &UpdateWorkloadEstimateInput{
		Identifier: ptr.String("__Identifier__"),
		Name:       ptr.String("__Name__"),
		ExpiresAt:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateWorkloadEstimate(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateWorkloadEstimate"); err != nil {
		t.Fatal(err)
	}
}
func TestUpdateRequestSnapshot_BatchCreateBillScenarioCommitmentModification(t *testing.T) {
	input := &BatchCreateBillScenarioCommitmentModificationInput{
		BillScenarioId: ptr.String("__BillScenarioId__"),
		CommitmentModifications: []types.BatchCreateBillScenarioCommitmentModificationEntry{
			{
				Key:            ptr.String("__Key__"),
				Group:          ptr.String("__Group__"),
				UsageAccountId: ptr.String("__UsageAccountId__"),
				CommitmentAction: &types.BillScenarioCommitmentModificationActionMemberAddReservedInstanceAction{
					Value: types.AddReservedInstanceAction{
						ReservedInstancesOfferingId: ptr.String("__ReservedInstancesOfferingId__"),
						InstanceCount:               ptr.Int32(1),
					},
				},
			},
			{
				Key:            ptr.String("__Key__"),
				Group:          ptr.String("__Group__"),
				UsageAccountId: ptr.String("__UsageAccountId__"),
				CommitmentAction: &types.BillScenarioCommitmentModificationActionMemberAddReservedInstanceAction{
					Value: types.AddReservedInstanceAction{
						ReservedInstancesOfferingId: ptr.String("__ReservedInstancesOfferingId__"),
						InstanceCount:               ptr.Int32(1),
					},
				},
			},
		},
		ClientToken: ptr.String("__ClientToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchCreateBillScenarioCommitmentModification(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchCreateBillScenarioCommitmentModification"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_BatchCreateBillScenarioUsageModification(t *testing.T) {
	input := &BatchCreateBillScenarioUsageModificationInput{
		BillScenarioId: ptr.String("__BillScenarioId__"),
		UsageModifications: []types.BatchCreateBillScenarioUsageModificationEntry{
			{
				ServiceCode:      ptr.String("__ServiceCode__"),
				UsageType:        ptr.String("__UsageType__"),
				Operation:        ptr.String("__Operation__"),
				AvailabilityZone: ptr.String("__AvailabilityZone__"),
				Key:              ptr.String("__Key__"),
				Group:            ptr.String("__Group__"),
				UsageAccountId:   ptr.String("__UsageAccountId__"),
				Amounts: []types.UsageAmount{
					{
						StartHour: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Amount:    ptr.Float64(1.0),
					},
					{
						StartHour: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Amount:    ptr.Float64(1.0),
					},
				},
				HistoricalUsage: &types.HistoricalUsageEntity{
					ServiceCode:    ptr.String("__ServiceCode__"),
					UsageType:      ptr.String("__UsageType__"),
					Operation:      ptr.String("__Operation__"),
					Location:       ptr.String("__Location__"),
					UsageAccountId: ptr.String("__UsageAccountId__"),
					BillInterval: &types.BillInterval{
						Start: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						End:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
					FilterExpression: &types.Expression{
						And: []types.Expression{
							{},
							{},
						},
						Or: []types.Expression{
							{},
							{},
						},
						Not: nil,
						CostCategories: &types.ExpressionFilter{
							Key: ptr.String("__Key__"),
							MatchOptions: []string{
								"__Member__",
								"__Member__",
							},
							Values: []string{
								"__Member__",
								"__Member__",
							},
						},
						Dimensions: &types.ExpressionFilter{
							Key: ptr.String("__Key__"),
							MatchOptions: []string{
								"__Member__",
								"__Member__",
							},
							Values: []string{
								"__Member__",
								"__Member__",
							},
						},
						Tags: &types.ExpressionFilter{
							Key: ptr.String("__Key__"),
							MatchOptions: []string{
								"__Member__",
								"__Member__",
							},
							Values: []string{
								"__Member__",
								"__Member__",
							},
						},
					},
				},
			},
			{
				ServiceCode:      ptr.String("__ServiceCode__"),
				UsageType:        ptr.String("__UsageType__"),
				Operation:        ptr.String("__Operation__"),
				AvailabilityZone: ptr.String("__AvailabilityZone__"),
				Key:              ptr.String("__Key__"),
				Group:            ptr.String("__Group__"),
				UsageAccountId:   ptr.String("__UsageAccountId__"),
				Amounts: []types.UsageAmount{
					{
						StartHour: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Amount:    ptr.Float64(1.0),
					},
					{
						StartHour: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Amount:    ptr.Float64(1.0),
					},
				},
				HistoricalUsage: &types.HistoricalUsageEntity{
					ServiceCode:    ptr.String("__ServiceCode__"),
					UsageType:      ptr.String("__UsageType__"),
					Operation:      ptr.String("__Operation__"),
					Location:       ptr.String("__Location__"),
					UsageAccountId: ptr.String("__UsageAccountId__"),
					BillInterval: &types.BillInterval{
						Start: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						End:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
					FilterExpression: &types.Expression{
						And: []types.Expression{
							{},
							{},
						},
						Or: []types.Expression{
							{},
							{},
						},
						Not: nil,
						CostCategories: &types.ExpressionFilter{
							Key: ptr.String("__Key__"),
							MatchOptions: []string{
								"__Member__",
								"__Member__",
							},
							Values: []string{
								"__Member__",
								"__Member__",
							},
						},
						Dimensions: &types.ExpressionFilter{
							Key: ptr.String("__Key__"),
							MatchOptions: []string{
								"__Member__",
								"__Member__",
							},
							Values: []string{
								"__Member__",
								"__Member__",
							},
						},
						Tags: &types.ExpressionFilter{
							Key: ptr.String("__Key__"),
							MatchOptions: []string{
								"__Member__",
								"__Member__",
							},
							Values: []string{
								"__Member__",
								"__Member__",
							},
						},
					},
				},
			},
		},
		ClientToken: ptr.String("__ClientToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchCreateBillScenarioUsageModification(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchCreateBillScenarioUsageModification"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_BatchCreateWorkloadEstimateUsage(t *testing.T) {
	input := &BatchCreateWorkloadEstimateUsageInput{
		WorkloadEstimateId: ptr.String("__WorkloadEstimateId__"),
		Usage: []types.BatchCreateWorkloadEstimateUsageEntry{
			{
				ServiceCode:    ptr.String("__ServiceCode__"),
				UsageType:      ptr.String("__UsageType__"),
				Operation:      ptr.String("__Operation__"),
				Key:            ptr.String("__Key__"),
				Group:          ptr.String("__Group__"),
				UsageAccountId: ptr.String("__UsageAccountId__"),
				Amount:         ptr.Float64(1.0),
				HistoricalUsage: &types.HistoricalUsageEntity{
					ServiceCode:    ptr.String("__ServiceCode__"),
					UsageType:      ptr.String("__UsageType__"),
					Operation:      ptr.String("__Operation__"),
					Location:       ptr.String("__Location__"),
					UsageAccountId: ptr.String("__UsageAccountId__"),
					BillInterval: &types.BillInterval{
						Start: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						End:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
					FilterExpression: &types.Expression{
						And: []types.Expression{
							{},
							{},
						},
						Or: []types.Expression{
							{},
							{},
						},
						Not: nil,
						CostCategories: &types.ExpressionFilter{
							Key: ptr.String("__Key__"),
							MatchOptions: []string{
								"__Member__",
								"__Member__",
							},
							Values: []string{
								"__Member__",
								"__Member__",
							},
						},
						Dimensions: &types.ExpressionFilter{
							Key: ptr.String("__Key__"),
							MatchOptions: []string{
								"__Member__",
								"__Member__",
							},
							Values: []string{
								"__Member__",
								"__Member__",
							},
						},
						Tags: &types.ExpressionFilter{
							Key: ptr.String("__Key__"),
							MatchOptions: []string{
								"__Member__",
								"__Member__",
							},
							Values: []string{
								"__Member__",
								"__Member__",
							},
						},
					},
				},
			},
			{
				ServiceCode:    ptr.String("__ServiceCode__"),
				UsageType:      ptr.String("__UsageType__"),
				Operation:      ptr.String("__Operation__"),
				Key:            ptr.String("__Key__"),
				Group:          ptr.String("__Group__"),
				UsageAccountId: ptr.String("__UsageAccountId__"),
				Amount:         ptr.Float64(1.0),
				HistoricalUsage: &types.HistoricalUsageEntity{
					ServiceCode:    ptr.String("__ServiceCode__"),
					UsageType:      ptr.String("__UsageType__"),
					Operation:      ptr.String("__Operation__"),
					Location:       ptr.String("__Location__"),
					UsageAccountId: ptr.String("__UsageAccountId__"),
					BillInterval: &types.BillInterval{
						Start: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						End:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
					FilterExpression: &types.Expression{
						And: []types.Expression{
							{},
							{},
						},
						Or: []types.Expression{
							{},
							{},
						},
						Not: nil,
						CostCategories: &types.ExpressionFilter{
							Key: ptr.String("__Key__"),
							MatchOptions: []string{
								"__Member__",
								"__Member__",
							},
							Values: []string{
								"__Member__",
								"__Member__",
							},
						},
						Dimensions: &types.ExpressionFilter{
							Key: ptr.String("__Key__"),
							MatchOptions: []string{
								"__Member__",
								"__Member__",
							},
							Values: []string{
								"__Member__",
								"__Member__",
							},
						},
						Tags: &types.ExpressionFilter{
							Key: ptr.String("__Key__"),
							MatchOptions: []string{
								"__Member__",
								"__Member__",
							},
							Values: []string{
								"__Member__",
								"__Member__",
							},
						},
					},
				},
			},
		},
		ClientToken: ptr.String("__ClientToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchCreateWorkloadEstimateUsage(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchCreateWorkloadEstimateUsage"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

func TestUpdateRequestSnapshot_BatchUpdateBillScenarioCommitmentModification(t *testing.T) {
	input := &BatchUpdateBillScenarioCommitmentModificationInput{
		BillScenarioId: ptr.String("__BillScenarioId__"),
		CommitmentModifications: []types.BatchUpdateBillScenarioCommitmentModificationEntry{
			{
				Id:    ptr.String("__Id__"),
				Group: ptr.String("__Group__"),
			},
			{
				Id:    ptr.String("__Id__"),
				Group: ptr.String("__Group__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchUpdateBillScenarioCommitmentModification(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchUpdateBillScenarioCommitmentModification"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_BatchUpdateBillScenarioUsageModification(t *testing.T) {
	input := &BatchUpdateBillScenarioUsageModificationInput{
		BillScenarioId: ptr.String("__BillScenarioId__"),
		UsageModifications: []types.BatchUpdateBillScenarioUsageModificationEntry{
			{
				Id:    ptr.String("__Id__"),
				Group: ptr.String("__Group__"),
				Amounts: []types.UsageAmount{
					{
						StartHour: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Amount:    ptr.Float64(1.0),
					},
					{
						StartHour: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Amount:    ptr.Float64(1.0),
					},
				},
			},
			{
				Id:    ptr.String("__Id__"),
				Group: ptr.String("__Group__"),
				Amounts: []types.UsageAmount{
					{
						StartHour: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Amount:    ptr.Float64(1.0),
					},
					{
						StartHour: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Amount:    ptr.Float64(1.0),
					},
				},
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchUpdateBillScenarioUsageModification(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchUpdateBillScenarioUsageModification"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_BatchUpdateWorkloadEstimateUsage(t *testing.T) {
	input := &BatchUpdateWorkloadEstimateUsageInput{
		WorkloadEstimateId: ptr.String("__WorkloadEstimateId__"),
		Usage: []types.BatchUpdateWorkloadEstimateUsageEntry{
			{
				Id:     ptr.String("__Id__"),
				Group:  ptr.String("__Group__"),
				Amount: ptr.Float64(1.0),
			},
			{
				Id:     ptr.String("__Id__"),
				Group:  ptr.String("__Group__"),
				Amount: ptr.Float64(1.0),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.BatchUpdateWorkloadEstimateUsage(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "BatchUpdateWorkloadEstimateUsage"); err != nil {
		t.Fatal(err)
	}
}

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

func TestUpdateRequestSnapshot_CreateBillScenario(t *testing.T) {
	input := &CreateBillScenarioInput{
		Name:        ptr.String("__Name__"),
		ClientToken: ptr.String("__ClientToken__"),
		Tags: map[string]string{
			"key0": "__Value__",
		},
		GroupSharingPreference:                types.GroupSharingPreferenceEnum("OPEN"),
		CostCategoryGroupSharingPreferenceArn: ptr.String("__CostCategoryGroupSharingPreferenceArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateBillScenario(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateBillScenario"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

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

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

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

func TestUpdateRequestSnapshot_ListBillEstimateInputUsageModifications(t *testing.T) {
	input := &ListBillEstimateInputUsageModificationsInput{
		BillEstimateId: ptr.String("__BillEstimateId__"),
		Filters: []types.ListUsageFilter{
			{
				Name: types.ListUsageFilterName("USAGE_ACCOUNT_ID"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
			{
				Name: types.ListUsageFilterName("USAGE_ACCOUNT_ID"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBillEstimateInputUsageModifications(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListBillEstimateInputUsageModifications"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListBillEstimateLineItems(t *testing.T) {
	input := &ListBillEstimateLineItemsInput{
		BillEstimateId: ptr.String("__BillEstimateId__"),
		Filters: []types.ListBillEstimateLineItemsFilter{
			{
				Name: types.ListBillEstimateLineItemsFilterName("USAGE_ACCOUNT_ID"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
			{
				Name: types.ListBillEstimateLineItemsFilterName("USAGE_ACCOUNT_ID"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBillEstimateLineItems(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListBillEstimateLineItems"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListBillEstimates(t *testing.T) {
	input := &ListBillEstimatesInput{
		Filters: []types.ListBillEstimatesFilter{
			{
				Name: types.ListBillEstimatesFilterName("STATUS"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
			{
				Name: types.ListBillEstimatesFilterName("STATUS"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
		},
		CreatedAtFilter: &types.FilterTimestamp{
			AfterTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			BeforeTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		ExpiresAtFilter: &types.FilterTimestamp{
			AfterTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			BeforeTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBillEstimates(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListBillEstimates"); err != nil {
		t.Fatal(err)
	}
}

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

func TestUpdateRequestSnapshot_ListBillScenarios(t *testing.T) {
	input := &ListBillScenariosInput{
		Filters: []types.ListBillScenariosFilter{
			{
				Name: types.ListBillScenariosFilterName("STATUS"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
			{
				Name: types.ListBillScenariosFilterName("STATUS"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
		},
		CreatedAtFilter: &types.FilterTimestamp{
			AfterTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			BeforeTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		ExpiresAtFilter: &types.FilterTimestamp{
			AfterTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			BeforeTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBillScenarios(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListBillScenarios"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListBillScenarioUsageModifications(t *testing.T) {
	input := &ListBillScenarioUsageModificationsInput{
		BillScenarioId: ptr.String("__BillScenarioId__"),
		Filters: []types.ListUsageFilter{
			{
				Name: types.ListUsageFilterName("USAGE_ACCOUNT_ID"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
			{
				Name: types.ListUsageFilterName("USAGE_ACCOUNT_ID"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBillScenarioUsageModifications(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListBillScenarioUsageModifications"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListTagsForResource(t *testing.T) {
	input := &ListTagsForResourceInput{
		Arn: ptr.String("__Arn__"),
	}
	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_ListWorkloadEstimates(t *testing.T) {
	input := &ListWorkloadEstimatesInput{
		CreatedAtFilter: &types.FilterTimestamp{
			AfterTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			BeforeTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		ExpiresAtFilter: &types.FilterTimestamp{
			AfterTimestamp:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			BeforeTimestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		Filters: []types.ListWorkloadEstimatesFilter{
			{
				Name: types.ListWorkloadEstimatesFilterName("STATUS"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
			{
				Name: types.ListWorkloadEstimatesFilterName("STATUS"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListWorkloadEstimates(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListWorkloadEstimates"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListWorkloadEstimateUsage(t *testing.T) {
	input := &ListWorkloadEstimateUsageInput{
		WorkloadEstimateId: ptr.String("__WorkloadEstimateId__"),
		Filters: []types.ListUsageFilter{
			{
				Name: types.ListUsageFilterName("USAGE_ACCOUNT_ID"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
			{
				Name: types.ListUsageFilterName("USAGE_ACCOUNT_ID"),
				Values: []string{
					"__Member__",
					"__Member__",
				},
				MatchOption: types.MatchOption("EQUALS"),
			},
		},
		NextToken:  ptr.String("__NextToken__"),
		MaxResults: ptr.Int32(1),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListWorkloadEstimateUsage(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListWorkloadEstimateUsage"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_TagResource(t *testing.T) {
	input := &TagResourceInput{
		Arn: ptr.String("__Arn__"),
		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{
		Arn: ptr.String("__Arn__"),
		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_UpdateBillEstimate(t *testing.T) {
	input := &UpdateBillEstimateInput{
		Identifier: ptr.String("__Identifier__"),
		Name:       ptr.String("__Name__"),
		ExpiresAt:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateBillEstimate(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateBillEstimate"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_UpdateBillScenario(t *testing.T) {
	input := &UpdateBillScenarioInput{
		Identifier:                            ptr.String("__Identifier__"),
		Name:                                  ptr.String("__Name__"),
		ExpiresAt:                             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		GroupSharingPreference:                types.GroupSharingPreferenceEnum("OPEN"),
		CostCategoryGroupSharingPreferenceArn: ptr.String("__CostCategoryGroupSharingPreferenceArn__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateBillScenario(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateBillScenario"); err != nil {
		t.Fatal(err)
	}
}

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

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