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

//go:build response_snapshot

package bedrockdataautomation

import (
	"bufio"
	"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"
	smithytesting "github.com/aws/smithy-go/testing"
	smithyhttp "github.com/aws/smithy-go/transport/http"
	"io"
	"io/fs"
	"net/http"
	"net/url"
	"os"
	"strconv"
	"strings"
	"testing"
	"time"
)

const serdeRespSSPrefix = "response_snapshot"

func serdeRespSSPath(op string) string {
	return fmt.Sprintf("%s/%s.snap", serdeRespSSPrefix, op)
}

// serdeRespReadSnapshot parses a frozen wire response fixture: a status-code
// line, HTTP headers, a blank line, then the raw body.
func serdeRespReadSnapshot(op string) (int, http.Header, []byte, error) {
	raw, err := os.ReadFile(serdeRespSSPath(op))
	if err != nil {
		return 0, nil, nil, err
	}

	r := bufio.NewReader(bytes.NewReader(raw))
	statusLine, err := r.ReadString('\n')
	if err != nil {
		return 0, nil, nil, fmt.Errorf("read status line: %w", err)
	}
	status, err := strconv.Atoi(strings.TrimSpace(statusLine))
	if err != nil {
		return 0, nil, nil, fmt.Errorf("parse status: %w", err)
	}

	header := http.Header{}
	for {
		line, err := r.ReadString('\n')
		if err != nil && err != io.EOF {
			return 0, nil, nil, err
		}
		trimmed := strings.TrimRight(line, "\r\n")
		if trimmed == "" {
			break
		}
		k, v, ok := strings.Cut(trimmed, ": ")
		if !ok {
			return 0, nil, nil, fmt.Errorf("malformed header %q", trimmed)
		}
		header.Add(k, v)
		if err == io.EOF {
			break
		}
	}

	body, err := io.ReadAll(r)
	if err != nil {
		return 0, nil, nil, err
	}
	return status, header, body, nil
}

type serdeRespEndpointResolver struct{}

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

func serdeRespClient(status int, header http.Header, body []byte) *Client {
	return New(Options{
		Region: "us-east-1",
		HTTPClient: smithyhttp.ClientDoFunc(func(req *http.Request) (*http.Response, error) {
			resp := &http.Response{StatusCode: status, Header: header, Request: req}
			if len(body) > 0 {
				resp.ContentLength = int64(len(body))
				resp.Body = io.NopCloser(bytes.NewReader(body))
			} else {
				resp.Body = http.NoBody
			}
			return resp, nil
		}),
		EndpointResolverV2: &serdeRespEndpointResolver{},
		APIOptions: []func(*middleware.Stack) error{
			func(s *middleware.Stack) error {
				s.Finalize.Clear()
				s.Initialize.Remove("OperationInputValidation")
				return nil
			},
		},
	})
}
func TestCheckResponseSnapshot_CopyBlueprintStage(t *testing.T) {
	want := &CopyBlueprintStageOutput{}
	status, header, body, err := serdeRespReadSnapshot("CopyBlueprintStage.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CopyBlueprintStage(context.Background(), &CopyBlueprintStageInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CopyBlueprintStage.response", err)
	}
}

func TestCheckResponseSnapshot_CreateBlueprint(t *testing.T) {
	want := &CreateBlueprintOutput{
		Blueprint: &types.Blueprint{
			BlueprintArn:     ptr.String("__BlueprintArn__"),
			Schema:           ptr.String("__Schema__"),
			Type:             types.Type("DOCUMENT"),
			CreationTime:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LastModifiedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			BlueprintName:    ptr.String("__BlueprintName__"),
			BlueprintVersion: ptr.String("__BlueprintVersion__"),
			BlueprintStage:   types.BlueprintStage("DEVELOPMENT"),
			KmsKeyId:         ptr.String("__KmsKeyId__"),
			KmsEncryptionContext: map[string]string{
				"key0": "__Value__",
			},
			OptimizationSamples: []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__"),
					},
				},
			},
			OptimizationTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateBlueprint.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateBlueprint(context.Background(), &CreateBlueprintInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateBlueprint.response", err)
	}
}

