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

//go:build response_snapshot

package apigatewayv2

import (
	"bufio"
	"bytes"
	"context"
	"errors"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/apigatewayv2/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_CreateApi(t *testing.T) {
	want := &CreateApiOutput{
		ApiEndpoint:               ptr.String("__ApiEndpoint__"),
		ApiGatewayManaged:         ptr.Bool(true),
		ApiId:                     ptr.String("__ApiId__"),
		ApiKeySelectionExpression: ptr.String("__ApiKeySelectionExpression__"),
		CorsConfiguration: &types.Cors{
			AllowCredentials: ptr.Bool(true),
			AllowHeaders: []string{
				"__Member__",
				"__Member__",
			},
			AllowMethods: []string{
				"__Member__",
				"__Member__",
			},
			AllowOrigins: []string{
				"__Member__",
				"__Member__",
			},
			ExposeHeaders: []string{
				"__Member__",
				"__Member__",
			},
			MaxAge: ptr.Int32(1),
		},
		CreatedDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		Description:               ptr.String("__Description__"),
		DisableSchemaValidation:   ptr.Bool(true),
		DisableExecuteApiEndpoint: ptr.Bool(true),
		ImportInfo: []string{
			"__Member__",
			"__Member__",
		},
		IpAddressType:            types.IpAddressType("ipv4"),
		Name:                     ptr.String("__Name__"),
		ProtocolType:             types.ProtocolType("WEBSOCKET"),
		RouteSelectionExpression: ptr.String("__RouteSelectionExpression__"),
		Tags: map[string]string{
			"key0": "__Value__",
		},
		Version: ptr.String("__Version__"),
		Warnings: []string{
			"__Member__",
			"__Member__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateApi.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.CreateApi(context.Background(), &CreateApiInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateApi.response", err)
	}
}

func TestCheckResponseSnapshot_CreateApiMapping(t *testing.T) {
	want := &CreateApiMappingOutput{
		ApiId:         ptr.String("__ApiId__"),
		ApiMappingId:  ptr.String("__ApiMappingId__"),
		ApiMappingKey: ptr.String("__ApiMappingKey__"),
		Stage:         ptr.String("__Stage__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateApiMapping.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.CreateApiMapping(context.Background(), &CreateApiMappingInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateApiMapping.response", err)
	}
}

func TestCheckResponseSnapshot_CreateAuthorizer(t *testing.T) {
	want := &CreateAuthorizerOutput{
		AuthorizerCredentialsArn:       ptr.String("__AuthorizerCredentialsArn__"),
		AuthorizerId:                   ptr.String("__AuthorizerId__"),
		AuthorizerPayloadFormatVersion: ptr.String("__AuthorizerPayloadFormatVersion__"),
		AuthorizerResultTtlInSeconds:   ptr.Int32(1),
		AuthorizerType:                 types.AuthorizerType("REQUEST"),
		AuthorizerUri:                  ptr.String("__AuthorizerUri__"),
		EnableSimpleResponses:          ptr.Bool(true),
		IdentitySource: []string{
			"__Member__",
			"__Member__",
		},
		IdentityValidationExpression: ptr.String("__IdentityValidationExpression__"),
		JwtConfiguration: &types.JWTConfiguration{
			Audience: []string{
				"__Member__",
				"__Member__",
			},
			Issuer: ptr.String("__Issuer__"),
		},
		Name: ptr.String("__Name__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateAuthorizer.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.CreateAuthorizer(context.Background(), &CreateAuthorizerInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateAuthorizer.response", err)
	}
}

func TestCheckResponseSnapshot_CreateDeployment(t *testing.T) {
	want := &CreateDeploymentOutput{
		AutoDeployed:            ptr.Bool(true),
		CreatedDate:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		DeploymentId:            ptr.String("__DeploymentId__"),
		DeploymentStatus:        types.DeploymentStatus("PENDING"),
		DeploymentStatusMessage: ptr.String("__DeploymentStatusMessage__"),
		Description:             ptr.String("__Description__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateDeployment.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.CreateDeployment(context.Background(), &CreateDeploymentInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateDeployment.response", err)
	}
}

func TestCheckResponseSnapshot_CreateDomainName(t *testing.T) {
	want := &CreateDomainNameOutput{
		ApiMappingSelectionExpression: ptr.String("__ApiMappingSelectionExpression__"),
		DomainName:                    ptr.String("__DomainName__"),
		DomainNameArn:                 ptr.String("__DomainNameArn__"),
		DomainNameConfigurations: []types.DomainNameConfiguration{
			{
				ApiGatewayDomainName:                ptr.String("__ApiGatewayDomainName__"),
				CertificateArn:                      ptr.String("__CertificateArn__"),
				CertificateName:                     ptr.String("__CertificateName__"),
				CertificateUploadDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				DomainNameStatus:                    types.DomainNameStatus("AVAILABLE"),
				DomainNameStatusMessage:             ptr.String("__DomainNameStatusMessage__"),
				EndpointType:                        types.EndpointType("REGIONAL"),
				HostedZoneId:                        ptr.String("__HostedZoneId__"),
				IpAddressType:                       types.IpAddressType("ipv4"),
				SecurityPolicy:                      types.SecurityPolicy("TLS_1_0"),
				OwnershipVerificationCertificateArn: ptr.String("__OwnershipVerificationCertificateArn__"),
			},
			{
				ApiGatewayDomainName:                ptr.String("__ApiGatewayDomainName__"),
				CertificateArn:                      ptr.String("__CertificateArn__"),
				CertificateName:                     ptr.String("__CertificateName__"),
				CertificateUploadDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				DomainNameStatus:                    types.DomainNameStatus("AVAILABLE"),
				DomainNameStatusMessage:             ptr.String("__DomainNameStatusMessage__"),
				EndpointType:                        types.EndpointType("REGIONAL"),
				HostedZoneId:                        ptr.String("__HostedZoneId__"),
				IpAddressType:                       types.IpAddressType("ipv4"),
				SecurityPolicy:                      types.SecurityPolicy("TLS_1_0"),
				OwnershipVerificationCertificateArn: ptr.String("__OwnershipVerificationCertificateArn__"),
			},
		},
		MutualTlsAuthentication: &types.MutualTlsAuthentication{
			TruststoreUri:     ptr.String("__TruststoreUri__"),
			TruststoreVersion: ptr.String("__TruststoreVersion__"),
			TruststoreWarnings: []string{
				"__Member__",
				"__Member__",
			},
		},
		RoutingMode: types.RoutingMode("API_MAPPING_ONLY"),
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateDomainName.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.CreateDomainName(context.Background(), &CreateDomainNameInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateDomainName.response", err)
	}
}

func TestCheckResponseSnapshot_CreateIntegration(t *testing.T) {
	want := &CreateIntegrationOutput{
		ApiGatewayManaged:                      ptr.Bool(true),
		ConnectionId:                           ptr.String("__ConnectionId__"),
		ConnectionType:                         types.ConnectionType("INTERNET"),
		ContentHandlingStrategy:                types.ContentHandlingStrategy("CONVERT_TO_BINARY"),
		CredentialsArn:                         ptr.String("__CredentialsArn__"),
		Description:                            ptr.String("__Description__"),
		IntegrationId:                          ptr.String("__IntegrationId__"),
		IntegrationMethod:                      ptr.String("__IntegrationMethod__"),
		IntegrationResponseSelectionExpression: ptr.String("__IntegrationResponseSelectionExpression__"),
		IntegrationSubtype:                     ptr.String("__IntegrationSubtype__"),
		IntegrationType:                        types.IntegrationType("AWS"),
		IntegrationUri:                         ptr.String("__IntegrationUri__"),
		PassthroughBehavior:                    types.PassthroughBehavior("WHEN_NO_MATCH"),
		PayloadFormatVersion:                   ptr.String("__PayloadFormatVersion__"),
		RequestParameters: map[string]string{
			"key0": "__Value__",
		},
		RequestTemplates: map[string]string{
			"key0": "__Value__",
		},
		ResponseParameters: map[string]map[string]string{
			"key0": {
				"key0": "__Value__",
			},
		},
		TemplateSelectionExpression: ptr.String("__TemplateSelectionExpression__"),
		TimeoutInMillis:             ptr.Int32(1),
		TlsConfig: &types.TlsConfig{
			ServerNameToVerify: ptr.String("__ServerNameToVerify__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateIntegration.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.CreateIntegration(context.Background(), &CreateIntegrationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateIntegration.response", err)
	}
}

func TestCheckResponseSnapshot_CreateIntegrationResponse(t *testing.T) {
	want := &CreateIntegrationResponseOutput{
		ContentHandlingStrategy: types.ContentHandlingStrategy("CONVERT_TO_BINARY"),
		IntegrationResponseId:   ptr.String("__IntegrationResponseId__"),
		IntegrationResponseKey:  ptr.String("__IntegrationResponseKey__"),
		ResponseParameters: map[string]string{
			"key0": "__Value__",
		},
		ResponseTemplates: map[string]string{
			"key0": "__Value__",
		},
		TemplateSelectionExpression: ptr.String("__TemplateSelectionExpression__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateIntegrationResponse.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.CreateIntegrationResponse(context.Background(), &CreateIntegrationResponseInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateIntegrationResponse.response", err)
	}
}

func TestCheckResponseSnapshot_CreateModel(t *testing.T) {
	want := &CreateModelOutput{
		ContentType: ptr.String("__ContentType__"),
		Description: ptr.String("__Description__"),
		ModelId:     ptr.String("__ModelId__"),
		Name:        ptr.String("__Name__"),
		Schema:      ptr.String("__Schema__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateModel.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.CreateModel(context.Background(), &CreateModelInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateModel.response", err)
	}
}

func TestCheckResponseSnapshot_CreatePortal(t *testing.T) {
	want := &CreatePortalOutput{
		Authorization: &types.Authorization{
			CognitoConfig: &types.CognitoConfig{
				AppClientId:    ptr.String("__AppClientId__"),
				UserPoolArn:    ptr.String("__UserPoolArn__"),
				UserPoolDomain: ptr.String("__UserPoolDomain__"),
			},
			None: &types.None{},
		},
		EndpointConfiguration: &types.EndpointConfigurationResponse{
			CertificateArn:           ptr.String("__CertificateArn__"),
			DomainName:               ptr.String("__DomainName__"),
			PortalDefaultDomainName:  ptr.String("__PortalDefaultDomainName__"),
			PortalDomainHostedZoneId: ptr.String("__PortalDomainHostedZoneId__"),
		},
		IncludedPortalProductArns: []string{
			"__Member__",
			"__Member__",
		},
		LastModified:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		LastPublished:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		LastPublishedDescription: ptr.String("__LastPublishedDescription__"),
		PortalArn:                ptr.String("__PortalArn__"),
		PortalContent: &types.PortalContent{
			Description: ptr.String("__Description__"),
			DisplayName: ptr.String("__DisplayName__"),
			Theme: &types.PortalTheme{
				CustomColors: &types.CustomColors{
					AccentColor:          ptr.String("__AccentColor__"),
					BackgroundColor:      ptr.String("__BackgroundColor__"),
					ErrorValidationColor: ptr.String("__ErrorValidationColor__"),
					HeaderColor:          ptr.String("__HeaderColor__"),
					NavigationColor:      ptr.String("__NavigationColor__"),
					TextColor:            ptr.String("__TextColor__"),
				},
				LogoLastUploaded: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		PortalId:          ptr.String("__PortalId__"),
		PublishStatus:     types.PublishStatus("PUBLISHED"),
		RumAppMonitorName: ptr.String("__RumAppMonitorName__"),
		StatusException: &types.StatusException{
			Exception: ptr.String("__Exception__"),
			Message:   ptr.String("__Message__"),
		},
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreatePortal.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.CreatePortal(context.Background(), &CreatePortalInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreatePortal.response", err)
	}
}

func TestCheckResponseSnapshot_CreatePortalProduct(t *testing.T) {
	want := &CreatePortalProductOutput{
		Description: ptr.String("__Description__"),
		DisplayName: ptr.String("__DisplayName__"),
		DisplayOrder: &types.DisplayOrder{
			Contents: []types.Section{
				{
					ProductRestEndpointPageArns: []string{
						"__Member__",
						"__Member__",
					},
					SectionName: ptr.String("__SectionName__"),
				},
				{
					ProductRestEndpointPageArns: []string{
						"__Member__",
						"__Member__",
					},
					SectionName: ptr.String("__SectionName__"),
				},
			},
			OverviewPageArn: ptr.String("__OverviewPageArn__"),
			ProductPageArns: []string{
				"__Member__",
				"__Member__",
			},
		},
		LastModified:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		PortalProductArn: ptr.String("__PortalProductArn__"),
		PortalProductId:  ptr.String("__PortalProductId__"),
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreatePortalProduct.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.CreatePortalProduct(context.Background(), &CreatePortalProductInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreatePortalProduct.response", err)
	}
}

func TestCheckResponseSnapshot_CreateProductPage(t *testing.T) {
	want := &CreateProductPageOutput{
		DisplayContent: &types.DisplayContent{
			Body:  ptr.String("__Body__"),
			Title: ptr.String("__Title__"),
		},
		LastModified:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ProductPageArn: ptr.String("__ProductPageArn__"),
		ProductPageId:  ptr.String("__ProductPageId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateProductPage.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.CreateProductPage(context.Background(), &CreateProductPageInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateProductPage.response", err)
	}
}

func TestCheckResponseSnapshot_CreateProductRestEndpointPage(t *testing.T) {
	want := &CreateProductRestEndpointPageOutput{
		DisplayContent: &types.EndpointDisplayContentResponse{
			Body:          ptr.String("__Body__"),
			Endpoint:      ptr.String("__Endpoint__"),
			OperationName: ptr.String("__OperationName__"),
		},
		LastModified:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ProductRestEndpointPageArn: ptr.String("__ProductRestEndpointPageArn__"),
		ProductRestEndpointPageId:  ptr.String("__ProductRestEndpointPageId__"),
		RestEndpointIdentifier: &types.RestEndpointIdentifier{
			IdentifierParts: &types.IdentifierParts{
				Method:    ptr.String("__Method__"),
				Path:      ptr.String("__Path__"),
				RestApiId: ptr.String("__RestApiId__"),
				Stage:     ptr.String("__Stage__"),
			},
		},
		Status: types.Status("AVAILABLE"),
		StatusException: &types.StatusException{
			Exception: ptr.String("__Exception__"),
			Message:   ptr.String("__Message__"),
		},
		TryItState: types.TryItState("ENABLED"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateProductRestEndpointPage.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.CreateProductRestEndpointPage(context.Background(), &CreateProductRestEndpointPageInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateProductRestEndpointPage.response", err)
	}
}

func TestCheckResponseSnapshot_CreateRoute(t *testing.T) {
	want := &CreateRouteOutput{
		ApiGatewayManaged: ptr.Bool(true),
		ApiKeyRequired:    ptr.Bool(true),
		AuthorizationScopes: []string{
			"__Member__",
			"__Member__",
		},
		AuthorizationType:        types.AuthorizationType("NONE"),
		AuthorizerId:             ptr.String("__AuthorizerId__"),
		ModelSelectionExpression: ptr.String("__ModelSelectionExpression__"),
		OperationName:            ptr.String("__OperationName__"),
		RequestModels: map[string]string{
			"key0": "__Value__",
		},
		RequestParameters: map[string]types.ParameterConstraints{
			"key0": {
				Required: ptr.Bool(true),
			},
		},
		RouteId:                          ptr.String("__RouteId__"),
		RouteKey:                         ptr.String("__RouteKey__"),
		RouteResponseSelectionExpression: ptr.String("__RouteResponseSelectionExpression__"),
		Target:                           ptr.String("__Target__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateRoute.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.CreateRoute(context.Background(), &CreateRouteInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateRoute.response", err)
	}
}

func TestCheckResponseSnapshot_CreateRouteResponse(t *testing.T) {
	want := &CreateRouteResponseOutput{
		ModelSelectionExpression: ptr.String("__ModelSelectionExpression__"),
		ResponseModels: map[string]string{
			"key0": "__Value__",
		},
		ResponseParameters: map[string]types.ParameterConstraints{
			"key0": {
				Required: ptr.Bool(true),
			},
		},
		RouteResponseId:  ptr.String("__RouteResponseId__"),
		RouteResponseKey: ptr.String("__RouteResponseKey__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateRouteResponse.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.CreateRouteResponse(context.Background(), &CreateRouteResponseInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateRouteResponse.response", err)
	}
}

func TestCheckResponseSnapshot_CreateRoutingRule(t *testing.T) {
	want := &CreateRoutingRuleOutput{
		Actions: []types.RoutingRuleAction{
			{
				InvokeApi: &types.RoutingRuleActionInvokeApi{
					ApiId:         ptr.String("__ApiId__"),
					Stage:         ptr.String("__Stage__"),
					StripBasePath: ptr.Bool(true),
				},
			},
			{
				InvokeApi: &types.RoutingRuleActionInvokeApi{
					ApiId:         ptr.String("__ApiId__"),
					Stage:         ptr.String("__Stage__"),
					StripBasePath: ptr.Bool(true),
				},
			},
		},
		Conditions: []types.RoutingRuleCondition{
			{
				MatchBasePaths: &types.RoutingRuleMatchBasePaths{
					AnyOf: []string{
						"__Member__",
						"__Member__",
					},
				},
				MatchHeaders: &types.RoutingRuleMatchHeaders{
					AnyOf: []types.RoutingRuleMatchHeaderValue{
						{
							Header:    ptr.String("__Header__"),
							ValueGlob: ptr.String("__ValueGlob__"),
						},
						{
							Header:    ptr.String("__Header__"),
							ValueGlob: ptr.String("__ValueGlob__"),
						},
					},
				},
			},
			{
				MatchBasePaths: &types.RoutingRuleMatchBasePaths{
					AnyOf: []string{
						"__Member__",
						"__Member__",
					},
				},
				MatchHeaders: &types.RoutingRuleMatchHeaders{
					AnyOf: []types.RoutingRuleMatchHeaderValue{
						{
							Header:    ptr.String("__Header__"),
							ValueGlob: ptr.String("__ValueGlob__"),
						},
						{
							Header:    ptr.String("__Header__"),
							ValueGlob: ptr.String("__ValueGlob__"),
						},
					},
				},
			},
		},
		Priority:       ptr.Int32(1),
		RoutingRuleArn: ptr.String("__RoutingRuleArn__"),
		RoutingRuleId:  ptr.String("__RoutingRuleId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateRoutingRule.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.CreateRoutingRule(context.Background(), &CreateRoutingRuleInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateRoutingRule.response", err)
	}
}

func TestCheckResponseSnapshot_CreateStage(t *testing.T) {
	want := &CreateStageOutput{
		AccessLogSettings: &types.AccessLogSettings{
			DestinationArn: ptr.String("__DestinationArn__"),
			Format:         ptr.String("__Format__"),
		},
		ApiGatewayManaged:   ptr.Bool(true),
		AutoDeploy:          ptr.Bool(true),
		ClientCertificateId: ptr.String("__ClientCertificateId__"),
		CreatedDate:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		DefaultRouteSettings: &types.RouteSettings{
			DataTraceEnabled:       ptr.Bool(true),
			DetailedMetricsEnabled: ptr.Bool(true),
			LoggingLevel:           types.LoggingLevel("ERROR"),
			ThrottlingBurstLimit:   ptr.Int32(1),
			ThrottlingRateLimit:    ptr.Float64(1.0),
		},
		DeploymentId:                ptr.String("__DeploymentId__"),
		Description:                 ptr.String("__Description__"),
		LastDeploymentStatusMessage: ptr.String("__LastDeploymentStatusMessage__"),
		LastUpdatedDate:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		RouteSettings: map[string]types.RouteSettings{
			"key0": {
				DataTraceEnabled:       ptr.Bool(true),
				DetailedMetricsEnabled: ptr.Bool(true),
				LoggingLevel:           types.LoggingLevel("ERROR"),
				ThrottlingBurstLimit:   ptr.Int32(1),
				ThrottlingRateLimit:    ptr.Float64(1.0),
			},
		},
		StageName: ptr.String("__StageName__"),
		StageVariables: map[string]string{
			"key0": "__Value__",
		},
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateStage.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.CreateStage(context.Background(), &CreateStageInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateStage.response", err)
	}
}

func TestCheckResponseSnapshot_CreateVpcLink(t *testing.T) {
	want := &CreateVpcLinkOutput{
		CreatedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		Name:        ptr.String("__Name__"),
		SecurityGroupIds: []string{
			"__Member__",
			"__Member__",
		},
		SubnetIds: []string{
			"__Member__",
			"__Member__",
		},
		Tags: map[string]string{
			"key0": "__Value__",
		},
		VpcLinkId:            ptr.String("__VpcLinkId__"),
		VpcLinkStatus:        types.VpcLinkStatus("PENDING"),
		VpcLinkStatusMessage: ptr.String("__VpcLinkStatusMessage__"),
		VpcLinkVersion:       types.VpcLinkVersion("V2"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateVpcLink.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.CreateVpcLink(context.Background(), &CreateVpcLinkInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateVpcLink.response", err)
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func TestCheckResponseSnapshot_GetApi(t *testing.T) {
	want := &GetApiOutput{
		ApiEndpoint:               ptr.String("__ApiEndpoint__"),
		ApiGatewayManaged:         ptr.Bool(true),
		ApiId:                     ptr.String("__ApiId__"),
		ApiKeySelectionExpression: ptr.String("__ApiKeySelectionExpression__"),
		CorsConfiguration: &types.Cors{
			AllowCredentials: ptr.Bool(true),
			AllowHeaders: []string{
				"__Member__",
				"__Member__",
			},
			AllowMethods: []string{
				"__Member__",
				"__Member__",
			},
			AllowOrigins: []string{
				"__Member__",
				"__Member__",
			},
			ExposeHeaders: []string{
				"__Member__",
				"__Member__",
			},
			MaxAge: ptr.Int32(1),
		},
		CreatedDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		Description:               ptr.String("__Description__"),
		DisableSchemaValidation:   ptr.Bool(true),
		DisableExecuteApiEndpoint: ptr.Bool(true),
		ImportInfo: []string{
			"__Member__",
			"__Member__",
		},
		IpAddressType:            types.IpAddressType("ipv4"),
		Name:                     ptr.String("__Name__"),
		ProtocolType:             types.ProtocolType("WEBSOCKET"),
		RouteSelectionExpression: ptr.String("__RouteSelectionExpression__"),
		Tags: map[string]string{
			"key0": "__Value__",
		},
		Version: ptr.String("__Version__"),
		Warnings: []string{
			"__Member__",
			"__Member__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetApi.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.GetApi(context.Background(), &GetApiInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetApi.response", err)
	}
}

func TestCheckResponseSnapshot_GetApiMapping(t *testing.T) {
	want := &GetApiMappingOutput{
		ApiId:         ptr.String("__ApiId__"),
		ApiMappingId:  ptr.String("__ApiMappingId__"),
		ApiMappingKey: ptr.String("__ApiMappingKey__"),
		Stage:         ptr.String("__Stage__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetApiMapping.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.GetApiMapping(context.Background(), &GetApiMappingInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetApiMapping.response", err)
	}
}

func TestCheckResponseSnapshot_GetApiMappings(t *testing.T) {
	want := &GetApiMappingsOutput{
		Items: []types.ApiMapping{
			{
				ApiId:         ptr.String("__ApiId__"),
				ApiMappingId:  ptr.String("__ApiMappingId__"),
				ApiMappingKey: ptr.String("__ApiMappingKey__"),
				Stage:         ptr.String("__Stage__"),
			},
			{
				ApiId:         ptr.String("__ApiId__"),
				ApiMappingId:  ptr.String("__ApiMappingId__"),
				ApiMappingKey: ptr.String("__ApiMappingKey__"),
				Stage:         ptr.String("__Stage__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetApiMappings.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.GetApiMappings(context.Background(), &GetApiMappingsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetApiMappings.response", err)
	}
}

func TestCheckResponseSnapshot_GetApis(t *testing.T) {
	want := &GetApisOutput{
		Items: []types.Api{
			{
				ApiEndpoint:               ptr.String("__ApiEndpoint__"),
				ApiGatewayManaged:         ptr.Bool(true),
				ApiId:                     ptr.String("__ApiId__"),
				ApiKeySelectionExpression: ptr.String("__ApiKeySelectionExpression__"),
				CorsConfiguration: &types.Cors{
					AllowCredentials: ptr.Bool(true),
					AllowHeaders: []string{
						"__Member__",
						"__Member__",
					},
					AllowMethods: []string{
						"__Member__",
						"__Member__",
					},
					AllowOrigins: []string{
						"__Member__",
						"__Member__",
					},
					ExposeHeaders: []string{
						"__Member__",
						"__Member__",
					},
					MaxAge: ptr.Int32(1),
				},
				CreatedDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Description:               ptr.String("__Description__"),
				DisableSchemaValidation:   ptr.Bool(true),
				DisableExecuteApiEndpoint: ptr.Bool(true),
				ImportInfo: []string{
					"__Member__",
					"__Member__",
				},
				IpAddressType:            types.IpAddressType("ipv4"),
				Name:                     ptr.String("__Name__"),
				ProtocolType:             types.ProtocolType("WEBSOCKET"),
				RouteSelectionExpression: ptr.String("__RouteSelectionExpression__"),
				Tags: map[string]string{
					"key0": "__Value__",
				},
				Version: ptr.String("__Version__"),
				Warnings: []string{
					"__Member__",
					"__Member__",
				},
			},
			{
				ApiEndpoint:               ptr.String("__ApiEndpoint__"),
				ApiGatewayManaged:         ptr.Bool(true),
				ApiId:                     ptr.String("__ApiId__"),
				ApiKeySelectionExpression: ptr.String("__ApiKeySelectionExpression__"),
				CorsConfiguration: &types.Cors{
					AllowCredentials: ptr.Bool(true),
					AllowHeaders: []string{
						"__Member__",
						"__Member__",
					},
					AllowMethods: []string{
						"__Member__",
						"__Member__",
					},
					AllowOrigins: []string{
						"__Member__",
						"__Member__",
					},
					ExposeHeaders: []string{
						"__Member__",
						"__Member__",
					},
					MaxAge: ptr.Int32(1),
				},
				CreatedDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Description:               ptr.String("__Description__"),
				DisableSchemaValidation:   ptr.Bool(true),
				DisableExecuteApiEndpoint: ptr.Bool(true),
				ImportInfo: []string{
					"__Member__",
					"__Member__",
				},
				IpAddressType:            types.IpAddressType("ipv4"),
				Name:                     ptr.String("__Name__"),
				ProtocolType:             types.ProtocolType("WEBSOCKET"),
				RouteSelectionExpression: ptr.String("__RouteSelectionExpression__"),
				Tags: map[string]string{
					"key0": "__Value__",
				},
				Version: ptr.String("__Version__"),
				Warnings: []string{
					"__Member__",
					"__Member__",
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetApis.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.GetApis(context.Background(), &GetApisInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetApis.response", err)
	}
}

func TestCheckResponseSnapshot_GetAuthorizer(t *testing.T) {
	want := &GetAuthorizerOutput{
		AuthorizerCredentialsArn:       ptr.String("__AuthorizerCredentialsArn__"),
		AuthorizerId:                   ptr.String("__AuthorizerId__"),
		AuthorizerPayloadFormatVersion: ptr.String("__AuthorizerPayloadFormatVersion__"),
		AuthorizerResultTtlInSeconds:   ptr.Int32(1),
		AuthorizerType:                 types.AuthorizerType("REQUEST"),
		AuthorizerUri:                  ptr.String("__AuthorizerUri__"),
		EnableSimpleResponses:          ptr.Bool(true),
		IdentitySource: []string{
			"__Member__",
			"__Member__",
		},
		IdentityValidationExpression: ptr.String("__IdentityValidationExpression__"),
		JwtConfiguration: &types.JWTConfiguration{
			Audience: []string{
				"__Member__",
				"__Member__",
			},
			Issuer: ptr.String("__Issuer__"),
		},
		Name: ptr.String("__Name__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetAuthorizer.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.GetAuthorizer(context.Background(), &GetAuthorizerInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetAuthorizer.response", err)
	}
}

func TestCheckResponseSnapshot_GetAuthorizers(t *testing.T) {
	want := &GetAuthorizersOutput{
		Items: []types.Authorizer{
			{
				AuthorizerCredentialsArn:       ptr.String("__AuthorizerCredentialsArn__"),
				AuthorizerId:                   ptr.String("__AuthorizerId__"),
				AuthorizerPayloadFormatVersion: ptr.String("__AuthorizerPayloadFormatVersion__"),
				AuthorizerResultTtlInSeconds:   ptr.Int32(1),
				AuthorizerType:                 types.AuthorizerType("REQUEST"),
				AuthorizerUri:                  ptr.String("__AuthorizerUri__"),
				EnableSimpleResponses:          ptr.Bool(true),
				IdentitySource: []string{
					"__Member__",
					"__Member__",
				},
				IdentityValidationExpression: ptr.String("__IdentityValidationExpression__"),
				JwtConfiguration: &types.JWTConfiguration{
					Audience: []string{
						"__Member__",
						"__Member__",
					},
					Issuer: ptr.String("__Issuer__"),
				},
				Name: ptr.String("__Name__"),
			},
			{
				AuthorizerCredentialsArn:       ptr.String("__AuthorizerCredentialsArn__"),
				AuthorizerId:                   ptr.String("__AuthorizerId__"),
				AuthorizerPayloadFormatVersion: ptr.String("__AuthorizerPayloadFormatVersion__"),
				AuthorizerResultTtlInSeconds:   ptr.Int32(1),
				AuthorizerType:                 types.AuthorizerType("REQUEST"),
				AuthorizerUri:                  ptr.String("__AuthorizerUri__"),
				EnableSimpleResponses:          ptr.Bool(true),
				IdentitySource: []string{
					"__Member__",
					"__Member__",
				},
				IdentityValidationExpression: ptr.String("__IdentityValidationExpression__"),
				JwtConfiguration: &types.JWTConfiguration{
					Audience: []string{
						"__Member__",
						"__Member__",
					},
					Issuer: ptr.String("__Issuer__"),
				},
				Name: ptr.String("__Name__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetAuthorizers.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.GetAuthorizers(context.Background(), &GetAuthorizersInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetAuthorizers.response", err)
	}
}

func TestCheckResponseSnapshot_GetDeployment(t *testing.T) {
	want := &GetDeploymentOutput{
		AutoDeployed:            ptr.Bool(true),
		CreatedDate:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		DeploymentId:            ptr.String("__DeploymentId__"),
		DeploymentStatus:        types.DeploymentStatus("PENDING"),
		DeploymentStatusMessage: ptr.String("__DeploymentStatusMessage__"),
		Description:             ptr.String("__Description__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetDeployment.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.GetDeployment(context.Background(), &GetDeploymentInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetDeployment.response", err)
	}
}

func TestCheckResponseSnapshot_GetDeployments(t *testing.T) {
	want := &GetDeploymentsOutput{
		Items: []types.Deployment{
			{
				AutoDeployed:            ptr.Bool(true),
				CreatedDate:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				DeploymentId:            ptr.String("__DeploymentId__"),
				DeploymentStatus:        types.DeploymentStatus("PENDING"),
				DeploymentStatusMessage: ptr.String("__DeploymentStatusMessage__"),
				Description:             ptr.String("__Description__"),
			},
			{
				AutoDeployed:            ptr.Bool(true),
				CreatedDate:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				DeploymentId:            ptr.String("__DeploymentId__"),
				DeploymentStatus:        types.DeploymentStatus("PENDING"),
				DeploymentStatusMessage: ptr.String("__DeploymentStatusMessage__"),
				Description:             ptr.String("__Description__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetDeployments.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.GetDeployments(context.Background(), &GetDeploymentsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetDeployments.response", err)
	}
}

func TestCheckResponseSnapshot_GetDomainName(t *testing.T) {
	want := &GetDomainNameOutput{
		ApiMappingSelectionExpression: ptr.String("__ApiMappingSelectionExpression__"),
		DomainName:                    ptr.String("__DomainName__"),
		DomainNameArn:                 ptr.String("__DomainNameArn__"),
		DomainNameConfigurations: []types.DomainNameConfiguration{
			{
				ApiGatewayDomainName:                ptr.String("__ApiGatewayDomainName__"),
				CertificateArn:                      ptr.String("__CertificateArn__"),
				CertificateName:                     ptr.String("__CertificateName__"),
				CertificateUploadDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				DomainNameStatus:                    types.DomainNameStatus("AVAILABLE"),
				DomainNameStatusMessage:             ptr.String("__DomainNameStatusMessage__"),
				EndpointType:                        types.EndpointType("REGIONAL"),
				HostedZoneId:                        ptr.String("__HostedZoneId__"),
				IpAddressType:                       types.IpAddressType("ipv4"),
				SecurityPolicy:                      types.SecurityPolicy("TLS_1_0"),
				OwnershipVerificationCertificateArn: ptr.String("__OwnershipVerificationCertificateArn__"),
			},
			{
				ApiGatewayDomainName:                ptr.String("__ApiGatewayDomainName__"),
				CertificateArn:                      ptr.String("__CertificateArn__"),
				CertificateName:                     ptr.String("__CertificateName__"),
				CertificateUploadDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				DomainNameStatus:                    types.DomainNameStatus("AVAILABLE"),
				DomainNameStatusMessage:             ptr.String("__DomainNameStatusMessage__"),
				EndpointType:                        types.EndpointType("REGIONAL"),
				HostedZoneId:                        ptr.String("__HostedZoneId__"),
				IpAddressType:                       types.IpAddressType("ipv4"),
				SecurityPolicy:                      types.SecurityPolicy("TLS_1_0"),
				OwnershipVerificationCertificateArn: ptr.String("__OwnershipVerificationCertificateArn__"),
			},
		},
		MutualTlsAuthentication: &types.MutualTlsAuthentication{
			TruststoreUri:     ptr.String("__TruststoreUri__"),
			TruststoreVersion: ptr.String("__TruststoreVersion__"),
			TruststoreWarnings: []string{
				"__Member__",
				"__Member__",
			},
		},
		RoutingMode: types.RoutingMode("API_MAPPING_ONLY"),
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetDomainName.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.GetDomainName(context.Background(), &GetDomainNameInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetDomainName.response", err)
	}
}

func TestCheckResponseSnapshot_GetDomainNames(t *testing.T) {
	want := &GetDomainNamesOutput{
		Items: []types.DomainName{
			{
				ApiMappingSelectionExpression: ptr.String("__ApiMappingSelectionExpression__"),
				DomainName:                    ptr.String("__DomainName__"),
				DomainNameArn:                 ptr.String("__DomainNameArn__"),
				DomainNameConfigurations: []types.DomainNameConfiguration{
					{
						ApiGatewayDomainName:                ptr.String("__ApiGatewayDomainName__"),
						CertificateArn:                      ptr.String("__CertificateArn__"),
						CertificateName:                     ptr.String("__CertificateName__"),
						CertificateUploadDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						DomainNameStatus:                    types.DomainNameStatus("AVAILABLE"),
						DomainNameStatusMessage:             ptr.String("__DomainNameStatusMessage__"),
						EndpointType:                        types.EndpointType("REGIONAL"),
						HostedZoneId:                        ptr.String("__HostedZoneId__"),
						IpAddressType:                       types.IpAddressType("ipv4"),
						SecurityPolicy:                      types.SecurityPolicy("TLS_1_0"),
						OwnershipVerificationCertificateArn: ptr.String("__OwnershipVerificationCertificateArn__"),
					},
					{
						ApiGatewayDomainName:                ptr.String("__ApiGatewayDomainName__"),
						CertificateArn:                      ptr.String("__CertificateArn__"),
						CertificateName:                     ptr.String("__CertificateName__"),
						CertificateUploadDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						DomainNameStatus:                    types.DomainNameStatus("AVAILABLE"),
						DomainNameStatusMessage:             ptr.String("__DomainNameStatusMessage__"),
						EndpointType:                        types.EndpointType("REGIONAL"),
						HostedZoneId:                        ptr.String("__HostedZoneId__"),
						IpAddressType:                       types.IpAddressType("ipv4"),
						SecurityPolicy:                      types.SecurityPolicy("TLS_1_0"),
						OwnershipVerificationCertificateArn: ptr.String("__OwnershipVerificationCertificateArn__"),
					},
				},
				MutualTlsAuthentication: &types.MutualTlsAuthentication{
					TruststoreUri:     ptr.String("__TruststoreUri__"),
					TruststoreVersion: ptr.String("__TruststoreVersion__"),
					TruststoreWarnings: []string{
						"__Member__",
						"__Member__",
					},
				},
				RoutingMode: types.RoutingMode("API_MAPPING_ONLY"),
				Tags: map[string]string{
					"key0": "__Value__",
				},
			},
			{
				ApiMappingSelectionExpression: ptr.String("__ApiMappingSelectionExpression__"),
				DomainName:                    ptr.String("__DomainName__"),
				DomainNameArn:                 ptr.String("__DomainNameArn__"),
				DomainNameConfigurations: []types.DomainNameConfiguration{
					{
						ApiGatewayDomainName:                ptr.String("__ApiGatewayDomainName__"),
						CertificateArn:                      ptr.String("__CertificateArn__"),
						CertificateName:                     ptr.String("__CertificateName__"),
						CertificateUploadDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						DomainNameStatus:                    types.DomainNameStatus("AVAILABLE"),
						DomainNameStatusMessage:             ptr.String("__DomainNameStatusMessage__"),
						EndpointType:                        types.EndpointType("REGIONAL"),
						HostedZoneId:                        ptr.String("__HostedZoneId__"),
						IpAddressType:                       types.IpAddressType("ipv4"),
						SecurityPolicy:                      types.SecurityPolicy("TLS_1_0"),
						OwnershipVerificationCertificateArn: ptr.String("__OwnershipVerificationCertificateArn__"),
					},
					{
						ApiGatewayDomainName:                ptr.String("__ApiGatewayDomainName__"),
						CertificateArn:                      ptr.String("__CertificateArn__"),
						CertificateName:                     ptr.String("__CertificateName__"),
						CertificateUploadDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						DomainNameStatus:                    types.DomainNameStatus("AVAILABLE"),
						DomainNameStatusMessage:             ptr.String("__DomainNameStatusMessage__"),
						EndpointType:                        types.EndpointType("REGIONAL"),
						HostedZoneId:                        ptr.String("__HostedZoneId__"),
						IpAddressType:                       types.IpAddressType("ipv4"),
						SecurityPolicy:                      types.SecurityPolicy("TLS_1_0"),
						OwnershipVerificationCertificateArn: ptr.String("__OwnershipVerificationCertificateArn__"),
					},
				},
				MutualTlsAuthentication: &types.MutualTlsAuthentication{
					TruststoreUri:     ptr.String("__TruststoreUri__"),
					TruststoreVersion: ptr.String("__TruststoreVersion__"),
					TruststoreWarnings: []string{
						"__Member__",
						"__Member__",
					},
				},
				RoutingMode: types.RoutingMode("API_MAPPING_ONLY"),
				Tags: map[string]string{
					"key0": "__Value__",
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetDomainNames.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.GetDomainNames(context.Background(), &GetDomainNamesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetDomainNames.response", err)
	}
}

func TestCheckResponseSnapshot_GetIntegration(t *testing.T) {
	want := &GetIntegrationOutput{
		ApiGatewayManaged:                      ptr.Bool(true),
		ConnectionId:                           ptr.String("__ConnectionId__"),
		ConnectionType:                         types.ConnectionType("INTERNET"),
		ContentHandlingStrategy:                types.ContentHandlingStrategy("CONVERT_TO_BINARY"),
		CredentialsArn:                         ptr.String("__CredentialsArn__"),
		Description:                            ptr.String("__Description__"),
		IntegrationId:                          ptr.String("__IntegrationId__"),
		IntegrationMethod:                      ptr.String("__IntegrationMethod__"),
		IntegrationResponseSelectionExpression: ptr.String("__IntegrationResponseSelectionExpression__"),
		IntegrationSubtype:                     ptr.String("__IntegrationSubtype__"),
		IntegrationType:                        types.IntegrationType("AWS"),
		IntegrationUri:                         ptr.String("__IntegrationUri__"),
		PassthroughBehavior:                    types.PassthroughBehavior("WHEN_NO_MATCH"),
		PayloadFormatVersion:                   ptr.String("__PayloadFormatVersion__"),
		RequestParameters: map[string]string{
			"key0": "__Value__",
		},
		RequestTemplates: map[string]string{
			"key0": "__Value__",
		},
		ResponseParameters: map[string]map[string]string{
			"key0": {
				"key0": "__Value__",
			},
		},
		TemplateSelectionExpression: ptr.String("__TemplateSelectionExpression__"),
		TimeoutInMillis:             ptr.Int32(1),
		TlsConfig: &types.TlsConfig{
			ServerNameToVerify: ptr.String("__ServerNameToVerify__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetIntegration.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.GetIntegration(context.Background(), &GetIntegrationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetIntegration.response", err)
	}
}

func TestCheckResponseSnapshot_GetIntegrationResponse(t *testing.T) {
	want := &GetIntegrationResponseOutput{
		ContentHandlingStrategy: types.ContentHandlingStrategy("CONVERT_TO_BINARY"),
		IntegrationResponseId:   ptr.String("__IntegrationResponseId__"),
		IntegrationResponseKey:  ptr.String("__IntegrationResponseKey__"),
		ResponseParameters: map[string]string{
			"key0": "__Value__",
		},
		ResponseTemplates: map[string]string{
			"key0": "__Value__",
		},
		TemplateSelectionExpression: ptr.String("__TemplateSelectionExpression__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetIntegrationResponse.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.GetIntegrationResponse(context.Background(), &GetIntegrationResponseInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetIntegrationResponse.response", err)
	}
}

func TestCheckResponseSnapshot_GetIntegrationResponses(t *testing.T) {
	want := &GetIntegrationResponsesOutput{
		Items: []types.IntegrationResponse{
			{
				ContentHandlingStrategy: types.ContentHandlingStrategy("CONVERT_TO_BINARY"),
				IntegrationResponseId:   ptr.String("__IntegrationResponseId__"),
				IntegrationResponseKey:  ptr.String("__IntegrationResponseKey__"),
				ResponseParameters: map[string]string{
					"key0": "__Value__",
				},
				ResponseTemplates: map[string]string{
					"key0": "__Value__",
				},
				TemplateSelectionExpression: ptr.String("__TemplateSelectionExpression__"),
			},
			{
				ContentHandlingStrategy: types.ContentHandlingStrategy("CONVERT_TO_BINARY"),
				IntegrationResponseId:   ptr.String("__IntegrationResponseId__"),
				IntegrationResponseKey:  ptr.String("__IntegrationResponseKey__"),
				ResponseParameters: map[string]string{
					"key0": "__Value__",
				},
				ResponseTemplates: map[string]string{
					"key0": "__Value__",
				},
				TemplateSelectionExpression: ptr.String("__TemplateSelectionExpression__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetIntegrationResponses.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.GetIntegrationResponses(context.Background(), &GetIntegrationResponsesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetIntegrationResponses.response", err)
	}
}

func TestCheckResponseSnapshot_GetIntegrations(t *testing.T) {
	want := &GetIntegrationsOutput{
		Items: []types.Integration{
			{
				ApiGatewayManaged:                      ptr.Bool(true),
				ConnectionId:                           ptr.String("__ConnectionId__"),
				ConnectionType:                         types.ConnectionType("INTERNET"),
				ContentHandlingStrategy:                types.ContentHandlingStrategy("CONVERT_TO_BINARY"),
				CredentialsArn:                         ptr.String("__CredentialsArn__"),
				Description:                            ptr.String("__Description__"),
				IntegrationId:                          ptr.String("__IntegrationId__"),
				IntegrationMethod:                      ptr.String("__IntegrationMethod__"),
				IntegrationResponseSelectionExpression: ptr.String("__IntegrationResponseSelectionExpression__"),
				IntegrationSubtype:                     ptr.String("__IntegrationSubtype__"),
				IntegrationType:                        types.IntegrationType("AWS"),
				IntegrationUri:                         ptr.String("__IntegrationUri__"),
				PassthroughBehavior:                    types.PassthroughBehavior("WHEN_NO_MATCH"),
				PayloadFormatVersion:                   ptr.String("__PayloadFormatVersion__"),
				RequestParameters: map[string]string{
					"key0": "__Value__",
				},
				RequestTemplates: map[string]string{
					"key0": "__Value__",
				},
				ResponseParameters: map[string]map[string]string{
					"key0": {
						"key0": "__Value__",
					},
				},
				TemplateSelectionExpression: ptr.String("__TemplateSelectionExpression__"),
				TimeoutInMillis:             ptr.Int32(1),
				TlsConfig: &types.TlsConfig{
					ServerNameToVerify: ptr.String("__ServerNameToVerify__"),
				},
			},
			{
				ApiGatewayManaged:                      ptr.Bool(true),
				ConnectionId:                           ptr.String("__ConnectionId__"),
				ConnectionType:                         types.ConnectionType("INTERNET"),
				ContentHandlingStrategy:                types.ContentHandlingStrategy("CONVERT_TO_BINARY"),
				CredentialsArn:                         ptr.String("__CredentialsArn__"),
				Description:                            ptr.String("__Description__"),
				IntegrationId:                          ptr.String("__IntegrationId__"),
				IntegrationMethod:                      ptr.String("__IntegrationMethod__"),
				IntegrationResponseSelectionExpression: ptr.String("__IntegrationResponseSelectionExpression__"),
				IntegrationSubtype:                     ptr.String("__IntegrationSubtype__"),
				IntegrationType:                        types.IntegrationType("AWS"),
				IntegrationUri:                         ptr.String("__IntegrationUri__"),
				PassthroughBehavior:                    types.PassthroughBehavior("WHEN_NO_MATCH"),
				PayloadFormatVersion:                   ptr.String("__PayloadFormatVersion__"),
				RequestParameters: map[string]string{
					"key0": "__Value__",
				},
				RequestTemplates: map[string]string{
					"key0": "__Value__",
				},
				ResponseParameters: map[string]map[string]string{
					"key0": {
						"key0": "__Value__",
					},
				},
				TemplateSelectionExpression: ptr.String("__TemplateSelectionExpression__"),
				TimeoutInMillis:             ptr.Int32(1),
				TlsConfig: &types.TlsConfig{
					ServerNameToVerify: ptr.String("__ServerNameToVerify__"),
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetIntegrations.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.GetIntegrations(context.Background(), &GetIntegrationsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetIntegrations.response", err)
	}
}

func TestCheckResponseSnapshot_GetModel(t *testing.T) {
	want := &GetModelOutput{
		ContentType: ptr.String("__ContentType__"),
		Description: ptr.String("__Description__"),
		ModelId:     ptr.String("__ModelId__"),
		Name:        ptr.String("__Name__"),
		Schema:      ptr.String("__Schema__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetModel.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.GetModel(context.Background(), &GetModelInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetModel.response", err)
	}
}

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

func TestCheckResponseSnapshot_GetModels(t *testing.T) {
	want := &GetModelsOutput{
		Items: []types.Model{
			{
				ContentType: ptr.String("__ContentType__"),
				Description: ptr.String("__Description__"),
				ModelId:     ptr.String("__ModelId__"),
				Name:        ptr.String("__Name__"),
				Schema:      ptr.String("__Schema__"),
			},
			{
				ContentType: ptr.String("__ContentType__"),
				Description: ptr.String("__Description__"),
				ModelId:     ptr.String("__ModelId__"),
				Name:        ptr.String("__Name__"),
				Schema:      ptr.String("__Schema__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetModels.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.GetModels(context.Background(), &GetModelsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetModels.response", err)
	}
}

func TestCheckResponseSnapshot_GetPortal(t *testing.T) {
	want := &GetPortalOutput{
		Authorization: &types.Authorization{
			CognitoConfig: &types.CognitoConfig{
				AppClientId:    ptr.String("__AppClientId__"),
				UserPoolArn:    ptr.String("__UserPoolArn__"),
				UserPoolDomain: ptr.String("__UserPoolDomain__"),
			},
			None: &types.None{},
		},
		EndpointConfiguration: &types.EndpointConfigurationResponse{
			CertificateArn:           ptr.String("__CertificateArn__"),
			DomainName:               ptr.String("__DomainName__"),
			PortalDefaultDomainName:  ptr.String("__PortalDefaultDomainName__"),
			PortalDomainHostedZoneId: ptr.String("__PortalDomainHostedZoneId__"),
		},
		IncludedPortalProductArns: []string{
			"__Member__",
			"__Member__",
		},
		LastModified:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		LastPublished:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		LastPublishedDescription: ptr.String("__LastPublishedDescription__"),
		PortalArn:                ptr.String("__PortalArn__"),
		PortalContent: &types.PortalContent{
			Description: ptr.String("__Description__"),
			DisplayName: ptr.String("__DisplayName__"),
			Theme: &types.PortalTheme{
				CustomColors: &types.CustomColors{
					AccentColor:          ptr.String("__AccentColor__"),
					BackgroundColor:      ptr.String("__BackgroundColor__"),
					ErrorValidationColor: ptr.String("__ErrorValidationColor__"),
					HeaderColor:          ptr.String("__HeaderColor__"),
					NavigationColor:      ptr.String("__NavigationColor__"),
					TextColor:            ptr.String("__TextColor__"),
				},
				LogoLastUploaded: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		PortalId: ptr.String("__PortalId__"),
		Preview: &types.Preview{
			PreviewStatus: types.PreviewStatus("PREVIEW_IN_PROGRESS"),
			PreviewUrl:    ptr.String("__PreviewUrl__"),
			StatusException: &types.StatusException{
				Exception: ptr.String("__Exception__"),
				Message:   ptr.String("__Message__"),
			},
		},
		PublishStatus:     types.PublishStatus("PUBLISHED"),
		RumAppMonitorName: ptr.String("__RumAppMonitorName__"),
		StatusException: &types.StatusException{
			Exception: ptr.String("__Exception__"),
			Message:   ptr.String("__Message__"),
		},
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetPortal.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.GetPortal(context.Background(), &GetPortalInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetPortal.response", err)
	}
}

func TestCheckResponseSnapshot_GetPortalProduct(t *testing.T) {
	want := &GetPortalProductOutput{
		Description: ptr.String("__Description__"),
		DisplayName: ptr.String("__DisplayName__"),
		DisplayOrder: &types.DisplayOrder{
			Contents: []types.Section{
				{
					ProductRestEndpointPageArns: []string{
						"__Member__",
						"__Member__",
					},
					SectionName: ptr.String("__SectionName__"),
				},
				{
					ProductRestEndpointPageArns: []string{
						"__Member__",
						"__Member__",
					},
					SectionName: ptr.String("__SectionName__"),
				},
			},
			OverviewPageArn: ptr.String("__OverviewPageArn__"),
			ProductPageArns: []string{
				"__Member__",
				"__Member__",
			},
		},
		LastModified:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		PortalProductArn: ptr.String("__PortalProductArn__"),
		PortalProductId:  ptr.String("__PortalProductId__"),
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetPortalProduct.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.GetPortalProduct(context.Background(), &GetPortalProductInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetPortalProduct.response", err)
	}
}

func TestCheckResponseSnapshot_GetPortalProductSharingPolicy(t *testing.T) {
	want := &GetPortalProductSharingPolicyOutput{
		PolicyDocument:  ptr.String("__PolicyDocument__"),
		PortalProductId: ptr.String("__PortalProductId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetPortalProductSharingPolicy.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.GetPortalProductSharingPolicy(context.Background(), &GetPortalProductSharingPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetPortalProductSharingPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_GetProductPage(t *testing.T) {
	want := &GetProductPageOutput{
		DisplayContent: &types.DisplayContent{
			Body:  ptr.String("__Body__"),
			Title: ptr.String("__Title__"),
		},
		LastModified:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ProductPageArn: ptr.String("__ProductPageArn__"),
		ProductPageId:  ptr.String("__ProductPageId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetProductPage.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.GetProductPage(context.Background(), &GetProductPageInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetProductPage.response", err)
	}
}

func TestCheckResponseSnapshot_GetProductRestEndpointPage(t *testing.T) {
	want := &GetProductRestEndpointPageOutput{
		DisplayContent: &types.EndpointDisplayContentResponse{
			Body:          ptr.String("__Body__"),
			Endpoint:      ptr.String("__Endpoint__"),
			OperationName: ptr.String("__OperationName__"),
		},
		LastModified:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ProductRestEndpointPageArn: ptr.String("__ProductRestEndpointPageArn__"),
		ProductRestEndpointPageId:  ptr.String("__ProductRestEndpointPageId__"),
		RawDisplayContent:          ptr.String("__RawDisplayContent__"),
		RestEndpointIdentifier: &types.RestEndpointIdentifier{
			IdentifierParts: &types.IdentifierParts{
				Method:    ptr.String("__Method__"),
				Path:      ptr.String("__Path__"),
				RestApiId: ptr.String("__RestApiId__"),
				Stage:     ptr.String("__Stage__"),
			},
		},
		Status: types.Status("AVAILABLE"),
		StatusException: &types.StatusException{
			Exception: ptr.String("__Exception__"),
			Message:   ptr.String("__Message__"),
		},
		TryItState: types.TryItState("ENABLED"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetProductRestEndpointPage.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.GetProductRestEndpointPage(context.Background(), &GetProductRestEndpointPageInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetProductRestEndpointPage.response", err)
	}
}

func TestCheckResponseSnapshot_GetRoute(t *testing.T) {
	want := &GetRouteOutput{
		ApiGatewayManaged: ptr.Bool(true),
		ApiKeyRequired:    ptr.Bool(true),
		AuthorizationScopes: []string{
			"__Member__",
			"__Member__",
		},
		AuthorizationType:        types.AuthorizationType("NONE"),
		AuthorizerId:             ptr.String("__AuthorizerId__"),
		ModelSelectionExpression: ptr.String("__ModelSelectionExpression__"),
		OperationName:            ptr.String("__OperationName__"),
		RequestModels: map[string]string{
			"key0": "__Value__",
		},
		RequestParameters: map[string]types.ParameterConstraints{
			"key0": {
				Required: ptr.Bool(true),
			},
		},
		RouteId:                          ptr.String("__RouteId__"),
		RouteKey:                         ptr.String("__RouteKey__"),
		RouteResponseSelectionExpression: ptr.String("__RouteResponseSelectionExpression__"),
		Target:                           ptr.String("__Target__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetRoute.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.GetRoute(context.Background(), &GetRouteInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetRoute.response", err)
	}
}

func TestCheckResponseSnapshot_GetRouteResponse(t *testing.T) {
	want := &GetRouteResponseOutput{
		ModelSelectionExpression: ptr.String("__ModelSelectionExpression__"),
		ResponseModels: map[string]string{
			"key0": "__Value__",
		},
		ResponseParameters: map[string]types.ParameterConstraints{
			"key0": {
				Required: ptr.Bool(true),
			},
		},
		RouteResponseId:  ptr.String("__RouteResponseId__"),
		RouteResponseKey: ptr.String("__RouteResponseKey__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetRouteResponse.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.GetRouteResponse(context.Background(), &GetRouteResponseInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetRouteResponse.response", err)
	}
}

func TestCheckResponseSnapshot_GetRouteResponses(t *testing.T) {
	want := &GetRouteResponsesOutput{
		Items: []types.RouteResponse{
			{
				ModelSelectionExpression: ptr.String("__ModelSelectionExpression__"),
				ResponseModels: map[string]string{
					"key0": "__Value__",
				},
				ResponseParameters: map[string]types.ParameterConstraints{
					"key0": {
						Required: ptr.Bool(true),
					},
				},
				RouteResponseId:  ptr.String("__RouteResponseId__"),
				RouteResponseKey: ptr.String("__RouteResponseKey__"),
			},
			{
				ModelSelectionExpression: ptr.String("__ModelSelectionExpression__"),
				ResponseModels: map[string]string{
					"key0": "__Value__",
				},
				ResponseParameters: map[string]types.ParameterConstraints{
					"key0": {
						Required: ptr.Bool(true),
					},
				},
				RouteResponseId:  ptr.String("__RouteResponseId__"),
				RouteResponseKey: ptr.String("__RouteResponseKey__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetRouteResponses.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.GetRouteResponses(context.Background(), &GetRouteResponsesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetRouteResponses.response", err)
	}
}

func TestCheckResponseSnapshot_GetRoutes(t *testing.T) {
	want := &GetRoutesOutput{
		Items: []types.Route{
			{
				ApiGatewayManaged: ptr.Bool(true),
				ApiKeyRequired:    ptr.Bool(true),
				AuthorizationScopes: []string{
					"__Member__",
					"__Member__",
				},
				AuthorizationType:        types.AuthorizationType("NONE"),
				AuthorizerId:             ptr.String("__AuthorizerId__"),
				ModelSelectionExpression: ptr.String("__ModelSelectionExpression__"),
				OperationName:            ptr.String("__OperationName__"),
				RequestModels: map[string]string{
					"key0": "__Value__",
				},
				RequestParameters: map[string]types.ParameterConstraints{
					"key0": {
						Required: ptr.Bool(true),
					},
				},
				RouteId:                          ptr.String("__RouteId__"),
				RouteKey:                         ptr.String("__RouteKey__"),
				RouteResponseSelectionExpression: ptr.String("__RouteResponseSelectionExpression__"),
				Target:                           ptr.String("__Target__"),
			},
			{
				ApiGatewayManaged: ptr.Bool(true),
				ApiKeyRequired:    ptr.Bool(true),
				AuthorizationScopes: []string{
					"__Member__",
					"__Member__",
				},
				AuthorizationType:        types.AuthorizationType("NONE"),
				AuthorizerId:             ptr.String("__AuthorizerId__"),
				ModelSelectionExpression: ptr.String("__ModelSelectionExpression__"),
				OperationName:            ptr.String("__OperationName__"),
				RequestModels: map[string]string{
					"key0": "__Value__",
				},
				RequestParameters: map[string]types.ParameterConstraints{
					"key0": {
						Required: ptr.Bool(true),
					},
				},
				RouteId:                          ptr.String("__RouteId__"),
				RouteKey:                         ptr.String("__RouteKey__"),
				RouteResponseSelectionExpression: ptr.String("__RouteResponseSelectionExpression__"),
				Target:                           ptr.String("__Target__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetRoutes.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.GetRoutes(context.Background(), &GetRoutesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetRoutes.response", err)
	}
}

func TestCheckResponseSnapshot_GetRoutingRule(t *testing.T) {
	want := &GetRoutingRuleOutput{
		Actions: []types.RoutingRuleAction{
			{
				InvokeApi: &types.RoutingRuleActionInvokeApi{
					ApiId:         ptr.String("__ApiId__"),
					Stage:         ptr.String("__Stage__"),
					StripBasePath: ptr.Bool(true),
				},
			},
			{
				InvokeApi: &types.RoutingRuleActionInvokeApi{
					ApiId:         ptr.String("__ApiId__"),
					Stage:         ptr.String("__Stage__"),
					StripBasePath: ptr.Bool(true),
				},
			},
		},
		Conditions: []types.RoutingRuleCondition{
			{
				MatchBasePaths: &types.RoutingRuleMatchBasePaths{
					AnyOf: []string{
						"__Member__",
						"__Member__",
					},
				},
				MatchHeaders: &types.RoutingRuleMatchHeaders{
					AnyOf: []types.RoutingRuleMatchHeaderValue{
						{
							Header:    ptr.String("__Header__"),
							ValueGlob: ptr.String("__ValueGlob__"),
						},
						{
							Header:    ptr.String("__Header__"),
							ValueGlob: ptr.String("__ValueGlob__"),
						},
					},
				},
			},
			{
				MatchBasePaths: &types.RoutingRuleMatchBasePaths{
					AnyOf: []string{
						"__Member__",
						"__Member__",
					},
				},
				MatchHeaders: &types.RoutingRuleMatchHeaders{
					AnyOf: []types.RoutingRuleMatchHeaderValue{
						{
							Header:    ptr.String("__Header__"),
							ValueGlob: ptr.String("__ValueGlob__"),
						},
						{
							Header:    ptr.String("__Header__"),
							ValueGlob: ptr.String("__ValueGlob__"),
						},
					},
				},
			},
		},
		Priority:       ptr.Int32(1),
		RoutingRuleArn: ptr.String("__RoutingRuleArn__"),
		RoutingRuleId:  ptr.String("__RoutingRuleId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetRoutingRule.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.GetRoutingRule(context.Background(), &GetRoutingRuleInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetRoutingRule.response", err)
	}
}

func TestCheckResponseSnapshot_GetStage(t *testing.T) {
	want := &GetStageOutput{
		AccessLogSettings: &types.AccessLogSettings{
			DestinationArn: ptr.String("__DestinationArn__"),
			Format:         ptr.String("__Format__"),
		},
		ApiGatewayManaged:   ptr.Bool(true),
		AutoDeploy:          ptr.Bool(true),
		ClientCertificateId: ptr.String("__ClientCertificateId__"),
		CreatedDate:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		DefaultRouteSettings: &types.RouteSettings{
			DataTraceEnabled:       ptr.Bool(true),
			DetailedMetricsEnabled: ptr.Bool(true),
			LoggingLevel:           types.LoggingLevel("ERROR"),
			ThrottlingBurstLimit:   ptr.Int32(1),
			ThrottlingRateLimit:    ptr.Float64(1.0),
		},
		DeploymentId:                ptr.String("__DeploymentId__"),
		Description:                 ptr.String("__Description__"),
		LastDeploymentStatusMessage: ptr.String("__LastDeploymentStatusMessage__"),
		LastUpdatedDate:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		RouteSettings: map[string]types.RouteSettings{
			"key0": {
				DataTraceEnabled:       ptr.Bool(true),
				DetailedMetricsEnabled: ptr.Bool(true),
				LoggingLevel:           types.LoggingLevel("ERROR"),
				ThrottlingBurstLimit:   ptr.Int32(1),
				ThrottlingRateLimit:    ptr.Float64(1.0),
			},
		},
		StageName: ptr.String("__StageName__"),
		StageVariables: map[string]string{
			"key0": "__Value__",
		},
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetStage.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.GetStage(context.Background(), &GetStageInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetStage.response", err)
	}
}

func TestCheckResponseSnapshot_GetStages(t *testing.T) {
	want := &GetStagesOutput{
		Items: []types.Stage{
			{
				AccessLogSettings: &types.AccessLogSettings{
					DestinationArn: ptr.String("__DestinationArn__"),
					Format:         ptr.String("__Format__"),
				},
				ApiGatewayManaged:   ptr.Bool(true),
				AutoDeploy:          ptr.Bool(true),
				ClientCertificateId: ptr.String("__ClientCertificateId__"),
				CreatedDate:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				DefaultRouteSettings: &types.RouteSettings{
					DataTraceEnabled:       ptr.Bool(true),
					DetailedMetricsEnabled: ptr.Bool(true),
					LoggingLevel:           types.LoggingLevel("ERROR"),
					ThrottlingBurstLimit:   ptr.Int32(1),
					ThrottlingRateLimit:    ptr.Float64(1.0),
				},
				DeploymentId:                ptr.String("__DeploymentId__"),
				Description:                 ptr.String("__Description__"),
				LastDeploymentStatusMessage: ptr.String("__LastDeploymentStatusMessage__"),
				LastUpdatedDate:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				RouteSettings: map[string]types.RouteSettings{
					"key0": {
						DataTraceEnabled:       ptr.Bool(true),
						DetailedMetricsEnabled: ptr.Bool(true),
						LoggingLevel:           types.LoggingLevel("ERROR"),
						ThrottlingBurstLimit:   ptr.Int32(1),
						ThrottlingRateLimit:    ptr.Float64(1.0),
					},
				},
				StageName: ptr.String("__StageName__"),
				StageVariables: map[string]string{
					"key0": "__Value__",
				},
				Tags: map[string]string{
					"key0": "__Value__",
				},
			},
			{
				AccessLogSettings: &types.AccessLogSettings{
					DestinationArn: ptr.String("__DestinationArn__"),
					Format:         ptr.String("__Format__"),
				},
				ApiGatewayManaged:   ptr.Bool(true),
				AutoDeploy:          ptr.Bool(true),
				ClientCertificateId: ptr.String("__ClientCertificateId__"),
				CreatedDate:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				DefaultRouteSettings: &types.RouteSettings{
					DataTraceEnabled:       ptr.Bool(true),
					DetailedMetricsEnabled: ptr.Bool(true),
					LoggingLevel:           types.LoggingLevel("ERROR"),
					ThrottlingBurstLimit:   ptr.Int32(1),
					ThrottlingRateLimit:    ptr.Float64(1.0),
				},
				DeploymentId:                ptr.String("__DeploymentId__"),
				Description:                 ptr.String("__Description__"),
				LastDeploymentStatusMessage: ptr.String("__LastDeploymentStatusMessage__"),
				LastUpdatedDate:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				RouteSettings: map[string]types.RouteSettings{
					"key0": {
						DataTraceEnabled:       ptr.Bool(true),
						DetailedMetricsEnabled: ptr.Bool(true),
						LoggingLevel:           types.LoggingLevel("ERROR"),
						ThrottlingBurstLimit:   ptr.Int32(1),
						ThrottlingRateLimit:    ptr.Float64(1.0),
					},
				},
				StageName: ptr.String("__StageName__"),
				StageVariables: map[string]string{
					"key0": "__Value__",
				},
				Tags: map[string]string{
					"key0": "__Value__",
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetStages.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.GetStages(context.Background(), &GetStagesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetStages.response", err)
	}
}

func TestCheckResponseSnapshot_GetTags(t *testing.T) {
	want := &GetTagsOutput{
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetTags.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.GetTags(context.Background(), &GetTagsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetTags.response", err)
	}
}

func TestCheckResponseSnapshot_GetVpcLink(t *testing.T) {
	want := &GetVpcLinkOutput{
		CreatedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		Name:        ptr.String("__Name__"),
		SecurityGroupIds: []string{
			"__Member__",
			"__Member__",
		},
		SubnetIds: []string{
			"__Member__",
			"__Member__",
		},
		Tags: map[string]string{
			"key0": "__Value__",
		},
		VpcLinkId:            ptr.String("__VpcLinkId__"),
		VpcLinkStatus:        types.VpcLinkStatus("PENDING"),
		VpcLinkStatusMessage: ptr.String("__VpcLinkStatusMessage__"),
		VpcLinkVersion:       types.VpcLinkVersion("V2"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetVpcLink.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.GetVpcLink(context.Background(), &GetVpcLinkInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetVpcLink.response", err)
	}
}

func TestCheckResponseSnapshot_GetVpcLinks(t *testing.T) {
	want := &GetVpcLinksOutput{
		Items: []types.VpcLink{
			{
				CreatedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Name:        ptr.String("__Name__"),
				SecurityGroupIds: []string{
					"__Member__",
					"__Member__",
				},
				SubnetIds: []string{
					"__Member__",
					"__Member__",
				},
				Tags: map[string]string{
					"key0": "__Value__",
				},
				VpcLinkId:            ptr.String("__VpcLinkId__"),
				VpcLinkStatus:        types.VpcLinkStatus("PENDING"),
				VpcLinkStatusMessage: ptr.String("__VpcLinkStatusMessage__"),
				VpcLinkVersion:       types.VpcLinkVersion("V2"),
			},
			{
				CreatedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Name:        ptr.String("__Name__"),
				SecurityGroupIds: []string{
					"__Member__",
					"__Member__",
				},
				SubnetIds: []string{
					"__Member__",
					"__Member__",
				},
				Tags: map[string]string{
					"key0": "__Value__",
				},
				VpcLinkId:            ptr.String("__VpcLinkId__"),
				VpcLinkStatus:        types.VpcLinkStatus("PENDING"),
				VpcLinkStatusMessage: ptr.String("__VpcLinkStatusMessage__"),
				VpcLinkVersion:       types.VpcLinkVersion("V2"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetVpcLinks.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.GetVpcLinks(context.Background(), &GetVpcLinksInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetVpcLinks.response", err)
	}
}

func TestCheckResponseSnapshot_ImportApi(t *testing.T) {
	want := &ImportApiOutput{
		ApiEndpoint:               ptr.String("__ApiEndpoint__"),
		ApiGatewayManaged:         ptr.Bool(true),
		ApiId:                     ptr.String("__ApiId__"),
		ApiKeySelectionExpression: ptr.String("__ApiKeySelectionExpression__"),
		CorsConfiguration: &types.Cors{
			AllowCredentials: ptr.Bool(true),
			AllowHeaders: []string{
				"__Member__",
				"__Member__",
			},
			AllowMethods: []string{
				"__Member__",
				"__Member__",
			},
			AllowOrigins: []string{
				"__Member__",
				"__Member__",
			},
			ExposeHeaders: []string{
				"__Member__",
				"__Member__",
			},
			MaxAge: ptr.Int32(1),
		},
		CreatedDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		Description:               ptr.String("__Description__"),
		DisableSchemaValidation:   ptr.Bool(true),
		DisableExecuteApiEndpoint: ptr.Bool(true),
		ImportInfo: []string{
			"__Member__",
			"__Member__",
		},
		IpAddressType:            types.IpAddressType("ipv4"),
		Name:                     ptr.String("__Name__"),
		ProtocolType:             types.ProtocolType("WEBSOCKET"),
		RouteSelectionExpression: ptr.String("__RouteSelectionExpression__"),
		Tags: map[string]string{
			"key0": "__Value__",
		},
		Version: ptr.String("__Version__"),
		Warnings: []string{
			"__Member__",
			"__Member__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ImportApi.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.ImportApi(context.Background(), &ImportApiInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ImportApi.response", err)
	}
}

func TestCheckResponseSnapshot_ListPortalProducts(t *testing.T) {
	want := &ListPortalProductsOutput{
		Items: []types.PortalProductSummary{
			{
				Description:      ptr.String("__Description__"),
				DisplayName:      ptr.String("__DisplayName__"),
				LastModified:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PortalProductArn: ptr.String("__PortalProductArn__"),
				PortalProductId:  ptr.String("__PortalProductId__"),
				Tags: map[string]string{
					"key0": "__Value__",
				},
			},
			{
				Description:      ptr.String("__Description__"),
				DisplayName:      ptr.String("__DisplayName__"),
				LastModified:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PortalProductArn: ptr.String("__PortalProductArn__"),
				PortalProductId:  ptr.String("__PortalProductId__"),
				Tags: map[string]string{
					"key0": "__Value__",
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListPortalProducts.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.ListPortalProducts(context.Background(), &ListPortalProductsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListPortalProducts.response", err)
	}
}

func TestCheckResponseSnapshot_ListPortals(t *testing.T) {
	want := &ListPortalsOutput{
		Items: []types.PortalSummary{
			{
				Authorization: &types.Authorization{
					CognitoConfig: &types.CognitoConfig{
						AppClientId:    ptr.String("__AppClientId__"),
						UserPoolArn:    ptr.String("__UserPoolArn__"),
						UserPoolDomain: ptr.String("__UserPoolDomain__"),
					},
					None: &types.None{},
				},
				EndpointConfiguration: &types.EndpointConfigurationResponse{
					CertificateArn:           ptr.String("__CertificateArn__"),
					DomainName:               ptr.String("__DomainName__"),
					PortalDefaultDomainName:  ptr.String("__PortalDefaultDomainName__"),
					PortalDomainHostedZoneId: ptr.String("__PortalDomainHostedZoneId__"),
				},
				IncludedPortalProductArns: []string{
					"__Member__",
					"__Member__",
				},
				LastModified:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastPublished:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastPublishedDescription: ptr.String("__LastPublishedDescription__"),
				PortalArn:                ptr.String("__PortalArn__"),
				PortalContent: &types.PortalContent{
					Description: ptr.String("__Description__"),
					DisplayName: ptr.String("__DisplayName__"),
					Theme: &types.PortalTheme{
						CustomColors: &types.CustomColors{
							AccentColor:          ptr.String("__AccentColor__"),
							BackgroundColor:      ptr.String("__BackgroundColor__"),
							ErrorValidationColor: ptr.String("__ErrorValidationColor__"),
							HeaderColor:          ptr.String("__HeaderColor__"),
							NavigationColor:      ptr.String("__NavigationColor__"),
							TextColor:            ptr.String("__TextColor__"),
						},
						LogoLastUploaded: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
				},
				PortalId: ptr.String("__PortalId__"),
				Preview: &types.Preview{
					PreviewStatus: types.PreviewStatus("PREVIEW_IN_PROGRESS"),
					PreviewUrl:    ptr.String("__PreviewUrl__"),
					StatusException: &types.StatusException{
						Exception: ptr.String("__Exception__"),
						Message:   ptr.String("__Message__"),
					},
				},
				PublishStatus:     types.PublishStatus("PUBLISHED"),
				RumAppMonitorName: ptr.String("__RumAppMonitorName__"),
				StatusException: &types.StatusException{
					Exception: ptr.String("__Exception__"),
					Message:   ptr.String("__Message__"),
				},
				Tags: map[string]string{
					"key0": "__Value__",
				},
			},
			{
				Authorization: &types.Authorization{
					CognitoConfig: &types.CognitoConfig{
						AppClientId:    ptr.String("__AppClientId__"),
						UserPoolArn:    ptr.String("__UserPoolArn__"),
						UserPoolDomain: ptr.String("__UserPoolDomain__"),
					},
					None: &types.None{},
				},
				EndpointConfiguration: &types.EndpointConfigurationResponse{
					CertificateArn:           ptr.String("__CertificateArn__"),
					DomainName:               ptr.String("__DomainName__"),
					PortalDefaultDomainName:  ptr.String("__PortalDefaultDomainName__"),
					PortalDomainHostedZoneId: ptr.String("__PortalDomainHostedZoneId__"),
				},
				IncludedPortalProductArns: []string{
					"__Member__",
					"__Member__",
				},
				LastModified:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastPublished:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastPublishedDescription: ptr.String("__LastPublishedDescription__"),
				PortalArn:                ptr.String("__PortalArn__"),
				PortalContent: &types.PortalContent{
					Description: ptr.String("__Description__"),
					DisplayName: ptr.String("__DisplayName__"),
					Theme: &types.PortalTheme{
						CustomColors: &types.CustomColors{
							AccentColor:          ptr.String("__AccentColor__"),
							BackgroundColor:      ptr.String("__BackgroundColor__"),
							ErrorValidationColor: ptr.String("__ErrorValidationColor__"),
							HeaderColor:          ptr.String("__HeaderColor__"),
							NavigationColor:      ptr.String("__NavigationColor__"),
							TextColor:            ptr.String("__TextColor__"),
						},
						LogoLastUploaded: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
				},
				PortalId: ptr.String("__PortalId__"),
				Preview: &types.Preview{
					PreviewStatus: types.PreviewStatus("PREVIEW_IN_PROGRESS"),
					PreviewUrl:    ptr.String("__PreviewUrl__"),
					StatusException: &types.StatusException{
						Exception: ptr.String("__Exception__"),
						Message:   ptr.String("__Message__"),
					},
				},
				PublishStatus:     types.PublishStatus("PUBLISHED"),
				RumAppMonitorName: ptr.String("__RumAppMonitorName__"),
				StatusException: &types.StatusException{
					Exception: ptr.String("__Exception__"),
					Message:   ptr.String("__Message__"),
				},
				Tags: map[string]string{
					"key0": "__Value__",
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListPortals.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.ListPortals(context.Background(), &ListPortalsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListPortals.response", err)
	}
}

func TestCheckResponseSnapshot_ListProductPages(t *testing.T) {
	want := &ListProductPagesOutput{
		Items: []types.ProductPageSummaryNoBody{
			{
				LastModified:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PageTitle:      ptr.String("__PageTitle__"),
				ProductPageArn: ptr.String("__ProductPageArn__"),
				ProductPageId:  ptr.String("__ProductPageId__"),
			},
			{
				LastModified:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PageTitle:      ptr.String("__PageTitle__"),
				ProductPageArn: ptr.String("__ProductPageArn__"),
				ProductPageId:  ptr.String("__ProductPageId__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListProductPages.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.ListProductPages(context.Background(), &ListProductPagesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListProductPages.response", err)
	}
}

func TestCheckResponseSnapshot_ListProductRestEndpointPages(t *testing.T) {
	want := &ListProductRestEndpointPagesOutput{
		Items: []types.ProductRestEndpointPageSummaryNoBody{
			{
				Endpoint:                   ptr.String("__Endpoint__"),
				LastModified:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				OperationName:              ptr.String("__OperationName__"),
				ProductRestEndpointPageArn: ptr.String("__ProductRestEndpointPageArn__"),
				ProductRestEndpointPageId:  ptr.String("__ProductRestEndpointPageId__"),
				RestEndpointIdentifier: &types.RestEndpointIdentifier{
					IdentifierParts: &types.IdentifierParts{
						Method:    ptr.String("__Method__"),
						Path:      ptr.String("__Path__"),
						RestApiId: ptr.String("__RestApiId__"),
						Stage:     ptr.String("__Stage__"),
					},
				},
				Status: types.Status("AVAILABLE"),
				StatusException: &types.StatusException{
					Exception: ptr.String("__Exception__"),
					Message:   ptr.String("__Message__"),
				},
				TryItState: types.TryItState("ENABLED"),
			},
			{
				Endpoint:                   ptr.String("__Endpoint__"),
				LastModified:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				OperationName:              ptr.String("__OperationName__"),
				ProductRestEndpointPageArn: ptr.String("__ProductRestEndpointPageArn__"),
				ProductRestEndpointPageId:  ptr.String("__ProductRestEndpointPageId__"),
				RestEndpointIdentifier: &types.RestEndpointIdentifier{
					IdentifierParts: &types.IdentifierParts{
						Method:    ptr.String("__Method__"),
						Path:      ptr.String("__Path__"),
						RestApiId: ptr.String("__RestApiId__"),
						Stage:     ptr.String("__Stage__"),
					},
				},
				Status: types.Status("AVAILABLE"),
				StatusException: &types.StatusException{
					Exception: ptr.String("__Exception__"),
					Message:   ptr.String("__Message__"),
				},
				TryItState: types.TryItState("ENABLED"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListProductRestEndpointPages.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.ListProductRestEndpointPages(context.Background(), &ListProductRestEndpointPagesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListProductRestEndpointPages.response", err)
	}
}

func TestCheckResponseSnapshot_ListRoutingRules(t *testing.T) {
	want := &ListRoutingRulesOutput{
		NextToken: ptr.String("__NextToken__"),
		RoutingRules: []types.RoutingRule{
			{
				Actions: []types.RoutingRuleAction{
					{
						InvokeApi: &types.RoutingRuleActionInvokeApi{
							ApiId:         ptr.String("__ApiId__"),
							Stage:         ptr.String("__Stage__"),
							StripBasePath: ptr.Bool(true),
						},
					},
					{
						InvokeApi: &types.RoutingRuleActionInvokeApi{
							ApiId:         ptr.String("__ApiId__"),
							Stage:         ptr.String("__Stage__"),
							StripBasePath: ptr.Bool(true),
						},
					},
				},
				Conditions: []types.RoutingRuleCondition{
					{
						MatchBasePaths: &types.RoutingRuleMatchBasePaths{
							AnyOf: []string{
								"__Member__",
								"__Member__",
							},
						},
						MatchHeaders: &types.RoutingRuleMatchHeaders{
							AnyOf: []types.RoutingRuleMatchHeaderValue{
								{
									Header:    ptr.String("__Header__"),
									ValueGlob: ptr.String("__ValueGlob__"),
								},
								{
									Header:    ptr.String("__Header__"),
									ValueGlob: ptr.String("__ValueGlob__"),
								},
							},
						},
					},
					{
						MatchBasePaths: &types.RoutingRuleMatchBasePaths{
							AnyOf: []string{
								"__Member__",
								"__Member__",
							},
						},
						MatchHeaders: &types.RoutingRuleMatchHeaders{
							AnyOf: []types.RoutingRuleMatchHeaderValue{
								{
									Header:    ptr.String("__Header__"),
									ValueGlob: ptr.String("__ValueGlob__"),
								},
								{
									Header:    ptr.String("__Header__"),
									ValueGlob: ptr.String("__ValueGlob__"),
								},
							},
						},
					},
				},
				Priority:       ptr.Int32(1),
				RoutingRuleArn: ptr.String("__RoutingRuleArn__"),
				RoutingRuleId:  ptr.String("__RoutingRuleId__"),
			},
			{
				Actions: []types.RoutingRuleAction{
					{
						InvokeApi: &types.RoutingRuleActionInvokeApi{
							ApiId:         ptr.String("__ApiId__"),
							Stage:         ptr.String("__Stage__"),
							StripBasePath: ptr.Bool(true),
						},
					},
					{
						InvokeApi: &types.RoutingRuleActionInvokeApi{
							ApiId:         ptr.String("__ApiId__"),
							Stage:         ptr.String("__Stage__"),
							StripBasePath: ptr.Bool(true),
						},
					},
				},
				Conditions: []types.RoutingRuleCondition{
					{
						MatchBasePaths: &types.RoutingRuleMatchBasePaths{
							AnyOf: []string{
								"__Member__",
								"__Member__",
							},
						},
						MatchHeaders: &types.RoutingRuleMatchHeaders{
							AnyOf: []types.RoutingRuleMatchHeaderValue{
								{
									Header:    ptr.String("__Header__"),
									ValueGlob: ptr.String("__ValueGlob__"),
								},
								{
									Header:    ptr.String("__Header__"),
									ValueGlob: ptr.String("__ValueGlob__"),
								},
							},
						},
					},
					{
						MatchBasePaths: &types.RoutingRuleMatchBasePaths{
							AnyOf: []string{
								"__Member__",
								"__Member__",
							},
						},
						MatchHeaders: &types.RoutingRuleMatchHeaders{
							AnyOf: []types.RoutingRuleMatchHeaderValue{
								{
									Header:    ptr.String("__Header__"),
									ValueGlob: ptr.String("__ValueGlob__"),
								},
								{
									Header:    ptr.String("__Header__"),
									ValueGlob: ptr.String("__ValueGlob__"),
								},
							},
						},
					},
				},
				Priority:       ptr.Int32(1),
				RoutingRuleArn: ptr.String("__RoutingRuleArn__"),
				RoutingRuleId:  ptr.String("__RoutingRuleId__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListRoutingRules.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.ListRoutingRules(context.Background(), &ListRoutingRulesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListRoutingRules.response", err)
	}
}

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

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

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

func TestCheckResponseSnapshot_PutRoutingRule(t *testing.T) {
	want := &PutRoutingRuleOutput{
		Actions: []types.RoutingRuleAction{
			{
				InvokeApi: &types.RoutingRuleActionInvokeApi{
					ApiId:         ptr.String("__ApiId__"),
					Stage:         ptr.String("__Stage__"),
					StripBasePath: ptr.Bool(true),
				},
			},
			{
				InvokeApi: &types.RoutingRuleActionInvokeApi{
					ApiId:         ptr.String("__ApiId__"),
					Stage:         ptr.String("__Stage__"),
					StripBasePath: ptr.Bool(true),
				},
			},
		},
		Conditions: []types.RoutingRuleCondition{
			{
				MatchBasePaths: &types.RoutingRuleMatchBasePaths{
					AnyOf: []string{
						"__Member__",
						"__Member__",
					},
				},
				MatchHeaders: &types.RoutingRuleMatchHeaders{
					AnyOf: []types.RoutingRuleMatchHeaderValue{
						{
							Header:    ptr.String("__Header__"),
							ValueGlob: ptr.String("__ValueGlob__"),
						},
						{
							Header:    ptr.String("__Header__"),
							ValueGlob: ptr.String("__ValueGlob__"),
						},
					},
				},
			},
			{
				MatchBasePaths: &types.RoutingRuleMatchBasePaths{
					AnyOf: []string{
						"__Member__",
						"__Member__",
					},
				},
				MatchHeaders: &types.RoutingRuleMatchHeaders{
					AnyOf: []types.RoutingRuleMatchHeaderValue{
						{
							Header:    ptr.String("__Header__"),
							ValueGlob: ptr.String("__ValueGlob__"),
						},
						{
							Header:    ptr.String("__Header__"),
							ValueGlob: ptr.String("__ValueGlob__"),
						},
					},
				},
			},
		},
		Priority:       ptr.Int32(1),
		RoutingRuleArn: ptr.String("__RoutingRuleArn__"),
		RoutingRuleId:  ptr.String("__RoutingRuleId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PutRoutingRule.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.PutRoutingRule(context.Background(), &PutRoutingRuleInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutRoutingRule.response", err)
	}
}

func TestCheckResponseSnapshot_ReimportApi(t *testing.T) {
	want := &ReimportApiOutput{
		ApiEndpoint:               ptr.String("__ApiEndpoint__"),
		ApiGatewayManaged:         ptr.Bool(true),
		ApiId:                     ptr.String("__ApiId__"),
		ApiKeySelectionExpression: ptr.String("__ApiKeySelectionExpression__"),
		CorsConfiguration: &types.Cors{
			AllowCredentials: ptr.Bool(true),
			AllowHeaders: []string{
				"__Member__",
				"__Member__",
			},
			AllowMethods: []string{
				"__Member__",
				"__Member__",
			},
			AllowOrigins: []string{
				"__Member__",
				"__Member__",
			},
			ExposeHeaders: []string{
				"__Member__",
				"__Member__",
			},
			MaxAge: ptr.Int32(1),
		},
		CreatedDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		Description:               ptr.String("__Description__"),
		DisableSchemaValidation:   ptr.Bool(true),
		DisableExecuteApiEndpoint: ptr.Bool(true),
		ImportInfo: []string{
			"__Member__",
			"__Member__",
		},
		IpAddressType:            types.IpAddressType("ipv4"),
		Name:                     ptr.String("__Name__"),
		ProtocolType:             types.ProtocolType("WEBSOCKET"),
		RouteSelectionExpression: ptr.String("__RouteSelectionExpression__"),
		Tags: map[string]string{
			"key0": "__Value__",
		},
		Version: ptr.String("__Version__"),
		Warnings: []string{
			"__Member__",
			"__Member__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ReimportApi.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.ReimportApi(context.Background(), &ReimportApiInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ReimportApi.response", err)
	}
}

func TestCheckResponseSnapshot_ResetAuthorizersCache(t *testing.T) {
	want := &ResetAuthorizersCacheOutput{}
	status, header, body, err := serdeRespReadSnapshot("ResetAuthorizersCache.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.ResetAuthorizersCache(context.Background(), &ResetAuthorizersCacheInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ResetAuthorizersCache.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_UpdateApi(t *testing.T) {
	want := &UpdateApiOutput{
		ApiEndpoint:               ptr.String("__ApiEndpoint__"),
		ApiGatewayManaged:         ptr.Bool(true),
		ApiId:                     ptr.String("__ApiId__"),
		ApiKeySelectionExpression: ptr.String("__ApiKeySelectionExpression__"),
		CorsConfiguration: &types.Cors{
			AllowCredentials: ptr.Bool(true),
			AllowHeaders: []string{
				"__Member__",
				"__Member__",
			},
			AllowMethods: []string{
				"__Member__",
				"__Member__",
			},
			AllowOrigins: []string{
				"__Member__",
				"__Member__",
			},
			ExposeHeaders: []string{
				"__Member__",
				"__Member__",
			},
			MaxAge: ptr.Int32(1),
		},
		CreatedDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		Description:               ptr.String("__Description__"),
		DisableSchemaValidation:   ptr.Bool(true),
		DisableExecuteApiEndpoint: ptr.Bool(true),
		ImportInfo: []string{
			"__Member__",
			"__Member__",
		},
		IpAddressType:            types.IpAddressType("ipv4"),
		Name:                     ptr.String("__Name__"),
		ProtocolType:             types.ProtocolType("WEBSOCKET"),
		RouteSelectionExpression: ptr.String("__RouteSelectionExpression__"),
		Tags: map[string]string{
			"key0": "__Value__",
		},
		Version: ptr.String("__Version__"),
		Warnings: []string{
			"__Member__",
			"__Member__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateApi.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.UpdateApi(context.Background(), &UpdateApiInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateApi.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateApiMapping(t *testing.T) {
	want := &UpdateApiMappingOutput{
		ApiId:         ptr.String("__ApiId__"),
		ApiMappingId:  ptr.String("__ApiMappingId__"),
		ApiMappingKey: ptr.String("__ApiMappingKey__"),
		Stage:         ptr.String("__Stage__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateApiMapping.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.UpdateApiMapping(context.Background(), &UpdateApiMappingInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateApiMapping.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateAuthorizer(t *testing.T) {
	want := &UpdateAuthorizerOutput{
		AuthorizerCredentialsArn:       ptr.String("__AuthorizerCredentialsArn__"),
		AuthorizerId:                   ptr.String("__AuthorizerId__"),
		AuthorizerPayloadFormatVersion: ptr.String("__AuthorizerPayloadFormatVersion__"),
		AuthorizerResultTtlInSeconds:   ptr.Int32(1),
		AuthorizerType:                 types.AuthorizerType("REQUEST"),
		AuthorizerUri:                  ptr.String("__AuthorizerUri__"),
		EnableSimpleResponses:          ptr.Bool(true),
		IdentitySource: []string{
			"__Member__",
			"__Member__",
		},
		IdentityValidationExpression: ptr.String("__IdentityValidationExpression__"),
		JwtConfiguration: &types.JWTConfiguration{
			Audience: []string{
				"__Member__",
				"__Member__",
			},
			Issuer: ptr.String("__Issuer__"),
		},
		Name: ptr.String("__Name__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateAuthorizer.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.UpdateAuthorizer(context.Background(), &UpdateAuthorizerInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateAuthorizer.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateDeployment(t *testing.T) {
	want := &UpdateDeploymentOutput{
		AutoDeployed:            ptr.Bool(true),
		CreatedDate:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		DeploymentId:            ptr.String("__DeploymentId__"),
		DeploymentStatus:        types.DeploymentStatus("PENDING"),
		DeploymentStatusMessage: ptr.String("__DeploymentStatusMessage__"),
		Description:             ptr.String("__Description__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateDeployment.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.UpdateDeployment(context.Background(), &UpdateDeploymentInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateDeployment.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateDomainName(t *testing.T) {
	want := &UpdateDomainNameOutput{
		ApiMappingSelectionExpression: ptr.String("__ApiMappingSelectionExpression__"),
		DomainName:                    ptr.String("__DomainName__"),
		DomainNameArn:                 ptr.String("__DomainNameArn__"),
		DomainNameConfigurations: []types.DomainNameConfiguration{
			{
				ApiGatewayDomainName:                ptr.String("__ApiGatewayDomainName__"),
				CertificateArn:                      ptr.String("__CertificateArn__"),
				CertificateName:                     ptr.String("__CertificateName__"),
				CertificateUploadDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				DomainNameStatus:                    types.DomainNameStatus("AVAILABLE"),
				DomainNameStatusMessage:             ptr.String("__DomainNameStatusMessage__"),
				EndpointType:                        types.EndpointType("REGIONAL"),
				HostedZoneId:                        ptr.String("__HostedZoneId__"),
				IpAddressType:                       types.IpAddressType("ipv4"),
				SecurityPolicy:                      types.SecurityPolicy("TLS_1_0"),
				OwnershipVerificationCertificateArn: ptr.String("__OwnershipVerificationCertificateArn__"),
			},
			{
				ApiGatewayDomainName:                ptr.String("__ApiGatewayDomainName__"),
				CertificateArn:                      ptr.String("__CertificateArn__"),
				CertificateName:                     ptr.String("__CertificateName__"),
				CertificateUploadDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				DomainNameStatus:                    types.DomainNameStatus("AVAILABLE"),
				DomainNameStatusMessage:             ptr.String("__DomainNameStatusMessage__"),
				EndpointType:                        types.EndpointType("REGIONAL"),
				HostedZoneId:                        ptr.String("__HostedZoneId__"),
				IpAddressType:                       types.IpAddressType("ipv4"),
				SecurityPolicy:                      types.SecurityPolicy("TLS_1_0"),
				OwnershipVerificationCertificateArn: ptr.String("__OwnershipVerificationCertificateArn__"),
			},
		},
		MutualTlsAuthentication: &types.MutualTlsAuthentication{
			TruststoreUri:     ptr.String("__TruststoreUri__"),
			TruststoreVersion: ptr.String("__TruststoreVersion__"),
			TruststoreWarnings: []string{
				"__Member__",
				"__Member__",
			},
		},
		RoutingMode: types.RoutingMode("API_MAPPING_ONLY"),
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateDomainName.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.UpdateDomainName(context.Background(), &UpdateDomainNameInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateDomainName.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateIntegration(t *testing.T) {
	want := &UpdateIntegrationOutput{
		ApiGatewayManaged:                      ptr.Bool(true),
		ConnectionId:                           ptr.String("__ConnectionId__"),
		ConnectionType:                         types.ConnectionType("INTERNET"),
		ContentHandlingStrategy:                types.ContentHandlingStrategy("CONVERT_TO_BINARY"),
		CredentialsArn:                         ptr.String("__CredentialsArn__"),
		Description:                            ptr.String("__Description__"),
		IntegrationId:                          ptr.String("__IntegrationId__"),
		IntegrationMethod:                      ptr.String("__IntegrationMethod__"),
		IntegrationResponseSelectionExpression: ptr.String("__IntegrationResponseSelectionExpression__"),
		IntegrationSubtype:                     ptr.String("__IntegrationSubtype__"),
		IntegrationType:                        types.IntegrationType("AWS"),
		IntegrationUri:                         ptr.String("__IntegrationUri__"),
		PassthroughBehavior:                    types.PassthroughBehavior("WHEN_NO_MATCH"),
		PayloadFormatVersion:                   ptr.String("__PayloadFormatVersion__"),
		RequestParameters: map[string]string{
			"key0": "__Value__",
		},
		RequestTemplates: map[string]string{
			"key0": "__Value__",
		},
		ResponseParameters: map[string]map[string]string{
			"key0": {
				"key0": "__Value__",
			},
		},
		TemplateSelectionExpression: ptr.String("__TemplateSelectionExpression__"),
		TimeoutInMillis:             ptr.Int32(1),
		TlsConfig: &types.TlsConfig{
			ServerNameToVerify: ptr.String("__ServerNameToVerify__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateIntegration.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.UpdateIntegration(context.Background(), &UpdateIntegrationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateIntegration.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateIntegrationResponse(t *testing.T) {
	want := &UpdateIntegrationResponseOutput{
		ContentHandlingStrategy: types.ContentHandlingStrategy("CONVERT_TO_BINARY"),
		IntegrationResponseId:   ptr.String("__IntegrationResponseId__"),
		IntegrationResponseKey:  ptr.String("__IntegrationResponseKey__"),
		ResponseParameters: map[string]string{
			"key0": "__Value__",
		},
		ResponseTemplates: map[string]string{
			"key0": "__Value__",
		},
		TemplateSelectionExpression: ptr.String("__TemplateSelectionExpression__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateIntegrationResponse.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.UpdateIntegrationResponse(context.Background(), &UpdateIntegrationResponseInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateIntegrationResponse.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateModel(t *testing.T) {
	want := &UpdateModelOutput{
		ContentType: ptr.String("__ContentType__"),
		Description: ptr.String("__Description__"),
		ModelId:     ptr.String("__ModelId__"),
		Name:        ptr.String("__Name__"),
		Schema:      ptr.String("__Schema__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateModel.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.UpdateModel(context.Background(), &UpdateModelInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateModel.response", err)
	}
}

func TestCheckResponseSnapshot_UpdatePortal(t *testing.T) {
	want := &UpdatePortalOutput{
		Authorization: &types.Authorization{
			CognitoConfig: &types.CognitoConfig{
				AppClientId:    ptr.String("__AppClientId__"),
				UserPoolArn:    ptr.String("__UserPoolArn__"),
				UserPoolDomain: ptr.String("__UserPoolDomain__"),
			},
			None: &types.None{},
		},
		EndpointConfiguration: &types.EndpointConfigurationResponse{
			CertificateArn:           ptr.String("__CertificateArn__"),
			DomainName:               ptr.String("__DomainName__"),
			PortalDefaultDomainName:  ptr.String("__PortalDefaultDomainName__"),
			PortalDomainHostedZoneId: ptr.String("__PortalDomainHostedZoneId__"),
		},
		IncludedPortalProductArns: []string{
			"__Member__",
			"__Member__",
		},
		LastModified:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		LastPublished:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		LastPublishedDescription: ptr.String("__LastPublishedDescription__"),
		PortalArn:                ptr.String("__PortalArn__"),
		PortalContent: &types.PortalContent{
			Description: ptr.String("__Description__"),
			DisplayName: ptr.String("__DisplayName__"),
			Theme: &types.PortalTheme{
				CustomColors: &types.CustomColors{
					AccentColor:          ptr.String("__AccentColor__"),
					BackgroundColor:      ptr.String("__BackgroundColor__"),
					ErrorValidationColor: ptr.String("__ErrorValidationColor__"),
					HeaderColor:          ptr.String("__HeaderColor__"),
					NavigationColor:      ptr.String("__NavigationColor__"),
					TextColor:            ptr.String("__TextColor__"),
				},
				LogoLastUploaded: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		PortalId: ptr.String("__PortalId__"),
		Preview: &types.Preview{
			PreviewStatus: types.PreviewStatus("PREVIEW_IN_PROGRESS"),
			PreviewUrl:    ptr.String("__PreviewUrl__"),
			StatusException: &types.StatusException{
				Exception: ptr.String("__Exception__"),
				Message:   ptr.String("__Message__"),
			},
		},
		PublishStatus:     types.PublishStatus("PUBLISHED"),
		RumAppMonitorName: ptr.String("__RumAppMonitorName__"),
		StatusException: &types.StatusException{
			Exception: ptr.String("__Exception__"),
			Message:   ptr.String("__Message__"),
		},
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdatePortal.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.UpdatePortal(context.Background(), &UpdatePortalInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdatePortal.response", err)
	}
}

func TestCheckResponseSnapshot_UpdatePortalProduct(t *testing.T) {
	want := &UpdatePortalProductOutput{
		Description: ptr.String("__Description__"),
		DisplayName: ptr.String("__DisplayName__"),
		DisplayOrder: &types.DisplayOrder{
			Contents: []types.Section{
				{
					ProductRestEndpointPageArns: []string{
						"__Member__",
						"__Member__",
					},
					SectionName: ptr.String("__SectionName__"),
				},
				{
					ProductRestEndpointPageArns: []string{
						"__Member__",
						"__Member__",
					},
					SectionName: ptr.String("__SectionName__"),
				},
			},
			OverviewPageArn: ptr.String("__OverviewPageArn__"),
			ProductPageArns: []string{
				"__Member__",
				"__Member__",
			},
		},
		LastModified:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		PortalProductArn: ptr.String("__PortalProductArn__"),
		PortalProductId:  ptr.String("__PortalProductId__"),
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdatePortalProduct.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.UpdatePortalProduct(context.Background(), &UpdatePortalProductInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdatePortalProduct.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateProductPage(t *testing.T) {
	want := &UpdateProductPageOutput{
		DisplayContent: &types.DisplayContent{
			Body:  ptr.String("__Body__"),
			Title: ptr.String("__Title__"),
		},
		LastModified:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ProductPageArn: ptr.String("__ProductPageArn__"),
		ProductPageId:  ptr.String("__ProductPageId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateProductPage.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.UpdateProductPage(context.Background(), &UpdateProductPageInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateProductPage.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateProductRestEndpointPage(t *testing.T) {
	want := &UpdateProductRestEndpointPageOutput{
		DisplayContent: &types.EndpointDisplayContentResponse{
			Body:          ptr.String("__Body__"),
			Endpoint:      ptr.String("__Endpoint__"),
			OperationName: ptr.String("__OperationName__"),
		},
		LastModified:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ProductRestEndpointPageArn: ptr.String("__ProductRestEndpointPageArn__"),
		ProductRestEndpointPageId:  ptr.String("__ProductRestEndpointPageId__"),
		RestEndpointIdentifier: &types.RestEndpointIdentifier{
			IdentifierParts: &types.IdentifierParts{
				Method:    ptr.String("__Method__"),
				Path:      ptr.String("__Path__"),
				RestApiId: ptr.String("__RestApiId__"),
				Stage:     ptr.String("__Stage__"),
			},
		},
		Status: types.Status("AVAILABLE"),
		StatusException: &types.StatusException{
			Exception: ptr.String("__Exception__"),
			Message:   ptr.String("__Message__"),
		},
		TryItState: types.TryItState("ENABLED"),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateProductRestEndpointPage.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.UpdateProductRestEndpointPage(context.Background(), &UpdateProductRestEndpointPageInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateProductRestEndpointPage.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateRoute(t *testing.T) {
	want := &UpdateRouteOutput{
		ApiGatewayManaged: ptr.Bool(true),
		ApiKeyRequired:    ptr.Bool(true),
		AuthorizationScopes: []string{
			"__Member__",
			"__Member__",
		},
		AuthorizationType:        types.AuthorizationType("NONE"),
		AuthorizerId:             ptr.String("__AuthorizerId__"),
		ModelSelectionExpression: ptr.String("__ModelSelectionExpression__"),
		OperationName:            ptr.String("__OperationName__"),
		RequestModels: map[string]string{
			"key0": "__Value__",
		},
		RequestParameters: map[string]types.ParameterConstraints{
			"key0": {
				Required: ptr.Bool(true),
			},
		},
		RouteId:                          ptr.String("__RouteId__"),
		RouteKey:                         ptr.String("__RouteKey__"),
		RouteResponseSelectionExpression: ptr.String("__RouteResponseSelectionExpression__"),
		Target:                           ptr.String("__Target__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateRoute.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.UpdateRoute(context.Background(), &UpdateRouteInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateRoute.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateRouteResponse(t *testing.T) {
	want := &UpdateRouteResponseOutput{
		ModelSelectionExpression: ptr.String("__ModelSelectionExpression__"),
		ResponseModels: map[string]string{
			"key0": "__Value__",
		},
		ResponseParameters: map[string]types.ParameterConstraints{
			"key0": {
				Required: ptr.Bool(true),
			},
		},
		RouteResponseId:  ptr.String("__RouteResponseId__"),
		RouteResponseKey: ptr.String("__RouteResponseKey__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateRouteResponse.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.UpdateRouteResponse(context.Background(), &UpdateRouteResponseInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateRouteResponse.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateStage(t *testing.T) {
	want := &UpdateStageOutput{
		AccessLogSettings: &types.AccessLogSettings{
			DestinationArn: ptr.String("__DestinationArn__"),
			Format:         ptr.String("__Format__"),
		},
		ApiGatewayManaged:   ptr.Bool(true),
		AutoDeploy:          ptr.Bool(true),
		ClientCertificateId: ptr.String("__ClientCertificateId__"),
		CreatedDate:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		DefaultRouteSettings: &types.RouteSettings{
			DataTraceEnabled:       ptr.Bool(true),
			DetailedMetricsEnabled: ptr.Bool(true),
			LoggingLevel:           types.LoggingLevel("ERROR"),
			ThrottlingBurstLimit:   ptr.Int32(1),
			ThrottlingRateLimit:    ptr.Float64(1.0),
		},
		DeploymentId:                ptr.String("__DeploymentId__"),
		Description:                 ptr.String("__Description__"),
		LastDeploymentStatusMessage: ptr.String("__LastDeploymentStatusMessage__"),
		LastUpdatedDate:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		RouteSettings: map[string]types.RouteSettings{
			"key0": {
				DataTraceEnabled:       ptr.Bool(true),
				DetailedMetricsEnabled: ptr.Bool(true),
				LoggingLevel:           types.LoggingLevel("ERROR"),
				ThrottlingBurstLimit:   ptr.Int32(1),
				ThrottlingRateLimit:    ptr.Float64(1.0),
			},
		},
		StageName: ptr.String("__StageName__"),
		StageVariables: map[string]string{
			"key0": "__Value__",
		},
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateStage.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.UpdateStage(context.Background(), &UpdateStageInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateStage.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateVpcLink(t *testing.T) {
	want := &UpdateVpcLinkOutput{
		CreatedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		Name:        ptr.String("__Name__"),
		SecurityGroupIds: []string{
			"__Member__",
			"__Member__",
		},
		SubnetIds: []string{
			"__Member__",
			"__Member__",
		},
		Tags: map[string]string{
			"key0": "__Value__",
		},
		VpcLinkId:            ptr.String("__VpcLinkId__"),
		VpcLinkStatus:        types.VpcLinkStatus("PENDING"),
		VpcLinkStatusMessage: ptr.String("__VpcLinkStatusMessage__"),
		VpcLinkVersion:       types.VpcLinkVersion("V2"),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateVpcLink.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.UpdateVpcLink(context.Background(), &UpdateVpcLinkInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateVpcLink.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.CreateDomainName(context.Background(), &CreateDomainNameInput{})
	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_BadRequestException(t *testing.T) {
	want := &types.BadRequestException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("BadRequestException.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.CreateApi(context.Background(), &CreateApiInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.BadRequestException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.BadRequestException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "BadRequestException.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.CreateApi(context.Background(), &CreateApiInput{})
	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_NotFoundException(t *testing.T) {
	want := &types.NotFoundException{
		Message:      ptr.String("__Message__"),
		ResourceType: ptr.String("__ResourceType__"),
	}
	status, header, body, err := serdeRespReadSnapshot("NotFoundException.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.CreateApi(context.Background(), &CreateApiInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.NotFoundException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.NotFoundException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "NotFoundException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_TooManyRequestsException(t *testing.T) {
	want := &types.TooManyRequestsException{
		LimitType: ptr.String("__LimitType__"),
		Message:   ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("TooManyRequestsException.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.CreateApi(context.Background(), &CreateApiInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.TooManyRequestsException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.TooManyRequestsException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "TooManyRequestsException.error", err)
	}
}
