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

//go:build response_snapshot

package bedrock

import (
	"bufio"
	"bytes"
	"context"
	"errors"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/bedrock/document"
	"github.com/aws/aws-sdk-go-v2/service/bedrock/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_BatchDeleteAdvancedPromptOptimizationJob(t *testing.T) {
	want := &BatchDeleteAdvancedPromptOptimizationJobOutput{
		Errors: []types.BatchDeleteAdvancedPromptOptimizationJobError{
			{
				JobIdentifier: ptr.String("__JobIdentifier__"),
				Code:          ptr.String("__Code__"),
				Message:       ptr.String("__Message__"),
			},
			{
				JobIdentifier: ptr.String("__JobIdentifier__"),
				Code:          ptr.String("__Code__"),
				Message:       ptr.String("__Message__"),
			},
		},
		AdvancedPromptOptimizationJobs: []types.BatchDeleteAdvancedPromptOptimizationJobItem{
			{
				JobIdentifier: ptr.String("__JobIdentifier__"),
				JobStatus:     types.AdvancedPromptOptimizationJobStatus("InProgress"),
			},
			{
				JobIdentifier: ptr.String("__JobIdentifier__"),
				JobStatus:     types.AdvancedPromptOptimizationJobStatus("InProgress"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("BatchDeleteAdvancedPromptOptimizationJob.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.BatchDeleteAdvancedPromptOptimizationJob(context.Background(), &BatchDeleteAdvancedPromptOptimizationJobInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "BatchDeleteAdvancedPromptOptimizationJob.response", err)
	}
}

func TestCheckResponseSnapshot_BatchDeleteEvaluationJob(t *testing.T) {
	want := &BatchDeleteEvaluationJobOutput{
		Errors: []types.BatchDeleteEvaluationJobError{
			{
				JobIdentifier: ptr.String("__JobIdentifier__"),
				Code:          ptr.String("__Code__"),
				Message:       ptr.String("__Message__"),
			},
			{
				JobIdentifier: ptr.String("__JobIdentifier__"),
				Code:          ptr.String("__Code__"),
				Message:       ptr.String("__Message__"),
			},
		},
		EvaluationJobs: []types.BatchDeleteEvaluationJobItem{
			{
				JobIdentifier: ptr.String("__JobIdentifier__"),
				JobStatus:     types.EvaluationJobStatus("InProgress"),
			},
			{
				JobIdentifier: ptr.String("__JobIdentifier__"),
				JobStatus:     types.EvaluationJobStatus("InProgress"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("BatchDeleteEvaluationJob.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.BatchDeleteEvaluationJob(context.Background(), &BatchDeleteEvaluationJobInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "BatchDeleteEvaluationJob.response", err)
	}
}

func TestCheckResponseSnapshot_CancelAutomatedReasoningPolicyBuildWorkflow(t *testing.T) {
	want := &CancelAutomatedReasoningPolicyBuildWorkflowOutput{}
	status, header, body, err := serdeRespReadSnapshot("CancelAutomatedReasoningPolicyBuildWorkflow.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.CancelAutomatedReasoningPolicyBuildWorkflow(context.Background(), &CancelAutomatedReasoningPolicyBuildWorkflowInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CancelAutomatedReasoningPolicyBuildWorkflow.response", err)
	}
}

func TestCheckResponseSnapshot_CreateAdvancedPromptOptimizationJob(t *testing.T) {
	want := &CreateAdvancedPromptOptimizationJobOutput{
		JobArn: ptr.String("__JobArn__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateAdvancedPromptOptimizationJob.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.CreateAdvancedPromptOptimizationJob(context.Background(), &CreateAdvancedPromptOptimizationJobInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateAdvancedPromptOptimizationJob.response", err)
	}
}

func TestCheckResponseSnapshot_CreateAutomatedReasoningPolicy(t *testing.T) {
	want := &CreateAutomatedReasoningPolicyOutput{
		PolicyArn:      ptr.String("__PolicyArn__"),
		Version:        ptr.String("__Version__"),
		Name:           ptr.String("__Name__"),
		Description:    ptr.String("__Description__"),
		DefinitionHash: ptr.String("__DefinitionHash__"),
		CreatedAt:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		UpdatedAt:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateAutomatedReasoningPolicy.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.CreateAutomatedReasoningPolicy(context.Background(), &CreateAutomatedReasoningPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateAutomatedReasoningPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_CreateAutomatedReasoningPolicyTestCase(t *testing.T) {
	want := &CreateAutomatedReasoningPolicyTestCaseOutput{
		PolicyArn:  ptr.String("__PolicyArn__"),
		TestCaseId: ptr.String("__TestCaseId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateAutomatedReasoningPolicyTestCase.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.CreateAutomatedReasoningPolicyTestCase(context.Background(), &CreateAutomatedReasoningPolicyTestCaseInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateAutomatedReasoningPolicyTestCase.response", err)
	}
}

func TestCheckResponseSnapshot_CreateAutomatedReasoningPolicyVersion(t *testing.T) {
	want := &CreateAutomatedReasoningPolicyVersionOutput{
		PolicyArn:      ptr.String("__PolicyArn__"),
		Version:        ptr.String("__Version__"),
		Name:           ptr.String("__Name__"),
		Description:    ptr.String("__Description__"),
		DefinitionHash: ptr.String("__DefinitionHash__"),
		CreatedAt:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateAutomatedReasoningPolicyVersion.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.CreateAutomatedReasoningPolicyVersion(context.Background(), &CreateAutomatedReasoningPolicyVersionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateAutomatedReasoningPolicyVersion.response", err)
	}
}

func TestCheckResponseSnapshot_CreateCustomModel(t *testing.T) {
	want := &CreateCustomModelOutput{
		ModelArn: ptr.String("__ModelArn__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateCustomModel.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.CreateCustomModel(context.Background(), &CreateCustomModelInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateCustomModel.response", err)
	}
}

func TestCheckResponseSnapshot_CreateCustomModelDeployment(t *testing.T) {
	want := &CreateCustomModelDeploymentOutput{
		CustomModelDeploymentArn: ptr.String("__CustomModelDeploymentArn__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateCustomModelDeployment.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.CreateCustomModelDeployment(context.Background(), &CreateCustomModelDeploymentInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateCustomModelDeployment.response", err)
	}
}

func TestCheckResponseSnapshot_CreateEvaluationJob(t *testing.T) {
	want := &CreateEvaluationJobOutput{
		JobArn: ptr.String("__JobArn__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateEvaluationJob.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.CreateEvaluationJob(context.Background(), &CreateEvaluationJobInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateEvaluationJob.response", err)
	}
}

func TestCheckResponseSnapshot_CreateFoundationModelAgreement(t *testing.T) {
	want := &CreateFoundationModelAgreementOutput{
		ModelId: ptr.String("__ModelId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateFoundationModelAgreement.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.CreateFoundationModelAgreement(context.Background(), &CreateFoundationModelAgreementInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateFoundationModelAgreement.response", err)
	}
}

func TestCheckResponseSnapshot_CreateGuardrail(t *testing.T) {
	want := &CreateGuardrailOutput{
		GuardrailId:  ptr.String("__GuardrailId__"),
		GuardrailArn: ptr.String("__GuardrailArn__"),
		Version:      ptr.String("__Version__"),
		CreatedAt:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateGuardrail.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.CreateGuardrail(context.Background(), &CreateGuardrailInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateGuardrail.response", err)
	}
}

func TestCheckResponseSnapshot_CreateGuardrailVersion(t *testing.T) {
	want := &CreateGuardrailVersionOutput{
		GuardrailId: ptr.String("__GuardrailId__"),
		Version:     ptr.String("__Version__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateGuardrailVersion.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.CreateGuardrailVersion(context.Background(), &CreateGuardrailVersionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateGuardrailVersion.response", err)
	}
}

func TestCheckResponseSnapshot_CreateInferenceProfile(t *testing.T) {
	want := &CreateInferenceProfileOutput{
		InferenceProfileArn: ptr.String("__InferenceProfileArn__"),
		Status:              types.InferenceProfileStatus("ACTIVE"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateInferenceProfile.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.CreateInferenceProfile(context.Background(), &CreateInferenceProfileInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateInferenceProfile.response", err)
	}
}

func TestCheckResponseSnapshot_CreateMarketplaceModelEndpoint(t *testing.T) {
	want := &CreateMarketplaceModelEndpointOutput{
		MarketplaceModelEndpoint: &types.MarketplaceModelEndpoint{
			EndpointArn:           ptr.String("__EndpointArn__"),
			ModelSourceIdentifier: ptr.String("__ModelSourceIdentifier__"),
			Status:                types.Status("REGISTERED"),
			StatusMessage:         ptr.String("__StatusMessage__"),
			CreatedAt:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			UpdatedAt:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			EndpointConfig: &types.EndpointConfigMemberSageMaker{
				Value: types.SageMakerEndpoint{
					InitialInstanceCount: ptr.Int32(1),
					InstanceType:         ptr.String("__InstanceType__"),
					ExecutionRole:        ptr.String("__ExecutionRole__"),
					KmsEncryptionKey:     ptr.String("__KmsEncryptionKey__"),
					Vpc: &types.VpcConfig{
						SubnetIds: []string{
							"__Member__",
							"__Member__",
						},
						SecurityGroupIds: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
			},
			EndpointStatus:        ptr.String("__EndpointStatus__"),
			EndpointStatusMessage: ptr.String("__EndpointStatusMessage__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateMarketplaceModelEndpoint.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.CreateMarketplaceModelEndpoint(context.Background(), &CreateMarketplaceModelEndpointInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateMarketplaceModelEndpoint.response", err)
	}
}

func TestCheckResponseSnapshot_CreateModelCopyJob(t *testing.T) {
	want := &CreateModelCopyJobOutput{
		JobArn: ptr.String("__JobArn__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateModelCopyJob.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.CreateModelCopyJob(context.Background(), &CreateModelCopyJobInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateModelCopyJob.response", err)
	}
}

func TestCheckResponseSnapshot_CreateModelCustomizationJob(t *testing.T) {
	want := &CreateModelCustomizationJobOutput{
		JobArn: ptr.String("__JobArn__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateModelCustomizationJob.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.CreateModelCustomizationJob(context.Background(), &CreateModelCustomizationJobInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateModelCustomizationJob.response", err)
	}
}

func TestCheckResponseSnapshot_CreateModelImportJob(t *testing.T) {
	want := &CreateModelImportJobOutput{
		JobArn: ptr.String("__JobArn__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateModelImportJob.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.CreateModelImportJob(context.Background(), &CreateModelImportJobInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateModelImportJob.response", err)
	}
}

func TestCheckResponseSnapshot_CreateModelInvocationJob(t *testing.T) {
	want := &CreateModelInvocationJobOutput{
		JobArn: ptr.String("__JobArn__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateModelInvocationJob.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.CreateModelInvocationJob(context.Background(), &CreateModelInvocationJobInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateModelInvocationJob.response", err)
	}
}

func TestCheckResponseSnapshot_CreatePromptRouter(t *testing.T) {
	want := &CreatePromptRouterOutput{
		PromptRouterArn: ptr.String("__PromptRouterArn__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreatePromptRouter.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.CreatePromptRouter(context.Background(), &CreatePromptRouterInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreatePromptRouter.response", err)
	}
}

func TestCheckResponseSnapshot_CreateProvisionedModelThroughput(t *testing.T) {
	want := &CreateProvisionedModelThroughputOutput{
		ProvisionedModelArn: ptr.String("__ProvisionedModelArn__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateProvisionedModelThroughput.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.CreateProvisionedModelThroughput(context.Background(), &CreateProvisionedModelThroughputInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateProvisionedModelThroughput.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteAutomatedReasoningPolicy(t *testing.T) {
	want := &DeleteAutomatedReasoningPolicyOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteAutomatedReasoningPolicy.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.DeleteAutomatedReasoningPolicy(context.Background(), &DeleteAutomatedReasoningPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteAutomatedReasoningPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteAutomatedReasoningPolicyBuildWorkflow(t *testing.T) {
	want := &DeleteAutomatedReasoningPolicyBuildWorkflowOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteAutomatedReasoningPolicyBuildWorkflow.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.DeleteAutomatedReasoningPolicyBuildWorkflow(context.Background(), &DeleteAutomatedReasoningPolicyBuildWorkflowInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteAutomatedReasoningPolicyBuildWorkflow.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteAutomatedReasoningPolicyTestCase(t *testing.T) {
	want := &DeleteAutomatedReasoningPolicyTestCaseOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteAutomatedReasoningPolicyTestCase.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.DeleteAutomatedReasoningPolicyTestCase(context.Background(), &DeleteAutomatedReasoningPolicyTestCaseInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteAutomatedReasoningPolicyTestCase.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteCustomModel(t *testing.T) {
	want := &DeleteCustomModelOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteCustomModel.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.DeleteCustomModel(context.Background(), &DeleteCustomModelInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteCustomModel.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteCustomModelDeployment(t *testing.T) {
	want := &DeleteCustomModelDeploymentOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteCustomModelDeployment.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.DeleteCustomModelDeployment(context.Background(), &DeleteCustomModelDeploymentInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteCustomModelDeployment.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteEnforcedGuardrailConfiguration(t *testing.T) {
	want := &DeleteEnforcedGuardrailConfigurationOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteEnforcedGuardrailConfiguration.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.DeleteEnforcedGuardrailConfiguration(context.Background(), &DeleteEnforcedGuardrailConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteEnforcedGuardrailConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteFoundationModelAgreement(t *testing.T) {
	want := &DeleteFoundationModelAgreementOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteFoundationModelAgreement.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.DeleteFoundationModelAgreement(context.Background(), &DeleteFoundationModelAgreementInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteFoundationModelAgreement.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteGuardrail(t *testing.T) {
	want := &DeleteGuardrailOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteGuardrail.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.DeleteGuardrail(context.Background(), &DeleteGuardrailInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteGuardrail.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteImportedModel(t *testing.T) {
	want := &DeleteImportedModelOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteImportedModel.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.DeleteImportedModel(context.Background(), &DeleteImportedModelInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteImportedModel.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteInferenceProfile(t *testing.T) {
	want := &DeleteInferenceProfileOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteInferenceProfile.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.DeleteInferenceProfile(context.Background(), &DeleteInferenceProfileInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteInferenceProfile.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteMarketplaceModelEndpoint(t *testing.T) {
	want := &DeleteMarketplaceModelEndpointOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteMarketplaceModelEndpoint.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.DeleteMarketplaceModelEndpoint(context.Background(), &DeleteMarketplaceModelEndpointInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteMarketplaceModelEndpoint.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteModelInvocationLoggingConfiguration(t *testing.T) {
	want := &DeleteModelInvocationLoggingConfigurationOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteModelInvocationLoggingConfiguration.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.DeleteModelInvocationLoggingConfiguration(context.Background(), &DeleteModelInvocationLoggingConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteModelInvocationLoggingConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_DeletePromptRouter(t *testing.T) {
	want := &DeletePromptRouterOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeletePromptRouter.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.DeletePromptRouter(context.Background(), &DeletePromptRouterInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeletePromptRouter.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteProvisionedModelThroughput(t *testing.T) {
	want := &DeleteProvisionedModelThroughputOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteProvisionedModelThroughput.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.DeleteProvisionedModelThroughput(context.Background(), &DeleteProvisionedModelThroughputInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteProvisionedModelThroughput.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteResourcePolicy(t *testing.T) {
	want := &DeleteResourcePolicyOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteResourcePolicy.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.DeleteResourcePolicy(context.Background(), &DeleteResourcePolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteResourcePolicy.response", err)
	}
}

func TestCheckResponseSnapshot_DeregisterMarketplaceModelEndpoint(t *testing.T) {
	want := &DeregisterMarketplaceModelEndpointOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeregisterMarketplaceModelEndpoint.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.DeregisterMarketplaceModelEndpoint(context.Background(), &DeregisterMarketplaceModelEndpointInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeregisterMarketplaceModelEndpoint.response", err)
	}
}

func TestCheckResponseSnapshot_ExportAutomatedReasoningPolicyVersion(t *testing.T) {
	want := &ExportAutomatedReasoningPolicyVersionOutput{
		PolicyDefinition: &types.AutomatedReasoningPolicyDefinition{
			Version: ptr.String("__Version__"),
			Types: []types.AutomatedReasoningPolicyDefinitionType{
				{
					Name:        ptr.String("__Name__"),
					Description: ptr.String("__Description__"),
					Values: []types.AutomatedReasoningPolicyDefinitionTypeValue{
						{
							Value:       ptr.String("__Value__"),
							Description: ptr.String("__Description__"),
						},
						{
							Value:       ptr.String("__Value__"),
							Description: ptr.String("__Description__"),
						},
					},
				},
				{
					Name:        ptr.String("__Name__"),
					Description: ptr.String("__Description__"),
					Values: []types.AutomatedReasoningPolicyDefinitionTypeValue{
						{
							Value:       ptr.String("__Value__"),
							Description: ptr.String("__Description__"),
						},
						{
							Value:       ptr.String("__Value__"),
							Description: ptr.String("__Description__"),
						},
					},
				},
			},
			Rules: []types.AutomatedReasoningPolicyDefinitionRule{
				{
					Id:                  ptr.String("__Id__"),
					Expression:          ptr.String("__Expression__"),
					AlternateExpression: ptr.String("__AlternateExpression__"),
				},
				{
					Id:                  ptr.String("__Id__"),
					Expression:          ptr.String("__Expression__"),
					AlternateExpression: ptr.String("__AlternateExpression__"),
				},
			},
			Variables: []types.AutomatedReasoningPolicyDefinitionVariable{
				{
					Name:        ptr.String("__Name__"),
					Type:        ptr.String("__Type__"),
					Description: ptr.String("__Description__"),
				},
				{
					Name:        ptr.String("__Name__"),
					Type:        ptr.String("__Type__"),
					Description: ptr.String("__Description__"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ExportAutomatedReasoningPolicyVersion.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.ExportAutomatedReasoningPolicyVersion(context.Background(), &ExportAutomatedReasoningPolicyVersionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ExportAutomatedReasoningPolicyVersion.response", err)
	}
}

func TestCheckResponseSnapshot_GetAccountDataRetention(t *testing.T) {
	want := &GetAccountDataRetentionOutput{
		Mode:      types.DataRetentionMode("default"),
		UpdatedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("GetAccountDataRetention.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.GetAccountDataRetention(context.Background(), &GetAccountDataRetentionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetAccountDataRetention.response", err)
	}
}

func TestCheckResponseSnapshot_GetAdvancedPromptOptimizationJob(t *testing.T) {
	want := &GetAdvancedPromptOptimizationJobOutput{
		JobArn:         ptr.String("__JobArn__"),
		JobName:        ptr.String("__JobName__"),
		JobDescription: ptr.String("__JobDescription__"),
		JobStatus:      types.AdvancedPromptOptimizationJobStatus("InProgress"),
		InputConfig: &types.AdvancedPromptOptimizationInputConfig{
			S3Uri: ptr.String("__S3Uri__"),
		},
		OutputConfig: &types.AdvancedPromptOptimizationOutputConfig{
			S3Uri: ptr.String("__S3Uri__"),
		},
		EncryptionKeyArn: ptr.String("__EncryptionKeyArn__"),
		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)),
		FailureMessage:   ptr.String("__FailureMessage__"),
		ModelConfigurations: []types.ModelConfiguration{
			{
				ModelId: ptr.String("__ModelId__"),
				InferenceConfig: &types.InferenceConfiguration{
					MaxTokens:   ptr.Int32(1),
					Temperature: ptr.Float32(1.0),
					TopP:        ptr.Float32(1.0),
					StopSequences: []string{
						"__Member__",
						"__Member__",
					},
				},
				AdditionalModelRequestFields: map[string]document.Interface{
					"key0": nil,
				},
			},
			{
				ModelId: ptr.String("__ModelId__"),
				InferenceConfig: &types.InferenceConfiguration{
					MaxTokens:   ptr.Int32(1),
					Temperature: ptr.Float32(1.0),
					TopP:        ptr.Float32(1.0),
					StopSequences: []string{
						"__Member__",
						"__Member__",
					},
				},
				AdditionalModelRequestFields: map[string]document.Interface{
					"key0": nil,
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetAdvancedPromptOptimizationJob.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.GetAdvancedPromptOptimizationJob(context.Background(), &GetAdvancedPromptOptimizationJobInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetAdvancedPromptOptimizationJob.response", err)
	}
}

func TestCheckResponseSnapshot_GetAutomatedReasoningPolicy(t *testing.T) {
	want := &GetAutomatedReasoningPolicyOutput{
		PolicyArn:      ptr.String("__PolicyArn__"),
		Name:           ptr.String("__Name__"),
		Version:        ptr.String("__Version__"),
		PolicyId:       ptr.String("__PolicyId__"),
		Description:    ptr.String("__Description__"),
		DefinitionHash: ptr.String("__DefinitionHash__"),
		KmsKeyArn:      ptr.String("__KmsKeyArn__"),
		CreatedAt:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		UpdatedAt:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("GetAutomatedReasoningPolicy.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.GetAutomatedReasoningPolicy(context.Background(), &GetAutomatedReasoningPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetAutomatedReasoningPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_GetAutomatedReasoningPolicyAnnotations(t *testing.T) {
	want := &GetAutomatedReasoningPolicyAnnotationsOutput{
		PolicyArn:       ptr.String("__PolicyArn__"),
		Name:            ptr.String("__Name__"),
		BuildWorkflowId: ptr.String("__BuildWorkflowId__"),
		Annotations: []types.AutomatedReasoningPolicyAnnotation{
			&types.AutomatedReasoningPolicyAnnotationMemberAddType{
				Value: types.AutomatedReasoningPolicyAddTypeAnnotation{
					Name:        ptr.String("__Name__"),
					Description: ptr.String("__Description__"),
					Values: []types.AutomatedReasoningPolicyDefinitionTypeValue{
						{
							Value:       ptr.String("__Value__"),
							Description: ptr.String("__Description__"),
						},
						{
							Value:       ptr.String("__Value__"),
							Description: ptr.String("__Description__"),
						},
					},
				},
			},
			&types.AutomatedReasoningPolicyAnnotationMemberAddType{
				Value: types.AutomatedReasoningPolicyAddTypeAnnotation{
					Name:        ptr.String("__Name__"),
					Description: ptr.String("__Description__"),
					Values: []types.AutomatedReasoningPolicyDefinitionTypeValue{
						{
							Value:       ptr.String("__Value__"),
							Description: ptr.String("__Description__"),
						},
						{
							Value:       ptr.String("__Value__"),
							Description: ptr.String("__Description__"),
						},
					},
				},
			},
		},
		AnnotationSetHash: ptr.String("__AnnotationSetHash__"),
		UpdatedAt:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("GetAutomatedReasoningPolicyAnnotations.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.GetAutomatedReasoningPolicyAnnotations(context.Background(), &GetAutomatedReasoningPolicyAnnotationsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetAutomatedReasoningPolicyAnnotations.response", err)
	}
}

func TestCheckResponseSnapshot_GetAutomatedReasoningPolicyBuildWorkflow(t *testing.T) {
	want := &GetAutomatedReasoningPolicyBuildWorkflowOutput{
		PolicyArn:           ptr.String("__PolicyArn__"),
		BuildWorkflowId:     ptr.String("__BuildWorkflowId__"),
		Status:              types.AutomatedReasoningPolicyBuildWorkflowStatus("SCHEDULED"),
		BuildWorkflowType:   types.AutomatedReasoningPolicyBuildWorkflowType("INGEST_CONTENT"),
		DocumentName:        ptr.String("__DocumentName__"),
		DocumentContentType: types.AutomatedReasoningPolicyBuildDocumentContentType("pdf"),
		DocumentDescription: ptr.String("__DocumentDescription__"),
		CreatedAt:           ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		UpdatedAt:           ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("GetAutomatedReasoningPolicyBuildWorkflow.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.GetAutomatedReasoningPolicyBuildWorkflow(context.Background(), &GetAutomatedReasoningPolicyBuildWorkflowInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetAutomatedReasoningPolicyBuildWorkflow.response", err)
	}
}

func TestCheckResponseSnapshot_GetAutomatedReasoningPolicyBuildWorkflowResultAssets(t *testing.T) {
	want := &GetAutomatedReasoningPolicyBuildWorkflowResultAssetsOutput{
		PolicyArn:       ptr.String("__PolicyArn__"),
		BuildWorkflowId: ptr.String("__BuildWorkflowId__"),
		BuildWorkflowAssets: &types.AutomatedReasoningPolicyBuildResultAssetsMemberPolicyDefinition{
			Value: types.AutomatedReasoningPolicyDefinition{
				Version: ptr.String("__Version__"),
				Types: []types.AutomatedReasoningPolicyDefinitionType{
					{
						Name:        ptr.String("__Name__"),
						Description: ptr.String("__Description__"),
						Values: []types.AutomatedReasoningPolicyDefinitionTypeValue{
							{
								Value:       ptr.String("__Value__"),
								Description: ptr.String("__Description__"),
							},
							{
								Value:       ptr.String("__Value__"),
								Description: ptr.String("__Description__"),
							},
						},
					},
					{
						Name:        ptr.String("__Name__"),
						Description: ptr.String("__Description__"),
						Values: []types.AutomatedReasoningPolicyDefinitionTypeValue{
							{
								Value:       ptr.String("__Value__"),
								Description: ptr.String("__Description__"),
							},
							{
								Value:       ptr.String("__Value__"),
								Description: ptr.String("__Description__"),
							},
						},
					},
				},
				Rules: []types.AutomatedReasoningPolicyDefinitionRule{
					{
						Id:                  ptr.String("__Id__"),
						Expression:          ptr.String("__Expression__"),
						AlternateExpression: ptr.String("__AlternateExpression__"),
					},
					{
						Id:                  ptr.String("__Id__"),
						Expression:          ptr.String("__Expression__"),
						AlternateExpression: ptr.String("__AlternateExpression__"),
					},
				},
				Variables: []types.AutomatedReasoningPolicyDefinitionVariable{
					{
						Name:        ptr.String("__Name__"),
						Type:        ptr.String("__Type__"),
						Description: ptr.String("__Description__"),
					},
					{
						Name:        ptr.String("__Name__"),
						Type:        ptr.String("__Type__"),
						Description: ptr.String("__Description__"),
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetAutomatedReasoningPolicyBuildWorkflowResultAssets.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.GetAutomatedReasoningPolicyBuildWorkflowResultAssets(context.Background(), &GetAutomatedReasoningPolicyBuildWorkflowResultAssetsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetAutomatedReasoningPolicyBuildWorkflowResultAssets.response", err)
	}
}

func TestCheckResponseSnapshot_GetAutomatedReasoningPolicyNextScenario(t *testing.T) {
	want := &GetAutomatedReasoningPolicyNextScenarioOutput{
		PolicyArn: ptr.String("__PolicyArn__"),
		Scenario: &types.AutomatedReasoningPolicyScenario{
			Expression:          ptr.String("__Expression__"),
			AlternateExpression: ptr.String("__AlternateExpression__"),
			ExpectedResult:      types.AutomatedReasoningCheckResult("VALID"),
			RuleIds: []string{
				"__Member__",
				"__Member__",
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetAutomatedReasoningPolicyNextScenario.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.GetAutomatedReasoningPolicyNextScenario(context.Background(), &GetAutomatedReasoningPolicyNextScenarioInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetAutomatedReasoningPolicyNextScenario.response", err)
	}
}

func TestCheckResponseSnapshot_GetAutomatedReasoningPolicyTestCase(t *testing.T) {
	want := &GetAutomatedReasoningPolicyTestCaseOutput{
		PolicyArn: ptr.String("__PolicyArn__"),
		TestCase: &types.AutomatedReasoningPolicyTestCase{
			TestCaseId:                       ptr.String("__TestCaseId__"),
			GuardContent:                     ptr.String("__GuardContent__"),
			QueryContent:                     ptr.String("__QueryContent__"),
			ExpectedAggregatedFindingsResult: types.AutomatedReasoningCheckResult("VALID"),
			CreatedAt:                        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			UpdatedAt:                        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			ConfidenceThreshold:              ptr.Float64(1.0),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetAutomatedReasoningPolicyTestCase.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.GetAutomatedReasoningPolicyTestCase(context.Background(), &GetAutomatedReasoningPolicyTestCaseInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetAutomatedReasoningPolicyTestCase.response", err)
	}
}

func TestCheckResponseSnapshot_GetAutomatedReasoningPolicyTestResult(t *testing.T) {
	want := &GetAutomatedReasoningPolicyTestResultOutput{
		TestResult: &types.AutomatedReasoningPolicyTestResult{
			TestCase: &types.AutomatedReasoningPolicyTestCase{
				TestCaseId:                       ptr.String("__TestCaseId__"),
				GuardContent:                     ptr.String("__GuardContent__"),
				QueryContent:                     ptr.String("__QueryContent__"),
				ExpectedAggregatedFindingsResult: types.AutomatedReasoningCheckResult("VALID"),
				CreatedAt:                        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedAt:                        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ConfidenceThreshold:              ptr.Float64(1.0),
			},
			PolicyArn:     ptr.String("__PolicyArn__"),
			TestRunStatus: types.AutomatedReasoningPolicyTestRunStatus("NOT_STARTED"),
			TestFindings: []types.AutomatedReasoningCheckFinding{
				&types.AutomatedReasoningCheckFindingMemberValid{
					Value: types.AutomatedReasoningCheckValidFinding{
						Translation: &types.AutomatedReasoningCheckTranslation{
							Premises: []types.AutomatedReasoningLogicStatement{
								{
									Logic:           ptr.String("__Logic__"),
									NaturalLanguage: ptr.String("__NaturalLanguage__"),
								},
								{
									Logic:           ptr.String("__Logic__"),
									NaturalLanguage: ptr.String("__NaturalLanguage__"),
								},
							},
							Claims: []types.AutomatedReasoningLogicStatement{
								{
									Logic:           ptr.String("__Logic__"),
									NaturalLanguage: ptr.String("__NaturalLanguage__"),
								},
								{
									Logic:           ptr.String("__Logic__"),
									NaturalLanguage: ptr.String("__NaturalLanguage__"),
								},
							},
							UntranslatedPremises: []types.AutomatedReasoningCheckInputTextReference{
								{
									Text: ptr.String("__Text__"),
								},
								{
									Text: ptr.String("__Text__"),
								},
							},
							UntranslatedClaims: []types.AutomatedReasoningCheckInputTextReference{
								{
									Text: ptr.String("__Text__"),
								},
								{
									Text: ptr.String("__Text__"),
								},
							},
							Confidence: ptr.Float64(1.0),
						},
						ClaimsTrueScenario: &types.AutomatedReasoningCheckScenario{
							Statements: []types.AutomatedReasoningLogicStatement{
								{
									Logic:           ptr.String("__Logic__"),
									NaturalLanguage: ptr.String("__NaturalLanguage__"),
								},
								{
									Logic:           ptr.String("__Logic__"),
									NaturalLanguage: ptr.String("__NaturalLanguage__"),
								},
							},
						},
						SupportingRules: []types.AutomatedReasoningCheckRule{
							{
								Id:               ptr.String("__Id__"),
								PolicyVersionArn: ptr.String("__PolicyVersionArn__"),
							},
							{
								Id:               ptr.String("__Id__"),
								PolicyVersionArn: ptr.String("__PolicyVersionArn__"),
							},
						},
						LogicWarning: &types.AutomatedReasoningCheckLogicWarning{
							Type: types.AutomatedReasoningCheckLogicWarningType("ALWAYS_TRUE"),
							Premises: []types.AutomatedReasoningLogicStatement{
								{
									Logic:           ptr.String("__Logic__"),
									NaturalLanguage: ptr.String("__NaturalLanguage__"),
								},
								{
									Logic:           ptr.String("__Logic__"),
									NaturalLanguage: ptr.String("__NaturalLanguage__"),
								},
							},
							Claims: []types.AutomatedReasoningLogicStatement{
								{
									Logic:           ptr.String("__Logic__"),
									NaturalLanguage: ptr.String("__NaturalLanguage__"),
								},
								{
									Logic:           ptr.String("__Logic__"),
									NaturalLanguage: ptr.String("__NaturalLanguage__"),
								},
							},
						},
					},
				},
				&types.AutomatedReasoningCheckFindingMemberValid{
					Value: types.AutomatedReasoningCheckValidFinding{
						Translation: &types.AutomatedReasoningCheckTranslation{
							Premises: []types.AutomatedReasoningLogicStatement{
								{
									Logic:           ptr.String("__Logic__"),
									NaturalLanguage: ptr.String("__NaturalLanguage__"),
								},
								{
									Logic:           ptr.String("__Logic__"),
									NaturalLanguage: ptr.String("__NaturalLanguage__"),
								},
							},
							Claims: []types.AutomatedReasoningLogicStatement{
								{
									Logic:           ptr.String("__Logic__"),
									NaturalLanguage: ptr.String("__NaturalLanguage__"),
								},
								{
									Logic:           ptr.String("__Logic__"),
									NaturalLanguage: ptr.String("__NaturalLanguage__"),
								},
							},
							UntranslatedPremises: []types.AutomatedReasoningCheckInputTextReference{
								{
									Text: ptr.String("__Text__"),
								},
								{
									Text: ptr.String("__Text__"),
								},
							},
							UntranslatedClaims: []types.AutomatedReasoningCheckInputTextReference{
								{
									Text: ptr.String("__Text__"),
								},
								{
									Text: ptr.String("__Text__"),
								},
							},
							Confidence: ptr.Float64(1.0),
						},
						ClaimsTrueScenario: &types.AutomatedReasoningCheckScenario{
							Statements: []types.AutomatedReasoningLogicStatement{
								{
									Logic:           ptr.String("__Logic__"),
									NaturalLanguage: ptr.String("__NaturalLanguage__"),
								},
								{
									Logic:           ptr.String("__Logic__"),
									NaturalLanguage: ptr.String("__NaturalLanguage__"),
								},
							},
						},
						SupportingRules: []types.AutomatedReasoningCheckRule{
							{
								Id:               ptr.String("__Id__"),
								PolicyVersionArn: ptr.String("__PolicyVersionArn__"),
							},
							{
								Id:               ptr.String("__Id__"),
								PolicyVersionArn: ptr.String("__PolicyVersionArn__"),
							},
						},
						LogicWarning: &types.AutomatedReasoningCheckLogicWarning{
							Type: types.AutomatedReasoningCheckLogicWarningType("ALWAYS_TRUE"),
							Premises: []types.AutomatedReasoningLogicStatement{
								{
									Logic:           ptr.String("__Logic__"),
									NaturalLanguage: ptr.String("__NaturalLanguage__"),
								},
								{
									Logic:           ptr.String("__Logic__"),
									NaturalLanguage: ptr.String("__NaturalLanguage__"),
								},
							},
							Claims: []types.AutomatedReasoningLogicStatement{
								{
									Logic:           ptr.String("__Logic__"),
									NaturalLanguage: ptr.String("__NaturalLanguage__"),
								},
								{
									Logic:           ptr.String("__Logic__"),
									NaturalLanguage: ptr.String("__NaturalLanguage__"),
								},
							},
						},
					},
				},
			},
			TestRunResult:                types.AutomatedReasoningPolicyTestRunResult("PASSED"),
			AggregatedTestFindingsResult: types.AutomatedReasoningCheckResult("VALID"),
			UpdatedAt:                    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetAutomatedReasoningPolicyTestResult.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.GetAutomatedReasoningPolicyTestResult(context.Background(), &GetAutomatedReasoningPolicyTestResultInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetAutomatedReasoningPolicyTestResult.response", err)
	}
}

func TestCheckResponseSnapshot_GetCustomModel(t *testing.T) {
	want := &GetCustomModelOutput{
		ModelArn:          ptr.String("__ModelArn__"),
		ModelName:         ptr.String("__ModelName__"),
		JobName:           ptr.String("__JobName__"),
		JobArn:            ptr.String("__JobArn__"),
		BaseModelArn:      ptr.String("__BaseModelArn__"),
		CustomizationType: types.CustomizationType("FINE_TUNING"),
		ModelKmsKeyArn:    ptr.String("__ModelKmsKeyArn__"),
		HyperParameters: map[string]string{
			"key0": "__Value__",
		},
		TrainingDataConfig: &types.TrainingDataConfig{
			S3Uri: ptr.String("__S3Uri__"),
			InvocationLogsConfig: &types.InvocationLogsConfig{
				UsePromptResponse: true,
				InvocationLogSource: &types.InvocationLogSourceMemberS3Uri{
					Value: "__InvocationLogSourceMemberS3Uri__",
				},
				RequestMetadataFilters: &types.RequestMetadataFiltersMemberEquals{
					Value: map[string]string{
						"key0": "__Value__",
					},
				},
			},
		},
		ValidationDataConfig: &types.ValidationDataConfig{
			Validators: []types.Validator{
				{
					S3Uri: ptr.String("__S3Uri__"),
				},
				{
					S3Uri: ptr.String("__S3Uri__"),
				},
			},
		},
		OutputDataConfig: &types.OutputDataConfig{
			S3Uri: ptr.String("__S3Uri__"),
		},
		TrainingMetrics: &types.TrainingMetrics{
			TrainingLoss: ptr.Float32(1.0),
		},
		ValidationMetrics: []types.ValidatorMetric{
			{
				ValidationLoss: ptr.Float32(1.0),
			},
			{
				ValidationLoss: ptr.Float32(1.0),
			},
		},
		CreationTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		CustomizationConfig: &types.CustomizationConfigMemberDistillationConfig{
			Value: types.DistillationConfig{
				TeacherModelConfig: &types.TeacherModelConfig{
					TeacherModelIdentifier:        ptr.String("__TeacherModelIdentifier__"),
					MaxResponseLengthForInference: ptr.Int32(1),
				},
			},
		},
		ModelStatus:    types.ModelStatus("Active"),
		FailureMessage: ptr.String("__FailureMessage__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetCustomModel.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.GetCustomModel(context.Background(), &GetCustomModelInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetCustomModel.response", err)
	}
}

func TestCheckResponseSnapshot_GetCustomModelDeployment(t *testing.T) {
	want := &GetCustomModelDeploymentOutput{
		CustomModelDeploymentArn: ptr.String("__CustomModelDeploymentArn__"),
		ModelDeploymentName:      ptr.String("__ModelDeploymentName__"),
		ModelArn:                 ptr.String("__ModelArn__"),
		CreatedAt:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		Status:                   types.CustomModelDeploymentStatus("Creating"),
		Description:              ptr.String("__Description__"),
		UpdateDetails: &types.CustomModelDeploymentUpdateDetails{
			ModelArn:     ptr.String("__ModelArn__"),
			UpdateStatus: types.CustomModelDeploymentUpdateStatus("Updating"),
		},
		FailureMessage: ptr.String("__FailureMessage__"),
		LastUpdatedAt:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("GetCustomModelDeployment.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.GetCustomModelDeployment(context.Background(), &GetCustomModelDeploymentInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetCustomModelDeployment.response", err)
	}
}

func TestCheckResponseSnapshot_GetEvaluationJob(t *testing.T) {
	want := &GetEvaluationJobOutput{
		JobName:                 ptr.String("__JobName__"),
		Status:                  types.EvaluationJobStatus("InProgress"),
		JobArn:                  ptr.String("__JobArn__"),
		JobDescription:          ptr.String("__JobDescription__"),
		RoleArn:                 ptr.String("__RoleArn__"),
		CustomerEncryptionKeyId: ptr.String("__CustomerEncryptionKeyId__"),
		JobType:                 types.EvaluationJobType("Human"),
		ApplicationType:         types.ApplicationType("ModelEvaluation"),
		EvaluationConfig: &types.EvaluationConfigMemberAutomated{
			Value: types.AutomatedEvaluationConfig{
				DatasetMetricConfigs: []types.EvaluationDatasetMetricConfig{
					{
						TaskType: types.EvaluationTaskType("Summarization"),
						Dataset: &types.EvaluationDataset{
							Name: ptr.String("__Name__"),
							DatasetLocation: &types.EvaluationDatasetLocationMemberS3Uri{
								Value: "__EvaluationDatasetLocationMemberS3Uri__",
							},
						},
						MetricNames: []string{
							"__Member__",
							"__Member__",
						},
					},
					{
						TaskType: types.EvaluationTaskType("Summarization"),
						Dataset: &types.EvaluationDataset{
							Name: ptr.String("__Name__"),
							DatasetLocation: &types.EvaluationDatasetLocationMemberS3Uri{
								Value: "__EvaluationDatasetLocationMemberS3Uri__",
							},
						},
						MetricNames: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
				EvaluatorModelConfig: &types.EvaluatorModelConfigMemberBedrockEvaluatorModels{
					Value: []types.BedrockEvaluatorModel{
						{
							ModelIdentifier: ptr.String("__ModelIdentifier__"),
						},
						{
							ModelIdentifier: ptr.String("__ModelIdentifier__"),
						},
					},
				},
				CustomMetricConfig: &types.AutomatedEvaluationCustomMetricConfig{
					CustomMetrics: []types.AutomatedEvaluationCustomMetricSource{
						&types.AutomatedEvaluationCustomMetricSourceMemberCustomMetricDefinition{
							Value: types.CustomMetricDefinition{
								Name:         ptr.String("__Name__"),
								Instructions: ptr.String("__Instructions__"),
								RatingScale: []types.RatingScaleItem{
									{
										Definition: ptr.String("__Definition__"),
										Value: &types.RatingScaleItemValueMemberStringValue{
											Value: "__RatingScaleItemValueMemberStringValue__",
										},
									},
									{
										Definition: ptr.String("__Definition__"),
										Value: &types.RatingScaleItemValueMemberStringValue{
											Value: "__RatingScaleItemValueMemberStringValue__",
										},
									},
								},
							},
						},
						&types.AutomatedEvaluationCustomMetricSourceMemberCustomMetricDefinition{
							Value: types.CustomMetricDefinition{
								Name:         ptr.String("__Name__"),
								Instructions: ptr.String("__Instructions__"),
								RatingScale: []types.RatingScaleItem{
									{
										Definition: ptr.String("__Definition__"),
										Value: &types.RatingScaleItemValueMemberStringValue{
											Value: "__RatingScaleItemValueMemberStringValue__",
										},
									},
									{
										Definition: ptr.String("__Definition__"),
										Value: &types.RatingScaleItemValueMemberStringValue{
											Value: "__RatingScaleItemValueMemberStringValue__",
										},
									},
								},
							},
						},
					},
					EvaluatorModelConfig: &types.CustomMetricEvaluatorModelConfig{
						BedrockEvaluatorModels: []types.CustomMetricBedrockEvaluatorModel{
							{
								ModelIdentifier: ptr.String("__ModelIdentifier__"),
							},
							{
								ModelIdentifier: ptr.String("__ModelIdentifier__"),
							},
						},
					},
				},
			},
		},
		InferenceConfig: &types.EvaluationInferenceConfigMemberModels{
			Value: []types.EvaluationModelConfig{
				&types.EvaluationModelConfigMemberBedrockModel{
					Value: types.EvaluationBedrockModel{
						ModelIdentifier: ptr.String("__ModelIdentifier__"),
						InferenceParams: ptr.String("__InferenceParams__"),
						PerformanceConfig: &types.PerformanceConfiguration{
							Latency: types.PerformanceConfigLatency("standard"),
						},
					},
				},
				&types.EvaluationModelConfigMemberBedrockModel{
					Value: types.EvaluationBedrockModel{
						ModelIdentifier: ptr.String("__ModelIdentifier__"),
						InferenceParams: ptr.String("__InferenceParams__"),
						PerformanceConfig: &types.PerformanceConfiguration{
							Latency: types.PerformanceConfigLatency("standard"),
						},
					},
				},
			},
		},
		OutputDataConfig: &types.EvaluationOutputDataConfig{
			S3Uri: ptr.String("__S3Uri__"),
		},
		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)),
		FailureMessages: []string{
			"__Member__",
			"__Member__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetEvaluationJob.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.GetEvaluationJob(context.Background(), &GetEvaluationJobInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetEvaluationJob.response", err)
	}
}

func TestCheckResponseSnapshot_GetFoundationModel(t *testing.T) {
	want := &GetFoundationModelOutput{
		ModelDetails: &types.FoundationModelDetails{
			ModelArn:     ptr.String("__ModelArn__"),
			ModelId:      ptr.String("__ModelId__"),
			ModelName:    ptr.String("__ModelName__"),
			ProviderName: ptr.String("__ProviderName__"),
			InputModalities: []types.ModelModality{
				types.ModelModality("TEXT"),
				types.ModelModality("TEXT"),
			},
			OutputModalities: []types.ModelModality{
				types.ModelModality("TEXT"),
				types.ModelModality("TEXT"),
			},
			ResponseStreamingSupported: ptr.Bool(true),
			CustomizationsSupported: []types.ModelCustomization{
				types.ModelCustomization("FINE_TUNING"),
				types.ModelCustomization("FINE_TUNING"),
			},
			InferenceTypesSupported: []types.InferenceType{
				types.InferenceType("ON_DEMAND"),
				types.InferenceType("ON_DEMAND"),
			},
			ModelLifecycle: &types.FoundationModelLifecycle{
				Status:                   types.FoundationModelLifecycleStatus("ACTIVE"),
				StartOfLifeTime:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				EndOfLifeTime:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LegacyTime:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PublicExtendedAccessTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetFoundationModel.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.GetFoundationModel(context.Background(), &GetFoundationModelInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetFoundationModel.response", err)
	}
}

func TestCheckResponseSnapshot_GetFoundationModelAvailability(t *testing.T) {
	want := &GetFoundationModelAvailabilityOutput{
		ModelId: ptr.String("__ModelId__"),
		AgreementAvailability: &types.AgreementAvailability{
			Status:       types.AgreementStatus("AVAILABLE"),
			ErrorMessage: ptr.String("__ErrorMessage__"),
		},
		AuthorizationStatus:     types.AuthorizationStatus("AUTHORIZED"),
		EntitlementAvailability: types.EntitlementAvailability("AVAILABLE"),
		RegionAvailability:      types.RegionAvailability("AVAILABLE"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetFoundationModelAvailability.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.GetFoundationModelAvailability(context.Background(), &GetFoundationModelAvailabilityInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetFoundationModelAvailability.response", err)
	}
}

func TestCheckResponseSnapshot_GetGuardrail(t *testing.T) {
	want := &GetGuardrailOutput{
		Name:         ptr.String("__Name__"),
		Description:  ptr.String("__Description__"),
		GuardrailId:  ptr.String("__GuardrailId__"),
		GuardrailArn: ptr.String("__GuardrailArn__"),
		Version:      ptr.String("__Version__"),
		Status:       types.GuardrailStatus("CREATING"),
		TopicPolicy: &types.GuardrailTopicPolicy{
			Topics: []types.GuardrailTopic{
				{
					Name:       ptr.String("__Name__"),
					Definition: ptr.String("__Definition__"),
					Examples: []string{
						"__Member__",
						"__Member__",
					},
					Type:          types.GuardrailTopicType("DENY"),
					InputAction:   types.GuardrailTopicAction("BLOCK"),
					OutputAction:  types.GuardrailTopicAction("BLOCK"),
					InputEnabled:  ptr.Bool(true),
					OutputEnabled: ptr.Bool(true),
				},
				{
					Name:       ptr.String("__Name__"),
					Definition: ptr.String("__Definition__"),
					Examples: []string{
						"__Member__",
						"__Member__",
					},
					Type:          types.GuardrailTopicType("DENY"),
					InputAction:   types.GuardrailTopicAction("BLOCK"),
					OutputAction:  types.GuardrailTopicAction("BLOCK"),
					InputEnabled:  ptr.Bool(true),
					OutputEnabled: ptr.Bool(true),
				},
			},
			Tier: &types.GuardrailTopicsTier{
				TierName: types.GuardrailTopicsTierName("CLASSIC"),
			},
		},
		ContentPolicy: &types.GuardrailContentPolicy{
			Filters: []types.GuardrailContentFilter{
				{
					Type:           types.GuardrailContentFilterType("SEXUAL"),
					InputStrength:  types.GuardrailFilterStrength("NONE"),
					OutputStrength: types.GuardrailFilterStrength("NONE"),
					InputModalities: []types.GuardrailModality{
						types.GuardrailModality("TEXT"),
						types.GuardrailModality("TEXT"),
					},
					OutputModalities: []types.GuardrailModality{
						types.GuardrailModality("TEXT"),
						types.GuardrailModality("TEXT"),
					},
					InputAction:   types.GuardrailContentFilterAction("BLOCK"),
					OutputAction:  types.GuardrailContentFilterAction("BLOCK"),
					InputEnabled:  ptr.Bool(true),
					OutputEnabled: ptr.Bool(true),
				},
				{
					Type:           types.GuardrailContentFilterType("SEXUAL"),
					InputStrength:  types.GuardrailFilterStrength("NONE"),
					OutputStrength: types.GuardrailFilterStrength("NONE"),
					InputModalities: []types.GuardrailModality{
						types.GuardrailModality("TEXT"),
						types.GuardrailModality("TEXT"),
					},
					OutputModalities: []types.GuardrailModality{
						types.GuardrailModality("TEXT"),
						types.GuardrailModality("TEXT"),
					},
					InputAction:   types.GuardrailContentFilterAction("BLOCK"),
					OutputAction:  types.GuardrailContentFilterAction("BLOCK"),
					InputEnabled:  ptr.Bool(true),
					OutputEnabled: ptr.Bool(true),
				},
			},
			Tier: &types.GuardrailContentFiltersTier{
				TierName: types.GuardrailContentFiltersTierName("CLASSIC"),
			},
		},
		WordPolicy: &types.GuardrailWordPolicy{
			Words: []types.GuardrailWord{
				{
					Text:          ptr.String("__Text__"),
					InputAction:   types.GuardrailWordAction("BLOCK"),
					OutputAction:  types.GuardrailWordAction("BLOCK"),
					InputEnabled:  ptr.Bool(true),
					OutputEnabled: ptr.Bool(true),
				},
				{
					Text:          ptr.String("__Text__"),
					InputAction:   types.GuardrailWordAction("BLOCK"),
					OutputAction:  types.GuardrailWordAction("BLOCK"),
					InputEnabled:  ptr.Bool(true),
					OutputEnabled: ptr.Bool(true),
				},
			},
			ManagedWordLists: []types.GuardrailManagedWords{
				{
					Type:          types.GuardrailManagedWordsType("PROFANITY"),
					InputAction:   types.GuardrailWordAction("BLOCK"),
					OutputAction:  types.GuardrailWordAction("BLOCK"),
					InputEnabled:  ptr.Bool(true),
					OutputEnabled: ptr.Bool(true),
				},
				{
					Type:          types.GuardrailManagedWordsType("PROFANITY"),
					InputAction:   types.GuardrailWordAction("BLOCK"),
					OutputAction:  types.GuardrailWordAction("BLOCK"),
					InputEnabled:  ptr.Bool(true),
					OutputEnabled: ptr.Bool(true),
				},
			},
		},
		SensitiveInformationPolicy: &types.GuardrailSensitiveInformationPolicy{
			PiiEntities: []types.GuardrailPiiEntity{
				{
					Type:          types.GuardrailPiiEntityType("ADDRESS"),
					Action:        types.GuardrailSensitiveInformationAction("BLOCK"),
					InputAction:   types.GuardrailSensitiveInformationAction("BLOCK"),
					OutputAction:  types.GuardrailSensitiveInformationAction("BLOCK"),
					InputEnabled:  ptr.Bool(true),
					OutputEnabled: ptr.Bool(true),
				},
				{
					Type:          types.GuardrailPiiEntityType("ADDRESS"),
					Action:        types.GuardrailSensitiveInformationAction("BLOCK"),
					InputAction:   types.GuardrailSensitiveInformationAction("BLOCK"),
					OutputAction:  types.GuardrailSensitiveInformationAction("BLOCK"),
					InputEnabled:  ptr.Bool(true),
					OutputEnabled: ptr.Bool(true),
				},
			},
			Regexes: []types.GuardrailRegex{
				{
					Name:          ptr.String("__Name__"),
					Description:   ptr.String("__Description__"),
					Pattern:       ptr.String("__Pattern__"),
					Action:        types.GuardrailSensitiveInformationAction("BLOCK"),
					InputAction:   types.GuardrailSensitiveInformationAction("BLOCK"),
					OutputAction:  types.GuardrailSensitiveInformationAction("BLOCK"),
					InputEnabled:  ptr.Bool(true),
					OutputEnabled: ptr.Bool(true),
				},
				{
					Name:          ptr.String("__Name__"),
					Description:   ptr.String("__Description__"),
					Pattern:       ptr.String("__Pattern__"),
					Action:        types.GuardrailSensitiveInformationAction("BLOCK"),
					InputAction:   types.GuardrailSensitiveInformationAction("BLOCK"),
					OutputAction:  types.GuardrailSensitiveInformationAction("BLOCK"),
					InputEnabled:  ptr.Bool(true),
					OutputEnabled: ptr.Bool(true),
				},
			},
		},
		ContextualGroundingPolicy: &types.GuardrailContextualGroundingPolicy{
			Filters: []types.GuardrailContextualGroundingFilter{
				{
					Type:      types.GuardrailContextualGroundingFilterType("GROUNDING"),
					Threshold: ptr.Float64(1.0),
					Action:    types.GuardrailContextualGroundingAction("BLOCK"),
					Enabled:   ptr.Bool(true),
				},
				{
					Type:      types.GuardrailContextualGroundingFilterType("GROUNDING"),
					Threshold: ptr.Float64(1.0),
					Action:    types.GuardrailContextualGroundingAction("BLOCK"),
					Enabled:   ptr.Bool(true),
				},
			},
		},
		AutomatedReasoningPolicy: &types.GuardrailAutomatedReasoningPolicy{
			Policies: []string{
				"__Member__",
				"__Member__",
			},
			ConfidenceThreshold: ptr.Float64(1.0),
		},
		CrossRegionDetails: &types.GuardrailCrossRegionDetails{
			GuardrailProfileId:  ptr.String("__GuardrailProfileId__"),
			GuardrailProfileArn: ptr.String("__GuardrailProfileArn__"),
		},
		CreatedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		UpdatedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		StatusReasons: []string{
			"__Member__",
			"__Member__",
		},
		FailureRecommendations: []string{
			"__Member__",
			"__Member__",
		},
		BlockedInputMessaging:   ptr.String("__BlockedInputMessaging__"),
		BlockedOutputsMessaging: ptr.String("__BlockedOutputsMessaging__"),
		KmsKeyArn:               ptr.String("__KmsKeyArn__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetGuardrail.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.GetGuardrail(context.Background(), &GetGuardrailInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetGuardrail.response", err)
	}
}

func TestCheckResponseSnapshot_GetImportedModel(t *testing.T) {
	want := &GetImportedModelOutput{
		ModelArn:  ptr.String("__ModelArn__"),
		ModelName: ptr.String("__ModelName__"),
		JobName:   ptr.String("__JobName__"),
		JobArn:    ptr.String("__JobArn__"),
		ModelDataSource: &types.ModelDataSourceMemberS3DataSource{
			Value: types.S3DataSource{
				S3Uri: ptr.String("__S3Uri__"),
			},
		},
		CreationTime:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ModelArchitecture: ptr.String("__ModelArchitecture__"),
		ModelKmsKeyArn:    ptr.String("__ModelKmsKeyArn__"),
		InstructSupported: ptr.Bool(true),
		CustomModelUnits: &types.CustomModelUnits{
			CustomModelUnitsPerModelCopy: ptr.Int32(1),
			CustomModelUnitsVersion:      ptr.String("__CustomModelUnitsVersion__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetImportedModel.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.GetImportedModel(context.Background(), &GetImportedModelInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetImportedModel.response", err)
	}
}

func TestCheckResponseSnapshot_GetInferenceProfile(t *testing.T) {
	want := &GetInferenceProfileOutput{
		InferenceProfileName: ptr.String("__InferenceProfileName__"),
		Description:          ptr.String("__Description__"),
		CreatedAt:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		UpdatedAt:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		InferenceProfileArn:  ptr.String("__InferenceProfileArn__"),
		Models: []types.InferenceProfileModel{
			{
				ModelArn: ptr.String("__ModelArn__"),
			},
			{
				ModelArn: ptr.String("__ModelArn__"),
			},
		},
		InferenceProfileId: ptr.String("__InferenceProfileId__"),
		Status:             types.InferenceProfileStatus("ACTIVE"),
		Type:               types.InferenceProfileType("SYSTEM_DEFINED"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetInferenceProfile.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.GetInferenceProfile(context.Background(), &GetInferenceProfileInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetInferenceProfile.response", err)
	}
}

func TestCheckResponseSnapshot_GetMarketplaceModelEndpoint(t *testing.T) {
	want := &GetMarketplaceModelEndpointOutput{
		MarketplaceModelEndpoint: &types.MarketplaceModelEndpoint{
			EndpointArn:           ptr.String("__EndpointArn__"),
			ModelSourceIdentifier: ptr.String("__ModelSourceIdentifier__"),
			Status:                types.Status("REGISTERED"),
			StatusMessage:         ptr.String("__StatusMessage__"),
			CreatedAt:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			UpdatedAt:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			EndpointConfig: &types.EndpointConfigMemberSageMaker{
				Value: types.SageMakerEndpoint{
					InitialInstanceCount: ptr.Int32(1),
					InstanceType:         ptr.String("__InstanceType__"),
					ExecutionRole:        ptr.String("__ExecutionRole__"),
					KmsEncryptionKey:     ptr.String("__KmsEncryptionKey__"),
					Vpc: &types.VpcConfig{
						SubnetIds: []string{
							"__Member__",
							"__Member__",
						},
						SecurityGroupIds: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
			},
			EndpointStatus:        ptr.String("__EndpointStatus__"),
			EndpointStatusMessage: ptr.String("__EndpointStatusMessage__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetMarketplaceModelEndpoint.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.GetMarketplaceModelEndpoint(context.Background(), &GetMarketplaceModelEndpointInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetMarketplaceModelEndpoint.response", err)
	}
}

func TestCheckResponseSnapshot_GetModelCopyJob(t *testing.T) {
	want := &GetModelCopyJobOutput{
		JobArn:               ptr.String("__JobArn__"),
		Status:               types.ModelCopyJobStatus("InProgress"),
		CreationTime:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		TargetModelArn:       ptr.String("__TargetModelArn__"),
		TargetModelName:      ptr.String("__TargetModelName__"),
		SourceAccountId:      ptr.String("__SourceAccountId__"),
		SourceModelArn:       ptr.String("__SourceModelArn__"),
		TargetModelKmsKeyArn: ptr.String("__TargetModelKmsKeyArn__"),
		TargetModelTags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		FailureMessage:  ptr.String("__FailureMessage__"),
		SourceModelName: ptr.String("__SourceModelName__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetModelCopyJob.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.GetModelCopyJob(context.Background(), &GetModelCopyJobInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetModelCopyJob.response", err)
	}
}

func TestCheckResponseSnapshot_GetModelCustomizationJob(t *testing.T) {
	want := &GetModelCustomizationJobOutput{
		JobArn:             ptr.String("__JobArn__"),
		JobName:            ptr.String("__JobName__"),
		OutputModelName:    ptr.String("__OutputModelName__"),
		OutputModelArn:     ptr.String("__OutputModelArn__"),
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		RoleArn:            ptr.String("__RoleArn__"),
		Status:             types.ModelCustomizationJobStatus("InProgress"),
		StatusDetails: &types.StatusDetails{
			ValidationDetails: &types.ValidationDetails{
				Status:           types.JobStatusDetails("InProgress"),
				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)),
			},
			DataProcessingDetails: &types.DataProcessingDetails{
				Status:           types.JobStatusDetails("InProgress"),
				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)),
			},
			TrainingDetails: &types.TrainingDetails{
				Status:           types.JobStatusDetails("InProgress"),
				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)),
			},
		},
		FailureMessage:   ptr.String("__FailureMessage__"),
		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)),
		EndTime:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		BaseModelArn:     ptr.String("__BaseModelArn__"),
		HyperParameters: map[string]string{
			"key0": "__Value__",
		},
		TrainingDataConfig: &types.TrainingDataConfig{
			S3Uri: ptr.String("__S3Uri__"),
			InvocationLogsConfig: &types.InvocationLogsConfig{
				UsePromptResponse: true,
				InvocationLogSource: &types.InvocationLogSourceMemberS3Uri{
					Value: "__InvocationLogSourceMemberS3Uri__",
				},
				RequestMetadataFilters: &types.RequestMetadataFiltersMemberEquals{
					Value: map[string]string{
						"key0": "__Value__",
					},
				},
			},
		},
		ValidationDataConfig: &types.ValidationDataConfig{
			Validators: []types.Validator{
				{
					S3Uri: ptr.String("__S3Uri__"),
				},
				{
					S3Uri: ptr.String("__S3Uri__"),
				},
			},
		},
		OutputDataConfig: &types.OutputDataConfig{
			S3Uri: ptr.String("__S3Uri__"),
		},
		CustomizationType:    types.CustomizationType("FINE_TUNING"),
		OutputModelKmsKeyArn: ptr.String("__OutputModelKmsKeyArn__"),
		TrainingMetrics: &types.TrainingMetrics{
			TrainingLoss: ptr.Float32(1.0),
		},
		ValidationMetrics: []types.ValidatorMetric{
			{
				ValidationLoss: ptr.Float32(1.0),
			},
			{
				ValidationLoss: ptr.Float32(1.0),
			},
		},
		VpcConfig: &types.VpcConfig{
			SubnetIds: []string{
				"__Member__",
				"__Member__",
			},
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
		},
		CustomizationConfig: &types.CustomizationConfigMemberDistillationConfig{
			Value: types.DistillationConfig{
				TeacherModelConfig: &types.TeacherModelConfig{
					TeacherModelIdentifier:        ptr.String("__TeacherModelIdentifier__"),
					MaxResponseLengthForInference: ptr.Int32(1),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetModelCustomizationJob.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.GetModelCustomizationJob(context.Background(), &GetModelCustomizationJobInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetModelCustomizationJob.response", err)
	}
}

func TestCheckResponseSnapshot_GetModelImportJob(t *testing.T) {
	want := &GetModelImportJobOutput{
		JobArn:            ptr.String("__JobArn__"),
		JobName:           ptr.String("__JobName__"),
		ImportedModelName: ptr.String("__ImportedModelName__"),
		ImportedModelArn:  ptr.String("__ImportedModelArn__"),
		RoleArn:           ptr.String("__RoleArn__"),
		ModelDataSource: &types.ModelDataSourceMemberS3DataSource{
			Value: types.S3DataSource{
				S3Uri: ptr.String("__S3Uri__"),
			},
		},
		Status:           types.ModelImportJobStatus("InProgress"),
		FailureMessage:   ptr.String("__FailureMessage__"),
		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)),
		EndTime:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		VpcConfig: &types.VpcConfig{
			SubnetIds: []string{
				"__Member__",
				"__Member__",
			},
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
		},
		ImportedModelKmsKeyArn: ptr.String("__ImportedModelKmsKeyArn__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetModelImportJob.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.GetModelImportJob(context.Background(), &GetModelImportJobInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetModelImportJob.response", err)
	}
}

func TestCheckResponseSnapshot_GetModelInvocationJob(t *testing.T) {
	want := &GetModelInvocationJobOutput{
		JobArn:             ptr.String("__JobArn__"),
		JobName:            ptr.String("__JobName__"),
		ModelId:            ptr.String("__ModelId__"),
		ClientRequestToken: ptr.String("__ClientRequestToken__"),
		RoleArn:            ptr.String("__RoleArn__"),
		Status:             types.ModelInvocationJobStatus("Submitted"),
		Message:            ptr.String("__Message__"),
		SubmitTime:         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)),
		EndTime:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		InputDataConfig: &types.ModelInvocationJobInputDataConfigMemberS3InputDataConfig{
			Value: types.ModelInvocationJobS3InputDataConfig{
				S3InputFormat: types.S3InputFormat("JSONL"),
				S3Uri:         ptr.String("__S3Uri__"),
				S3BucketOwner: ptr.String("__S3BucketOwner__"),
			},
		},
		OutputDataConfig: &types.ModelInvocationJobOutputDataConfigMemberS3OutputDataConfig{
			Value: types.ModelInvocationJobS3OutputDataConfig{
				S3Uri:             ptr.String("__S3Uri__"),
				S3EncryptionKeyId: ptr.String("__S3EncryptionKeyId__"),
				S3BucketOwner:     ptr.String("__S3BucketOwner__"),
			},
		},
		VpcConfig: &types.VpcConfig{
			SubnetIds: []string{
				"__Member__",
				"__Member__",
			},
			SecurityGroupIds: []string{
				"__Member__",
				"__Member__",
			},
		},
		TimeoutDurationInHours: ptr.Int32(1),
		JobExpirationTime:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ModelInvocationType:    types.ModelInvocationType("InvokeModel"),
		TotalRecordCount:       ptr.Int64(1),
		ProcessedRecordCount:   ptr.Int64(1),
		SuccessRecordCount:     ptr.Int64(1),
		ErrorRecordCount:       ptr.Int64(1),
	}
	status, header, body, err := serdeRespReadSnapshot("GetModelInvocationJob.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.GetModelInvocationJob(context.Background(), &GetModelInvocationJobInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetModelInvocationJob.response", err)
	}
}

func TestCheckResponseSnapshot_GetModelInvocationLoggingConfiguration(t *testing.T) {
	want := &GetModelInvocationLoggingConfigurationOutput{
		LoggingConfig: &types.LoggingConfig{
			CloudWatchConfig: &types.CloudWatchConfig{
				LogGroupName: ptr.String("__LogGroupName__"),
				RoleArn:      ptr.String("__RoleArn__"),
				LargeDataDeliveryS3Config: &types.S3Config{
					BucketName: ptr.String("__BucketName__"),
					KeyPrefix:  ptr.String("__KeyPrefix__"),
				},
			},
			S3Config: &types.S3Config{
				BucketName: ptr.String("__BucketName__"),
				KeyPrefix:  ptr.String("__KeyPrefix__"),
			},
			TextDataDeliveryEnabled:      ptr.Bool(true),
			ImageDataDeliveryEnabled:     ptr.Bool(true),
			EmbeddingDataDeliveryEnabled: ptr.Bool(true),
			VideoDataDeliveryEnabled:     ptr.Bool(true),
			AudioDataDeliveryEnabled:     ptr.Bool(true),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetModelInvocationLoggingConfiguration.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.GetModelInvocationLoggingConfiguration(context.Background(), &GetModelInvocationLoggingConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetModelInvocationLoggingConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_GetPromptRouter(t *testing.T) {
	want := &GetPromptRouterOutput{
		PromptRouterName: ptr.String("__PromptRouterName__"),
		RoutingCriteria: &types.RoutingCriteria{
			ResponseQualityDifference: ptr.Float64(1.0),
		},
		Description:     ptr.String("__Description__"),
		CreatedAt:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		UpdatedAt:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		PromptRouterArn: ptr.String("__PromptRouterArn__"),
		Models: []types.PromptRouterTargetModel{
			{
				ModelArn: ptr.String("__ModelArn__"),
			},
			{
				ModelArn: ptr.String("__ModelArn__"),
			},
		},
		FallbackModel: &types.PromptRouterTargetModel{
			ModelArn: ptr.String("__ModelArn__"),
		},
		Status: types.PromptRouterStatus("AVAILABLE"),
		Type:   types.PromptRouterType("custom"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetPromptRouter.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.GetPromptRouter(context.Background(), &GetPromptRouterInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetPromptRouter.response", err)
	}
}

func TestCheckResponseSnapshot_GetProvisionedModelThroughput(t *testing.T) {
	want := &GetProvisionedModelThroughputOutput{
		ModelUnits:               ptr.Int32(1),
		DesiredModelUnits:        ptr.Int32(1),
		ProvisionedModelName:     ptr.String("__ProvisionedModelName__"),
		ProvisionedModelArn:      ptr.String("__ProvisionedModelArn__"),
		ModelArn:                 ptr.String("__ModelArn__"),
		DesiredModelArn:          ptr.String("__DesiredModelArn__"),
		FoundationModelArn:       ptr.String("__FoundationModelArn__"),
		Status:                   types.ProvisionedModelStatus("Creating"),
		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)),
		FailureMessage:           ptr.String("__FailureMessage__"),
		CommitmentDuration:       types.CommitmentDuration("OneMonth"),
		CommitmentExpirationTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("GetProvisionedModelThroughput.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.GetProvisionedModelThroughput(context.Background(), &GetProvisionedModelThroughputInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetProvisionedModelThroughput.response", err)
	}
}

func TestCheckResponseSnapshot_GetResourcePolicy(t *testing.T) {
	want := &GetResourcePolicyOutput{
		ResourcePolicy: ptr.String("__ResourcePolicy__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetResourcePolicy.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.GetResourcePolicy(context.Background(), &GetResourcePolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetResourcePolicy.response", err)
	}
}

func TestCheckResponseSnapshot_GetUseCaseForModelAccess(t *testing.T) {
	want := &GetUseCaseForModelAccessOutput{
		FormData: []byte("blob"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetUseCaseForModelAccess.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.GetUseCaseForModelAccess(context.Background(), &GetUseCaseForModelAccessInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetUseCaseForModelAccess.response", err)
	}
}

func TestCheckResponseSnapshot_ListAdvancedPromptOptimizationJobs(t *testing.T) {
	want := &ListAdvancedPromptOptimizationJobsOutput{
		JobSummaries: []types.AdvancedPromptOptimizationJobSummary{
			{
				JobArn:           ptr.String("__JobArn__"),
				JobName:          ptr.String("__JobName__"),
				JobStatus:        types.AdvancedPromptOptimizationJobStatus("InProgress"),
				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)),
			},
			{
				JobArn:           ptr.String("__JobArn__"),
				JobName:          ptr.String("__JobName__"),
				JobStatus:        types.AdvancedPromptOptimizationJobStatus("InProgress"),
				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("ListAdvancedPromptOptimizationJobs.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.ListAdvancedPromptOptimizationJobs(context.Background(), &ListAdvancedPromptOptimizationJobsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListAdvancedPromptOptimizationJobs.response", err)
	}
}

func TestCheckResponseSnapshot_ListAutomatedReasoningPolicies(t *testing.T) {
	want := &ListAutomatedReasoningPoliciesOutput{
		AutomatedReasoningPolicySummaries: []types.AutomatedReasoningPolicySummary{
			{
				PolicyArn:   ptr.String("__PolicyArn__"),
				Name:        ptr.String("__Name__"),
				Description: ptr.String("__Description__"),
				Version:     ptr.String("__Version__"),
				PolicyId:    ptr.String("__PolicyId__"),
				CreatedAt:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedAt:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				PolicyArn:   ptr.String("__PolicyArn__"),
				Name:        ptr.String("__Name__"),
				Description: ptr.String("__Description__"),
				Version:     ptr.String("__Version__"),
				PolicyId:    ptr.String("__PolicyId__"),
				CreatedAt:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedAt:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListAutomatedReasoningPolicies.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.ListAutomatedReasoningPolicies(context.Background(), &ListAutomatedReasoningPoliciesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListAutomatedReasoningPolicies.response", err)
	}
}

func TestCheckResponseSnapshot_ListAutomatedReasoningPolicyBuildWorkflows(t *testing.T) {
	want := &ListAutomatedReasoningPolicyBuildWorkflowsOutput{
		AutomatedReasoningPolicyBuildWorkflowSummaries: []types.AutomatedReasoningPolicyBuildWorkflowSummary{
			{
				PolicyArn:         ptr.String("__PolicyArn__"),
				BuildWorkflowId:   ptr.String("__BuildWorkflowId__"),
				Status:            types.AutomatedReasoningPolicyBuildWorkflowStatus("SCHEDULED"),
				BuildWorkflowType: types.AutomatedReasoningPolicyBuildWorkflowType("INGEST_CONTENT"),
				CreatedAt:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedAt:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				PolicyArn:         ptr.String("__PolicyArn__"),
				BuildWorkflowId:   ptr.String("__BuildWorkflowId__"),
				Status:            types.AutomatedReasoningPolicyBuildWorkflowStatus("SCHEDULED"),
				BuildWorkflowType: types.AutomatedReasoningPolicyBuildWorkflowType("INGEST_CONTENT"),
				CreatedAt:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedAt:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListAutomatedReasoningPolicyBuildWorkflows.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.ListAutomatedReasoningPolicyBuildWorkflows(context.Background(), &ListAutomatedReasoningPolicyBuildWorkflowsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListAutomatedReasoningPolicyBuildWorkflows.response", err)
	}
}

func TestCheckResponseSnapshot_ListAutomatedReasoningPolicyTestCases(t *testing.T) {
	want := &ListAutomatedReasoningPolicyTestCasesOutput{
		TestCases: []types.AutomatedReasoningPolicyTestCase{
			{
				TestCaseId:                       ptr.String("__TestCaseId__"),
				GuardContent:                     ptr.String("__GuardContent__"),
				QueryContent:                     ptr.String("__QueryContent__"),
				ExpectedAggregatedFindingsResult: types.AutomatedReasoningCheckResult("VALID"),
				CreatedAt:                        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedAt:                        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ConfidenceThreshold:              ptr.Float64(1.0),
			},
			{
				TestCaseId:                       ptr.String("__TestCaseId__"),
				GuardContent:                     ptr.String("__GuardContent__"),
				QueryContent:                     ptr.String("__QueryContent__"),
				ExpectedAggregatedFindingsResult: types.AutomatedReasoningCheckResult("VALID"),
				CreatedAt:                        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedAt:                        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ConfidenceThreshold:              ptr.Float64(1.0),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListAutomatedReasoningPolicyTestCases.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.ListAutomatedReasoningPolicyTestCases(context.Background(), &ListAutomatedReasoningPolicyTestCasesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListAutomatedReasoningPolicyTestCases.response", err)
	}
}

func TestCheckResponseSnapshot_ListAutomatedReasoningPolicyTestResults(t *testing.T) {
	want := &ListAutomatedReasoningPolicyTestResultsOutput{
		TestResults: []types.AutomatedReasoningPolicyTestResult{
			{
				TestCase: &types.AutomatedReasoningPolicyTestCase{
					TestCaseId:                       ptr.String("__TestCaseId__"),
					GuardContent:                     ptr.String("__GuardContent__"),
					QueryContent:                     ptr.String("__QueryContent__"),
					ExpectedAggregatedFindingsResult: types.AutomatedReasoningCheckResult("VALID"),
					CreatedAt:                        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					UpdatedAt:                        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					ConfidenceThreshold:              ptr.Float64(1.0),
				},
				PolicyArn:     ptr.String("__PolicyArn__"),
				TestRunStatus: types.AutomatedReasoningPolicyTestRunStatus("NOT_STARTED"),
				TestFindings: []types.AutomatedReasoningCheckFinding{
					&types.AutomatedReasoningCheckFindingMemberValid{
						Value: types.AutomatedReasoningCheckValidFinding{
							Translation: &types.AutomatedReasoningCheckTranslation{
								Premises: []types.AutomatedReasoningLogicStatement{
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
								},
								Claims: []types.AutomatedReasoningLogicStatement{
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
								},
								UntranslatedPremises: []types.AutomatedReasoningCheckInputTextReference{
									{
										Text: ptr.String("__Text__"),
									},
									{
										Text: ptr.String("__Text__"),
									},
								},
								UntranslatedClaims: []types.AutomatedReasoningCheckInputTextReference{
									{
										Text: ptr.String("__Text__"),
									},
									{
										Text: ptr.String("__Text__"),
									},
								},
								Confidence: ptr.Float64(1.0),
							},
							ClaimsTrueScenario: &types.AutomatedReasoningCheckScenario{
								Statements: []types.AutomatedReasoningLogicStatement{
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
								},
							},
							SupportingRules: []types.AutomatedReasoningCheckRule{
								{
									Id:               ptr.String("__Id__"),
									PolicyVersionArn: ptr.String("__PolicyVersionArn__"),
								},
								{
									Id:               ptr.String("__Id__"),
									PolicyVersionArn: ptr.String("__PolicyVersionArn__"),
								},
							},
							LogicWarning: &types.AutomatedReasoningCheckLogicWarning{
								Type: types.AutomatedReasoningCheckLogicWarningType("ALWAYS_TRUE"),
								Premises: []types.AutomatedReasoningLogicStatement{
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
								},
								Claims: []types.AutomatedReasoningLogicStatement{
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
								},
							},
						},
					},
					&types.AutomatedReasoningCheckFindingMemberValid{
						Value: types.AutomatedReasoningCheckValidFinding{
							Translation: &types.AutomatedReasoningCheckTranslation{
								Premises: []types.AutomatedReasoningLogicStatement{
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
								},
								Claims: []types.AutomatedReasoningLogicStatement{
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
								},
								UntranslatedPremises: []types.AutomatedReasoningCheckInputTextReference{
									{
										Text: ptr.String("__Text__"),
									},
									{
										Text: ptr.String("__Text__"),
									},
								},
								UntranslatedClaims: []types.AutomatedReasoningCheckInputTextReference{
									{
										Text: ptr.String("__Text__"),
									},
									{
										Text: ptr.String("__Text__"),
									},
								},
								Confidence: ptr.Float64(1.0),
							},
							ClaimsTrueScenario: &types.AutomatedReasoningCheckScenario{
								Statements: []types.AutomatedReasoningLogicStatement{
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
								},
							},
							SupportingRules: []types.AutomatedReasoningCheckRule{
								{
									Id:               ptr.String("__Id__"),
									PolicyVersionArn: ptr.String("__PolicyVersionArn__"),
								},
								{
									Id:               ptr.String("__Id__"),
									PolicyVersionArn: ptr.String("__PolicyVersionArn__"),
								},
							},
							LogicWarning: &types.AutomatedReasoningCheckLogicWarning{
								Type: types.AutomatedReasoningCheckLogicWarningType("ALWAYS_TRUE"),
								Premises: []types.AutomatedReasoningLogicStatement{
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
								},
								Claims: []types.AutomatedReasoningLogicStatement{
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
								},
							},
						},
					},
				},
				TestRunResult:                types.AutomatedReasoningPolicyTestRunResult("PASSED"),
				AggregatedTestFindingsResult: types.AutomatedReasoningCheckResult("VALID"),
				UpdatedAt:                    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				TestCase: &types.AutomatedReasoningPolicyTestCase{
					TestCaseId:                       ptr.String("__TestCaseId__"),
					GuardContent:                     ptr.String("__GuardContent__"),
					QueryContent:                     ptr.String("__QueryContent__"),
					ExpectedAggregatedFindingsResult: types.AutomatedReasoningCheckResult("VALID"),
					CreatedAt:                        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					UpdatedAt:                        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					ConfidenceThreshold:              ptr.Float64(1.0),
				},
				PolicyArn:     ptr.String("__PolicyArn__"),
				TestRunStatus: types.AutomatedReasoningPolicyTestRunStatus("NOT_STARTED"),
				TestFindings: []types.AutomatedReasoningCheckFinding{
					&types.AutomatedReasoningCheckFindingMemberValid{
						Value: types.AutomatedReasoningCheckValidFinding{
							Translation: &types.AutomatedReasoningCheckTranslation{
								Premises: []types.AutomatedReasoningLogicStatement{
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
								},
								Claims: []types.AutomatedReasoningLogicStatement{
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
								},
								UntranslatedPremises: []types.AutomatedReasoningCheckInputTextReference{
									{
										Text: ptr.String("__Text__"),
									},
									{
										Text: ptr.String("__Text__"),
									},
								},
								UntranslatedClaims: []types.AutomatedReasoningCheckInputTextReference{
									{
										Text: ptr.String("__Text__"),
									},
									{
										Text: ptr.String("__Text__"),
									},
								},
								Confidence: ptr.Float64(1.0),
							},
							ClaimsTrueScenario: &types.AutomatedReasoningCheckScenario{
								Statements: []types.AutomatedReasoningLogicStatement{
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
								},
							},
							SupportingRules: []types.AutomatedReasoningCheckRule{
								{
									Id:               ptr.String("__Id__"),
									PolicyVersionArn: ptr.String("__PolicyVersionArn__"),
								},
								{
									Id:               ptr.String("__Id__"),
									PolicyVersionArn: ptr.String("__PolicyVersionArn__"),
								},
							},
							LogicWarning: &types.AutomatedReasoningCheckLogicWarning{
								Type: types.AutomatedReasoningCheckLogicWarningType("ALWAYS_TRUE"),
								Premises: []types.AutomatedReasoningLogicStatement{
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
								},
								Claims: []types.AutomatedReasoningLogicStatement{
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
								},
							},
						},
					},
					&types.AutomatedReasoningCheckFindingMemberValid{
						Value: types.AutomatedReasoningCheckValidFinding{
							Translation: &types.AutomatedReasoningCheckTranslation{
								Premises: []types.AutomatedReasoningLogicStatement{
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
								},
								Claims: []types.AutomatedReasoningLogicStatement{
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
								},
								UntranslatedPremises: []types.AutomatedReasoningCheckInputTextReference{
									{
										Text: ptr.String("__Text__"),
									},
									{
										Text: ptr.String("__Text__"),
									},
								},
								UntranslatedClaims: []types.AutomatedReasoningCheckInputTextReference{
									{
										Text: ptr.String("__Text__"),
									},
									{
										Text: ptr.String("__Text__"),
									},
								},
								Confidence: ptr.Float64(1.0),
							},
							ClaimsTrueScenario: &types.AutomatedReasoningCheckScenario{
								Statements: []types.AutomatedReasoningLogicStatement{
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
								},
							},
							SupportingRules: []types.AutomatedReasoningCheckRule{
								{
									Id:               ptr.String("__Id__"),
									PolicyVersionArn: ptr.String("__PolicyVersionArn__"),
								},
								{
									Id:               ptr.String("__Id__"),
									PolicyVersionArn: ptr.String("__PolicyVersionArn__"),
								},
							},
							LogicWarning: &types.AutomatedReasoningCheckLogicWarning{
								Type: types.AutomatedReasoningCheckLogicWarningType("ALWAYS_TRUE"),
								Premises: []types.AutomatedReasoningLogicStatement{
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
								},
								Claims: []types.AutomatedReasoningLogicStatement{
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
									{
										Logic:           ptr.String("__Logic__"),
										NaturalLanguage: ptr.String("__NaturalLanguage__"),
									},
								},
							},
						},
					},
				},
				TestRunResult:                types.AutomatedReasoningPolicyTestRunResult("PASSED"),
				AggregatedTestFindingsResult: types.AutomatedReasoningCheckResult("VALID"),
				UpdatedAt:                    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListAutomatedReasoningPolicyTestResults.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.ListAutomatedReasoningPolicyTestResults(context.Background(), &ListAutomatedReasoningPolicyTestResultsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListAutomatedReasoningPolicyTestResults.response", err)
	}
}

func TestCheckResponseSnapshot_ListCustomModelDeployments(t *testing.T) {
	want := &ListCustomModelDeploymentsOutput{
		NextToken: ptr.String("__NextToken__"),
		ModelDeploymentSummaries: []types.CustomModelDeploymentSummary{
			{
				CustomModelDeploymentArn:  ptr.String("__CustomModelDeploymentArn__"),
				CustomModelDeploymentName: ptr.String("__CustomModelDeploymentName__"),
				ModelArn:                  ptr.String("__ModelArn__"),
				CreatedAt:                 ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Status:                    types.CustomModelDeploymentStatus("Creating"),
				LastUpdatedAt:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				FailureMessage:            ptr.String("__FailureMessage__"),
			},
			{
				CustomModelDeploymentArn:  ptr.String("__CustomModelDeploymentArn__"),
				CustomModelDeploymentName: ptr.String("__CustomModelDeploymentName__"),
				ModelArn:                  ptr.String("__ModelArn__"),
				CreatedAt:                 ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Status:                    types.CustomModelDeploymentStatus("Creating"),
				LastUpdatedAt:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				FailureMessage:            ptr.String("__FailureMessage__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListCustomModelDeployments.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.ListCustomModelDeployments(context.Background(), &ListCustomModelDeploymentsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListCustomModelDeployments.response", err)
	}
}

func TestCheckResponseSnapshot_ListCustomModels(t *testing.T) {
	want := &ListCustomModelsOutput{
		NextToken: ptr.String("__NextToken__"),
		ModelSummaries: []types.CustomModelSummary{
			{
				ModelArn:          ptr.String("__ModelArn__"),
				ModelName:         ptr.String("__ModelName__"),
				CreationTime:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				BaseModelArn:      ptr.String("__BaseModelArn__"),
				BaseModelName:     ptr.String("__BaseModelName__"),
				CustomizationType: types.CustomizationType("FINE_TUNING"),
				OwnerAccountId:    ptr.String("__OwnerAccountId__"),
				ModelStatus:       types.ModelStatus("Active"),
			},
			{
				ModelArn:          ptr.String("__ModelArn__"),
				ModelName:         ptr.String("__ModelName__"),
				CreationTime:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				BaseModelArn:      ptr.String("__BaseModelArn__"),
				BaseModelName:     ptr.String("__BaseModelName__"),
				CustomizationType: types.CustomizationType("FINE_TUNING"),
				OwnerAccountId:    ptr.String("__OwnerAccountId__"),
				ModelStatus:       types.ModelStatus("Active"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListCustomModels.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.ListCustomModels(context.Background(), &ListCustomModelsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListCustomModels.response", err)
	}
}

func TestCheckResponseSnapshot_ListEnforcedGuardrailsConfiguration(t *testing.T) {
	want := &ListEnforcedGuardrailsConfigurationOutput{
		GuardrailsConfig: []types.AccountEnforcedGuardrailOutputConfiguration{
			{
				ConfigId:     ptr.String("__ConfigId__"),
				GuardrailArn: ptr.String("__GuardrailArn__"),
				GuardrailId:  ptr.String("__GuardrailId__"),
				InputTags:    types.InputTags("HONOR"),
				SelectiveContentGuarding: &types.SelectiveContentGuarding{
					System:   types.SelectiveGuardingMode("SELECTIVE"),
					Messages: types.SelectiveGuardingMode("SELECTIVE"),
				},
				GuardrailVersion: ptr.String("__GuardrailVersion__"),
				CreatedAt:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CreatedBy:        ptr.String("__CreatedBy__"),
				UpdatedAt:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedBy:        ptr.String("__UpdatedBy__"),
				Owner:            types.ConfigurationOwner("ACCOUNT"),
				ModelEnforcement: &types.ModelEnforcement{
					IncludedModels: []string{
						"__Member__",
						"__Member__",
					},
					ExcludedModels: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
			{
				ConfigId:     ptr.String("__ConfigId__"),
				GuardrailArn: ptr.String("__GuardrailArn__"),
				GuardrailId:  ptr.String("__GuardrailId__"),
				InputTags:    types.InputTags("HONOR"),
				SelectiveContentGuarding: &types.SelectiveContentGuarding{
					System:   types.SelectiveGuardingMode("SELECTIVE"),
					Messages: types.SelectiveGuardingMode("SELECTIVE"),
				},
				GuardrailVersion: ptr.String("__GuardrailVersion__"),
				CreatedAt:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CreatedBy:        ptr.String("__CreatedBy__"),
				UpdatedAt:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedBy:        ptr.String("__UpdatedBy__"),
				Owner:            types.ConfigurationOwner("ACCOUNT"),
				ModelEnforcement: &types.ModelEnforcement{
					IncludedModels: []string{
						"__Member__",
						"__Member__",
					},
					ExcludedModels: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListEnforcedGuardrailsConfiguration.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.ListEnforcedGuardrailsConfiguration(context.Background(), &ListEnforcedGuardrailsConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListEnforcedGuardrailsConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_ListEvaluationJobs(t *testing.T) {
	want := &ListEvaluationJobsOutput{
		NextToken: ptr.String("__NextToken__"),
		JobSummaries: []types.EvaluationSummary{
			{
				JobArn:       ptr.String("__JobArn__"),
				JobName:      ptr.String("__JobName__"),
				Status:       types.EvaluationJobStatus("InProgress"),
				CreationTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				JobType:      types.EvaluationJobType("Human"),
				EvaluationTaskTypes: []types.EvaluationTaskType{
					types.EvaluationTaskType("Summarization"),
					types.EvaluationTaskType("Summarization"),
				},
				ModelIdentifiers: []string{
					"__Member__",
					"__Member__",
				},
				RagIdentifiers: []string{
					"__Member__",
					"__Member__",
				},
				EvaluatorModelIdentifiers: []string{
					"__Member__",
					"__Member__",
				},
				CustomMetricsEvaluatorModelIdentifiers: []string{
					"__Member__",
					"__Member__",
				},
				InferenceConfigSummary: &types.EvaluationInferenceConfigSummary{
					ModelConfigSummary: &types.EvaluationModelConfigSummary{
						BedrockModelIdentifiers: []string{
							"__Member__",
							"__Member__",
						},
						PrecomputedInferenceSourceIdentifiers: []string{
							"__Member__",
							"__Member__",
						},
					},
					RagConfigSummary: &types.EvaluationRagConfigSummary{
						BedrockKnowledgeBaseIdentifiers: []string{
							"__Member__",
							"__Member__",
						},
						PrecomputedRagSourceIdentifiers: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
				ApplicationType: types.ApplicationType("ModelEvaluation"),
			},
			{
				JobArn:       ptr.String("__JobArn__"),
				JobName:      ptr.String("__JobName__"),
				Status:       types.EvaluationJobStatus("InProgress"),
				CreationTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				JobType:      types.EvaluationJobType("Human"),
				EvaluationTaskTypes: []types.EvaluationTaskType{
					types.EvaluationTaskType("Summarization"),
					types.EvaluationTaskType("Summarization"),
				},
				ModelIdentifiers: []string{
					"__Member__",
					"__Member__",
				},
				RagIdentifiers: []string{
					"__Member__",
					"__Member__",
				},
				EvaluatorModelIdentifiers: []string{
					"__Member__",
					"__Member__",
				},
				CustomMetricsEvaluatorModelIdentifiers: []string{
					"__Member__",
					"__Member__",
				},
				InferenceConfigSummary: &types.EvaluationInferenceConfigSummary{
					ModelConfigSummary: &types.EvaluationModelConfigSummary{
						BedrockModelIdentifiers: []string{
							"__Member__",
							"__Member__",
						},
						PrecomputedInferenceSourceIdentifiers: []string{
							"__Member__",
							"__Member__",
						},
					},
					RagConfigSummary: &types.EvaluationRagConfigSummary{
						BedrockKnowledgeBaseIdentifiers: []string{
							"__Member__",
							"__Member__",
						},
						PrecomputedRagSourceIdentifiers: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
				ApplicationType: types.ApplicationType("ModelEvaluation"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListEvaluationJobs.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.ListEvaluationJobs(context.Background(), &ListEvaluationJobsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListEvaluationJobs.response", err)
	}
}

func TestCheckResponseSnapshot_ListFoundationModelAgreementOffers(t *testing.T) {
	want := &ListFoundationModelAgreementOffersOutput{
		ModelId: ptr.String("__ModelId__"),
		Offers: []types.Offer{
			{
				OfferId:    ptr.String("__OfferId__"),
				OfferToken: ptr.String("__OfferToken__"),
				TermDetails: &types.TermDetails{
					UsageBasedPricingTerm: &types.PricingTerm{
						RateCard: []types.DimensionalPriceRate{
							{
								Dimension:   ptr.String("__Dimension__"),
								Price:       ptr.String("__Price__"),
								Description: ptr.String("__Description__"),
								Unit:        ptr.String("__Unit__"),
							},
							{
								Dimension:   ptr.String("__Dimension__"),
								Price:       ptr.String("__Price__"),
								Description: ptr.String("__Description__"),
								Unit:        ptr.String("__Unit__"),
							},
						},
					},
					LegalTerm: &types.LegalTerm{
						Url: ptr.String("__Url__"),
					},
					SupportTerm: &types.SupportTerm{
						RefundPolicyDescription: ptr.String("__RefundPolicyDescription__"),
					},
					ValidityTerm: &types.ValidityTerm{
						AgreementDuration: ptr.String("__AgreementDuration__"),
					},
				},
			},
			{
				OfferId:    ptr.String("__OfferId__"),
				OfferToken: ptr.String("__OfferToken__"),
				TermDetails: &types.TermDetails{
					UsageBasedPricingTerm: &types.PricingTerm{
						RateCard: []types.DimensionalPriceRate{
							{
								Dimension:   ptr.String("__Dimension__"),
								Price:       ptr.String("__Price__"),
								Description: ptr.String("__Description__"),
								Unit:        ptr.String("__Unit__"),
							},
							{
								Dimension:   ptr.String("__Dimension__"),
								Price:       ptr.String("__Price__"),
								Description: ptr.String("__Description__"),
								Unit:        ptr.String("__Unit__"),
							},
						},
					},
					LegalTerm: &types.LegalTerm{
						Url: ptr.String("__Url__"),
					},
					SupportTerm: &types.SupportTerm{
						RefundPolicyDescription: ptr.String("__RefundPolicyDescription__"),
					},
					ValidityTerm: &types.ValidityTerm{
						AgreementDuration: ptr.String("__AgreementDuration__"),
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListFoundationModelAgreementOffers.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.ListFoundationModelAgreementOffers(context.Background(), &ListFoundationModelAgreementOffersInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListFoundationModelAgreementOffers.response", err)
	}
}

func TestCheckResponseSnapshot_ListFoundationModels(t *testing.T) {
	want := &ListFoundationModelsOutput{
		ModelSummaries: []types.FoundationModelSummary{
			{
				ModelArn:     ptr.String("__ModelArn__"),
				ModelId:      ptr.String("__ModelId__"),
				ModelName:    ptr.String("__ModelName__"),
				ProviderName: ptr.String("__ProviderName__"),
				InputModalities: []types.ModelModality{
					types.ModelModality("TEXT"),
					types.ModelModality("TEXT"),
				},
				OutputModalities: []types.ModelModality{
					types.ModelModality("TEXT"),
					types.ModelModality("TEXT"),
				},
				ResponseStreamingSupported: ptr.Bool(true),
				CustomizationsSupported: []types.ModelCustomization{
					types.ModelCustomization("FINE_TUNING"),
					types.ModelCustomization("FINE_TUNING"),
				},
				InferenceTypesSupported: []types.InferenceType{
					types.InferenceType("ON_DEMAND"),
					types.InferenceType("ON_DEMAND"),
				},
				ModelLifecycle: &types.FoundationModelLifecycle{
					Status:                   types.FoundationModelLifecycleStatus("ACTIVE"),
					StartOfLifeTime:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					EndOfLifeTime:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					LegacyTime:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					PublicExtendedAccessTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
			{
				ModelArn:     ptr.String("__ModelArn__"),
				ModelId:      ptr.String("__ModelId__"),
				ModelName:    ptr.String("__ModelName__"),
				ProviderName: ptr.String("__ProviderName__"),
				InputModalities: []types.ModelModality{
					types.ModelModality("TEXT"),
					types.ModelModality("TEXT"),
				},
				OutputModalities: []types.ModelModality{
					types.ModelModality("TEXT"),
					types.ModelModality("TEXT"),
				},
				ResponseStreamingSupported: ptr.Bool(true),
				CustomizationsSupported: []types.ModelCustomization{
					types.ModelCustomization("FINE_TUNING"),
					types.ModelCustomization("FINE_TUNING"),
				},
				InferenceTypesSupported: []types.InferenceType{
					types.InferenceType("ON_DEMAND"),
					types.InferenceType("ON_DEMAND"),
				},
				ModelLifecycle: &types.FoundationModelLifecycle{
					Status:                   types.FoundationModelLifecycleStatus("ACTIVE"),
					StartOfLifeTime:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					EndOfLifeTime:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					LegacyTime:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					PublicExtendedAccessTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListFoundationModels.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.ListFoundationModels(context.Background(), &ListFoundationModelsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListFoundationModels.response", err)
	}
}

func TestCheckResponseSnapshot_ListGuardrails(t *testing.T) {
	want := &ListGuardrailsOutput{
		Guardrails: []types.GuardrailSummary{
			{
				Id:          ptr.String("__Id__"),
				Arn:         ptr.String("__Arn__"),
				Status:      types.GuardrailStatus("CREATING"),
				Name:        ptr.String("__Name__"),
				Description: ptr.String("__Description__"),
				Version:     ptr.String("__Version__"),
				CreatedAt:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedAt:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CrossRegionDetails: &types.GuardrailCrossRegionDetails{
					GuardrailProfileId:  ptr.String("__GuardrailProfileId__"),
					GuardrailProfileArn: ptr.String("__GuardrailProfileArn__"),
				},
			},
			{
				Id:          ptr.String("__Id__"),
				Arn:         ptr.String("__Arn__"),
				Status:      types.GuardrailStatus("CREATING"),
				Name:        ptr.String("__Name__"),
				Description: ptr.String("__Description__"),
				Version:     ptr.String("__Version__"),
				CreatedAt:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedAt:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CrossRegionDetails: &types.GuardrailCrossRegionDetails{
					GuardrailProfileId:  ptr.String("__GuardrailProfileId__"),
					GuardrailProfileArn: ptr.String("__GuardrailProfileArn__"),
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListGuardrails.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.ListGuardrails(context.Background(), &ListGuardrailsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListGuardrails.response", err)
	}
}

func TestCheckResponseSnapshot_ListImportedModels(t *testing.T) {
	want := &ListImportedModelsOutput{
		NextToken: ptr.String("__NextToken__"),
		ModelSummaries: []types.ImportedModelSummary{
			{
				ModelArn:          ptr.String("__ModelArn__"),
				ModelName:         ptr.String("__ModelName__"),
				CreationTime:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				InstructSupported: ptr.Bool(true),
				ModelArchitecture: ptr.String("__ModelArchitecture__"),
			},
			{
				ModelArn:          ptr.String("__ModelArn__"),
				ModelName:         ptr.String("__ModelName__"),
				CreationTime:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				InstructSupported: ptr.Bool(true),
				ModelArchitecture: ptr.String("__ModelArchitecture__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListImportedModels.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.ListImportedModels(context.Background(), &ListImportedModelsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListImportedModels.response", err)
	}
}

func TestCheckResponseSnapshot_ListInferenceProfiles(t *testing.T) {
	want := &ListInferenceProfilesOutput{
		InferenceProfileSummaries: []types.InferenceProfileSummary{
			{
				InferenceProfileName: ptr.String("__InferenceProfileName__"),
				Description:          ptr.String("__Description__"),
				CreatedAt:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedAt:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				InferenceProfileArn:  ptr.String("__InferenceProfileArn__"),
				Models: []types.InferenceProfileModel{
					{
						ModelArn: ptr.String("__ModelArn__"),
					},
					{
						ModelArn: ptr.String("__ModelArn__"),
					},
				},
				InferenceProfileId: ptr.String("__InferenceProfileId__"),
				Status:             types.InferenceProfileStatus("ACTIVE"),
				Type:               types.InferenceProfileType("SYSTEM_DEFINED"),
			},
			{
				InferenceProfileName: ptr.String("__InferenceProfileName__"),
				Description:          ptr.String("__Description__"),
				CreatedAt:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedAt:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				InferenceProfileArn:  ptr.String("__InferenceProfileArn__"),
				Models: []types.InferenceProfileModel{
					{
						ModelArn: ptr.String("__ModelArn__"),
					},
					{
						ModelArn: ptr.String("__ModelArn__"),
					},
				},
				InferenceProfileId: ptr.String("__InferenceProfileId__"),
				Status:             types.InferenceProfileStatus("ACTIVE"),
				Type:               types.InferenceProfileType("SYSTEM_DEFINED"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListInferenceProfiles.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.ListInferenceProfiles(context.Background(), &ListInferenceProfilesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListInferenceProfiles.response", err)
	}
}

func TestCheckResponseSnapshot_ListMarketplaceModelEndpoints(t *testing.T) {
	want := &ListMarketplaceModelEndpointsOutput{
		MarketplaceModelEndpoints: []types.MarketplaceModelEndpointSummary{
			{
				EndpointArn:           ptr.String("__EndpointArn__"),
				ModelSourceIdentifier: ptr.String("__ModelSourceIdentifier__"),
				Status:                types.Status("REGISTERED"),
				StatusMessage:         ptr.String("__StatusMessage__"),
				CreatedAt:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedAt:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				EndpointArn:           ptr.String("__EndpointArn__"),
				ModelSourceIdentifier: ptr.String("__ModelSourceIdentifier__"),
				Status:                types.Status("REGISTERED"),
				StatusMessage:         ptr.String("__StatusMessage__"),
				CreatedAt:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedAt:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListMarketplaceModelEndpoints.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.ListMarketplaceModelEndpoints(context.Background(), &ListMarketplaceModelEndpointsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListMarketplaceModelEndpoints.response", err)
	}
}

func TestCheckResponseSnapshot_ListModelCopyJobs(t *testing.T) {
	want := &ListModelCopyJobsOutput{
		NextToken: ptr.String("__NextToken__"),
		ModelCopyJobSummaries: []types.ModelCopyJobSummary{
			{
				JobArn:               ptr.String("__JobArn__"),
				Status:               types.ModelCopyJobStatus("InProgress"),
				CreationTime:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				TargetModelArn:       ptr.String("__TargetModelArn__"),
				TargetModelName:      ptr.String("__TargetModelName__"),
				SourceAccountId:      ptr.String("__SourceAccountId__"),
				SourceModelArn:       ptr.String("__SourceModelArn__"),
				TargetModelKmsKeyArn: ptr.String("__TargetModelKmsKeyArn__"),
				TargetModelTags: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
				FailureMessage:  ptr.String("__FailureMessage__"),
				SourceModelName: ptr.String("__SourceModelName__"),
			},
			{
				JobArn:               ptr.String("__JobArn__"),
				Status:               types.ModelCopyJobStatus("InProgress"),
				CreationTime:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				TargetModelArn:       ptr.String("__TargetModelArn__"),
				TargetModelName:      ptr.String("__TargetModelName__"),
				SourceAccountId:      ptr.String("__SourceAccountId__"),
				SourceModelArn:       ptr.String("__SourceModelArn__"),
				TargetModelKmsKeyArn: ptr.String("__TargetModelKmsKeyArn__"),
				TargetModelTags: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
				FailureMessage:  ptr.String("__FailureMessage__"),
				SourceModelName: ptr.String("__SourceModelName__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListModelCopyJobs.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.ListModelCopyJobs(context.Background(), &ListModelCopyJobsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListModelCopyJobs.response", err)
	}
}

func TestCheckResponseSnapshot_ListModelCustomizationJobs(t *testing.T) {
	want := &ListModelCustomizationJobsOutput{
		NextToken: ptr.String("__NextToken__"),
		ModelCustomizationJobSummaries: []types.ModelCustomizationJobSummary{
			{
				JobArn:       ptr.String("__JobArn__"),
				BaseModelArn: ptr.String("__BaseModelArn__"),
				JobName:      ptr.String("__JobName__"),
				Status:       types.ModelCustomizationJobStatus("InProgress"),
				StatusDetails: &types.StatusDetails{
					ValidationDetails: &types.ValidationDetails{
						Status:           types.JobStatusDetails("InProgress"),
						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)),
					},
					DataProcessingDetails: &types.DataProcessingDetails{
						Status:           types.JobStatusDetails("InProgress"),
						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)),
					},
					TrainingDetails: &types.TrainingDetails{
						Status:           types.JobStatusDetails("InProgress"),
						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)),
					},
				},
				LastModifiedTime:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CreationTime:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				EndTime:           ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CustomModelArn:    ptr.String("__CustomModelArn__"),
				CustomModelName:   ptr.String("__CustomModelName__"),
				CustomizationType: types.CustomizationType("FINE_TUNING"),
			},
			{
				JobArn:       ptr.String("__JobArn__"),
				BaseModelArn: ptr.String("__BaseModelArn__"),
				JobName:      ptr.String("__JobName__"),
				Status:       types.ModelCustomizationJobStatus("InProgress"),
				StatusDetails: &types.StatusDetails{
					ValidationDetails: &types.ValidationDetails{
						Status:           types.JobStatusDetails("InProgress"),
						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)),
					},
					DataProcessingDetails: &types.DataProcessingDetails{
						Status:           types.JobStatusDetails("InProgress"),
						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)),
					},
					TrainingDetails: &types.TrainingDetails{
						Status:           types.JobStatusDetails("InProgress"),
						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)),
					},
				},
				LastModifiedTime:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CreationTime:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				EndTime:           ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CustomModelArn:    ptr.String("__CustomModelArn__"),
				CustomModelName:   ptr.String("__CustomModelName__"),
				CustomizationType: types.CustomizationType("FINE_TUNING"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListModelCustomizationJobs.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.ListModelCustomizationJobs(context.Background(), &ListModelCustomizationJobsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListModelCustomizationJobs.response", err)
	}
}

func TestCheckResponseSnapshot_ListModelImportJobs(t *testing.T) {
	want := &ListModelImportJobsOutput{
		NextToken: ptr.String("__NextToken__"),
		ModelImportJobSummaries: []types.ModelImportJobSummary{
			{
				JobArn:            ptr.String("__JobArn__"),
				JobName:           ptr.String("__JobName__"),
				Status:            types.ModelImportJobStatus("InProgress"),
				LastModifiedTime:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CreationTime:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				EndTime:           ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ImportedModelArn:  ptr.String("__ImportedModelArn__"),
				ImportedModelName: ptr.String("__ImportedModelName__"),
			},
			{
				JobArn:            ptr.String("__JobArn__"),
				JobName:           ptr.String("__JobName__"),
				Status:            types.ModelImportJobStatus("InProgress"),
				LastModifiedTime:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CreationTime:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				EndTime:           ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ImportedModelArn:  ptr.String("__ImportedModelArn__"),
				ImportedModelName: ptr.String("__ImportedModelName__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListModelImportJobs.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.ListModelImportJobs(context.Background(), &ListModelImportJobsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListModelImportJobs.response", err)
	}
}

func TestCheckResponseSnapshot_ListModelInvocationJobs(t *testing.T) {
	want := &ListModelInvocationJobsOutput{
		NextToken: ptr.String("__NextToken__"),
		InvocationJobSummaries: []types.ModelInvocationJobSummary{
			{
				JobArn:             ptr.String("__JobArn__"),
				JobName:            ptr.String("__JobName__"),
				ModelId:            ptr.String("__ModelId__"),
				ClientRequestToken: ptr.String("__ClientRequestToken__"),
				RoleArn:            ptr.String("__RoleArn__"),
				Status:             types.ModelInvocationJobStatus("Submitted"),
				Message:            ptr.String("__Message__"),
				SubmitTime:         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)),
				EndTime:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				InputDataConfig: &types.ModelInvocationJobInputDataConfigMemberS3InputDataConfig{
					Value: types.ModelInvocationJobS3InputDataConfig{
						S3InputFormat: types.S3InputFormat("JSONL"),
						S3Uri:         ptr.String("__S3Uri__"),
						S3BucketOwner: ptr.String("__S3BucketOwner__"),
					},
				},
				OutputDataConfig: &types.ModelInvocationJobOutputDataConfigMemberS3OutputDataConfig{
					Value: types.ModelInvocationJobS3OutputDataConfig{
						S3Uri:             ptr.String("__S3Uri__"),
						S3EncryptionKeyId: ptr.String("__S3EncryptionKeyId__"),
						S3BucketOwner:     ptr.String("__S3BucketOwner__"),
					},
				},
				VpcConfig: &types.VpcConfig{
					SubnetIds: []string{
						"__Member__",
						"__Member__",
					},
					SecurityGroupIds: []string{
						"__Member__",
						"__Member__",
					},
				},
				TimeoutDurationInHours: ptr.Int32(1),
				JobExpirationTime:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ModelInvocationType:    types.ModelInvocationType("InvokeModel"),
				TotalRecordCount:       ptr.Int64(1),
				ProcessedRecordCount:   ptr.Int64(1),
				SuccessRecordCount:     ptr.Int64(1),
				ErrorRecordCount:       ptr.Int64(1),
			},
			{
				JobArn:             ptr.String("__JobArn__"),
				JobName:            ptr.String("__JobName__"),
				ModelId:            ptr.String("__ModelId__"),
				ClientRequestToken: ptr.String("__ClientRequestToken__"),
				RoleArn:            ptr.String("__RoleArn__"),
				Status:             types.ModelInvocationJobStatus("Submitted"),
				Message:            ptr.String("__Message__"),
				SubmitTime:         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)),
				EndTime:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				InputDataConfig: &types.ModelInvocationJobInputDataConfigMemberS3InputDataConfig{
					Value: types.ModelInvocationJobS3InputDataConfig{
						S3InputFormat: types.S3InputFormat("JSONL"),
						S3Uri:         ptr.String("__S3Uri__"),
						S3BucketOwner: ptr.String("__S3BucketOwner__"),
					},
				},
				OutputDataConfig: &types.ModelInvocationJobOutputDataConfigMemberS3OutputDataConfig{
					Value: types.ModelInvocationJobS3OutputDataConfig{
						S3Uri:             ptr.String("__S3Uri__"),
						S3EncryptionKeyId: ptr.String("__S3EncryptionKeyId__"),
						S3BucketOwner:     ptr.String("__S3BucketOwner__"),
					},
				},
				VpcConfig: &types.VpcConfig{
					SubnetIds: []string{
						"__Member__",
						"__Member__",
					},
					SecurityGroupIds: []string{
						"__Member__",
						"__Member__",
					},
				},
				TimeoutDurationInHours: ptr.Int32(1),
				JobExpirationTime:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ModelInvocationType:    types.ModelInvocationType("InvokeModel"),
				TotalRecordCount:       ptr.Int64(1),
				ProcessedRecordCount:   ptr.Int64(1),
				SuccessRecordCount:     ptr.Int64(1),
				ErrorRecordCount:       ptr.Int64(1),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListModelInvocationJobs.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.ListModelInvocationJobs(context.Background(), &ListModelInvocationJobsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListModelInvocationJobs.response", err)
	}
}

func TestCheckResponseSnapshot_ListPromptRouters(t *testing.T) {
	want := &ListPromptRoutersOutput{
		PromptRouterSummaries: []types.PromptRouterSummary{
			{
				PromptRouterName: ptr.String("__PromptRouterName__"),
				RoutingCriteria: &types.RoutingCriteria{
					ResponseQualityDifference: ptr.Float64(1.0),
				},
				Description:     ptr.String("__Description__"),
				CreatedAt:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedAt:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PromptRouterArn: ptr.String("__PromptRouterArn__"),
				Models: []types.PromptRouterTargetModel{
					{
						ModelArn: ptr.String("__ModelArn__"),
					},
					{
						ModelArn: ptr.String("__ModelArn__"),
					},
				},
				FallbackModel: &types.PromptRouterTargetModel{
					ModelArn: ptr.String("__ModelArn__"),
				},
				Status: types.PromptRouterStatus("AVAILABLE"),
				Type:   types.PromptRouterType("custom"),
			},
			{
				PromptRouterName: ptr.String("__PromptRouterName__"),
				RoutingCriteria: &types.RoutingCriteria{
					ResponseQualityDifference: ptr.Float64(1.0),
				},
				Description:     ptr.String("__Description__"),
				CreatedAt:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdatedAt:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PromptRouterArn: ptr.String("__PromptRouterArn__"),
				Models: []types.PromptRouterTargetModel{
					{
						ModelArn: ptr.String("__ModelArn__"),
					},
					{
						ModelArn: ptr.String("__ModelArn__"),
					},
				},
				FallbackModel: &types.PromptRouterTargetModel{
					ModelArn: ptr.String("__ModelArn__"),
				},
				Status: types.PromptRouterStatus("AVAILABLE"),
				Type:   types.PromptRouterType("custom"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListPromptRouters.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.ListPromptRouters(context.Background(), &ListPromptRoutersInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListPromptRouters.response", err)
	}
}

func TestCheckResponseSnapshot_ListProvisionedModelThroughputs(t *testing.T) {
	want := &ListProvisionedModelThroughputsOutput{
		NextToken: ptr.String("__NextToken__"),
		ProvisionedModelSummaries: []types.ProvisionedModelSummary{
			{
				ProvisionedModelName:     ptr.String("__ProvisionedModelName__"),
				ProvisionedModelArn:      ptr.String("__ProvisionedModelArn__"),
				ModelArn:                 ptr.String("__ModelArn__"),
				DesiredModelArn:          ptr.String("__DesiredModelArn__"),
				FoundationModelArn:       ptr.String("__FoundationModelArn__"),
				ModelUnits:               ptr.Int32(1),
				DesiredModelUnits:        ptr.Int32(1),
				Status:                   types.ProvisionedModelStatus("Creating"),
				CommitmentDuration:       types.CommitmentDuration("OneMonth"),
				CommitmentExpirationTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				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)),
			},
			{
				ProvisionedModelName:     ptr.String("__ProvisionedModelName__"),
				ProvisionedModelArn:      ptr.String("__ProvisionedModelArn__"),
				ModelArn:                 ptr.String("__ModelArn__"),
				DesiredModelArn:          ptr.String("__DesiredModelArn__"),
				FoundationModelArn:       ptr.String("__FoundationModelArn__"),
				ModelUnits:               ptr.Int32(1),
				DesiredModelUnits:        ptr.Int32(1),
				Status:                   types.ProvisionedModelStatus("Creating"),
				CommitmentDuration:       types.CommitmentDuration("OneMonth"),
				CommitmentExpirationTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				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)),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListProvisionedModelThroughputs.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.ListProvisionedModelThroughputs(context.Background(), &ListProvisionedModelThroughputsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListProvisionedModelThroughputs.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_PutAccountDataRetention(t *testing.T) {
	want := &PutAccountDataRetentionOutput{
		Mode:      types.DataRetentionMode("default"),
		UpdatedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("PutAccountDataRetention.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.PutAccountDataRetention(context.Background(), &PutAccountDataRetentionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutAccountDataRetention.response", err)
	}
}

func TestCheckResponseSnapshot_PutEnforcedGuardrailConfiguration(t *testing.T) {
	want := &PutEnforcedGuardrailConfigurationOutput{
		ConfigId:  ptr.String("__ConfigId__"),
		UpdatedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		UpdatedBy: ptr.String("__UpdatedBy__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PutEnforcedGuardrailConfiguration.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.PutEnforcedGuardrailConfiguration(context.Background(), &PutEnforcedGuardrailConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutEnforcedGuardrailConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_PutModelInvocationLoggingConfiguration(t *testing.T) {
	want := &PutModelInvocationLoggingConfigurationOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutModelInvocationLoggingConfiguration.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.PutModelInvocationLoggingConfiguration(context.Background(), &PutModelInvocationLoggingConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutModelInvocationLoggingConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_PutResourcePolicy(t *testing.T) {
	want := &PutResourcePolicyOutput{
		ResourceArn: ptr.String("__ResourceArn__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PutResourcePolicy.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.PutResourcePolicy(context.Background(), &PutResourcePolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutResourcePolicy.response", err)
	}
}

func TestCheckResponseSnapshot_PutUseCaseForModelAccess(t *testing.T) {
	want := &PutUseCaseForModelAccessOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutUseCaseForModelAccess.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.PutUseCaseForModelAccess(context.Background(), &PutUseCaseForModelAccessInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutUseCaseForModelAccess.response", err)
	}
}

func TestCheckResponseSnapshot_RegisterMarketplaceModelEndpoint(t *testing.T) {
	want := &RegisterMarketplaceModelEndpointOutput{
		MarketplaceModelEndpoint: &types.MarketplaceModelEndpoint{
			EndpointArn:           ptr.String("__EndpointArn__"),
			ModelSourceIdentifier: ptr.String("__ModelSourceIdentifier__"),
			Status:                types.Status("REGISTERED"),
			StatusMessage:         ptr.String("__StatusMessage__"),
			CreatedAt:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			UpdatedAt:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			EndpointConfig: &types.EndpointConfigMemberSageMaker{
				Value: types.SageMakerEndpoint{
					InitialInstanceCount: ptr.Int32(1),
					InstanceType:         ptr.String("__InstanceType__"),
					ExecutionRole:        ptr.String("__ExecutionRole__"),
					KmsEncryptionKey:     ptr.String("__KmsEncryptionKey__"),
					Vpc: &types.VpcConfig{
						SubnetIds: []string{
							"__Member__",
							"__Member__",
						},
						SecurityGroupIds: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
			},
			EndpointStatus:        ptr.String("__EndpointStatus__"),
			EndpointStatusMessage: ptr.String("__EndpointStatusMessage__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("RegisterMarketplaceModelEndpoint.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.RegisterMarketplaceModelEndpoint(context.Background(), &RegisterMarketplaceModelEndpointInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "RegisterMarketplaceModelEndpoint.response", err)
	}
}

func TestCheckResponseSnapshot_StartAutomatedReasoningPolicyBuildWorkflow(t *testing.T) {
	want := &StartAutomatedReasoningPolicyBuildWorkflowOutput{
		PolicyArn:       ptr.String("__PolicyArn__"),
		BuildWorkflowId: ptr.String("__BuildWorkflowId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("StartAutomatedReasoningPolicyBuildWorkflow.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.StartAutomatedReasoningPolicyBuildWorkflow(context.Background(), &StartAutomatedReasoningPolicyBuildWorkflowInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StartAutomatedReasoningPolicyBuildWorkflow.response", err)
	}
}

func TestCheckResponseSnapshot_StartAutomatedReasoningPolicyTestWorkflow(t *testing.T) {
	want := &StartAutomatedReasoningPolicyTestWorkflowOutput{
		PolicyArn: ptr.String("__PolicyArn__"),
	}
	status, header, body, err := serdeRespReadSnapshot("StartAutomatedReasoningPolicyTestWorkflow.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.StartAutomatedReasoningPolicyTestWorkflow(context.Background(), &StartAutomatedReasoningPolicyTestWorkflowInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StartAutomatedReasoningPolicyTestWorkflow.response", err)
	}
}

func TestCheckResponseSnapshot_StopAdvancedPromptOptimizationJob(t *testing.T) {
	want := &StopAdvancedPromptOptimizationJobOutput{}
	status, header, body, err := serdeRespReadSnapshot("StopAdvancedPromptOptimizationJob.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.StopAdvancedPromptOptimizationJob(context.Background(), &StopAdvancedPromptOptimizationJobInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StopAdvancedPromptOptimizationJob.response", err)
	}
}

func TestCheckResponseSnapshot_StopEvaluationJob(t *testing.T) {
	want := &StopEvaluationJobOutput{}
	status, header, body, err := serdeRespReadSnapshot("StopEvaluationJob.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.StopEvaluationJob(context.Background(), &StopEvaluationJobInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StopEvaluationJob.response", err)
	}
}

func TestCheckResponseSnapshot_StopModelCustomizationJob(t *testing.T) {
	want := &StopModelCustomizationJobOutput{}
	status, header, body, err := serdeRespReadSnapshot("StopModelCustomizationJob.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.StopModelCustomizationJob(context.Background(), &StopModelCustomizationJobInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StopModelCustomizationJob.response", err)
	}
}

func TestCheckResponseSnapshot_StopModelInvocationJob(t *testing.T) {
	want := &StopModelInvocationJobOutput{}
	status, header, body, err := serdeRespReadSnapshot("StopModelInvocationJob.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.StopModelInvocationJob(context.Background(), &StopModelInvocationJobInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StopModelInvocationJob.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_UpdateAutomatedReasoningPolicy(t *testing.T) {
	want := &UpdateAutomatedReasoningPolicyOutput{
		PolicyArn:      ptr.String("__PolicyArn__"),
		Name:           ptr.String("__Name__"),
		DefinitionHash: ptr.String("__DefinitionHash__"),
		UpdatedAt:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateAutomatedReasoningPolicy.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.UpdateAutomatedReasoningPolicy(context.Background(), &UpdateAutomatedReasoningPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateAutomatedReasoningPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateAutomatedReasoningPolicyAnnotations(t *testing.T) {
	want := &UpdateAutomatedReasoningPolicyAnnotationsOutput{
		PolicyArn:         ptr.String("__PolicyArn__"),
		BuildWorkflowId:   ptr.String("__BuildWorkflowId__"),
		AnnotationSetHash: ptr.String("__AnnotationSetHash__"),
		UpdatedAt:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateAutomatedReasoningPolicyAnnotations.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.UpdateAutomatedReasoningPolicyAnnotations(context.Background(), &UpdateAutomatedReasoningPolicyAnnotationsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateAutomatedReasoningPolicyAnnotations.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateAutomatedReasoningPolicyTestCase(t *testing.T) {
	want := &UpdateAutomatedReasoningPolicyTestCaseOutput{
		PolicyArn:  ptr.String("__PolicyArn__"),
		TestCaseId: ptr.String("__TestCaseId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateAutomatedReasoningPolicyTestCase.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.UpdateAutomatedReasoningPolicyTestCase(context.Background(), &UpdateAutomatedReasoningPolicyTestCaseInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateAutomatedReasoningPolicyTestCase.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateCustomModelDeployment(t *testing.T) {
	want := &UpdateCustomModelDeploymentOutput{
		CustomModelDeploymentArn: ptr.String("__CustomModelDeploymentArn__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateCustomModelDeployment.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.UpdateCustomModelDeployment(context.Background(), &UpdateCustomModelDeploymentInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateCustomModelDeployment.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateGuardrail(t *testing.T) {
	want := &UpdateGuardrailOutput{
		GuardrailId:  ptr.String("__GuardrailId__"),
		GuardrailArn: ptr.String("__GuardrailArn__"),
		Version:      ptr.String("__Version__"),
		UpdatedAt:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateGuardrail.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.UpdateGuardrail(context.Background(), &UpdateGuardrailInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateGuardrail.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateMarketplaceModelEndpoint(t *testing.T) {
	want := &UpdateMarketplaceModelEndpointOutput{
		MarketplaceModelEndpoint: &types.MarketplaceModelEndpoint{
			EndpointArn:           ptr.String("__EndpointArn__"),
			ModelSourceIdentifier: ptr.String("__ModelSourceIdentifier__"),
			Status:                types.Status("REGISTERED"),
			StatusMessage:         ptr.String("__StatusMessage__"),
			CreatedAt:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			UpdatedAt:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			EndpointConfig: &types.EndpointConfigMemberSageMaker{
				Value: types.SageMakerEndpoint{
					InitialInstanceCount: ptr.Int32(1),
					InstanceType:         ptr.String("__InstanceType__"),
					ExecutionRole:        ptr.String("__ExecutionRole__"),
					KmsEncryptionKey:     ptr.String("__KmsEncryptionKey__"),
					Vpc: &types.VpcConfig{
						SubnetIds: []string{
							"__Member__",
							"__Member__",
						},
						SecurityGroupIds: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
			},
			EndpointStatus:        ptr.String("__EndpointStatus__"),
			EndpointStatusMessage: ptr.String("__EndpointStatusMessage__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateMarketplaceModelEndpoint.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.UpdateMarketplaceModelEndpoint(context.Background(), &UpdateMarketplaceModelEndpointInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateMarketplaceModelEndpoint.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateProvisionedModelThroughput(t *testing.T) {
	want := &UpdateProvisionedModelThroughputOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdateProvisionedModelThroughput.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.UpdateProvisionedModelThroughput(context.Background(), &UpdateProvisionedModelThroughputInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateProvisionedModelThroughput.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.BatchDeleteAdvancedPromptOptimizationJob(context.Background(), &BatchDeleteAdvancedPromptOptimizationJobInput{})
	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.BatchDeleteEvaluationJob(context.Background(), &BatchDeleteEvaluationJobInput{})
	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.BatchDeleteAdvancedPromptOptimizationJob(context.Background(), &BatchDeleteAdvancedPromptOptimizationJobInput{})
	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_ResourceInUseException(t *testing.T) {
	want := &types.ResourceInUseException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ResourceInUseException.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.DeleteAutomatedReasoningPolicy(context.Background(), &DeleteAutomatedReasoningPolicyInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ResourceInUseException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ResourceInUseException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ResourceInUseException.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.BatchDeleteEvaluationJob(context.Background(), &BatchDeleteEvaluationJobInput{})
	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.CreateAdvancedPromptOptimizationJob(context.Background(), &CreateAdvancedPromptOptimizationJobInput{})
	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_ServiceUnavailableException(t *testing.T) {
	want := &types.ServiceUnavailableException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ServiceUnavailableException.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.DeregisterMarketplaceModelEndpoint(context.Background(), &DeregisterMarketplaceModelEndpointInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ServiceUnavailableException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ServiceUnavailableException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ServiceUnavailableException.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.BatchDeleteAdvancedPromptOptimizationJob(context.Background(), &BatchDeleteAdvancedPromptOptimizationJobInput{})
	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_TooManyTagsException(t *testing.T) {
	want := &types.TooManyTagsException{
		Message:      ptr.String("__Message__"),
		ResourceName: ptr.String("__ResourceName__"),
	}
	status, header, body, err := serdeRespReadSnapshot("TooManyTagsException.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.CreateAdvancedPromptOptimizationJob(context.Background(), &CreateAdvancedPromptOptimizationJobInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.TooManyTagsException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.TooManyTagsException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "TooManyTagsException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ValidationException(t *testing.T) {
	want := &types.ValidationException{
		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.BatchDeleteAdvancedPromptOptimizationJob(context.Background(), &BatchDeleteAdvancedPromptOptimizationJobInput{})
	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)
	}
}
