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

//go:build response_snapshot

package appflow

import (
	"bufio"
	"bytes"
	"context"
	"errors"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/appflow/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_CancelFlowExecutions(t *testing.T) {
	want := &CancelFlowExecutionsOutput{
		InvalidExecutions: []string{
			"__Member__",
			"__Member__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CancelFlowExecutions.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.CancelFlowExecutions(context.Background(), &CancelFlowExecutionsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CancelFlowExecutions.response", err)
	}
}

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

func TestCheckResponseSnapshot_CreateFlow(t *testing.T) {
	want := &CreateFlowOutput{
		FlowArn:    ptr.String("__FlowArn__"),
		FlowStatus: types.FlowStatus("Active"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateFlow.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.CreateFlow(context.Background(), &CreateFlowInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateFlow.response", err)
	}
}

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

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

func TestCheckResponseSnapshot_DescribeConnector(t *testing.T) {
	want := &DescribeConnectorOutput{
		ConnectorConfiguration: &types.ConnectorConfiguration{
			CanUseAsSource:      true,
			CanUseAsDestination: true,
			SupportedDestinationConnectors: []types.ConnectorType{
				types.ConnectorType("Salesforce"),
				types.ConnectorType("Salesforce"),
			},
			SupportedSchedulingFrequencies: []types.ScheduleFrequencyType{
				types.ScheduleFrequencyType("BYMINUTE"),
				types.ScheduleFrequencyType("BYMINUTE"),
			},
			IsPrivateLinkEnabled:             true,
			IsPrivateLinkEndpointUrlRequired: true,
			SupportedTriggerTypes: []types.TriggerType{
				types.TriggerType("Scheduled"),
				types.TriggerType("Scheduled"),
			},
			ConnectorMetadata: &types.ConnectorMetadata{
				Amplitude: &types.AmplitudeMetadata{},
				Datadog:   &types.DatadogMetadata{},
				Dynatrace: &types.DynatraceMetadata{},
				GoogleAnalytics: &types.GoogleAnalyticsMetadata{
					OAuthScopes: []string{
						"__Member__",
						"__Member__",
					},
				},
				InforNexus: &types.InforNexusMetadata{},
				Marketo:    &types.MarketoMetadata{},
				Redshift:   &types.RedshiftMetadata{},
				S3:         &types.S3Metadata{},
				Salesforce: &types.SalesforceMetadata{
					OAuthScopes: []string{
						"__Member__",
						"__Member__",
					},
					DataTransferApis: []types.SalesforceDataTransferApi{
						types.SalesforceDataTransferApi("AUTOMATIC"),
						types.SalesforceDataTransferApi("AUTOMATIC"),
					},
					Oauth2GrantTypesSupported: []types.OAuth2GrantType{
						types.OAuth2GrantType("CLIENT_CREDENTIALS"),
						types.OAuth2GrantType("CLIENT_CREDENTIALS"),
					},
				},
				ServiceNow: &types.ServiceNowMetadata{},
				Singular:   &types.SingularMetadata{},
				Slack: &types.SlackMetadata{
					OAuthScopes: []string{
						"__Member__",
						"__Member__",
					},
				},
				Snowflake: &types.SnowflakeMetadata{
					SupportedRegions: []string{
						"__Member__",
						"__Member__",
					},
				},
				Trendmicro: &types.TrendmicroMetadata{},
				Veeva:      &types.VeevaMetadata{},
				Zendesk: &types.ZendeskMetadata{
					OAuthScopes: []string{
						"__Member__",
						"__Member__",
					},
				},
				EventBridge:      &types.EventBridgeMetadata{},
				Upsolver:         &types.UpsolverMetadata{},
				CustomerProfiles: &types.CustomerProfilesMetadata{},
				Honeycode: &types.HoneycodeMetadata{
					OAuthScopes: []string{
						"__Member__",
						"__Member__",
					},
				},
				SAPOData: &types.SAPODataMetadata{},
				Pardot:   &types.PardotMetadata{},
			},
			ConnectorType:        types.ConnectorType("Salesforce"),
			ConnectorLabel:       ptr.String("__ConnectorLabel__"),
			ConnectorDescription: ptr.String("__ConnectorDescription__"),
			ConnectorOwner:       ptr.String("__ConnectorOwner__"),
			ConnectorName:        ptr.String("__ConnectorName__"),
			ConnectorVersion:     ptr.String("__ConnectorVersion__"),
			ConnectorArn:         ptr.String("__ConnectorArn__"),
			ConnectorModes: []string{
				"__Member__",
				"__Member__",
			},
			AuthenticationConfig: &types.AuthenticationConfig{
				IsBasicAuthSupported:  true,
				IsApiKeyAuthSupported: true,
				IsOAuth2Supported:     true,
				IsCustomAuthSupported: true,
				OAuth2Defaults: &types.OAuth2Defaults{
					OauthScopes: []string{
						"__Member__",
						"__Member__",
					},
					TokenUrls: []string{
						"__Member__",
						"__Member__",
					},
					AuthCodeUrls: []string{
						"__Member__",
						"__Member__",
					},
					Oauth2GrantTypesSupported: []types.OAuth2GrantType{
						types.OAuth2GrantType("CLIENT_CREDENTIALS"),
						types.OAuth2GrantType("CLIENT_CREDENTIALS"),
					},
					Oauth2CustomProperties: []types.OAuth2CustomParameter{
						{
							Key:              ptr.String("__Key__"),
							IsRequired:       true,
							Label:            ptr.String("__Label__"),
							Description:      ptr.String("__Description__"),
							IsSensitiveField: true,
							ConnectorSuppliedValues: []string{
								"__Member__",
								"__Member__",
							},
							Type: types.OAuth2CustomPropType("TOKEN_URL"),
						},
						{
							Key:              ptr.String("__Key__"),
							IsRequired:       true,
							Label:            ptr.String("__Label__"),
							Description:      ptr.String("__Description__"),
							IsSensitiveField: true,
							ConnectorSuppliedValues: []string{
								"__Member__",
								"__Member__",
							},
							Type: types.OAuth2CustomPropType("TOKEN_URL"),
						},
					},
				},
				CustomAuthConfigs: []types.CustomAuthConfig{
					{
						CustomAuthenticationType: ptr.String("__CustomAuthenticationType__"),
						AuthParameters: []types.AuthParameter{
							{
								Key:              ptr.String("__Key__"),
								IsRequired:       true,
								Label:            ptr.String("__Label__"),
								Description:      ptr.String("__Description__"),
								IsSensitiveField: true,
								ConnectorSuppliedValues: []string{
									"__Member__",
									"__Member__",
								},
							},
							{
								Key:              ptr.String("__Key__"),
								IsRequired:       true,
								Label:            ptr.String("__Label__"),
								Description:      ptr.String("__Description__"),
								IsSensitiveField: true,
								ConnectorSuppliedValues: []string{
									"__Member__",
									"__Member__",
								},
							},
						},
					},
					{
						CustomAuthenticationType: ptr.String("__CustomAuthenticationType__"),
						AuthParameters: []types.AuthParameter{
							{
								Key:              ptr.String("__Key__"),
								IsRequired:       true,
								Label:            ptr.String("__Label__"),
								Description:      ptr.String("__Description__"),
								IsSensitiveField: true,
								ConnectorSuppliedValues: []string{
									"__Member__",
									"__Member__",
								},
							},
							{
								Key:              ptr.String("__Key__"),
								IsRequired:       true,
								Label:            ptr.String("__Label__"),
								Description:      ptr.String("__Description__"),
								IsSensitiveField: true,
								ConnectorSuppliedValues: []string{
									"__Member__",
									"__Member__",
								},
							},
						},
					},
				},
			},
			ConnectorRuntimeSettings: []types.ConnectorRuntimeSetting{
				{
					Key:         ptr.String("__Key__"),
					DataType:    ptr.String("__DataType__"),
					IsRequired:  true,
					Label:       ptr.String("__Label__"),
					Description: ptr.String("__Description__"),
					Scope:       ptr.String("__Scope__"),
					ConnectorSuppliedValueOptions: []string{
						"__Member__",
						"__Member__",
					},
				},
				{
					Key:         ptr.String("__Key__"),
					DataType:    ptr.String("__DataType__"),
					IsRequired:  true,
					Label:       ptr.String("__Label__"),
					Description: ptr.String("__Description__"),
					Scope:       ptr.String("__Scope__"),
					ConnectorSuppliedValueOptions: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
			SupportedApiVersions: []string{
				"__Member__",
				"__Member__",
			},
			SupportedOperators: []types.Operators{
				types.Operators("PROJECTION"),
				types.Operators("PROJECTION"),
			},
			SupportedWriteOperations: []types.WriteOperationType{
				types.WriteOperationType("INSERT"),
				types.WriteOperationType("INSERT"),
			},
			ConnectorProvisioningType: types.ConnectorProvisioningType("LAMBDA"),
			ConnectorProvisioningConfig: &types.ConnectorProvisioningConfig{
				Lambda: &types.LambdaConnectorProvisioningConfig{
					LambdaArn: ptr.String("__LambdaArn__"),
				},
			},
			LogoURL:      ptr.String("__LogoURL__"),
			RegisteredAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			RegisteredBy: ptr.String("__RegisteredBy__"),
			SupportedDataTransferTypes: []types.SupportedDataTransferType{
				types.SupportedDataTransferType("RECORD"),
				types.SupportedDataTransferType("RECORD"),
			},
			SupportedDataTransferApis: []types.DataTransferApi{
				{
					Name: ptr.String("__Name__"),
					Type: types.DataTransferApiType("SYNC"),
				},
				{
					Name: ptr.String("__Name__"),
					Type: types.DataTransferApiType("SYNC"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeConnector.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.DescribeConnector(context.Background(), &DescribeConnectorInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeConnector.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeConnectorEntity(t *testing.T) {
	want := &DescribeConnectorEntityOutput{
		ConnectorEntityFields: []types.ConnectorEntityField{
			{
				Identifier:       ptr.String("__Identifier__"),
				ParentIdentifier: ptr.String("__ParentIdentifier__"),
				Label:            ptr.String("__Label__"),
				IsPrimaryKey:     true,
				DefaultValue:     ptr.String("__DefaultValue__"),
				IsDeprecated:     true,
				SupportedFieldTypeDetails: &types.SupportedFieldTypeDetails{
					V1: &types.FieldTypeDetails{
						FieldType: ptr.String("__FieldType__"),
						FilterOperators: []types.Operator{
							types.Operator("PROJECTION"),
							types.Operator("PROJECTION"),
						},
						SupportedValues: []string{
							"__Member__",
							"__Member__",
						},
						ValueRegexPattern:   ptr.String("__ValueRegexPattern__"),
						SupportedDateFormat: ptr.String("__SupportedDateFormat__"),
						FieldValueRange: &types.Range{
							Maximum: 1.0,
							Minimum: 1.0,
						},
						FieldLengthRange: &types.Range{
							Maximum: 1.0,
							Minimum: 1.0,
						},
					},
				},
				Description: ptr.String("__Description__"),
				SourceProperties: &types.SourceFieldProperties{
					IsRetrievable:                         true,
					IsQueryable:                           true,
					IsTimestampFieldForIncrementalQueries: true,
				},
				DestinationProperties: &types.DestinationFieldProperties{
					IsCreatable:         true,
					IsNullable:          true,
					IsUpsertable:        true,
					IsUpdatable:         true,
					IsDefaultedOnCreate: true,
					SupportedWriteOperations: []types.WriteOperationType{
						types.WriteOperationType("INSERT"),
						types.WriteOperationType("INSERT"),
					},
				},
				CustomProperties: map[string]string{
					"key0": "__Value__",
				},
			},
			{
				Identifier:       ptr.String("__Identifier__"),
				ParentIdentifier: ptr.String("__ParentIdentifier__"),
				Label:            ptr.String("__Label__"),
				IsPrimaryKey:     true,
				DefaultValue:     ptr.String("__DefaultValue__"),
				IsDeprecated:     true,
				SupportedFieldTypeDetails: &types.SupportedFieldTypeDetails{
					V1: &types.FieldTypeDetails{
						FieldType: ptr.String("__FieldType__"),
						FilterOperators: []types.Operator{
							types.Operator("PROJECTION"),
							types.Operator("PROJECTION"),
						},
						SupportedValues: []string{
							"__Member__",
							"__Member__",
						},
						ValueRegexPattern:   ptr.String("__ValueRegexPattern__"),
						SupportedDateFormat: ptr.String("__SupportedDateFormat__"),
						FieldValueRange: &types.Range{
							Maximum: 1.0,
							Minimum: 1.0,
						},
						FieldLengthRange: &types.Range{
							Maximum: 1.0,
							Minimum: 1.0,
						},
					},
				},
				Description: ptr.String("__Description__"),
				SourceProperties: &types.SourceFieldProperties{
					IsRetrievable:                         true,
					IsQueryable:                           true,
					IsTimestampFieldForIncrementalQueries: true,
				},
				DestinationProperties: &types.DestinationFieldProperties{
					IsCreatable:         true,
					IsNullable:          true,
					IsUpsertable:        true,
					IsUpdatable:         true,
					IsDefaultedOnCreate: true,
					SupportedWriteOperations: []types.WriteOperationType{
						types.WriteOperationType("INSERT"),
						types.WriteOperationType("INSERT"),
					},
				},
				CustomProperties: map[string]string{
					"key0": "__Value__",
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeConnectorEntity.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.DescribeConnectorEntity(context.Background(), &DescribeConnectorEntityInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeConnectorEntity.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeConnectorProfiles(t *testing.T) {
	want := &DescribeConnectorProfilesOutput{
		ConnectorProfileDetails: []types.ConnectorProfile{
			{
				ConnectorProfileArn:  ptr.String("__ConnectorProfileArn__"),
				ConnectorProfileName: ptr.String("__ConnectorProfileName__"),
				ConnectorType:        types.ConnectorType("Salesforce"),
				ConnectorLabel:       ptr.String("__ConnectorLabel__"),
				ConnectionMode:       types.ConnectionMode("Public"),
				CredentialsArn:       ptr.String("__CredentialsArn__"),
				ConnectorProfileProperties: &types.ConnectorProfileProperties{
					Amplitude: &types.AmplitudeConnectorProfileProperties{},
					Datadog: &types.DatadogConnectorProfileProperties{
						InstanceUrl: ptr.String("__InstanceUrl__"),
					},
					Dynatrace: &types.DynatraceConnectorProfileProperties{
						InstanceUrl: ptr.String("__InstanceUrl__"),
					},
					GoogleAnalytics: &types.GoogleAnalyticsConnectorProfileProperties{},
					Honeycode:       &types.HoneycodeConnectorProfileProperties{},
					InforNexus: &types.InforNexusConnectorProfileProperties{
						InstanceUrl: ptr.String("__InstanceUrl__"),
					},
					Marketo: &types.MarketoConnectorProfileProperties{
						InstanceUrl: ptr.String("__InstanceUrl__"),
					},
					Redshift: &types.RedshiftConnectorProfileProperties{
						DatabaseUrl:          ptr.String("__DatabaseUrl__"),
						BucketName:           ptr.String("__BucketName__"),
						BucketPrefix:         ptr.String("__BucketPrefix__"),
						RoleArn:              ptr.String("__RoleArn__"),
						DataApiRoleArn:       ptr.String("__DataApiRoleArn__"),
						IsRedshiftServerless: true,
						ClusterIdentifier:    ptr.String("__ClusterIdentifier__"),
						WorkgroupName:        ptr.String("__WorkgroupName__"),
						DatabaseName:         ptr.String("__DatabaseName__"),
					},
					Salesforce: &types.SalesforceConnectorProfileProperties{
						InstanceUrl:          ptr.String("__InstanceUrl__"),
						IsSandboxEnvironment: true,
						UsePrivateLinkForMetadataAndAuthorization: true,
					},
					ServiceNow: &types.ServiceNowConnectorProfileProperties{
						InstanceUrl: ptr.String("__InstanceUrl__"),
					},
					Singular: &types.SingularConnectorProfileProperties{},
					Slack: &types.SlackConnectorProfileProperties{
						InstanceUrl: ptr.String("__InstanceUrl__"),
					},
					Snowflake: &types.SnowflakeConnectorProfileProperties{
						Warehouse:              ptr.String("__Warehouse__"),
						Stage:                  ptr.String("__Stage__"),
						BucketName:             ptr.String("__BucketName__"),
						BucketPrefix:           ptr.String("__BucketPrefix__"),
						PrivateLinkServiceName: ptr.String("__PrivateLinkServiceName__"),
						AccountName:            ptr.String("__AccountName__"),
						Region:                 ptr.String("__Region__"),
					},
					Trendmicro: &types.TrendmicroConnectorProfileProperties{},
					Veeva: &types.VeevaConnectorProfileProperties{
						InstanceUrl: ptr.String("__InstanceUrl__"),
					},
					Zendesk: &types.ZendeskConnectorProfileProperties{
						InstanceUrl: ptr.String("__InstanceUrl__"),
					},
					SAPOData: &types.SAPODataConnectorProfileProperties{
						ApplicationHostUrl:     ptr.String("__ApplicationHostUrl__"),
						ApplicationServicePath: ptr.String("__ApplicationServicePath__"),
						PortNumber:             ptr.Int32(1),
						ClientNumber:           ptr.String("__ClientNumber__"),
						LogonLanguage:          ptr.String("__LogonLanguage__"),
						PrivateLinkServiceName: ptr.String("__PrivateLinkServiceName__"),
						OAuthProperties: &types.OAuthProperties{
							TokenUrl:    ptr.String("__TokenUrl__"),
							AuthCodeUrl: ptr.String("__AuthCodeUrl__"),
							OAuthScopes: []string{
								"__Member__",
								"__Member__",
							},
						},
						DisableSSO: true,
					},
					CustomConnector: &types.CustomConnectorProfileProperties{
						ProfileProperties: map[string]string{
							"key0": "__Value__",
						},
						OAuth2Properties: &types.OAuth2Properties{
							TokenUrl:        ptr.String("__TokenUrl__"),
							OAuth2GrantType: types.OAuth2GrantType("CLIENT_CREDENTIALS"),
							TokenUrlCustomProperties: map[string]string{
								"key0": "__Value__",
							},
						},
					},
					Pardot: &types.PardotConnectorProfileProperties{
						InstanceUrl:          ptr.String("__InstanceUrl__"),
						IsSandboxEnvironment: true,
						BusinessUnitId:       ptr.String("__BusinessUnitId__"),
					},
				},
				CreatedAt:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastUpdatedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PrivateConnectionProvisioningState: &types.PrivateConnectionProvisioningState{
					Status:         types.PrivateConnectionProvisioningStatus("FAILED"),
					FailureMessage: ptr.String("__FailureMessage__"),
					FailureCause:   types.PrivateConnectionProvisioningFailureCause("CONNECTOR_AUTHENTICATION"),
				},
			},
			{
				ConnectorProfileArn:  ptr.String("__ConnectorProfileArn__"),
				ConnectorProfileName: ptr.String("__ConnectorProfileName__"),
				ConnectorType:        types.ConnectorType("Salesforce"),
				ConnectorLabel:       ptr.String("__ConnectorLabel__"),
				ConnectionMode:       types.ConnectionMode("Public"),
				CredentialsArn:       ptr.String("__CredentialsArn__"),
				ConnectorProfileProperties: &types.ConnectorProfileProperties{
					Amplitude: &types.AmplitudeConnectorProfileProperties{},
					Datadog: &types.DatadogConnectorProfileProperties{
						InstanceUrl: ptr.String("__InstanceUrl__"),
					},
					Dynatrace: &types.DynatraceConnectorProfileProperties{
						InstanceUrl: ptr.String("__InstanceUrl__"),
					},
					GoogleAnalytics: &types.GoogleAnalyticsConnectorProfileProperties{},
					Honeycode:       &types.HoneycodeConnectorProfileProperties{},
					InforNexus: &types.InforNexusConnectorProfileProperties{
						InstanceUrl: ptr.String("__InstanceUrl__"),
					},
					Marketo: &types.MarketoConnectorProfileProperties{
						InstanceUrl: ptr.String("__InstanceUrl__"),
					},
					Redshift: &types.RedshiftConnectorProfileProperties{
						DatabaseUrl:          ptr.String("__DatabaseUrl__"),
						BucketName:           ptr.String("__BucketName__"),
						BucketPrefix:         ptr.String("__BucketPrefix__"),
						RoleArn:              ptr.String("__RoleArn__"),
						DataApiRoleArn:       ptr.String("__DataApiRoleArn__"),
						IsRedshiftServerless: true,
						ClusterIdentifier:    ptr.String("__ClusterIdentifier__"),
						WorkgroupName:        ptr.String("__WorkgroupName__"),
						DatabaseName:         ptr.String("__DatabaseName__"),
					},
					Salesforce: &types.SalesforceConnectorProfileProperties{
						InstanceUrl:          ptr.String("__InstanceUrl__"),
						IsSandboxEnvironment: true,
						UsePrivateLinkForMetadataAndAuthorization: true,
					},
					ServiceNow: &types.ServiceNowConnectorProfileProperties{
						InstanceUrl: ptr.String("__InstanceUrl__"),
					},
					Singular: &types.SingularConnectorProfileProperties{},
					Slack: &types.SlackConnectorProfileProperties{
						InstanceUrl: ptr.String("__InstanceUrl__"),
					},
					Snowflake: &types.SnowflakeConnectorProfileProperties{
						Warehouse:              ptr.String("__Warehouse__"),
						Stage:                  ptr.String("__Stage__"),
						BucketName:             ptr.String("__BucketName__"),
						BucketPrefix:           ptr.String("__BucketPrefix__"),
						PrivateLinkServiceName: ptr.String("__PrivateLinkServiceName__"),
						AccountName:            ptr.String("__AccountName__"),
						Region:                 ptr.String("__Region__"),
					},
					Trendmicro: &types.TrendmicroConnectorProfileProperties{},
					Veeva: &types.VeevaConnectorProfileProperties{
						InstanceUrl: ptr.String("__InstanceUrl__"),
					},
					Zendesk: &types.ZendeskConnectorProfileProperties{
						InstanceUrl: ptr.String("__InstanceUrl__"),
					},
					SAPOData: &types.SAPODataConnectorProfileProperties{
						ApplicationHostUrl:     ptr.String("__ApplicationHostUrl__"),
						ApplicationServicePath: ptr.String("__ApplicationServicePath__"),
						PortNumber:             ptr.Int32(1),
						ClientNumber:           ptr.String("__ClientNumber__"),
						LogonLanguage:          ptr.String("__LogonLanguage__"),
						PrivateLinkServiceName: ptr.String("__PrivateLinkServiceName__"),
						OAuthProperties: &types.OAuthProperties{
							TokenUrl:    ptr.String("__TokenUrl__"),
							AuthCodeUrl: ptr.String("__AuthCodeUrl__"),
							OAuthScopes: []string{
								"__Member__",
								"__Member__",
							},
						},
						DisableSSO: true,
					},
					CustomConnector: &types.CustomConnectorProfileProperties{
						ProfileProperties: map[string]string{
							"key0": "__Value__",
						},
						OAuth2Properties: &types.OAuth2Properties{
							TokenUrl:        ptr.String("__TokenUrl__"),
							OAuth2GrantType: types.OAuth2GrantType("CLIENT_CREDENTIALS"),
							TokenUrlCustomProperties: map[string]string{
								"key0": "__Value__",
							},
						},
					},
					Pardot: &types.PardotConnectorProfileProperties{
						InstanceUrl:          ptr.String("__InstanceUrl__"),
						IsSandboxEnvironment: true,
						BusinessUnitId:       ptr.String("__BusinessUnitId__"),
					},
				},
				CreatedAt:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastUpdatedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PrivateConnectionProvisioningState: &types.PrivateConnectionProvisioningState{
					Status:         types.PrivateConnectionProvisioningStatus("FAILED"),
					FailureMessage: ptr.String("__FailureMessage__"),
					FailureCause:   types.PrivateConnectionProvisioningFailureCause("CONNECTOR_AUTHENTICATION"),
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeConnectorProfiles.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.DescribeConnectorProfiles(context.Background(), &DescribeConnectorProfilesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeConnectorProfiles.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeConnectors(t *testing.T) {
	want := &DescribeConnectorsOutput{
		ConnectorConfigurations: map[string]types.ConnectorConfiguration{
			"key0": {
				CanUseAsSource:      true,
				CanUseAsDestination: true,
				SupportedDestinationConnectors: []types.ConnectorType{
					types.ConnectorType("Salesforce"),
					types.ConnectorType("Salesforce"),
				},
				SupportedSchedulingFrequencies: []types.ScheduleFrequencyType{
					types.ScheduleFrequencyType("BYMINUTE"),
					types.ScheduleFrequencyType("BYMINUTE"),
				},
				IsPrivateLinkEnabled:             true,
				IsPrivateLinkEndpointUrlRequired: true,
				SupportedTriggerTypes: []types.TriggerType{
					types.TriggerType("Scheduled"),
					types.TriggerType("Scheduled"),
				},
				ConnectorMetadata: &types.ConnectorMetadata{
					Amplitude: &types.AmplitudeMetadata{},
					Datadog:   &types.DatadogMetadata{},
					Dynatrace: &types.DynatraceMetadata{},
					GoogleAnalytics: &types.GoogleAnalyticsMetadata{
						OAuthScopes: []string{
							"__Member__",
							"__Member__",
						},
					},
					InforNexus: &types.InforNexusMetadata{},
					Marketo:    &types.MarketoMetadata{},
					Redshift:   &types.RedshiftMetadata{},
					S3:         &types.S3Metadata{},
					Salesforce: &types.SalesforceMetadata{
						OAuthScopes: []string{
							"__Member__",
							"__Member__",
						},
						DataTransferApis: []types.SalesforceDataTransferApi{
							types.SalesforceDataTransferApi("AUTOMATIC"),
							types.SalesforceDataTransferApi("AUTOMATIC"),
						},
						Oauth2GrantTypesSupported: []types.OAuth2GrantType{
							types.OAuth2GrantType("CLIENT_CREDENTIALS"),
							types.OAuth2GrantType("CLIENT_CREDENTIALS"),
						},
					},
					ServiceNow: &types.ServiceNowMetadata{},
					Singular:   &types.SingularMetadata{},
					Slack: &types.SlackMetadata{
						OAuthScopes: []string{
							"__Member__",
							"__Member__",
						},
					},
					Snowflake: &types.SnowflakeMetadata{
						SupportedRegions: []string{
							"__Member__",
							"__Member__",
						},
					},
					Trendmicro: &types.TrendmicroMetadata{},
					Veeva:      &types.VeevaMetadata{},
					Zendesk: &types.ZendeskMetadata{
						OAuthScopes: []string{
							"__Member__",
							"__Member__",
						},
					},
					EventBridge:      &types.EventBridgeMetadata{},
					Upsolver:         &types.UpsolverMetadata{},
					CustomerProfiles: &types.CustomerProfilesMetadata{},
					Honeycode: &types.HoneycodeMetadata{
						OAuthScopes: []string{
							"__Member__",
							"__Member__",
						},
					},
					SAPOData: &types.SAPODataMetadata{},
					Pardot:   &types.PardotMetadata{},
				},
				ConnectorType:        types.ConnectorType("Salesforce"),
				ConnectorLabel:       ptr.String("__ConnectorLabel__"),
				ConnectorDescription: ptr.String("__ConnectorDescription__"),
				ConnectorOwner:       ptr.String("__ConnectorOwner__"),
				ConnectorName:        ptr.String("__ConnectorName__"),
				ConnectorVersion:     ptr.String("__ConnectorVersion__"),
				ConnectorArn:         ptr.String("__ConnectorArn__"),
				ConnectorModes: []string{
					"__Member__",
					"__Member__",
				},
				AuthenticationConfig: &types.AuthenticationConfig{
					IsBasicAuthSupported:  true,
					IsApiKeyAuthSupported: true,
					IsOAuth2Supported:     true,
					IsCustomAuthSupported: true,
					OAuth2Defaults: &types.OAuth2Defaults{
						OauthScopes: []string{
							"__Member__",
							"__Member__",
						},
						TokenUrls: []string{
							"__Member__",
							"__Member__",
						},
						AuthCodeUrls: []string{
							"__Member__",
							"__Member__",
						},
						Oauth2GrantTypesSupported: []types.OAuth2GrantType{
							types.OAuth2GrantType("CLIENT_CREDENTIALS"),
							types.OAuth2GrantType("CLIENT_CREDENTIALS"),
						},
						Oauth2CustomProperties: []types.OAuth2CustomParameter{
							{
								Key:              ptr.String("__Key__"),
								IsRequired:       true,
								Label:            ptr.String("__Label__"),
								Description:      ptr.String("__Description__"),
								IsSensitiveField: true,
								ConnectorSuppliedValues: []string{
									"__Member__",
									"__Member__",
								},
								Type: types.OAuth2CustomPropType("TOKEN_URL"),
							},
							{
								Key:              ptr.String("__Key__"),
								IsRequired:       true,
								Label:            ptr.String("__Label__"),
								Description:      ptr.String("__Description__"),
								IsSensitiveField: true,
								ConnectorSuppliedValues: []string{
									"__Member__",
									"__Member__",
								},
								Type: types.OAuth2CustomPropType("TOKEN_URL"),
							},
						},
					},
					CustomAuthConfigs: []types.CustomAuthConfig{
						{
							CustomAuthenticationType: ptr.String("__CustomAuthenticationType__"),
							AuthParameters: []types.AuthParameter{
								{
									Key:              ptr.String("__Key__"),
									IsRequired:       true,
									Label:            ptr.String("__Label__"),
									Description:      ptr.String("__Description__"),
									IsSensitiveField: true,
									ConnectorSuppliedValues: []string{
										"__Member__",
										"__Member__",
									},
								},
								{
									Key:              ptr.String("__Key__"),
									IsRequired:       true,
									Label:            ptr.String("__Label__"),
									Description:      ptr.String("__Description__"),
									IsSensitiveField: true,
									ConnectorSuppliedValues: []string{
										"__Member__",
										"__Member__",
									},
								},
							},
						},
						{
							CustomAuthenticationType: ptr.String("__CustomAuthenticationType__"),
							AuthParameters: []types.AuthParameter{
								{
									Key:              ptr.String("__Key__"),
									IsRequired:       true,
									Label:            ptr.String("__Label__"),
									Description:      ptr.String("__Description__"),
									IsSensitiveField: true,
									ConnectorSuppliedValues: []string{
										"__Member__",
										"__Member__",
									},
								},
								{
									Key:              ptr.String("__Key__"),
									IsRequired:       true,
									Label:            ptr.String("__Label__"),
									Description:      ptr.String("__Description__"),
									IsSensitiveField: true,
									ConnectorSuppliedValues: []string{
										"__Member__",
										"__Member__",
									},
								},
							},
						},
					},
				},
				ConnectorRuntimeSettings: []types.ConnectorRuntimeSetting{
					{
						Key:         ptr.String("__Key__"),
						DataType:    ptr.String("__DataType__"),
						IsRequired:  true,
						Label:       ptr.String("__Label__"),
						Description: ptr.String("__Description__"),
						Scope:       ptr.String("__Scope__"),
						ConnectorSuppliedValueOptions: []string{
							"__Member__",
							"__Member__",
						},
					},
					{
						Key:         ptr.String("__Key__"),
						DataType:    ptr.String("__DataType__"),
						IsRequired:  true,
						Label:       ptr.String("__Label__"),
						Description: ptr.String("__Description__"),
						Scope:       ptr.String("__Scope__"),
						ConnectorSuppliedValueOptions: []string{
							"__Member__",
							"__Member__",
						},
					},
				},
				SupportedApiVersions: []string{
					"__Member__",
					"__Member__",
				},
				SupportedOperators: []types.Operators{
					types.Operators("PROJECTION"),
					types.Operators("PROJECTION"),
				},
				SupportedWriteOperations: []types.WriteOperationType{
					types.WriteOperationType("INSERT"),
					types.WriteOperationType("INSERT"),
				},
				ConnectorProvisioningType: types.ConnectorProvisioningType("LAMBDA"),
				ConnectorProvisioningConfig: &types.ConnectorProvisioningConfig{
					Lambda: &types.LambdaConnectorProvisioningConfig{
						LambdaArn: ptr.String("__LambdaArn__"),
					},
				},
				LogoURL:      ptr.String("__LogoURL__"),
				RegisteredAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				RegisteredBy: ptr.String("__RegisteredBy__"),
				SupportedDataTransferTypes: []types.SupportedDataTransferType{
					types.SupportedDataTransferType("RECORD"),
					types.SupportedDataTransferType("RECORD"),
				},
				SupportedDataTransferApis: []types.DataTransferApi{
					{
						Name: ptr.String("__Name__"),
						Type: types.DataTransferApiType("SYNC"),
					},
					{
						Name: ptr.String("__Name__"),
						Type: types.DataTransferApiType("SYNC"),
					},
				},
			},
		},
		Connectors: []types.ConnectorDetail{
			{
				ConnectorDescription:      ptr.String("__ConnectorDescription__"),
				ConnectorName:             ptr.String("__ConnectorName__"),
				ConnectorOwner:            ptr.String("__ConnectorOwner__"),
				ConnectorVersion:          ptr.String("__ConnectorVersion__"),
				ApplicationType:           ptr.String("__ApplicationType__"),
				ConnectorType:             types.ConnectorType("Salesforce"),
				ConnectorLabel:            ptr.String("__ConnectorLabel__"),
				RegisteredAt:              ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				RegisteredBy:              ptr.String("__RegisteredBy__"),
				ConnectorProvisioningType: types.ConnectorProvisioningType("LAMBDA"),
				ConnectorModes: []string{
					"__Member__",
					"__Member__",
				},
				SupportedDataTransferTypes: []types.SupportedDataTransferType{
					types.SupportedDataTransferType("RECORD"),
					types.SupportedDataTransferType("RECORD"),
				},
			},
			{
				ConnectorDescription:      ptr.String("__ConnectorDescription__"),
				ConnectorName:             ptr.String("__ConnectorName__"),
				ConnectorOwner:            ptr.String("__ConnectorOwner__"),
				ConnectorVersion:          ptr.String("__ConnectorVersion__"),
				ApplicationType:           ptr.String("__ApplicationType__"),
				ConnectorType:             types.ConnectorType("Salesforce"),
				ConnectorLabel:            ptr.String("__ConnectorLabel__"),
				RegisteredAt:              ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				RegisteredBy:              ptr.String("__RegisteredBy__"),
				ConnectorProvisioningType: types.ConnectorProvisioningType("LAMBDA"),
				ConnectorModes: []string{
					"__Member__",
					"__Member__",
				},
				SupportedDataTransferTypes: []types.SupportedDataTransferType{
					types.SupportedDataTransferType("RECORD"),
					types.SupportedDataTransferType("RECORD"),
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeConnectors.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.DescribeConnectors(context.Background(), &DescribeConnectorsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeConnectors.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeFlow(t *testing.T) {
	want := &DescribeFlowOutput{
		FlowArn:           ptr.String("__FlowArn__"),
		Description:       ptr.String("__Description__"),
		FlowName:          ptr.String("__FlowName__"),
		KmsArn:            ptr.String("__KmsArn__"),
		FlowStatus:        types.FlowStatus("Active"),
		FlowStatusMessage: ptr.String("__FlowStatusMessage__"),
		SourceFlowConfig: &types.SourceFlowConfig{
			ConnectorType:        types.ConnectorType("Salesforce"),
			ApiVersion:           ptr.String("__ApiVersion__"),
			ConnectorProfileName: ptr.String("__ConnectorProfileName__"),
			SourceConnectorProperties: &types.SourceConnectorProperties{
				Amplitude: &types.AmplitudeSourceProperties{
					Object: ptr.String("__Object__"),
				},
				Datadog: &types.DatadogSourceProperties{
					Object: ptr.String("__Object__"),
				},
				Dynatrace: &types.DynatraceSourceProperties{
					Object: ptr.String("__Object__"),
				},
				GoogleAnalytics: &types.GoogleAnalyticsSourceProperties{
					Object: ptr.String("__Object__"),
				},
				InforNexus: &types.InforNexusSourceProperties{
					Object: ptr.String("__Object__"),
				},
				Marketo: &types.MarketoSourceProperties{
					Object: ptr.String("__Object__"),
				},
				S3: &types.S3SourceProperties{
					BucketName:   ptr.String("__BucketName__"),
					BucketPrefix: ptr.String("__BucketPrefix__"),
					S3InputFormatConfig: &types.S3InputFormatConfig{
						S3InputFileType: types.S3InputFileType("CSV"),
					},
				},
				Salesforce: &types.SalesforceSourceProperties{
					Object:                   ptr.String("__Object__"),
					EnableDynamicFieldUpdate: true,
					IncludeDeletedRecords:    true,
					DataTransferApi:          types.SalesforceDataTransferApi("AUTOMATIC"),
				},
				ServiceNow: &types.ServiceNowSourceProperties{
					Object: ptr.String("__Object__"),
				},
				Singular: &types.SingularSourceProperties{
					Object: ptr.String("__Object__"),
				},
				Slack: &types.SlackSourceProperties{
					Object: ptr.String("__Object__"),
				},
				Trendmicro: &types.TrendmicroSourceProperties{
					Object: ptr.String("__Object__"),
				},
				Veeva: &types.VeevaSourceProperties{
					Object:             ptr.String("__Object__"),
					DocumentType:       ptr.String("__DocumentType__"),
					IncludeSourceFiles: true,
					IncludeRenditions:  true,
					IncludeAllVersions: true,
				},
				Zendesk: &types.ZendeskSourceProperties{
					Object: ptr.String("__Object__"),
				},
				SAPOData: &types.SAPODataSourceProperties{
					ObjectPath: ptr.String("__ObjectPath__"),
					ParallelismConfig: &types.SAPODataParallelismConfig{
						MaxParallelism: ptr.Int32(1),
					},
					PaginationConfig: &types.SAPODataPaginationConfig{
						MaxPageSize: ptr.Int32(1),
					},
				},
				CustomConnector: &types.CustomConnectorSourceProperties{
					EntityName: ptr.String("__EntityName__"),
					CustomProperties: map[string]string{
						"key0": "__Value__",
					},
					DataTransferApi: &types.DataTransferApi{
						Name: ptr.String("__Name__"),
						Type: types.DataTransferApiType("SYNC"),
					},
				},
				Pardot: &types.PardotSourceProperties{
					Object: ptr.String("__Object__"),
				},
			},
			IncrementalPullConfig: &types.IncrementalPullConfig{
				DatetimeTypeFieldName: ptr.String("__DatetimeTypeFieldName__"),
			},
		},
		DestinationFlowConfigList: []types.DestinationFlowConfig{
			{
				ConnectorType:        types.ConnectorType("Salesforce"),
				ApiVersion:           ptr.String("__ApiVersion__"),
				ConnectorProfileName: ptr.String("__ConnectorProfileName__"),
				DestinationConnectorProperties: &types.DestinationConnectorProperties{
					Redshift: &types.RedshiftDestinationProperties{
						Object:                 ptr.String("__Object__"),
						IntermediateBucketName: ptr.String("__IntermediateBucketName__"),
						BucketPrefix:           ptr.String("__BucketPrefix__"),
						ErrorHandlingConfig: &types.ErrorHandlingConfig{
							FailOnFirstDestinationError: true,
							BucketPrefix:                ptr.String("__BucketPrefix__"),
							BucketName:                  ptr.String("__BucketName__"),
						},
					},
					S3: &types.S3DestinationProperties{
						BucketName:   ptr.String("__BucketName__"),
						BucketPrefix: ptr.String("__BucketPrefix__"),
						S3OutputFormatConfig: &types.S3OutputFormatConfig{
							FileType: types.FileType("CSV"),
							PrefixConfig: &types.PrefixConfig{
								PrefixType:   types.PrefixType("FILENAME"),
								PrefixFormat: types.PrefixFormat("YEAR"),
								PathPrefixHierarchy: []types.PathPrefix{
									types.PathPrefix("EXECUTION_ID"),
									types.PathPrefix("EXECUTION_ID"),
								},
							},
							AggregationConfig: &types.AggregationConfig{
								AggregationType: types.AggregationType("None"),
								TargetFileSize:  ptr.Int64(1),
							},
							PreserveSourceDataTyping: ptr.Bool(true),
						},
					},
					Salesforce: &types.SalesforceDestinationProperties{
						Object: ptr.String("__Object__"),
						IdFieldNames: []string{
							"__Member__",
							"__Member__",
						},
						ErrorHandlingConfig: &types.ErrorHandlingConfig{
							FailOnFirstDestinationError: true,
							BucketPrefix:                ptr.String("__BucketPrefix__"),
							BucketName:                  ptr.String("__BucketName__"),
						},
						WriteOperationType: types.WriteOperationType("INSERT"),
						DataTransferApi:    types.SalesforceDataTransferApi("AUTOMATIC"),
					},
					Snowflake: &types.SnowflakeDestinationProperties{
						Object:                 ptr.String("__Object__"),
						IntermediateBucketName: ptr.String("__IntermediateBucketName__"),
						BucketPrefix:           ptr.String("__BucketPrefix__"),
						ErrorHandlingConfig: &types.ErrorHandlingConfig{
							FailOnFirstDestinationError: true,
							BucketPrefix:                ptr.String("__BucketPrefix__"),
							BucketName:                  ptr.String("__BucketName__"),
						},
					},
					EventBridge: &types.EventBridgeDestinationProperties{
						Object: ptr.String("__Object__"),
						ErrorHandlingConfig: &types.ErrorHandlingConfig{
							FailOnFirstDestinationError: true,
							BucketPrefix:                ptr.String("__BucketPrefix__"),
							BucketName:                  ptr.String("__BucketName__"),
						},
					},
					LookoutMetrics: &types.LookoutMetricsDestinationProperties{},
					Upsolver: &types.UpsolverDestinationProperties{
						BucketName:   ptr.String("__BucketName__"),
						BucketPrefix: ptr.String("__BucketPrefix__"),
						S3OutputFormatConfig: &types.UpsolverS3OutputFormatConfig{
							FileType: types.FileType("CSV"),
							PrefixConfig: &types.PrefixConfig{
								PrefixType:   types.PrefixType("FILENAME"),
								PrefixFormat: types.PrefixFormat("YEAR"),
								PathPrefixHierarchy: []types.PathPrefix{
									types.PathPrefix("EXECUTION_ID"),
									types.PathPrefix("EXECUTION_ID"),
								},
							},
							AggregationConfig: &types.AggregationConfig{
								AggregationType: types.AggregationType("None"),
								TargetFileSize:  ptr.Int64(1),
							},
						},
					},
					Honeycode: &types.HoneycodeDestinationProperties{
						Object: ptr.String("__Object__"),
						ErrorHandlingConfig: &types.ErrorHandlingConfig{
							FailOnFirstDestinationError: true,
							BucketPrefix:                ptr.String("__BucketPrefix__"),
							BucketName:                  ptr.String("__BucketName__"),
						},
					},
					CustomerProfiles: &types.CustomerProfilesDestinationProperties{
						DomainName:     ptr.String("__DomainName__"),
						ObjectTypeName: ptr.String("__ObjectTypeName__"),
					},
					Zendesk: &types.ZendeskDestinationProperties{
						Object: ptr.String("__Object__"),
						IdFieldNames: []string{
							"__Member__",
							"__Member__",
						},
						ErrorHandlingConfig: &types.ErrorHandlingConfig{
							FailOnFirstDestinationError: true,
							BucketPrefix:                ptr.String("__BucketPrefix__"),
							BucketName:                  ptr.String("__BucketName__"),
						},
						WriteOperationType: types.WriteOperationType("INSERT"),
					},
					Marketo: &types.MarketoDestinationProperties{
						Object: ptr.String("__Object__"),
						ErrorHandlingConfig: &types.ErrorHandlingConfig{
							FailOnFirstDestinationError: true,
							BucketPrefix:                ptr.String("__BucketPrefix__"),
							BucketName:                  ptr.String("__BucketName__"),
						},
					},
					CustomConnector: &types.CustomConnectorDestinationProperties{
						EntityName: ptr.String("__EntityName__"),
						ErrorHandlingConfig: &types.ErrorHandlingConfig{
							FailOnFirstDestinationError: true,
							BucketPrefix:                ptr.String("__BucketPrefix__"),
							BucketName:                  ptr.String("__BucketName__"),
						},
						WriteOperationType: types.WriteOperationType("INSERT"),
						IdFieldNames: []string{
							"__Member__",
							"__Member__",
						},
						CustomProperties: map[string]string{
							"key0": "__Value__",
						},
					},
					SAPOData: &types.SAPODataDestinationProperties{
						ObjectPath: ptr.String("__ObjectPath__"),
						SuccessResponseHandlingConfig: &types.SuccessResponseHandlingConfig{
							BucketPrefix: ptr.String("__BucketPrefix__"),
							BucketName:   ptr.String("__BucketName__"),
						},
						IdFieldNames: []string{
							"__Member__",
							"__Member__",
						},
						ErrorHandlingConfig: &types.ErrorHandlingConfig{
							FailOnFirstDestinationError: true,
							BucketPrefix:                ptr.String("__BucketPrefix__"),
							BucketName:                  ptr.String("__BucketName__"),
						},
						WriteOperationType: types.WriteOperationType("INSERT"),
					},
				},
			},
			{
				ConnectorType:        types.ConnectorType("Salesforce"),
				ApiVersion:           ptr.String("__ApiVersion__"),
				ConnectorProfileName: ptr.String("__ConnectorProfileName__"),
				DestinationConnectorProperties: &types.DestinationConnectorProperties{
					Redshift: &types.RedshiftDestinationProperties{
						Object:                 ptr.String("__Object__"),
						IntermediateBucketName: ptr.String("__IntermediateBucketName__"),
						BucketPrefix:           ptr.String("__BucketPrefix__"),
						ErrorHandlingConfig: &types.ErrorHandlingConfig{
							FailOnFirstDestinationError: true,
							BucketPrefix:                ptr.String("__BucketPrefix__"),
							BucketName:                  ptr.String("__BucketName__"),
						},
					},
					S3: &types.S3DestinationProperties{
						BucketName:   ptr.String("__BucketName__"),
						BucketPrefix: ptr.String("__BucketPrefix__"),
						S3OutputFormatConfig: &types.S3OutputFormatConfig{
							FileType: types.FileType("CSV"),
							PrefixConfig: &types.PrefixConfig{
								PrefixType:   types.PrefixType("FILENAME"),
								PrefixFormat: types.PrefixFormat("YEAR"),
								PathPrefixHierarchy: []types.PathPrefix{
									types.PathPrefix("EXECUTION_ID"),
									types.PathPrefix("EXECUTION_ID"),
								},
							},
							AggregationConfig: &types.AggregationConfig{
								AggregationType: types.AggregationType("None"),
								TargetFileSize:  ptr.Int64(1),
							},
							PreserveSourceDataTyping: ptr.Bool(true),
						},
					},
					Salesforce: &types.SalesforceDestinationProperties{
						Object: ptr.String("__Object__"),
						IdFieldNames: []string{
							"__Member__",
							"__Member__",
						},
						ErrorHandlingConfig: &types.ErrorHandlingConfig{
							FailOnFirstDestinationError: true,
							BucketPrefix:                ptr.String("__BucketPrefix__"),
							BucketName:                  ptr.String("__BucketName__"),
						},
						WriteOperationType: types.WriteOperationType("INSERT"),
						DataTransferApi:    types.SalesforceDataTransferApi("AUTOMATIC"),
					},
					Snowflake: &types.SnowflakeDestinationProperties{
						Object:                 ptr.String("__Object__"),
						IntermediateBucketName: ptr.String("__IntermediateBucketName__"),
						BucketPrefix:           ptr.String("__BucketPrefix__"),
						ErrorHandlingConfig: &types.ErrorHandlingConfig{
							FailOnFirstDestinationError: true,
							BucketPrefix:                ptr.String("__BucketPrefix__"),
							BucketName:                  ptr.String("__BucketName__"),
						},
					},
					EventBridge: &types.EventBridgeDestinationProperties{
						Object: ptr.String("__Object__"),
						ErrorHandlingConfig: &types.ErrorHandlingConfig{
							FailOnFirstDestinationError: true,
							BucketPrefix:                ptr.String("__BucketPrefix__"),
							BucketName:                  ptr.String("__BucketName__"),
						},
					},
					LookoutMetrics: &types.LookoutMetricsDestinationProperties{},
					Upsolver: &types.UpsolverDestinationProperties{
						BucketName:   ptr.String("__BucketName__"),
						BucketPrefix: ptr.String("__BucketPrefix__"),
						S3OutputFormatConfig: &types.UpsolverS3OutputFormatConfig{
							FileType: types.FileType("CSV"),
							PrefixConfig: &types.PrefixConfig{
								PrefixType:   types.PrefixType("FILENAME"),
								PrefixFormat: types.PrefixFormat("YEAR"),
								PathPrefixHierarchy: []types.PathPrefix{
									types.PathPrefix("EXECUTION_ID"),
									types.PathPrefix("EXECUTION_ID"),
								},
							},
							AggregationConfig: &types.AggregationConfig{
								AggregationType: types.AggregationType("None"),
								TargetFileSize:  ptr.Int64(1),
							},
						},
					},
					Honeycode: &types.HoneycodeDestinationProperties{
						Object: ptr.String("__Object__"),
						ErrorHandlingConfig: &types.ErrorHandlingConfig{
							FailOnFirstDestinationError: true,
							BucketPrefix:                ptr.String("__BucketPrefix__"),
							BucketName:                  ptr.String("__BucketName__"),
						},
					},
					CustomerProfiles: &types.CustomerProfilesDestinationProperties{
						DomainName:     ptr.String("__DomainName__"),
						ObjectTypeName: ptr.String("__ObjectTypeName__"),
					},
					Zendesk: &types.ZendeskDestinationProperties{
						Object: ptr.String("__Object__"),
						IdFieldNames: []string{
							"__Member__",
							"__Member__",
						},
						ErrorHandlingConfig: &types.ErrorHandlingConfig{
							FailOnFirstDestinationError: true,
							BucketPrefix:                ptr.String("__BucketPrefix__"),
							BucketName:                  ptr.String("__BucketName__"),
						},
						WriteOperationType: types.WriteOperationType("INSERT"),
					},
					Marketo: &types.MarketoDestinationProperties{
						Object: ptr.String("__Object__"),
						ErrorHandlingConfig: &types.ErrorHandlingConfig{
							FailOnFirstDestinationError: true,
							BucketPrefix:                ptr.String("__BucketPrefix__"),
							BucketName:                  ptr.String("__BucketName__"),
						},
					},
					CustomConnector: &types.CustomConnectorDestinationProperties{
						EntityName: ptr.String("__EntityName__"),
						ErrorHandlingConfig: &types.ErrorHandlingConfig{
							FailOnFirstDestinationError: true,
							BucketPrefix:                ptr.String("__BucketPrefix__"),
							BucketName:                  ptr.String("__BucketName__"),
						},
						WriteOperationType: types.WriteOperationType("INSERT"),
						IdFieldNames: []string{
							"__Member__",
							"__Member__",
						},
						CustomProperties: map[string]string{
							"key0": "__Value__",
						},
					},
					SAPOData: &types.SAPODataDestinationProperties{
						ObjectPath: ptr.String("__ObjectPath__"),
						SuccessResponseHandlingConfig: &types.SuccessResponseHandlingConfig{
							BucketPrefix: ptr.String("__BucketPrefix__"),
							BucketName:   ptr.String("__BucketName__"),
						},
						IdFieldNames: []string{
							"__Member__",
							"__Member__",
						},
						ErrorHandlingConfig: &types.ErrorHandlingConfig{
							FailOnFirstDestinationError: true,
							BucketPrefix:                ptr.String("__BucketPrefix__"),
							BucketName:                  ptr.String("__BucketName__"),
						},
						WriteOperationType: types.WriteOperationType("INSERT"),
					},
				},
			},
		},
		LastRunExecutionDetails: &types.ExecutionDetails{
			MostRecentExecutionMessage: ptr.String("__MostRecentExecutionMessage__"),
			MostRecentExecutionTime:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			MostRecentExecutionStatus:  types.ExecutionStatus("InProgress"),
		},
		TriggerConfig: &types.TriggerConfig{
			TriggerType: types.TriggerType("Scheduled"),
			TriggerProperties: &types.TriggerProperties{
				Scheduled: &types.ScheduledTriggerProperties{
					ScheduleExpression:             ptr.String("__ScheduleExpression__"),
					DataPullMode:                   types.DataPullMode("Incremental"),
					ScheduleStartTime:              ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					ScheduleEndTime:                ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					Timezone:                       ptr.String("__Timezone__"),
					ScheduleOffset:                 ptr.Int64(1),
					FirstExecutionFrom:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					FlowErrorDeactivationThreshold: ptr.Int32(1),
				},
			},
		},
		Tasks: []types.Task{
			{
				SourceFields: []string{
					"__Member__",
					"__Member__",
				},
				ConnectorOperator: &types.ConnectorOperator{
					Amplitude:       types.AmplitudeConnectorOperator("BETWEEN"),
					Datadog:         types.DatadogConnectorOperator("PROJECTION"),
					Dynatrace:       types.DynatraceConnectorOperator("PROJECTION"),
					GoogleAnalytics: types.GoogleAnalyticsConnectorOperator("PROJECTION"),
					InforNexus:      types.InforNexusConnectorOperator("PROJECTION"),
					Marketo:         types.MarketoConnectorOperator("PROJECTION"),
					S3:              types.S3ConnectorOperator("PROJECTION"),
					Salesforce:      types.SalesforceConnectorOperator("PROJECTION"),
					ServiceNow:      types.ServiceNowConnectorOperator("PROJECTION"),
					Singular:        types.SingularConnectorOperator("PROJECTION"),
					Slack:           types.SlackConnectorOperator("PROJECTION"),
					Trendmicro:      types.TrendmicroConnectorOperator("PROJECTION"),
					Veeva:           types.VeevaConnectorOperator("PROJECTION"),
					Zendesk:         types.ZendeskConnectorOperator("PROJECTION"),
					SAPOData:        types.SAPODataConnectorOperator("PROJECTION"),
					CustomConnector: types.Operator("PROJECTION"),
					Pardot:          types.PardotConnectorOperator("PROJECTION"),
				},
				DestinationField: ptr.String("__DestinationField__"),
				TaskType:         types.TaskType("Arithmetic"),
				TaskProperties: map[string]string{
					"key0": "__Value__",
				},
			},
			{
				SourceFields: []string{
					"__Member__",
					"__Member__",
				},
				ConnectorOperator: &types.ConnectorOperator{
					Amplitude:       types.AmplitudeConnectorOperator("BETWEEN"),
					Datadog:         types.DatadogConnectorOperator("PROJECTION"),
					Dynatrace:       types.DynatraceConnectorOperator("PROJECTION"),
					GoogleAnalytics: types.GoogleAnalyticsConnectorOperator("PROJECTION"),
					InforNexus:      types.InforNexusConnectorOperator("PROJECTION"),
					Marketo:         types.MarketoConnectorOperator("PROJECTION"),
					S3:              types.S3ConnectorOperator("PROJECTION"),
					Salesforce:      types.SalesforceConnectorOperator("PROJECTION"),
					ServiceNow:      types.ServiceNowConnectorOperator("PROJECTION"),
					Singular:        types.SingularConnectorOperator("PROJECTION"),
					Slack:           types.SlackConnectorOperator("PROJECTION"),
					Trendmicro:      types.TrendmicroConnectorOperator("PROJECTION"),
					Veeva:           types.VeevaConnectorOperator("PROJECTION"),
					Zendesk:         types.ZendeskConnectorOperator("PROJECTION"),
					SAPOData:        types.SAPODataConnectorOperator("PROJECTION"),
					CustomConnector: types.Operator("PROJECTION"),
					Pardot:          types.PardotConnectorOperator("PROJECTION"),
				},
				DestinationField: ptr.String("__DestinationField__"),
				TaskType:         types.TaskType("Arithmetic"),
				TaskProperties: map[string]string{
					"key0": "__Value__",
				},
			},
		},
		CreatedAt:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		LastUpdatedAt: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		CreatedBy:     ptr.String("__CreatedBy__"),
		LastUpdatedBy: ptr.String("__LastUpdatedBy__"),
		Tags: map[string]string{
			"key0": "__Value__",
		},
		MetadataCatalogConfig: &types.MetadataCatalogConfig{
			GlueDataCatalog: &types.GlueDataCatalogConfig{
				RoleArn:      ptr.String("__RoleArn__"),
				DatabaseName: ptr.String("__DatabaseName__"),
				TablePrefix:  ptr.String("__TablePrefix__"),
			},
		},
		LastRunMetadataCatalogDetails: []types.MetadataCatalogDetail{
			{
				CatalogType: types.CatalogType("GLUE"),
				TableName:   ptr.String("__TableName__"),
				TableRegistrationOutput: &types.RegistrationOutput{
					Message: ptr.String("__Message__"),
					Result:  ptr.String("__Result__"),
					Status:  types.ExecutionStatus("InProgress"),
				},
				PartitionRegistrationOutput: &types.RegistrationOutput{
					Message: ptr.String("__Message__"),
					Result:  ptr.String("__Result__"),
					Status:  types.ExecutionStatus("InProgress"),
				},
			},
			{
				CatalogType: types.CatalogType("GLUE"),
				TableName:   ptr.String("__TableName__"),
				TableRegistrationOutput: &types.RegistrationOutput{
					Message: ptr.String("__Message__"),
					Result:  ptr.String("__Result__"),
					Status:  types.ExecutionStatus("InProgress"),
				},
				PartitionRegistrationOutput: &types.RegistrationOutput{
					Message: ptr.String("__Message__"),
					Result:  ptr.String("__Result__"),
					Status:  types.ExecutionStatus("InProgress"),
				},
			},
		},
		SchemaVersion: ptr.Int64(1),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeFlow.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.DescribeFlow(context.Background(), &DescribeFlowInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeFlow.response", err)
	}
}

func TestCheckResponseSnapshot_DescribeFlowExecutionRecords(t *testing.T) {
	want := &DescribeFlowExecutionRecordsOutput{
		FlowExecutions: []types.ExecutionRecord{
			{
				ExecutionId:     ptr.String("__ExecutionId__"),
				ExecutionStatus: types.ExecutionStatus("InProgress"),
				ExecutionResult: &types.ExecutionResult{
					ErrorInfo: &types.ErrorInfo{
						PutFailuresCount: ptr.Int64(1),
						ExecutionMessage: ptr.String("__ExecutionMessage__"),
					},
					BytesProcessed:       ptr.Int64(1),
					BytesWritten:         ptr.Int64(1),
					RecordsProcessed:     ptr.Int64(1),
					NumParallelProcesses: ptr.Int64(1),
					MaxPageSize:          ptr.Int64(1),
				},
				StartedAt:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastUpdatedAt:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				DataPullStartTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				DataPullEndTime:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				MetadataCatalogDetails: []types.MetadataCatalogDetail{
					{
						CatalogType: types.CatalogType("GLUE"),
						TableName:   ptr.String("__TableName__"),
						TableRegistrationOutput: &types.RegistrationOutput{
							Message: ptr.String("__Message__"),
							Result:  ptr.String("__Result__"),
							Status:  types.ExecutionStatus("InProgress"),
						},
						PartitionRegistrationOutput: &types.RegistrationOutput{
							Message: ptr.String("__Message__"),
							Result:  ptr.String("__Result__"),
							Status:  types.ExecutionStatus("InProgress"),
						},
					},
					{
						CatalogType: types.CatalogType("GLUE"),
						TableName:   ptr.String("__TableName__"),
						TableRegistrationOutput: &types.RegistrationOutput{
							Message: ptr.String("__Message__"),
							Result:  ptr.String("__Result__"),
							Status:  types.ExecutionStatus("InProgress"),
						},
						PartitionRegistrationOutput: &types.RegistrationOutput{
							Message: ptr.String("__Message__"),
							Result:  ptr.String("__Result__"),
							Status:  types.ExecutionStatus("InProgress"),
						},
					},
				},
			},
			{
				ExecutionId:     ptr.String("__ExecutionId__"),
				ExecutionStatus: types.ExecutionStatus("InProgress"),
				ExecutionResult: &types.ExecutionResult{
					ErrorInfo: &types.ErrorInfo{
						PutFailuresCount: ptr.Int64(1),
						ExecutionMessage: ptr.String("__ExecutionMessage__"),
					},
					BytesProcessed:       ptr.Int64(1),
					BytesWritten:         ptr.Int64(1),
					RecordsProcessed:     ptr.Int64(1),
					NumParallelProcesses: ptr.Int64(1),
					MaxPageSize:          ptr.Int64(1),
				},
				StartedAt:         ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastUpdatedAt:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				DataPullStartTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				DataPullEndTime:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				MetadataCatalogDetails: []types.MetadataCatalogDetail{
					{
						CatalogType: types.CatalogType("GLUE"),
						TableName:   ptr.String("__TableName__"),
						TableRegistrationOutput: &types.RegistrationOutput{
							Message: ptr.String("__Message__"),
							Result:  ptr.String("__Result__"),
							Status:  types.ExecutionStatus("InProgress"),
						},
						PartitionRegistrationOutput: &types.RegistrationOutput{
							Message: ptr.String("__Message__"),
							Result:  ptr.String("__Result__"),
							Status:  types.ExecutionStatus("InProgress"),
						},
					},
					{
						CatalogType: types.CatalogType("GLUE"),
						TableName:   ptr.String("__TableName__"),
						TableRegistrationOutput: &types.RegistrationOutput{
							Message: ptr.String("__Message__"),
							Result:  ptr.String("__Result__"),
							Status:  types.ExecutionStatus("InProgress"),
						},
						PartitionRegistrationOutput: &types.RegistrationOutput{
							Message: ptr.String("__Message__"),
							Result:  ptr.String("__Result__"),
							Status:  types.ExecutionStatus("InProgress"),
						},
					},
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DescribeFlowExecutionRecords.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.DescribeFlowExecutionRecords(context.Background(), &DescribeFlowExecutionRecordsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DescribeFlowExecutionRecords.response", err)
	}
}

func TestCheckResponseSnapshot_ListConnectorEntities(t *testing.T) {
	want := &ListConnectorEntitiesOutput{
		ConnectorEntityMap: map[string][]types.ConnectorEntity{
			"key0": {
				{
					Name:              ptr.String("__Name__"),
					Label:             ptr.String("__Label__"),
					HasNestedEntities: true,
				},
				{
					Name:              ptr.String("__Name__"),
					Label:             ptr.String("__Label__"),
					HasNestedEntities: true,
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListConnectorEntities.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.ListConnectorEntities(context.Background(), &ListConnectorEntitiesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListConnectorEntities.response", err)
	}
}

func TestCheckResponseSnapshot_ListConnectors(t *testing.T) {
	want := &ListConnectorsOutput{
		Connectors: []types.ConnectorDetail{
			{
				ConnectorDescription:      ptr.String("__ConnectorDescription__"),
				ConnectorName:             ptr.String("__ConnectorName__"),
				ConnectorOwner:            ptr.String("__ConnectorOwner__"),
				ConnectorVersion:          ptr.String("__ConnectorVersion__"),
				ApplicationType:           ptr.String("__ApplicationType__"),
				ConnectorType:             types.ConnectorType("Salesforce"),
				ConnectorLabel:            ptr.String("__ConnectorLabel__"),
				RegisteredAt:              ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				RegisteredBy:              ptr.String("__RegisteredBy__"),
				ConnectorProvisioningType: types.ConnectorProvisioningType("LAMBDA"),
				ConnectorModes: []string{
					"__Member__",
					"__Member__",
				},
				SupportedDataTransferTypes: []types.SupportedDataTransferType{
					types.SupportedDataTransferType("RECORD"),
					types.SupportedDataTransferType("RECORD"),
				},
			},
			{
				ConnectorDescription:      ptr.String("__ConnectorDescription__"),
				ConnectorName:             ptr.String("__ConnectorName__"),
				ConnectorOwner:            ptr.String("__ConnectorOwner__"),
				ConnectorVersion:          ptr.String("__ConnectorVersion__"),
				ApplicationType:           ptr.String("__ApplicationType__"),
				ConnectorType:             types.ConnectorType("Salesforce"),
				ConnectorLabel:            ptr.String("__ConnectorLabel__"),
				RegisteredAt:              ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				RegisteredBy:              ptr.String("__RegisteredBy__"),
				ConnectorProvisioningType: types.ConnectorProvisioningType("LAMBDA"),
				ConnectorModes: []string{
					"__Member__",
					"__Member__",
				},
				SupportedDataTransferTypes: []types.SupportedDataTransferType{
					types.SupportedDataTransferType("RECORD"),
					types.SupportedDataTransferType("RECORD"),
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListConnectors.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.ListConnectors(context.Background(), &ListConnectorsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListConnectors.response", err)
	}
}

func TestCheckResponseSnapshot_ListFlows(t *testing.T) {
	want := &ListFlowsOutput{
		Flows: []types.FlowDefinition{
			{
				FlowArn:                   ptr.String("__FlowArn__"),
				Description:               ptr.String("__Description__"),
				FlowName:                  ptr.String("__FlowName__"),
				FlowStatus:                types.FlowStatus("Active"),
				SourceConnectorType:       types.ConnectorType("Salesforce"),
				SourceConnectorLabel:      ptr.String("__SourceConnectorLabel__"),
				DestinationConnectorType:  types.ConnectorType("Salesforce"),
				DestinationConnectorLabel: ptr.String("__DestinationConnectorLabel__"),
				TriggerType:               types.TriggerType("Scheduled"),
				CreatedAt:                 ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastUpdatedAt:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CreatedBy:                 ptr.String("__CreatedBy__"),
				LastUpdatedBy:             ptr.String("__LastUpdatedBy__"),
				Tags: map[string]string{
					"key0": "__Value__",
				},
				LastRunExecutionDetails: &types.ExecutionDetails{
					MostRecentExecutionMessage: ptr.String("__MostRecentExecutionMessage__"),
					MostRecentExecutionTime:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					MostRecentExecutionStatus:  types.ExecutionStatus("InProgress"),
				},
			},
			{
				FlowArn:                   ptr.String("__FlowArn__"),
				Description:               ptr.String("__Description__"),
				FlowName:                  ptr.String("__FlowName__"),
				FlowStatus:                types.FlowStatus("Active"),
				SourceConnectorType:       types.ConnectorType("Salesforce"),
				SourceConnectorLabel:      ptr.String("__SourceConnectorLabel__"),
				DestinationConnectorType:  types.ConnectorType("Salesforce"),
				DestinationConnectorLabel: ptr.String("__DestinationConnectorLabel__"),
				TriggerType:               types.TriggerType("Scheduled"),
				CreatedAt:                 ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastUpdatedAt:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CreatedBy:                 ptr.String("__CreatedBy__"),
				LastUpdatedBy:             ptr.String("__LastUpdatedBy__"),
				Tags: map[string]string{
					"key0": "__Value__",
				},
				LastRunExecutionDetails: &types.ExecutionDetails{
					MostRecentExecutionMessage: ptr.String("__MostRecentExecutionMessage__"),
					MostRecentExecutionTime:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					MostRecentExecutionStatus:  types.ExecutionStatus("InProgress"),
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListFlows.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.ListFlows(context.Background(), &ListFlowsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListFlows.response", err)
	}
}

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

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

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

func TestCheckResponseSnapshot_StartFlow(t *testing.T) {
	want := &StartFlowOutput{
		FlowArn:     ptr.String("__FlowArn__"),
		FlowStatus:  types.FlowStatus("Active"),
		ExecutionId: ptr.String("__ExecutionId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("StartFlow.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.StartFlow(context.Background(), &StartFlowInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StartFlow.response", err)
	}
}

func TestCheckResponseSnapshot_StopFlow(t *testing.T) {
	want := &StopFlowOutput{
		FlowArn:    ptr.String("__FlowArn__"),
		FlowStatus: types.FlowStatus("Active"),
	}
	status, header, body, err := serdeRespReadSnapshot("StopFlow.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.StopFlow(context.Background(), &StopFlowInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StopFlow.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_UnregisterConnector(t *testing.T) {
	want := &UnregisterConnectorOutput{}
	status, header, body, err := serdeRespReadSnapshot("UnregisterConnector.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.UnregisterConnector(context.Background(), &UnregisterConnectorInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UnregisterConnector.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_UpdateConnectorProfile(t *testing.T) {
	want := &UpdateConnectorProfileOutput{
		ConnectorProfileArn: ptr.String("__ConnectorProfileArn__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateConnectorProfile.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.UpdateConnectorProfile(context.Background(), &UpdateConnectorProfileInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateConnectorProfile.response", err)
	}
}

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

func TestCheckResponseSnapshot_UpdateFlow(t *testing.T) {
	want := &UpdateFlowOutput{
		FlowStatus: types.FlowStatus("Active"),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateFlow.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.UpdateFlow(context.Background(), &UpdateFlowInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateFlow.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.CancelFlowExecutions(context.Background(), &CancelFlowExecutionsInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.AccessDeniedException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.AccessDeniedException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "AccessDeniedException.error", err)
	}
}

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

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

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

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

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

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

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

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