func TestCheckResponseSnapshot_CreateBlueprintVersion(t *testing.T) {
	want := &CreateBlueprintVersionOutput{
		Blueprint: &types.Blueprint{
			BlueprintArn:     ptr.String("__BlueprintArn__"),
			Schema:           ptr.String("__Schema__"),
			Type:             types.Type("DOCUMENT"),
			CreationTime:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LastModifiedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			BlueprintName:    ptr.String("__BlueprintName__"),
			BlueprintVersion: ptr.String("__BlueprintVersion__"),
			BlueprintStage:   types.BlueprintStage("DEVELOPMENT"),
			KmsKeyId:         ptr.String("__KmsKeyId__"),
			KmsEncryptionContext: map[string]string{
				"key0": "__Value__",
			},
			OptimizationSamples: []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__"),
					},
				},
			},
			OptimizationTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateBlueprintVersion.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateBlueprintVersion(context.Background(), &CreateBlueprintVersionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateBlueprintVersion.response", err)
	}
}

func TestCheckResponseSnapshot_CreateDataAutomationLibrary(t *testing.T) {
	want := &CreateDataAutomationLibraryOutput{
		LibraryArn: ptr.String("__LibraryArn__"),
		Status:     types.DataAutomationLibraryStatus("ACTIVE"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateDataAutomationLibrary.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateDataAutomationLibrary(context.Background(), &CreateDataAutomationLibraryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateDataAutomationLibrary.response", err)
	}
}

func TestCheckResponseSnapshot_CreateDataAutomationProject(t *testing.T) {
	want := &CreateDataAutomationProjectOutput{
		ProjectArn:   ptr.String("__ProjectArn__"),
		ProjectStage: types.DataAutomationProjectStage("DEVELOPMENT"),
		Status:       types.DataAutomationProjectStatus("COMPLETED"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateDataAutomationProject.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateDataAutomationProject(context.Background(), &CreateDataAutomationProjectInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateDataAutomationProject.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteBlueprint(t *testing.T) {
	want := &DeleteBlueprintOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteBlueprint.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteBlueprint(context.Background(), &DeleteBlueprintInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteBlueprint.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteDataAutomationLibrary(t *testing.T) {
	want := &DeleteDataAutomationLibraryOutput{
		LibraryArn: ptr.String("__LibraryArn__"),
		Status:     types.DataAutomationLibraryStatus("ACTIVE"),
	}
	status, header, body, err := serdeRespReadSnapshot("DeleteDataAutomationLibrary.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteDataAutomationLibrary(context.Background(), &DeleteDataAutomationLibraryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteDataAutomationLibrary.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteDataAutomationProject(t *testing.T) {
	want := &DeleteDataAutomationProjectOutput{
		ProjectArn: ptr.String("__ProjectArn__"),
		Status:     types.DataAutomationProjectStatus("COMPLETED"),
	}
	status, header, body, err := serdeRespReadSnapshot("DeleteDataAutomationProject.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteDataAutomationProject(context.Background(), &DeleteDataAutomationProjectInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteDataAutomationProject.response", err)
	}
}

func TestCheckResponseSnapshot_GetBlueprint(t *testing.T) {
	want := &GetBlueprintOutput{
		Blueprint: &types.Blueprint{
			BlueprintArn:     ptr.String("__BlueprintArn__"),
			Schema:           ptr.String("__Schema__"),
			Type:             types.Type("DOCUMENT"),
			CreationTime:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LastModifiedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			BlueprintName:    ptr.String("__BlueprintName__"),
			BlueprintVersion: ptr.String("__BlueprintVersion__"),
			BlueprintStage:   types.BlueprintStage("DEVELOPMENT"),
			KmsKeyId:         ptr.String("__KmsKeyId__"),
			KmsEncryptionContext: map[string]string{
				"key0": "__Value__",
			},
			OptimizationSamples: []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__"),
					},
				},
			},
			OptimizationTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetBlueprint.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetBlueprint(context.Background(), &GetBlueprintInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBlueprint.response", err)
	}
}

func TestCheckResponseSnapshot_GetBlueprintOptimizationStatus(t *testing.T) {
	want := &GetBlueprintOptimizationStatusOutput{
		Status:       types.BlueprintOptimizationJobStatus("Created"),
		ErrorType:    ptr.String("__ErrorType__"),
		ErrorMessage: ptr.String("__ErrorMessage__"),
		OutputConfiguration: &types.BlueprintOptimizationOutputConfiguration{
			S3Object: &types.S3Object{
				S3Uri:   ptr.String("__S3Uri__"),
				Version: ptr.String("__Version__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetBlueprintOptimizationStatus.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetBlueprintOptimizationStatus(context.Background(), &GetBlueprintOptimizationStatusInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetBlueprintOptimizationStatus.response", err)
	}
}

func TestCheckResponseSnapshot_GetDataAutomationLibrary(t *testing.T) {
	want := &GetDataAutomationLibraryOutput{
		Library: &types.DataAutomationLibrary{
			LibraryArn:         ptr.String("__LibraryArn__"),
			CreationTime:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LibraryName:        ptr.String("__LibraryName__"),
			LibraryDescription: ptr.String("__LibraryDescription__"),
			Status:             types.DataAutomationLibraryStatus("ACTIVE"),
			EntityTypes: []types.EntityTypeInfo{
				{
					EntityType:     types.EntityType("VOCABULARY"),
					EntityMetadata: ptr.String("__EntityMetadata__"),
				},
				{
					EntityType:     types.EntityType("VOCABULARY"),
					EntityMetadata: ptr.String("__EntityMetadata__"),
				},
			},
			KmsKeyId: ptr.String("__KmsKeyId__"),
			KmsEncryptionContext: map[string]string{
				"key0": "__Value__",
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetDataAutomationLibrary.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetDataAutomationLibrary(context.Background(), &GetDataAutomationLibraryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetDataAutomationLibrary.response", err)
	}
}

func TestCheckResponseSnapshot_GetDataAutomationLibraryEntity(t *testing.T) {
	want := &GetDataAutomationLibraryEntityOutput{
		Entity: &types.EntityDetailsMemberVocabulary{
			Value: types.VocabularyEntity{
				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__"),
					},
				},
				LastModifiedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetDataAutomationLibraryEntity.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetDataAutomationLibraryEntity(context.Background(), &GetDataAutomationLibraryEntityInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetDataAutomationLibraryEntity.response", err)
	}
}

func TestCheckResponseSnapshot_GetDataAutomationLibraryIngestionJob(t *testing.T) {
	want := &GetDataAutomationLibraryIngestionJobOutput{
		Job: &types.DataAutomationLibraryIngestionJob{
			JobArn:        ptr.String("__JobArn__"),
			CreationTime:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			EntityType:    types.EntityType("VOCABULARY"),
			OperationType: types.LibraryIngestionJobOperationType("UPSERT"),
			JobStatus:     types.LibraryIngestionJobStatus("IN_PROGRESS"),
			OutputConfiguration: &types.OutputConfiguration{
				S3Uri: ptr.String("__S3Uri__"),
			},
			CompletionTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			ErrorMessage:   ptr.String("__ErrorMessage__"),
			ErrorType:      ptr.String("__ErrorType__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetDataAutomationLibraryIngestionJob.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetDataAutomationLibraryIngestionJob(context.Background(), &GetDataAutomationLibraryIngestionJobInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetDataAutomationLibraryIngestionJob.response", err)
	}
}

func TestCheckResponseSnapshot_GetDataAutomationProject(t *testing.T) {
	want := &GetDataAutomationProjectOutput{
		Project: &types.DataAutomationProject{
			ProjectArn:         ptr.String("__ProjectArn__"),
			CreationTime:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LastModifiedTime:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			ProjectName:        ptr.String("__ProjectName__"),
			ProjectStage:       types.DataAutomationProjectStage("DEVELOPMENT"),
			ProjectType:        types.DataAutomationProjectType("ASYNC"),
			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__"),
					},
				},
			},
			Status:   types.DataAutomationProjectStatus("COMPLETED"),
			KmsKeyId: ptr.String("__KmsKeyId__"),
			KmsEncryptionContext: map[string]string{
				"key0": "__Value__",
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetDataAutomationProject.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetDataAutomationProject(context.Background(), &GetDataAutomationProjectInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetDataAutomationProject.response", err)
	}
}

func TestCheckResponseSnapshot_InvokeBlueprintOptimizationAsync(t *testing.T) {
	want := &InvokeBlueprintOptimizationAsyncOutput{
		InvocationArn: ptr.String("__InvocationArn__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvokeBlueprintOptimizationAsync.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.InvokeBlueprintOptimizationAsync(context.Background(), &InvokeBlueprintOptimizationAsyncInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "InvokeBlueprintOptimizationAsync.response", err)
	}
}

func TestCheckResponseSnapshot_InvokeDataAutomationLibraryIngestionJob(t *testing.T) {
	want := &InvokeDataAutomationLibraryIngestionJobOutput{
		JobArn: ptr.String("__JobArn__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvokeDataAutomationLibraryIngestionJob.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.InvokeDataAutomationLibraryIngestionJob(context.Background(), &InvokeDataAutomationLibraryIngestionJobInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "InvokeDataAutomationLibraryIngestionJob.response", err)
	}
}

func TestCheckResponseSnapshot_ListBlueprints(t *testing.T) {
	want := &ListBlueprintsOutput{
		Blueprints: []types.BlueprintSummary{
			{
				BlueprintArn:     ptr.String("__BlueprintArn__"),
				BlueprintVersion: ptr.String("__BlueprintVersion__"),
				BlueprintStage:   types.BlueprintStage("DEVELOPMENT"),
				BlueprintName:    ptr.String("__BlueprintName__"),
				CreationTime:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastModifiedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				BlueprintArn:     ptr.String("__BlueprintArn__"),
				BlueprintVersion: ptr.String("__BlueprintVersion__"),
				BlueprintStage:   types.BlueprintStage("DEVELOPMENT"),
				BlueprintName:    ptr.String("__BlueprintName__"),
				CreationTime:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastModifiedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListBlueprints.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListBlueprints(context.Background(), &ListBlueprintsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListBlueprints.response", err)
	}
}

func TestCheckResponseSnapshot_ListDataAutomationLibraries(t *testing.T) {
	want := &ListDataAutomationLibrariesOutput{
		Libraries: []types.DataAutomationLibrarySummary{
			{
				LibraryArn:   ptr.String("__LibraryArn__"),
				LibraryName:  ptr.String("__LibraryName__"),
				CreationTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				LibraryArn:   ptr.String("__LibraryArn__"),
				LibraryName:  ptr.String("__LibraryName__"),
				CreationTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListDataAutomationLibraries.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListDataAutomationLibraries(context.Background(), &ListDataAutomationLibrariesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListDataAutomationLibraries.response", err)
	}
}

func TestCheckResponseSnapshot_ListDataAutomationLibraryEntities(t *testing.T) {
	want := &ListDataAutomationLibraryEntitiesOutput{
		Entities: []types.DataAutomationLibraryEntitySummary{
			&types.DataAutomationLibraryEntitySummaryMemberVocabulary{
				Value: types.VocabularyEntitySummary{
					EntityId:         ptr.String("__EntityId__"),
					Description:      ptr.String("__Description__"),
					Language:         types.Language("EN"),
					NumOfPhrases:     ptr.Int32(1),
					LastModifiedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
			&types.DataAutomationLibraryEntitySummaryMemberVocabulary{
				Value: types.VocabularyEntitySummary{
					EntityId:         ptr.String("__EntityId__"),
					Description:      ptr.String("__Description__"),
					Language:         types.Language("EN"),
					NumOfPhrases:     ptr.Int32(1),
					LastModifiedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListDataAutomationLibraryEntities.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListDataAutomationLibraryEntities(context.Background(), &ListDataAutomationLibraryEntitiesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListDataAutomationLibraryEntities.response", err)
	}
}

func TestCheckResponseSnapshot_ListDataAutomationLibraryIngestionJobs(t *testing.T) {
	want := &ListDataAutomationLibraryIngestionJobsOutput{
		Jobs: []types.DataAutomationLibraryIngestionJobSummary{
			{
				JobArn:         ptr.String("__JobArn__"),
				JobStatus:      types.LibraryIngestionJobStatus("IN_PROGRESS"),
				EntityType:     types.EntityType("VOCABULARY"),
				OperationType:  types.LibraryIngestionJobOperationType("UPSERT"),
				CreationTime:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CompletionTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				JobArn:         ptr.String("__JobArn__"),
				JobStatus:      types.LibraryIngestionJobStatus("IN_PROGRESS"),
				EntityType:     types.EntityType("VOCABULARY"),
				OperationType:  types.LibraryIngestionJobOperationType("UPSERT"),
				CreationTime:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CompletionTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListDataAutomationLibraryIngestionJobs.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListDataAutomationLibraryIngestionJobs(context.Background(), &ListDataAutomationLibraryIngestionJobsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListDataAutomationLibraryIngestionJobs.response", err)
	}
}

func TestCheckResponseSnapshot_ListDataAutomationProjects(t *testing.T) {
	want := &ListDataAutomationProjectsOutput{
		Projects: []types.DataAutomationProjectSummary{
			{
				ProjectArn:   ptr.String("__ProjectArn__"),
				ProjectStage: types.DataAutomationProjectStage("DEVELOPMENT"),
				ProjectType:  types.DataAutomationProjectType("ASYNC"),
				ProjectName:  ptr.String("__ProjectName__"),
				CreationTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				ProjectArn:   ptr.String("__ProjectArn__"),
				ProjectStage: types.DataAutomationProjectStage("DEVELOPMENT"),
				ProjectType:  types.DataAutomationProjectType("ASYNC"),
				ProjectName:  ptr.String("__ProjectName__"),
				CreationTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListDataAutomationProjects.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListDataAutomationProjects(context.Background(), &ListDataAutomationProjectsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListDataAutomationProjects.response", err)
	}
}

func TestCheckResponseSnapshot_ListTagsForResource(t *testing.T) {
	want := &ListTagsForResourceOutput{
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListTagsForResource.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListTagsForResource(context.Background(), &ListTagsForResourceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListTagsForResource.response", err)
	}
}

func TestCheckResponseSnapshot_TagResource(t *testing.T) {
	want := &TagResourceOutput{}
	status, header, body, err := serdeRespReadSnapshot("TagResource.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.TagResource(context.Background(), &TagResourceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "TagResource.response", err)
	}
}

func TestCheckResponseSnapshot_UntagResource(t *testing.T) {
	want := &UntagResourceOutput{}
	status, header, body, err := serdeRespReadSnapshot("UntagResource.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UntagResource(context.Background(), &UntagResourceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UntagResource.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateBlueprint(t *testing.T) {
	want := &UpdateBlueprintOutput{
		Blueprint: &types.Blueprint{
			BlueprintArn:     ptr.String("__BlueprintArn__"),
			Schema:           ptr.String("__Schema__"),
			Type:             types.Type("DOCUMENT"),
			CreationTime:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LastModifiedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			BlueprintName:    ptr.String("__BlueprintName__"),
			BlueprintVersion: ptr.String("__BlueprintVersion__"),
			BlueprintStage:   types.BlueprintStage("DEVELOPMENT"),
			KmsKeyId:         ptr.String("__KmsKeyId__"),
			KmsEncryptionContext: map[string]string{
				"key0": "__Value__",
			},
			OptimizationSamples: []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__"),
					},
				},
			},
			OptimizationTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateBlueprint.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateBlueprint(context.Background(), &UpdateBlueprintInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateBlueprint.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateDataAutomationLibrary(t *testing.T) {
	want := &UpdateDataAutomationLibraryOutput{
		LibraryArn: ptr.String("__LibraryArn__"),
		Status:     types.DataAutomationLibraryStatus("ACTIVE"),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateDataAutomationLibrary.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateDataAutomationLibrary(context.Background(), &UpdateDataAutomationLibraryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateDataAutomationLibrary.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateDataAutomationProject(t *testing.T) {
	want := &UpdateDataAutomationProjectOutput{
		ProjectArn:   ptr.String("__ProjectArn__"),
		ProjectStage: types.DataAutomationProjectStage("DEVELOPMENT"),
		Status:       types.DataAutomationProjectStatus("COMPLETED"),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateDataAutomationProject.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateDataAutomationProject(context.Background(), &UpdateDataAutomationProjectInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateDataAutomationProject.response", err)
	}
}

func TestCheckResponseSnapshot_Error_AccessDeniedException(t *testing.T) {
	want := &types.AccessDeniedException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("AccessDeniedException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.CopyBlueprintStage(context.Background(), &CopyBlueprintStageInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.AccessDeniedException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.AccessDeniedException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "AccessDeniedException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ConflictException(t *testing.T) {
	want := &types.ConflictException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ConflictException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.CreateBlueprint(context.Background(), &CreateBlueprintInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ConflictException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ConflictException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ConflictException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InternalServerException(t *testing.T) {
	want := &types.InternalServerException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InternalServerException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.CopyBlueprintStage(context.Background(), &CopyBlueprintStageInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InternalServerException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InternalServerException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InternalServerException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ResourceNotFoundException(t *testing.T) {
	want := &types.ResourceNotFoundException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ResourceNotFoundException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.CopyBlueprintStage(context.Background(), &CopyBlueprintStageInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ResourceNotFoundException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ResourceNotFoundException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ResourceNotFoundException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ServiceQuotaExceededException(t *testing.T) {
	want := &types.ServiceQuotaExceededException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ServiceQuotaExceededException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.CreateBlueprint(context.Background(), &CreateBlueprintInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ServiceQuotaExceededException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ServiceQuotaExceededException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ServiceQuotaExceededException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ThrottlingException(t *testing.T) {
	want := &types.ThrottlingException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ThrottlingException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.CopyBlueprintStage(context.Background(), &CopyBlueprintStageInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ThrottlingException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ThrottlingException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ThrottlingException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ValidationException(t *testing.T) {
	want := &types.ValidationException{
		Message: ptr.String("__Message__"),
		FieldList: []types.ValidationExceptionField{
			{
				Name:    ptr.String("__Name__"),
				Message: ptr.String("__Message__"),
			},
			{
				Name:    ptr.String("__Name__"),
				Message: ptr.String("__Message__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ValidationException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.CopyBlueprintStage(context.Background(), &CopyBlueprintStageInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ValidationException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ValidationException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ValidationException.error", err)
	}
}
