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

//go:build request_snapshot

package bedrockdataautomation

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

const serdeSSPrefix = "request_snapshot"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type serdeEndpointResolver struct{}

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

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

func TestCheckRequestSnapshot_CreateBlueprint(t *testing.T) {
	input := &CreateBlueprintInput{
		BlueprintName:  ptr.String("__BlueprintName__"),
		Type:           types.Type("DOCUMENT"),
		BlueprintStage: types.BlueprintStage("DEVELOPMENT"),
		Schema:         ptr.String("__Schema__"),
		ClientToken:    ptr.String("__ClientToken__"),
		EncryptionConfiguration: &types.EncryptionConfiguration{
			KmsKeyId: ptr.String("__KmsKeyId__"),
			KmsEncryptionContext: map[string]string{
				"key0": "__Value__",
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateBlueprint(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateBlueprint"); err != nil {
		t.Fatal(err)
	}
}

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

func TestCheckRequestSnapshot_CreateDataAutomationLibrary(t *testing.T) {
	input := &CreateDataAutomationLibraryInput{
		LibraryName:        ptr.String("__LibraryName__"),
		LibraryDescription: ptr.String("__LibraryDescription__"),
		ClientToken:        ptr.String("__ClientToken__"),
		EncryptionConfiguration: &types.EncryptionConfiguration{
			KmsKeyId: ptr.String("__KmsKeyId__"),
			KmsEncryptionContext: map[string]string{
				"key0": "__Value__",
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateDataAutomationLibrary(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateDataAutomationLibrary"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_CreateDataAutomationProject(t *testing.T) {
	input := &CreateDataAutomationProjectInput{
		ProjectName:        ptr.String("__ProjectName__"),
		ProjectDescription: ptr.String("__ProjectDescription__"),
		ProjectStage:       types.DataAutomationProjectStage("DEVELOPMENT"),
		ProjectType:        types.DataAutomationProjectType("ASYNC"),
		StandardOutputConfiguration: &types.StandardOutputConfiguration{
			Document: &types.DocumentStandardOutputConfiguration{
				Extraction: &types.DocumentStandardExtraction{
					Granularity: &types.DocumentExtractionGranularity{
						Types: []types.DocumentExtractionGranularityType{
							types.DocumentExtractionGranularityType("DOCUMENT"),
							types.DocumentExtractionGranularityType("DOCUMENT"),
						},
					},
					BoundingBox: &types.DocumentBoundingBox{
						State: types.State("ENABLED"),
					},
				},
				GenerativeField: &types.DocumentStandardGenerativeField{
					State: types.State("ENABLED"),
				},
				OutputFormat: &types.DocumentOutputFormat{
					TextFormat: &types.DocumentOutputTextFormat{
						Types: []types.DocumentOutputTextFormatType{
							types.DocumentOutputTextFormatType("PLAIN_TEXT"),
							types.DocumentOutputTextFormatType("PLAIN_TEXT"),
						},
					},
					AdditionalFileFormat: &types.DocumentOutputAdditionalFileFormat{
						State: types.State("ENABLED"),
					},
				},
			},
			Image: &types.ImageStandardOutputConfiguration{
				Extraction: &types.ImageStandardExtraction{
					Category: &types.ImageExtractionCategory{
						State: types.State("ENABLED"),
						Types: []types.ImageExtractionCategoryType{
							types.ImageExtractionCategoryType("CONTENT_MODERATION"),
							types.ImageExtractionCategoryType("CONTENT_MODERATION"),
						},
					},
					BoundingBox: &types.ImageBoundingBox{
						State: types.State("ENABLED"),
					},
				},
				GenerativeField: &types.ImageStandardGenerativeField{
					State: types.State("ENABLED"),
					Types: []types.ImageStandardGenerativeFieldType{
						types.ImageStandardGenerativeFieldType("IMAGE_SUMMARY"),
						types.ImageStandardGenerativeFieldType("IMAGE_SUMMARY"),
					},
				},
			},
			Video: &types.VideoStandardOutputConfiguration{
				Extraction: &types.VideoStandardExtraction{
					Category: &types.VideoExtractionCategory{
						State: types.State("ENABLED"),
						Types: []types.VideoExtractionCategoryType{
							types.VideoExtractionCategoryType("CONTENT_MODERATION"),
							types.VideoExtractionCategoryType("CONTENT_MODERATION"),
						},
					},
					BoundingBox: &types.VideoBoundingBox{
						State: types.State("ENABLED"),
					},
				},
				GenerativeField: &types.VideoStandardGenerativeField{
					State: types.State("ENABLED"),
					Types: []types.VideoStandardGenerativeFieldType{
						types.VideoStandardGenerativeFieldType("VIDEO_SUMMARY"),
						types.VideoStandardGenerativeFieldType("VIDEO_SUMMARY"),
					},
				},
			},
			Audio: &types.AudioStandardOutputConfiguration{
				Extraction: &types.AudioStandardExtraction{
					Category: &types.AudioExtractionCategory{
						State: types.State("ENABLED"),
						Types: []types.AudioExtractionCategoryType{
							types.AudioExtractionCategoryType("AUDIO_CONTENT_MODERATION"),
							types.AudioExtractionCategoryType("AUDIO_CONTENT_MODERATION"),
						},
						TypeConfiguration: &types.AudioExtractionCategoryTypeConfiguration{
							Transcript: &types.TranscriptConfiguration{
								SpeakerLabeling: &types.SpeakerLabelingConfiguration{
									State: types.State("ENABLED"),
								},
								ChannelLabeling: &types.ChannelLabelingConfiguration{
									State: types.State("ENABLED"),
								},
							},
						},
					},
				},
				GenerativeField: &types.AudioStandardGenerativeField{
					State: types.State("ENABLED"),
					Types: []types.AudioStandardGenerativeFieldType{
						types.AudioStandardGenerativeFieldType("AUDIO_SUMMARY"),
						types.AudioStandardGenerativeFieldType("AUDIO_SUMMARY"),
					},
				},
			},
		},
		CustomOutputConfiguration: &types.CustomOutputConfiguration{
			Blueprints: []types.BlueprintItem{
				{
					BlueprintArn:     ptr.String("__BlueprintArn__"),
					BlueprintVersion: ptr.String("__BlueprintVersion__"),
					BlueprintStage:   types.BlueprintStage("DEVELOPMENT"),
				},
				{
					BlueprintArn:     ptr.String("__BlueprintArn__"),
					BlueprintVersion: ptr.String("__BlueprintVersion__"),
					BlueprintStage:   types.BlueprintStage("DEVELOPMENT"),
				},
			},
			Document: &types.DocumentCustomOutputConfiguration{
				FallbackBlueprints: []types.BlueprintItem{
					{
						BlueprintArn:     ptr.String("__BlueprintArn__"),
						BlueprintVersion: ptr.String("__BlueprintVersion__"),
						BlueprintStage:   types.BlueprintStage("DEVELOPMENT"),
					},
					{
						BlueprintArn:     ptr.String("__BlueprintArn__"),
						BlueprintVersion: ptr.String("__BlueprintVersion__"),
						BlueprintStage:   types.BlueprintStage("DEVELOPMENT"),
					},
				},
			},
		},
		OverrideConfiguration: &types.OverrideConfiguration{
			Document: &types.DocumentOverrideConfiguration{
				Splitter: &types.SplitterConfiguration{
					State: types.State("ENABLED"),
				},
				ModalityProcessing: &types.ModalityProcessingConfiguration{
					State: types.State("ENABLED"),
				},
				SensitiveDataConfiguration: &types.SensitiveDataConfiguration{
					DetectionMode: types.SensitiveDataDetectionMode("DETECTION"),
					DetectionScope: []types.SensitiveDataDetectionScopeType{
						types.SensitiveDataDetectionScopeType("STANDARD"),
						types.SensitiveDataDetectionScopeType("STANDARD"),
					},
					PiiEntitiesConfiguration: &types.PIIEntitiesConfiguration{
						PiiEntityTypes: []types.PIIEntityType{
							types.PIIEntityType("ALL"),
							types.PIIEntityType("ALL"),
						},
						RedactionMaskMode: types.PIIRedactionMaskMode("PII"),
					},
				},
			},
			Image: &types.ImageOverrideConfiguration{
				ModalityProcessing: &types.ModalityProcessingConfiguration{
					State: types.State("ENABLED"),
				},
				SensitiveDataConfiguration: &types.SensitiveDataConfiguration{
					DetectionMode: types.SensitiveDataDetectionMode("DETECTION"),
					DetectionScope: []types.SensitiveDataDetectionScopeType{
						types.SensitiveDataDetectionScopeType("STANDARD"),
						types.SensitiveDataDetectionScopeType("STANDARD"),
					},
					PiiEntitiesConfiguration: &types.PIIEntitiesConfiguration{
						PiiEntityTypes: []types.PIIEntityType{
							types.PIIEntityType("ALL"),
							types.PIIEntityType("ALL"),
						},
						RedactionMaskMode: types.PIIRedactionMaskMode("PII"),
					},
				},
			},
			Video: &types.VideoOverrideConfiguration{
				ModalityProcessing: &types.ModalityProcessingConfiguration{
					State: types.State("ENABLED"),
				},
				SensitiveDataConfiguration: &types.SensitiveDataConfiguration{
					DetectionMode: types.SensitiveDataDetectionMode("DETECTION"),
					DetectionScope: []types.SensitiveDataDetectionScopeType{
						types.SensitiveDataDetectionScopeType("STANDARD"),
						types.SensitiveDataDetectionScopeType("STANDARD"),
					},
					PiiEntitiesConfiguration: &types.PIIEntitiesConfiguration{
						PiiEntityTypes: []types.PIIEntityType{
							types.PIIEntityType("ALL"),
							types.PIIEntityType("ALL"),
						},
						RedactionMaskMode: types.PIIRedactionMaskMode("PII"),
					},
				},
			},
			Audio: &types.AudioOverrideConfiguration{
				ModalityProcessing: &types.ModalityProcessingConfiguration{
					State: types.State("ENABLED"),
				},
				LanguageConfiguration: &types.AudioLanguageConfiguration{
					InputLanguages: []types.Language{
						types.Language("EN"),
						types.Language("EN"),
					},
					GenerativeOutputLanguage:  types.AudioGenerativeOutputLanguage("DEFAULT"),
					IdentifyMultipleLanguages: ptr.Bool(true),
				},
				SensitiveDataConfiguration: &types.SensitiveDataConfiguration{
					DetectionMode: types.SensitiveDataDetectionMode("DETECTION"),
					DetectionScope: []types.SensitiveDataDetectionScopeType{
						types.SensitiveDataDetectionScopeType("STANDARD"),
						types.SensitiveDataDetectionScopeType("STANDARD"),
					},
					PiiEntitiesConfiguration: &types.PIIEntitiesConfiguration{
						PiiEntityTypes: []types.PIIEntityType{
							types.PIIEntityType("ALL"),
							types.PIIEntityType("ALL"),
						},
						RedactionMaskMode: types.PIIRedactionMaskMode("PII"),
					},
				},
			},
			ModalityRouting: &types.ModalityRoutingConfiguration{
				Jpeg: types.DesiredModality("IMAGE"),
				Png:  types.DesiredModality("IMAGE"),
				Mp4:  types.DesiredModality("IMAGE"),
				Mov:  types.DesiredModality("IMAGE"),
			},
		},
		DataAutomationLibraryConfiguration: &types.DataAutomationLibraryConfiguration{
			Libraries: []types.DataAutomationLibraryItem{
				{
					LibraryArn: ptr.String("__LibraryArn__"),
				},
				{
					LibraryArn: ptr.String("__LibraryArn__"),
				},
			},
		},
		ClientToken: ptr.String("__ClientToken__"),
		EncryptionConfiguration: &types.EncryptionConfiguration{
			KmsKeyId: ptr.String("__KmsKeyId__"),
			KmsEncryptionContext: map[string]string{
				"key0": "__Value__",
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateDataAutomationProject(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateDataAutomationProject"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

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

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

func TestCheckRequestSnapshot_InvokeBlueprintOptimizationAsync(t *testing.T) {
	input := &InvokeBlueprintOptimizationAsyncInput{
		Blueprint: &types.BlueprintOptimizationObject{
			BlueprintArn: ptr.String("__BlueprintArn__"),
			Stage:        types.BlueprintStage("DEVELOPMENT"),
		},
		Samples: []types.BlueprintOptimizationSample{
			{
				AssetS3Object: &types.S3Object{
					S3Uri:   ptr.String("__S3Uri__"),
					Version: ptr.String("__Version__"),
				},
				GroundTruthS3Object: &types.S3Object{
					S3Uri:   ptr.String("__S3Uri__"),
					Version: ptr.String("__Version__"),
				},
			},
			{
				AssetS3Object: &types.S3Object{
					S3Uri:   ptr.String("__S3Uri__"),
					Version: ptr.String("__Version__"),
				},
				GroundTruthS3Object: &types.S3Object{
					S3Uri:   ptr.String("__S3Uri__"),
					Version: ptr.String("__Version__"),
				},
			},
		},
		OutputConfiguration: &types.BlueprintOptimizationOutputConfiguration{
			S3Object: &types.S3Object{
				S3Uri:   ptr.String("__S3Uri__"),
				Version: ptr.String("__Version__"),
			},
		},
		DataAutomationProfileArn: ptr.String("__DataAutomationProfileArn__"),
		EncryptionConfiguration: &types.EncryptionConfiguration{
			KmsKeyId: ptr.String("__KmsKeyId__"),
			KmsEncryptionContext: map[string]string{
				"key0": "__Value__",
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.InvokeBlueprintOptimizationAsync(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "InvokeBlueprintOptimizationAsync"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_InvokeDataAutomationLibraryIngestionJob(t *testing.T) {
	input := &InvokeDataAutomationLibraryIngestionJobInput{
		LibraryArn:  ptr.String("__LibraryArn__"),
		ClientToken: ptr.String("__ClientToken__"),
		InputConfiguration: &types.InputConfiguration{
			S3Object: &types.S3Object{
				S3Uri:   ptr.String("__S3Uri__"),
				Version: ptr.String("__Version__"),
			},
			InlinePayload: &types.InlinePayloadMemberUpsertEntitiesInfo{
				Value: []types.UpsertEntityInfo{
					&types.UpsertEntityInfoMemberVocabulary{
						Value: types.VocabularyEntityInfo{
							EntityId:    ptr.String("__EntityId__"),
							Description: ptr.String("__Description__"),
							Language:    types.Language("EN"),
							Phrases: []types.Phrase{
								{
									Text:          ptr.String("__Text__"),
									DisplayAsText: ptr.String("__DisplayAsText__"),
								},
								{
									Text:          ptr.String("__Text__"),
									DisplayAsText: ptr.String("__DisplayAsText__"),
								},
							},
						},
					},
					&types.UpsertEntityInfoMemberVocabulary{
						Value: types.VocabularyEntityInfo{
							EntityId:    ptr.String("__EntityId__"),
							Description: ptr.String("__Description__"),
							Language:    types.Language("EN"),
							Phrases: []types.Phrase{
								{
									Text:          ptr.String("__Text__"),
									DisplayAsText: ptr.String("__DisplayAsText__"),
								},
								{
									Text:          ptr.String("__Text__"),
									DisplayAsText: ptr.String("__DisplayAsText__"),
								},
							},
						},
					},
				},
			},
		},
		EntityType:    types.EntityType("VOCABULARY"),
		OperationType: types.LibraryIngestionJobOperationType("UPSERT"),
		OutputConfiguration: &types.OutputConfiguration{
			S3Uri: ptr.String("__S3Uri__"),
		},
		NotificationConfiguration: &types.NotificationConfiguration{
			EventBridgeConfiguration: &types.EventBridgeConfiguration{
				EventBridgeEnabled: ptr.Bool(true),
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.InvokeDataAutomationLibraryIngestionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "InvokeDataAutomationLibraryIngestionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestCheckRequestSnapshot_ListBlueprints(t *testing.T) {
	input := &ListBlueprintsInput{
		BlueprintArn:         ptr.String("__BlueprintArn__"),
		ResourceOwner:        types.ResourceOwner("SERVICE"),
		BlueprintStageFilter: types.BlueprintStageFilter("DEVELOPMENT"),
		MaxResults:           ptr.Int32(1),
		NextToken:            ptr.String("__NextToken__"),
		ProjectFilter: &types.DataAutomationProjectFilter{
			ProjectArn:   ptr.String("__ProjectArn__"),
			ProjectStage: types.DataAutomationProjectStage("DEVELOPMENT"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBlueprints(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListBlueprints"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

func TestCheckRequestSnapshot_ListDataAutomationProjects(t *testing.T) {
	input := &ListDataAutomationProjectsInput{
		MaxResults:         ptr.Int32(1),
		NextToken:          ptr.String("__NextToken__"),
		ProjectStageFilter: types.DataAutomationProjectStageFilter("DEVELOPMENT"),
		BlueprintFilter: &types.BlueprintFilter{
			BlueprintArn:     ptr.String("__BlueprintArn__"),
			BlueprintVersion: ptr.String("__BlueprintVersion__"),
			BlueprintStage:   types.BlueprintStage("DEVELOPMENT"),
		},
		ResourceOwner: types.ResourceOwner("SERVICE"),
		LibraryFilter: &types.DataAutomationLibraryFilter{
			LibraryArn: ptr.String("__LibraryArn__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListDataAutomationProjects(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListDataAutomationProjects"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

func TestCheckRequestSnapshot_UpdateBlueprint(t *testing.T) {
	input := &UpdateBlueprintInput{
		BlueprintArn:   ptr.String("__BlueprintArn__"),
		Schema:         ptr.String("__Schema__"),
		BlueprintStage: types.BlueprintStage("DEVELOPMENT"),
		EncryptionConfiguration: &types.EncryptionConfiguration{
			KmsKeyId: ptr.String("__KmsKeyId__"),
			KmsEncryptionContext: map[string]string{
				"key0": "__Value__",
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateBlueprint(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateBlueprint"); err != nil {
		t.Fatal(err)
	}
}

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

func TestCheckRequestSnapshot_UpdateDataAutomationProject(t *testing.T) {
	input := &UpdateDataAutomationProjectInput{
		ProjectArn:         ptr.String("__ProjectArn__"),
		ProjectStage:       types.DataAutomationProjectStage("DEVELOPMENT"),
		ProjectDescription: ptr.String("__ProjectDescription__"),
		StandardOutputConfiguration: &types.StandardOutputConfiguration{
			Document: &types.DocumentStandardOutputConfiguration{
				Extraction: &types.DocumentStandardExtraction{
					Granularity: &types.DocumentExtractionGranularity{
						Types: []types.DocumentExtractionGranularityType{
							types.DocumentExtractionGranularityType("DOCUMENT"),
							types.DocumentExtractionGranularityType("DOCUMENT"),
						},
					},
					BoundingBox: &types.DocumentBoundingBox{
						State: types.State("ENABLED"),
					},
				},
				GenerativeField: &types.DocumentStandardGenerativeField{
					State: types.State("ENABLED"),
				},
				OutputFormat: &types.DocumentOutputFormat{
					TextFormat: &types.DocumentOutputTextFormat{
						Types: []types.DocumentOutputTextFormatType{
							types.DocumentOutputTextFormatType("PLAIN_TEXT"),
							types.DocumentOutputTextFormatType("PLAIN_TEXT"),
						},
					},
					AdditionalFileFormat: &types.DocumentOutputAdditionalFileFormat{
						State: types.State("ENABLED"),
					},
				},
			},
			Image: &types.ImageStandardOutputConfiguration{
				Extraction: &types.ImageStandardExtraction{
					Category: &types.ImageExtractionCategory{
						State: types.State("ENABLED"),
						Types: []types.ImageExtractionCategoryType{
							types.ImageExtractionCategoryType("CONTENT_MODERATION"),
							types.ImageExtractionCategoryType("CONTENT_MODERATION"),
						},
					},
					BoundingBox: &types.ImageBoundingBox{
						State: types.State("ENABLED"),
					},
				},
				GenerativeField: &types.ImageStandardGenerativeField{
					State: types.State("ENABLED"),
					Types: []types.ImageStandardGenerativeFieldType{
						types.ImageStandardGenerativeFieldType("IMAGE_SUMMARY"),
						types.ImageStandardGenerativeFieldType("IMAGE_SUMMARY"),
					},
				},
			},
			Video: &types.VideoStandardOutputConfiguration{
				Extraction: &types.VideoStandardExtraction{
					Category: &types.VideoExtractionCategory{
						State: types.State("ENABLED"),
						Types: []types.VideoExtractionCategoryType{
							types.VideoExtractionCategoryType("CONTENT_MODERATION"),
							types.VideoExtractionCategoryType("CONTENT_MODERATION"),
						},
					},
					BoundingBox: &types.VideoBoundingBox{
						State: types.State("ENABLED"),
					},
				},
				GenerativeField: &types.VideoStandardGenerativeField{
					State: types.State("ENABLED"),
					Types: []types.VideoStandardGenerativeFieldType{
						types.VideoStandardGenerativeFieldType("VIDEO_SUMMARY"),
						types.VideoStandardGenerativeFieldType("VIDEO_SUMMARY"),
					},
				},
			},
			Audio: &types.AudioStandardOutputConfiguration{
				Extraction: &types.AudioStandardExtraction{
					Category: &types.AudioExtractionCategory{
						State: types.State("ENABLED"),
						Types: []types.AudioExtractionCategoryType{
							types.AudioExtractionCategoryType("AUDIO_CONTENT_MODERATION"),
							types.AudioExtractionCategoryType("AUDIO_CONTENT_MODERATION"),
						},
						TypeConfiguration: &types.AudioExtractionCategoryTypeConfiguration{
							Transcript: &types.TranscriptConfiguration{
								SpeakerLabeling: &types.SpeakerLabelingConfiguration{
									State: types.State("ENABLED"),
								},
								ChannelLabeling: &types.ChannelLabelingConfiguration{
									State: types.State("ENABLED"),
								},
							},
						},
					},
				},
				GenerativeField: &types.AudioStandardGenerativeField{
					State: types.State("ENABLED"),
					Types: []types.AudioStandardGenerativeFieldType{
						types.AudioStandardGenerativeFieldType("AUDIO_SUMMARY"),
						types.AudioStandardGenerativeFieldType("AUDIO_SUMMARY"),
					},
				},
			},
		},
		CustomOutputConfiguration: &types.CustomOutputConfiguration{
			Blueprints: []types.BlueprintItem{
				{
					BlueprintArn:     ptr.String("__BlueprintArn__"),
					BlueprintVersion: ptr.String("__BlueprintVersion__"),
					BlueprintStage:   types.BlueprintStage("DEVELOPMENT"),
				},
				{
					BlueprintArn:     ptr.String("__BlueprintArn__"),
					BlueprintVersion: ptr.String("__BlueprintVersion__"),
					BlueprintStage:   types.BlueprintStage("DEVELOPMENT"),
				},
			},
			Document: &types.DocumentCustomOutputConfiguration{
				FallbackBlueprints: []types.BlueprintItem{
					{
						BlueprintArn:     ptr.String("__BlueprintArn__"),
						BlueprintVersion: ptr.String("__BlueprintVersion__"),
						BlueprintStage:   types.BlueprintStage("DEVELOPMENT"),
					},
					{
						BlueprintArn:     ptr.String("__BlueprintArn__"),
						BlueprintVersion: ptr.String("__BlueprintVersion__"),
						BlueprintStage:   types.BlueprintStage("DEVELOPMENT"),
					},
				},
			},
		},
		OverrideConfiguration: &types.OverrideConfiguration{
			Document: &types.DocumentOverrideConfiguration{
				Splitter: &types.SplitterConfiguration{
					State: types.State("ENABLED"),
				},
				ModalityProcessing: &types.ModalityProcessingConfiguration{
					State: types.State("ENABLED"),
				},
				SensitiveDataConfiguration: &types.SensitiveDataConfiguration{
					DetectionMode: types.SensitiveDataDetectionMode("DETECTION"),
					DetectionScope: []types.SensitiveDataDetectionScopeType{
						types.SensitiveDataDetectionScopeType("STANDARD"),
						types.SensitiveDataDetectionScopeType("STANDARD"),
					},
					PiiEntitiesConfiguration: &types.PIIEntitiesConfiguration{
						PiiEntityTypes: []types.PIIEntityType{
							types.PIIEntityType("ALL"),
							types.PIIEntityType("ALL"),
						},
						RedactionMaskMode: types.PIIRedactionMaskMode("PII"),
					},
				},
			},
			Image: &types.ImageOverrideConfiguration{
				ModalityProcessing: &types.ModalityProcessingConfiguration{
					State: types.State("ENABLED"),
				},
				SensitiveDataConfiguration: &types.SensitiveDataConfiguration{
					DetectionMode: types.SensitiveDataDetectionMode("DETECTION"),
					DetectionScope: []types.SensitiveDataDetectionScopeType{
						types.SensitiveDataDetectionScopeType("STANDARD"),
						types.SensitiveDataDetectionScopeType("STANDARD"),
					},
					PiiEntitiesConfiguration: &types.PIIEntitiesConfiguration{
						PiiEntityTypes: []types.PIIEntityType{
							types.PIIEntityType("ALL"),
							types.PIIEntityType("ALL"),
						},
						RedactionMaskMode: types.PIIRedactionMaskMode("PII"),
					},
				},
			},
			Video: &types.VideoOverrideConfiguration{
				ModalityProcessing: &types.ModalityProcessingConfiguration{
					State: types.State("ENABLED"),
				},
				SensitiveDataConfiguration: &types.SensitiveDataConfiguration{
					DetectionMode: types.SensitiveDataDetectionMode("DETECTION"),
					DetectionScope: []types.SensitiveDataDetectionScopeType{
						types.SensitiveDataDetectionScopeType("STANDARD"),
						types.SensitiveDataDetectionScopeType("STANDARD"),
					},
					PiiEntitiesConfiguration: &types.PIIEntitiesConfiguration{
						PiiEntityTypes: []types.PIIEntityType{
							types.PIIEntityType("ALL"),
							types.PIIEntityType("ALL"),
						},
						RedactionMaskMode: types.PIIRedactionMaskMode("PII"),
					},
				},
			},
			Audio: &types.AudioOverrideConfiguration{
				ModalityProcessing: &types.ModalityProcessingConfiguration{
					State: types.State("ENABLED"),
				},
				LanguageConfiguration: &types.AudioLanguageConfiguration{
					InputLanguages: []types.Language{
						types.Language("EN"),
						types.Language("EN"),
					},
					GenerativeOutputLanguage:  types.AudioGenerativeOutputLanguage("DEFAULT"),
					IdentifyMultipleLanguages: ptr.Bool(true),
				},
				SensitiveDataConfiguration: &types.SensitiveDataConfiguration{
					DetectionMode: types.SensitiveDataDetectionMode("DETECTION"),
					DetectionScope: []types.SensitiveDataDetectionScopeType{
						types.SensitiveDataDetectionScopeType("STANDARD"),
						types.SensitiveDataDetectionScopeType("STANDARD"),
					},
					PiiEntitiesConfiguration: &types.PIIEntitiesConfiguration{
						PiiEntityTypes: []types.PIIEntityType{
							types.PIIEntityType("ALL"),
							types.PIIEntityType("ALL"),
						},
						RedactionMaskMode: types.PIIRedactionMaskMode("PII"),
					},
				},
			},
			ModalityRouting: &types.ModalityRoutingConfiguration{
				Jpeg: types.DesiredModality("IMAGE"),
				Png:  types.DesiredModality("IMAGE"),
				Mp4:  types.DesiredModality("IMAGE"),
				Mov:  types.DesiredModality("IMAGE"),
			},
		},
		DataAutomationLibraryConfiguration: &types.DataAutomationLibraryConfiguration{
			Libraries: []types.DataAutomationLibraryItem{
				{
					LibraryArn: ptr.String("__LibraryArn__"),
				},
				{
					LibraryArn: ptr.String("__LibraryArn__"),
				},
			},
		},
		EncryptionConfiguration: &types.EncryptionConfiguration{
			KmsKeyId: ptr.String("__KmsKeyId__"),
			KmsEncryptionContext: map[string]string{
				"key0": "__Value__",
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateDataAutomationProject(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeTestSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateDataAutomationProject"); err != nil {
		t.Fatal(err)
	}
}
func TestUpdateRequestSnapshot_CopyBlueprintStage(t *testing.T) {
	input := &CopyBlueprintStageInput{
		BlueprintArn: ptr.String("__BlueprintArn__"),
		SourceStage:  types.BlueprintStage("DEVELOPMENT"),
		TargetStage:  types.BlueprintStage("DEVELOPMENT"),
		ClientToken:  ptr.String("__ClientToken__"),
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CopyBlueprintStage(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CopyBlueprintStage"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateBlueprint(t *testing.T) {
	input := &CreateBlueprintInput{
		BlueprintName:  ptr.String("__BlueprintName__"),
		Type:           types.Type("DOCUMENT"),
		BlueprintStage: types.BlueprintStage("DEVELOPMENT"),
		Schema:         ptr.String("__Schema__"),
		ClientToken:    ptr.String("__ClientToken__"),
		EncryptionConfiguration: &types.EncryptionConfiguration{
			KmsKeyId: ptr.String("__KmsKeyId__"),
			KmsEncryptionContext: map[string]string{
				"key0": "__Value__",
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateBlueprint(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateBlueprint"); err != nil {
		t.Fatal(err)
	}
}

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

func TestUpdateRequestSnapshot_CreateDataAutomationLibrary(t *testing.T) {
	input := &CreateDataAutomationLibraryInput{
		LibraryName:        ptr.String("__LibraryName__"),
		LibraryDescription: ptr.String("__LibraryDescription__"),
		ClientToken:        ptr.String("__ClientToken__"),
		EncryptionConfiguration: &types.EncryptionConfiguration{
			KmsKeyId: ptr.String("__KmsKeyId__"),
			KmsEncryptionContext: map[string]string{
				"key0": "__Value__",
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateDataAutomationLibrary(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateDataAutomationLibrary"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_CreateDataAutomationProject(t *testing.T) {
	input := &CreateDataAutomationProjectInput{
		ProjectName:        ptr.String("__ProjectName__"),
		ProjectDescription: ptr.String("__ProjectDescription__"),
		ProjectStage:       types.DataAutomationProjectStage("DEVELOPMENT"),
		ProjectType:        types.DataAutomationProjectType("ASYNC"),
		StandardOutputConfiguration: &types.StandardOutputConfiguration{
			Document: &types.DocumentStandardOutputConfiguration{
				Extraction: &types.DocumentStandardExtraction{
					Granularity: &types.DocumentExtractionGranularity{
						Types: []types.DocumentExtractionGranularityType{
							types.DocumentExtractionGranularityType("DOCUMENT"),
							types.DocumentExtractionGranularityType("DOCUMENT"),
						},
					},
					BoundingBox: &types.DocumentBoundingBox{
						State: types.State("ENABLED"),
					},
				},
				GenerativeField: &types.DocumentStandardGenerativeField{
					State: types.State("ENABLED"),
				},
				OutputFormat: &types.DocumentOutputFormat{
					TextFormat: &types.DocumentOutputTextFormat{
						Types: []types.DocumentOutputTextFormatType{
							types.DocumentOutputTextFormatType("PLAIN_TEXT"),
							types.DocumentOutputTextFormatType("PLAIN_TEXT"),
						},
					},
					AdditionalFileFormat: &types.DocumentOutputAdditionalFileFormat{
						State: types.State("ENABLED"),
					},
				},
			},
			Image: &types.ImageStandardOutputConfiguration{
				Extraction: &types.ImageStandardExtraction{
					Category: &types.ImageExtractionCategory{
						State: types.State("ENABLED"),
						Types: []types.ImageExtractionCategoryType{
							types.ImageExtractionCategoryType("CONTENT_MODERATION"),
							types.ImageExtractionCategoryType("CONTENT_MODERATION"),
						},
					},
					BoundingBox: &types.ImageBoundingBox{
						State: types.State("ENABLED"),
					},
				},
				GenerativeField: &types.ImageStandardGenerativeField{
					State: types.State("ENABLED"),
					Types: []types.ImageStandardGenerativeFieldType{
						types.ImageStandardGenerativeFieldType("IMAGE_SUMMARY"),
						types.ImageStandardGenerativeFieldType("IMAGE_SUMMARY"),
					},
				},
			},
			Video: &types.VideoStandardOutputConfiguration{
				Extraction: &types.VideoStandardExtraction{
					Category: &types.VideoExtractionCategory{
						State: types.State("ENABLED"),
						Types: []types.VideoExtractionCategoryType{
							types.VideoExtractionCategoryType("CONTENT_MODERATION"),
							types.VideoExtractionCategoryType("CONTENT_MODERATION"),
						},
					},
					BoundingBox: &types.VideoBoundingBox{
						State: types.State("ENABLED"),
					},
				},
				GenerativeField: &types.VideoStandardGenerativeField{
					State: types.State("ENABLED"),
					Types: []types.VideoStandardGenerativeFieldType{
						types.VideoStandardGenerativeFieldType("VIDEO_SUMMARY"),
						types.VideoStandardGenerativeFieldType("VIDEO_SUMMARY"),
					},
				},
			},
			Audio: &types.AudioStandardOutputConfiguration{
				Extraction: &types.AudioStandardExtraction{
					Category: &types.AudioExtractionCategory{
						State: types.State("ENABLED"),
						Types: []types.AudioExtractionCategoryType{
							types.AudioExtractionCategoryType("AUDIO_CONTENT_MODERATION"),
							types.AudioExtractionCategoryType("AUDIO_CONTENT_MODERATION"),
						},
						TypeConfiguration: &types.AudioExtractionCategoryTypeConfiguration{
							Transcript: &types.TranscriptConfiguration{
								SpeakerLabeling: &types.SpeakerLabelingConfiguration{
									State: types.State("ENABLED"),
								},
								ChannelLabeling: &types.ChannelLabelingConfiguration{
									State: types.State("ENABLED"),
								},
							},
						},
					},
				},
				GenerativeField: &types.AudioStandardGenerativeField{
					State: types.State("ENABLED"),
					Types: []types.AudioStandardGenerativeFieldType{
						types.AudioStandardGenerativeFieldType("AUDIO_SUMMARY"),
						types.AudioStandardGenerativeFieldType("AUDIO_SUMMARY"),
					},
				},
			},
		},
		CustomOutputConfiguration: &types.CustomOutputConfiguration{
			Blueprints: []types.BlueprintItem{
				{
					BlueprintArn:     ptr.String("__BlueprintArn__"),
					BlueprintVersion: ptr.String("__BlueprintVersion__"),
					BlueprintStage:   types.BlueprintStage("DEVELOPMENT"),
				},
				{
					BlueprintArn:     ptr.String("__BlueprintArn__"),
					BlueprintVersion: ptr.String("__BlueprintVersion__"),
					BlueprintStage:   types.BlueprintStage("DEVELOPMENT"),
				},
			},
			Document: &types.DocumentCustomOutputConfiguration{
				FallbackBlueprints: []types.BlueprintItem{
					{
						BlueprintArn:     ptr.String("__BlueprintArn__"),
						BlueprintVersion: ptr.String("__BlueprintVersion__"),
						BlueprintStage:   types.BlueprintStage("DEVELOPMENT"),
					},
					{
						BlueprintArn:     ptr.String("__BlueprintArn__"),
						BlueprintVersion: ptr.String("__BlueprintVersion__"),
						BlueprintStage:   types.BlueprintStage("DEVELOPMENT"),
					},
				},
			},
		},
		OverrideConfiguration: &types.OverrideConfiguration{
			Document: &types.DocumentOverrideConfiguration{
				Splitter: &types.SplitterConfiguration{
					State: types.State("ENABLED"),
				},
				ModalityProcessing: &types.ModalityProcessingConfiguration{
					State: types.State("ENABLED"),
				},
				SensitiveDataConfiguration: &types.SensitiveDataConfiguration{
					DetectionMode: types.SensitiveDataDetectionMode("DETECTION"),
					DetectionScope: []types.SensitiveDataDetectionScopeType{
						types.SensitiveDataDetectionScopeType("STANDARD"),
						types.SensitiveDataDetectionScopeType("STANDARD"),
					},
					PiiEntitiesConfiguration: &types.PIIEntitiesConfiguration{
						PiiEntityTypes: []types.PIIEntityType{
							types.PIIEntityType("ALL"),
							types.PIIEntityType("ALL"),
						},
						RedactionMaskMode: types.PIIRedactionMaskMode("PII"),
					},
				},
			},
			Image: &types.ImageOverrideConfiguration{
				ModalityProcessing: &types.ModalityProcessingConfiguration{
					State: types.State("ENABLED"),
				},
				SensitiveDataConfiguration: &types.SensitiveDataConfiguration{
					DetectionMode: types.SensitiveDataDetectionMode("DETECTION"),
					DetectionScope: []types.SensitiveDataDetectionScopeType{
						types.SensitiveDataDetectionScopeType("STANDARD"),
						types.SensitiveDataDetectionScopeType("STANDARD"),
					},
					PiiEntitiesConfiguration: &types.PIIEntitiesConfiguration{
						PiiEntityTypes: []types.PIIEntityType{
							types.PIIEntityType("ALL"),
							types.PIIEntityType("ALL"),
						},
						RedactionMaskMode: types.PIIRedactionMaskMode("PII"),
					},
				},
			},
			Video: &types.VideoOverrideConfiguration{
				ModalityProcessing: &types.ModalityProcessingConfiguration{
					State: types.State("ENABLED"),
				},
				SensitiveDataConfiguration: &types.SensitiveDataConfiguration{
					DetectionMode: types.SensitiveDataDetectionMode("DETECTION"),
					DetectionScope: []types.SensitiveDataDetectionScopeType{
						types.SensitiveDataDetectionScopeType("STANDARD"),
						types.SensitiveDataDetectionScopeType("STANDARD"),
					},
					PiiEntitiesConfiguration: &types.PIIEntitiesConfiguration{
						PiiEntityTypes: []types.PIIEntityType{
							types.PIIEntityType("ALL"),
							types.PIIEntityType("ALL"),
						},
						RedactionMaskMode: types.PIIRedactionMaskMode("PII"),
					},
				},
			},
			Audio: &types.AudioOverrideConfiguration{
				ModalityProcessing: &types.ModalityProcessingConfiguration{
					State: types.State("ENABLED"),
				},
				LanguageConfiguration: &types.AudioLanguageConfiguration{
					InputLanguages: []types.Language{
						types.Language("EN"),
						types.Language("EN"),
					},
					GenerativeOutputLanguage:  types.AudioGenerativeOutputLanguage("DEFAULT"),
					IdentifyMultipleLanguages: ptr.Bool(true),
				},
				SensitiveDataConfiguration: &types.SensitiveDataConfiguration{
					DetectionMode: types.SensitiveDataDetectionMode("DETECTION"),
					DetectionScope: []types.SensitiveDataDetectionScopeType{
						types.SensitiveDataDetectionScopeType("STANDARD"),
						types.SensitiveDataDetectionScopeType("STANDARD"),
					},
					PiiEntitiesConfiguration: &types.PIIEntitiesConfiguration{
						PiiEntityTypes: []types.PIIEntityType{
							types.PIIEntityType("ALL"),
							types.PIIEntityType("ALL"),
						},
						RedactionMaskMode: types.PIIRedactionMaskMode("PII"),
					},
				},
			},
			ModalityRouting: &types.ModalityRoutingConfiguration{
				Jpeg: types.DesiredModality("IMAGE"),
				Png:  types.DesiredModality("IMAGE"),
				Mp4:  types.DesiredModality("IMAGE"),
				Mov:  types.DesiredModality("IMAGE"),
			},
		},
		DataAutomationLibraryConfiguration: &types.DataAutomationLibraryConfiguration{
			Libraries: []types.DataAutomationLibraryItem{
				{
					LibraryArn: ptr.String("__LibraryArn__"),
				},
				{
					LibraryArn: ptr.String("__LibraryArn__"),
				},
			},
		},
		ClientToken: ptr.String("__ClientToken__"),
		EncryptionConfiguration: &types.EncryptionConfiguration{
			KmsKeyId: ptr.String("__KmsKeyId__"),
			KmsEncryptionContext: map[string]string{
				"key0": "__Value__",
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.CreateDataAutomationProject(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "CreateDataAutomationProject"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

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

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

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

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

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

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

func TestUpdateRequestSnapshot_InvokeBlueprintOptimizationAsync(t *testing.T) {
	input := &InvokeBlueprintOptimizationAsyncInput{
		Blueprint: &types.BlueprintOptimizationObject{
			BlueprintArn: ptr.String("__BlueprintArn__"),
			Stage:        types.BlueprintStage("DEVELOPMENT"),
		},
		Samples: []types.BlueprintOptimizationSample{
			{
				AssetS3Object: &types.S3Object{
					S3Uri:   ptr.String("__S3Uri__"),
					Version: ptr.String("__Version__"),
				},
				GroundTruthS3Object: &types.S3Object{
					S3Uri:   ptr.String("__S3Uri__"),
					Version: ptr.String("__Version__"),
				},
			},
			{
				AssetS3Object: &types.S3Object{
					S3Uri:   ptr.String("__S3Uri__"),
					Version: ptr.String("__Version__"),
				},
				GroundTruthS3Object: &types.S3Object{
					S3Uri:   ptr.String("__S3Uri__"),
					Version: ptr.String("__Version__"),
				},
			},
		},
		OutputConfiguration: &types.BlueprintOptimizationOutputConfiguration{
			S3Object: &types.S3Object{
				S3Uri:   ptr.String("__S3Uri__"),
				Version: ptr.String("__Version__"),
			},
		},
		DataAutomationProfileArn: ptr.String("__DataAutomationProfileArn__"),
		EncryptionConfiguration: &types.EncryptionConfiguration{
			KmsKeyId: ptr.String("__KmsKeyId__"),
			KmsEncryptionContext: map[string]string{
				"key0": "__Value__",
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.InvokeBlueprintOptimizationAsync(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "InvokeBlueprintOptimizationAsync"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_InvokeDataAutomationLibraryIngestionJob(t *testing.T) {
	input := &InvokeDataAutomationLibraryIngestionJobInput{
		LibraryArn:  ptr.String("__LibraryArn__"),
		ClientToken: ptr.String("__ClientToken__"),
		InputConfiguration: &types.InputConfiguration{
			S3Object: &types.S3Object{
				S3Uri:   ptr.String("__S3Uri__"),
				Version: ptr.String("__Version__"),
			},
			InlinePayload: &types.InlinePayloadMemberUpsertEntitiesInfo{
				Value: []types.UpsertEntityInfo{
					&types.UpsertEntityInfoMemberVocabulary{
						Value: types.VocabularyEntityInfo{
							EntityId:    ptr.String("__EntityId__"),
							Description: ptr.String("__Description__"),
							Language:    types.Language("EN"),
							Phrases: []types.Phrase{
								{
									Text:          ptr.String("__Text__"),
									DisplayAsText: ptr.String("__DisplayAsText__"),
								},
								{
									Text:          ptr.String("__Text__"),
									DisplayAsText: ptr.String("__DisplayAsText__"),
								},
							},
						},
					},
					&types.UpsertEntityInfoMemberVocabulary{
						Value: types.VocabularyEntityInfo{
							EntityId:    ptr.String("__EntityId__"),
							Description: ptr.String("__Description__"),
							Language:    types.Language("EN"),
							Phrases: []types.Phrase{
								{
									Text:          ptr.String("__Text__"),
									DisplayAsText: ptr.String("__DisplayAsText__"),
								},
								{
									Text:          ptr.String("__Text__"),
									DisplayAsText: ptr.String("__DisplayAsText__"),
								},
							},
						},
					},
				},
			},
		},
		EntityType:    types.EntityType("VOCABULARY"),
		OperationType: types.LibraryIngestionJobOperationType("UPSERT"),
		OutputConfiguration: &types.OutputConfiguration{
			S3Uri: ptr.String("__S3Uri__"),
		},
		NotificationConfiguration: &types.NotificationConfiguration{
			EventBridgeConfiguration: &types.EventBridgeConfiguration{
				EventBridgeEnabled: ptr.Bool(true),
			},
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.InvokeDataAutomationLibraryIngestionJob(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "InvokeDataAutomationLibraryIngestionJob"); err != nil {
		t.Fatal(err)
	}
}

func TestUpdateRequestSnapshot_ListBlueprints(t *testing.T) {
	input := &ListBlueprintsInput{
		BlueprintArn:         ptr.String("__BlueprintArn__"),
		ResourceOwner:        types.ResourceOwner("SERVICE"),
		BlueprintStageFilter: types.BlueprintStageFilter("DEVELOPMENT"),
		MaxResults:           ptr.Int32(1),
		NextToken:            ptr.String("__NextToken__"),
		ProjectFilter: &types.DataAutomationProjectFilter{
			ProjectArn:   ptr.String("__ProjectArn__"),
			ProjectStage: types.DataAutomationProjectStage("DEVELOPMENT"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListBlueprints(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListBlueprints"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

func TestUpdateRequestSnapshot_ListDataAutomationProjects(t *testing.T) {
	input := &ListDataAutomationProjectsInput{
		MaxResults:         ptr.Int32(1),
		NextToken:          ptr.String("__NextToken__"),
		ProjectStageFilter: types.DataAutomationProjectStageFilter("DEVELOPMENT"),
		BlueprintFilter: &types.BlueprintFilter{
			BlueprintArn:     ptr.String("__BlueprintArn__"),
			BlueprintVersion: ptr.String("__BlueprintVersion__"),
			BlueprintStage:   types.BlueprintStage("DEVELOPMENT"),
		},
		ResourceOwner: types.ResourceOwner("SERVICE"),
		LibraryFilter: &types.DataAutomationLibraryFilter{
			LibraryArn: ptr.String("__LibraryArn__"),
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.ListDataAutomationProjects(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "ListDataAutomationProjects"); err != nil {
		t.Fatal(err)
	}
}

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

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

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

func TestUpdateRequestSnapshot_UpdateBlueprint(t *testing.T) {
	input := &UpdateBlueprintInput{
		BlueprintArn:   ptr.String("__BlueprintArn__"),
		Schema:         ptr.String("__Schema__"),
		BlueprintStage: types.BlueprintStage("DEVELOPMENT"),
		EncryptionConfiguration: &types.EncryptionConfiguration{
			KmsKeyId: ptr.String("__KmsKeyId__"),
			KmsEncryptionContext: map[string]string{
				"key0": "__Value__",
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateBlueprint(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateBlueprint"); err != nil {
		t.Fatal(err)
	}
}

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

func TestUpdateRequestSnapshot_UpdateDataAutomationProject(t *testing.T) {
	input := &UpdateDataAutomationProjectInput{
		ProjectArn:         ptr.String("__ProjectArn__"),
		ProjectStage:       types.DataAutomationProjectStage("DEVELOPMENT"),
		ProjectDescription: ptr.String("__ProjectDescription__"),
		StandardOutputConfiguration: &types.StandardOutputConfiguration{
			Document: &types.DocumentStandardOutputConfiguration{
				Extraction: &types.DocumentStandardExtraction{
					Granularity: &types.DocumentExtractionGranularity{
						Types: []types.DocumentExtractionGranularityType{
							types.DocumentExtractionGranularityType("DOCUMENT"),
							types.DocumentExtractionGranularityType("DOCUMENT"),
						},
					},
					BoundingBox: &types.DocumentBoundingBox{
						State: types.State("ENABLED"),
					},
				},
				GenerativeField: &types.DocumentStandardGenerativeField{
					State: types.State("ENABLED"),
				},
				OutputFormat: &types.DocumentOutputFormat{
					TextFormat: &types.DocumentOutputTextFormat{
						Types: []types.DocumentOutputTextFormatType{
							types.DocumentOutputTextFormatType("PLAIN_TEXT"),
							types.DocumentOutputTextFormatType("PLAIN_TEXT"),
						},
					},
					AdditionalFileFormat: &types.DocumentOutputAdditionalFileFormat{
						State: types.State("ENABLED"),
					},
				},
			},
			Image: &types.ImageStandardOutputConfiguration{
				Extraction: &types.ImageStandardExtraction{
					Category: &types.ImageExtractionCategory{
						State: types.State("ENABLED"),
						Types: []types.ImageExtractionCategoryType{
							types.ImageExtractionCategoryType("CONTENT_MODERATION"),
							types.ImageExtractionCategoryType("CONTENT_MODERATION"),
						},
					},
					BoundingBox: &types.ImageBoundingBox{
						State: types.State("ENABLED"),
					},
				},
				GenerativeField: &types.ImageStandardGenerativeField{
					State: types.State("ENABLED"),
					Types: []types.ImageStandardGenerativeFieldType{
						types.ImageStandardGenerativeFieldType("IMAGE_SUMMARY"),
						types.ImageStandardGenerativeFieldType("IMAGE_SUMMARY"),
					},
				},
			},
			Video: &types.VideoStandardOutputConfiguration{
				Extraction: &types.VideoStandardExtraction{
					Category: &types.VideoExtractionCategory{
						State: types.State("ENABLED"),
						Types: []types.VideoExtractionCategoryType{
							types.VideoExtractionCategoryType("CONTENT_MODERATION"),
							types.VideoExtractionCategoryType("CONTENT_MODERATION"),
						},
					},
					BoundingBox: &types.VideoBoundingBox{
						State: types.State("ENABLED"),
					},
				},
				GenerativeField: &types.VideoStandardGenerativeField{
					State: types.State("ENABLED"),
					Types: []types.VideoStandardGenerativeFieldType{
						types.VideoStandardGenerativeFieldType("VIDEO_SUMMARY"),
						types.VideoStandardGenerativeFieldType("VIDEO_SUMMARY"),
					},
				},
			},
			Audio: &types.AudioStandardOutputConfiguration{
				Extraction: &types.AudioStandardExtraction{
					Category: &types.AudioExtractionCategory{
						State: types.State("ENABLED"),
						Types: []types.AudioExtractionCategoryType{
							types.AudioExtractionCategoryType("AUDIO_CONTENT_MODERATION"),
							types.AudioExtractionCategoryType("AUDIO_CONTENT_MODERATION"),
						},
						TypeConfiguration: &types.AudioExtractionCategoryTypeConfiguration{
							Transcript: &types.TranscriptConfiguration{
								SpeakerLabeling: &types.SpeakerLabelingConfiguration{
									State: types.State("ENABLED"),
								},
								ChannelLabeling: &types.ChannelLabelingConfiguration{
									State: types.State("ENABLED"),
								},
							},
						},
					},
				},
				GenerativeField: &types.AudioStandardGenerativeField{
					State: types.State("ENABLED"),
					Types: []types.AudioStandardGenerativeFieldType{
						types.AudioStandardGenerativeFieldType("AUDIO_SUMMARY"),
						types.AudioStandardGenerativeFieldType("AUDIO_SUMMARY"),
					},
				},
			},
		},
		CustomOutputConfiguration: &types.CustomOutputConfiguration{
			Blueprints: []types.BlueprintItem{
				{
					BlueprintArn:     ptr.String("__BlueprintArn__"),
					BlueprintVersion: ptr.String("__BlueprintVersion__"),
					BlueprintStage:   types.BlueprintStage("DEVELOPMENT"),
				},
				{
					BlueprintArn:     ptr.String("__BlueprintArn__"),
					BlueprintVersion: ptr.String("__BlueprintVersion__"),
					BlueprintStage:   types.BlueprintStage("DEVELOPMENT"),
				},
			},
			Document: &types.DocumentCustomOutputConfiguration{
				FallbackBlueprints: []types.BlueprintItem{
					{
						BlueprintArn:     ptr.String("__BlueprintArn__"),
						BlueprintVersion: ptr.String("__BlueprintVersion__"),
						BlueprintStage:   types.BlueprintStage("DEVELOPMENT"),
					},
					{
						BlueprintArn:     ptr.String("__BlueprintArn__"),
						BlueprintVersion: ptr.String("__BlueprintVersion__"),
						BlueprintStage:   types.BlueprintStage("DEVELOPMENT"),
					},
				},
			},
		},
		OverrideConfiguration: &types.OverrideConfiguration{
			Document: &types.DocumentOverrideConfiguration{
				Splitter: &types.SplitterConfiguration{
					State: types.State("ENABLED"),
				},
				ModalityProcessing: &types.ModalityProcessingConfiguration{
					State: types.State("ENABLED"),
				},
				SensitiveDataConfiguration: &types.SensitiveDataConfiguration{
					DetectionMode: types.SensitiveDataDetectionMode("DETECTION"),
					DetectionScope: []types.SensitiveDataDetectionScopeType{
						types.SensitiveDataDetectionScopeType("STANDARD"),
						types.SensitiveDataDetectionScopeType("STANDARD"),
					},
					PiiEntitiesConfiguration: &types.PIIEntitiesConfiguration{
						PiiEntityTypes: []types.PIIEntityType{
							types.PIIEntityType("ALL"),
							types.PIIEntityType("ALL"),
						},
						RedactionMaskMode: types.PIIRedactionMaskMode("PII"),
					},
				},
			},
			Image: &types.ImageOverrideConfiguration{
				ModalityProcessing: &types.ModalityProcessingConfiguration{
					State: types.State("ENABLED"),
				},
				SensitiveDataConfiguration: &types.SensitiveDataConfiguration{
					DetectionMode: types.SensitiveDataDetectionMode("DETECTION"),
					DetectionScope: []types.SensitiveDataDetectionScopeType{
						types.SensitiveDataDetectionScopeType("STANDARD"),
						types.SensitiveDataDetectionScopeType("STANDARD"),
					},
					PiiEntitiesConfiguration: &types.PIIEntitiesConfiguration{
						PiiEntityTypes: []types.PIIEntityType{
							types.PIIEntityType("ALL"),
							types.PIIEntityType("ALL"),
						},
						RedactionMaskMode: types.PIIRedactionMaskMode("PII"),
					},
				},
			},
			Video: &types.VideoOverrideConfiguration{
				ModalityProcessing: &types.ModalityProcessingConfiguration{
					State: types.State("ENABLED"),
				},
				SensitiveDataConfiguration: &types.SensitiveDataConfiguration{
					DetectionMode: types.SensitiveDataDetectionMode("DETECTION"),
					DetectionScope: []types.SensitiveDataDetectionScopeType{
						types.SensitiveDataDetectionScopeType("STANDARD"),
						types.SensitiveDataDetectionScopeType("STANDARD"),
					},
					PiiEntitiesConfiguration: &types.PIIEntitiesConfiguration{
						PiiEntityTypes: []types.PIIEntityType{
							types.PIIEntityType("ALL"),
							types.PIIEntityType("ALL"),
						},
						RedactionMaskMode: types.PIIRedactionMaskMode("PII"),
					},
				},
			},
			Audio: &types.AudioOverrideConfiguration{
				ModalityProcessing: &types.ModalityProcessingConfiguration{
					State: types.State("ENABLED"),
				},
				LanguageConfiguration: &types.AudioLanguageConfiguration{
					InputLanguages: []types.Language{
						types.Language("EN"),
						types.Language("EN"),
					},
					GenerativeOutputLanguage:  types.AudioGenerativeOutputLanguage("DEFAULT"),
					IdentifyMultipleLanguages: ptr.Bool(true),
				},
				SensitiveDataConfiguration: &types.SensitiveDataConfiguration{
					DetectionMode: types.SensitiveDataDetectionMode("DETECTION"),
					DetectionScope: []types.SensitiveDataDetectionScopeType{
						types.SensitiveDataDetectionScopeType("STANDARD"),
						types.SensitiveDataDetectionScopeType("STANDARD"),
					},
					PiiEntitiesConfiguration: &types.PIIEntitiesConfiguration{
						PiiEntityTypes: []types.PIIEntityType{
							types.PIIEntityType("ALL"),
							types.PIIEntityType("ALL"),
						},
						RedactionMaskMode: types.PIIRedactionMaskMode("PII"),
					},
				},
			},
			ModalityRouting: &types.ModalityRoutingConfiguration{
				Jpeg: types.DesiredModality("IMAGE"),
				Png:  types.DesiredModality("IMAGE"),
				Mp4:  types.DesiredModality("IMAGE"),
				Mov:  types.DesiredModality("IMAGE"),
			},
		},
		DataAutomationLibraryConfiguration: &types.DataAutomationLibraryConfiguration{
			Libraries: []types.DataAutomationLibraryItem{
				{
					LibraryArn: ptr.String("__LibraryArn__"),
				},
				{
					LibraryArn: ptr.String("__LibraryArn__"),
				},
			},
		},
		EncryptionConfiguration: &types.EncryptionConfiguration{
			KmsKeyId: ptr.String("__KmsKeyId__"),
			KmsEncryptionContext: map[string]string{
				"key0": "__Value__",
			},
		},
	}
	body := &bytes.Buffer{}
	method := ""
	rawPath := ""
	rawQuery := ""
	header := map[string][]string{}
	svc := serdeNewClient()
	_, err := svc.UpdateDataAutomationProject(context.Background(), input, func(o *Options) {
		o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
			stack.Initialize.Remove("OperationInputValidation")
			stack.Serialize.Remove("RequestCompression")
			return stack.Finalize.Add(&captureSerdeRequestMiddleware{
				body: body, method: &method, rawPath: &rawPath, rawQuery: &rawQuery, header: &header,
			}, middleware.Before)
		})
	})
	if err != nil && !errors.Is(err, errSerdeSnapshotOK) {
		t.Fatal(err)
	}
	if err := serdeUpdateSnapshot(method, rawPath, rawQuery, header, body.Bytes(), "UpdateDataAutomationProject"); err != nil {
		t.Fatal(err)
	}
}
