src

endpoints.go (21324B)

---

 // Code generated by smithy-go-codegen DO NOT EDIT.
 
 package sts
 
 import (
 	"context"
 	"errors"
 	"fmt"
 	"net/http"
 	"net/url"
 	"os"
 	"strings"
 
 	"github.com/aws/aws-sdk-go-v2/aws"
 	awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
 	internalConfig "github.com/aws/aws-sdk-go-v2/internal/configsources"
 	"github.com/aws/aws-sdk-go-v2/internal/endpoints"
 	"github.com/aws/aws-sdk-go-v2/internal/endpoints/awsrulesfn"
 	internalendpoints "github.com/aws/aws-sdk-go-v2/service/sts/internal/endpoints"
 	smithy "github.com/aws/smithy-go"
 	smithyauth "github.com/aws/smithy-go/auth"
 	smithyendpoints "github.com/aws/smithy-go/endpoints"
 	"github.com/aws/smithy-go/endpoints/private/bdd"
 	"github.com/aws/smithy-go/endpoints/private/rulesfn"
 	"github.com/aws/smithy-go/middleware"
 	"github.com/aws/smithy-go/ptr"
 	"github.com/aws/smithy-go/tracing"
 	smithyhttp "github.com/aws/smithy-go/transport/http"
 )
 
 // EndpointResolverOptions is the service endpoint resolver options
 type EndpointResolverOptions = internalendpoints.Options
 
 // EndpointResolver interface for resolving service endpoints.
 type EndpointResolver interface {
 	ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
 }
 
 var _ EndpointResolver = &internalendpoints.Resolver{}
 
 // NewDefaultEndpointResolver constructs a new service endpoint resolver
 func NewDefaultEndpointResolver() *internalendpoints.Resolver {
 	return internalendpoints.New()
 }
 
 // EndpointResolverFunc is a helper utility that wraps a function so it satisfies
 // the EndpointResolver interface. This is useful when you want to add additional
 // endpoint resolving logic, or stub out specific endpoints with custom values.
 type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)
 
 func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error) {
 	return fn(region, options)
 }
 
 // EndpointResolverFromURL returns an EndpointResolver configured using the
 // provided endpoint url. By default, the resolved endpoint resolver uses the
 // client region as signing region, and the endpoint source is set to
 // EndpointSourceCustom.You can provide functional options to configure endpoint
 // values for the resolved endpoint.
 func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver {
 	e := aws.Endpoint{URL: url, Source: aws.EndpointSourceCustom}
 	for _, fn := range optFns {
 		fn(&e)
 	}
 
 	return EndpointResolverFunc(
 		func(region string, options EndpointResolverOptions) (aws.Endpoint, error) {
 			if len(e.SigningRegion) == 0 {
 				e.SigningRegion = region
 			}
 			return e, nil
 		},
 	)
 }
 
 type ResolveEndpoint struct {
 	Resolver EndpointResolver
 	Options  EndpointResolverOptions
 }
 
 func (*ResolveEndpoint) ID() string {
 	return "ResolveEndpoint"
 }
 
 func (m *ResolveEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
 ) {
 	if !awsmiddleware.GetRequiresLegacyEndpoints(ctx) {
 		return next.HandleSerialize(ctx, in)
 	}
 
 	req, ok := in.Request.(*smithyhttp.Request)
 	if !ok {
 		return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
 	}
 
 	if m.Resolver == nil {
 		return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil")
 	}
 
 	eo := m.Options
 	eo.Logger = middleware.GetLogger(ctx)
 
 	var endpoint aws.Endpoint
 	endpoint, err = m.Resolver.ResolveEndpoint(awsmiddleware.GetRegion(ctx), eo)
 	if err != nil {
 		nf := (&aws.EndpointNotFoundError{})
 		if errors.As(err, &nf) {
 			ctx = awsmiddleware.SetRequiresLegacyEndpoints(ctx, false)
 			return next.HandleSerialize(ctx, in)
 		}
 		return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err)
 	}
 
 	req.URL, err = url.Parse(endpoint.URL)
 	if err != nil {
 		return out, metadata, fmt.Errorf("failed to parse endpoint URL: %w", err)
 	}
 
 	if len(awsmiddleware.GetSigningName(ctx)) == 0 {
 		signingName := endpoint.SigningName
 		if len(signingName) == 0 {
 			signingName = "sts"
 		}
 		ctx = awsmiddleware.SetSigningName(ctx, signingName)
 	}
 	ctx = awsmiddleware.SetEndpointSource(ctx, endpoint.Source)
 	ctx = smithyhttp.SetHostnameImmutable(ctx, endpoint.HostnameImmutable)
 	ctx = awsmiddleware.SetSigningRegion(ctx, endpoint.SigningRegion)
 	ctx = awsmiddleware.SetPartitionID(ctx, endpoint.PartitionID)
 	return next.HandleSerialize(ctx, in)
 }
 func addResolveEndpointMiddleware(stack *middleware.Stack, o Options) error {
 	return stack.Serialize.Insert(&ResolveEndpoint{
 		Resolver: o.EndpointResolver,
 		Options:  o.EndpointOptions,
 	}, "OperationSerializer", middleware.Before)
 }
 
 func removeResolveEndpointMiddleware(stack *middleware.Stack) error {
 	_, err := stack.Serialize.Remove((&ResolveEndpoint{}).ID())
 	return err
 }
 
 type wrappedEndpointResolver struct {
 	awsResolver aws.EndpointResolverWithOptions
 }
 
 func (w *wrappedEndpointResolver) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error) {
 	return w.awsResolver.ResolveEndpoint(ServiceID, region, options)
 }
 
 type awsEndpointResolverAdaptor func(service, region string) (aws.Endpoint, error)
 
 func (a awsEndpointResolverAdaptor) ResolveEndpoint(service, region string, options ...interface{}) (aws.Endpoint, error) {
 	return a(service, region)
 }
 
 var _ aws.EndpointResolverWithOptions = awsEndpointResolverAdaptor(nil)
 
 // withEndpointResolver returns an aws.EndpointResolverWithOptions that first delegates endpoint resolution to the awsResolver.
 // If awsResolver returns aws.EndpointNotFoundError error, the v1 resolver middleware will swallow the error,
 // and set an appropriate context flag such that fallback will occur when EndpointResolverV2 is invoked
 // via its middleware.
 //
 // If another error (besides aws.EndpointNotFoundError) is returned, then that error will be propagated.
 func withEndpointResolver(awsResolver aws.EndpointResolver, awsResolverWithOptions aws.EndpointResolverWithOptions) EndpointResolver {
 	var resolver aws.EndpointResolverWithOptions
 
 	if awsResolverWithOptions != nil {
 		resolver = awsResolverWithOptions
 	} else if awsResolver != nil {
 		resolver = awsEndpointResolverAdaptor(awsResolver.ResolveEndpoint)
 	}
 
 	return &wrappedEndpointResolver{
 		awsResolver: resolver,
 	}
 }
 
 func finalizeClientEndpointResolverOptions(options *Options) {
 	options.EndpointOptions.LogDeprecated = options.ClientLogMode.IsDeprecatedUsage()
 
 	if len(options.EndpointOptions.ResolvedRegion) == 0 {
 		const fipsInfix = "-fips-"
 		const fipsPrefix = "fips-"
 		const fipsSuffix = "-fips"
 
 		if strings.Contains(options.Region, fipsInfix) ||
 			strings.Contains(options.Region, fipsPrefix) ||
 			strings.Contains(options.Region, fipsSuffix) {
 			options.EndpointOptions.ResolvedRegion = strings.ReplaceAll(strings.ReplaceAll(strings.ReplaceAll(
 				options.Region, fipsInfix, "-"), fipsPrefix, ""), fipsSuffix, "")
 			options.EndpointOptions.UseFIPSEndpoint = aws.FIPSEndpointStateEnabled
 		}
 	}
 
 }
 
 func resolveEndpointResolverV2(options *Options) {
 	if options.EndpointResolverV2 == nil {
 		options.EndpointResolverV2 = NewDefaultEndpointResolverV2()
 	}
 }
 
 func resolveBaseEndpoint(cfg aws.Config, o *Options) {
 	if cfg.BaseEndpoint != nil {
 		o.BaseEndpoint = cfg.BaseEndpoint
 	}
 
 	_, g := os.LookupEnv("AWS_ENDPOINT_URL")
 	_, s := os.LookupEnv("AWS_ENDPOINT_URL_STS")
 
 	if g && !s {
 		return
 	}
 
 	value, found, err := internalConfig.ResolveServiceBaseEndpoint(context.Background(), "STS", cfg.ConfigSources)
 	if found && err == nil {
 		o.BaseEndpoint = &value
 	}
 }
 
 func bindRegion(region string) (*string, error) {
 	if region == "" {
 		return nil, nil
 	}
 	if !rulesfn.IsValidHostLabel(region, true) {
 		return nil, fmt.Errorf("invalid input region %s", region)
 	}
 
 	return aws.String(endpoints.MapFIPSRegion(region)), nil
 }
 
 var _ = rulesfn.StringSlice(nil)
 
 // EndpointParameters provides the parameters that influence how endpoints are
 // resolved.
 type EndpointParameters struct {
 	// The AWS region used to dispatch the request.
 	//
 	// Parameter is
 	// required.
 	//
 	// AWS::Region
 	Region *string
 
 	// When true, use the dual-stack endpoint. If the configured endpoint does not
 	// support dual-stack, dispatching the request MAY return an error.
 	//
 	// Defaults to
 	// false if no value is provided.
 	//
 	// AWS::UseDualStack
 	UseDualStack *bool
 
 	// When true, send this request to the FIPS-compliant regional endpoint. If the
 	// configured endpoint does not have a FIPS compliant endpoint, dispatching the
 	// request will return an error.
 	//
 	// Defaults to false if no value is
 	// provided.
 	//
 	// AWS::UseFIPS
 	UseFIPS *bool
 
 	// Override the endpoint used to send this request
 	//
 	// Parameter is
 	// required.
 	//
 	// SDK::Endpoint
 	Endpoint *string
 
 	// Whether the global endpoint should be used, rather then the regional endpoint
 	// for us-east-1.
 	//
 	// Defaults to false if no value is
 	// provided.
 	//
 	// AWS::STS::UseGlobalEndpoint
 	UseGlobalEndpoint *bool
 }
 
 // ValidateRequired validates required parameters are set.
 func (p EndpointParameters) ValidateRequired() error {
 	if p.UseDualStack == nil {
 		return fmt.Errorf("parameter UseDualStack is required")
 	}
 
 	if p.UseFIPS == nil {
 		return fmt.Errorf("parameter UseFIPS is required")
 	}
 
 	if p.UseGlobalEndpoint == nil {
 		return fmt.Errorf("parameter UseGlobalEndpoint is required")
 	}
 
 	return nil
 }
 
 // WithDefaults returns a shallow copy of EndpointParameterswith default values
 // applied to members where applicable.
 func (p EndpointParameters) WithDefaults() EndpointParameters {
 	if p.UseDualStack == nil {
 		p.UseDualStack = ptr.Bool(false)
 	}
 
 	if p.UseFIPS == nil {
 		p.UseFIPS = ptr.Bool(false)
 	}
 
 	if p.UseGlobalEndpoint == nil {
 		p.UseGlobalEndpoint = ptr.Bool(false)
 	}
 	return p
 }
 
 const bddRoot int32 = 2
 
 var bddNodes = [93]int32{
 	-1, 1, -1, 0, 30, 3, 1, 4, 100000014, 2, 5, 100000014, 3, 25, 6, 4, 24, 7, 5, 100000001, 8, 6, 9, 100000013, 7, 100000001, 10, 10, 100000001, 11, 11, 100000001, 12, 12, 100000001, 13, 13, 100000001, 14, 14, 100000001, 15, 15, 100000001, 16, 16, 100000001, 17, 17, 100000001, 18, 18, 100000001, 19, 19, 100000001, 20, 20, 100000001, 21, 21, 100000001, 22, 22, 100000001, 23, 23, 100000001, 100000002, 8, 100000011, 100000012, 4, 28, 26, 9, 27, 100000010, 24, 100000008, 100000009, 8, 29, 100000007, 9, 100000006, 100000007, 3, 100000003, 31, 4, 100000004, 100000005}
 
 type conditionContext struct {
 	PartitionResult *awsrulesfn.PartitionConfig
 }
 
 func evalCondition(idx int, params *EndpointParameters, c *conditionContext) bool {
 	switch idx {
 	case 0:
 		return params.Endpoint != nil
 	case 1:
 		return params.Region != nil
 	case 2:
 		if v := awsrulesfn.GetPartition(*params.Region); v != nil {
 			c.PartitionResult = v
 			return true
 		}
 		return false
 	case 3:
 		return *params.UseFIPS == true
 	case 4:
 		return *params.UseDualStack == true
 	case 5:
 		return *params.Region == "aws-global"
 	case 6:
 		return *params.UseGlobalEndpoint == true
 	case 7:
 		return *params.Region == "eu-central-1"
 	case 8:
 		return c.PartitionResult.SupportsDualStack == true
 	case 9:
 		return c.PartitionResult.SupportsFIPS == true
 	case 10:
 		return *params.Region == "ap-south-1"
 	case 11:
 		return *params.Region == "eu-north-1"
 	case 12:
 		return *params.Region == "eu-west-1"
 	case 13:
 		return *params.Region == "eu-west-2"
 	case 14:
 		return *params.Region == "eu-west-3"
 	case 15:
 		return *params.Region == "sa-east-1"
 	case 16:
 		return *params.Region == "us-east-1"
 	case 17:
 		return *params.Region == "us-east-2"
 	case 18:
 		return *params.Region == "us-west-2"
 	case 19:
 		return *params.Region == "us-west-1"
 	case 20:
 		return *params.Region == "ca-central-1"
 	case 21:
 		return *params.Region == "ap-southeast-1"
 	case 22:
 		return *params.Region == "ap-northeast-1"
 	case 23:
 		return *params.Region == "ap-southeast-2"
 	case 24:
 		return c.PartitionResult.Name == "aws-us-gov"
 	}
 	return false
 }
 
 func resolveResult(idx int32, params *EndpointParameters, c *conditionContext) (smithyendpoints.Endpoint, error) {
 	switch idx {
 	case 0:
 		return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint resolution failed: no matching rule")
 	case 1:
 		uriString := "https://sts.amazonaws.com"
 		uri, err := url.Parse(uriString)
 		if err != nil {
 			return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
 		}
 		return smithyendpoints.Endpoint{
 			URI:     *uri,
 			Headers: http.Header{},
 			Properties: func() smithy.Properties {
 				var out smithy.Properties
 				smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
 					{
 						SchemeID: "sigv4",
 						SignerProperties: func() smithy.Properties {
 							var sp smithy.Properties
 							smithyhttp.SetSigV4SigningName(&sp, "sts")
 							smithyhttp.SetSigV4ASigningName(&sp, "sts")
 
 							smithyhttp.SetSigV4SigningRegion(&sp, "us-east-1")
 							return sp
 						}(),
 					},
 				})
 				return out
 			}(),
 		}, nil
 	case 2:
 		uriString := func() string {
 			var out strings.Builder
 			out.WriteString("https://sts.")
 			out.WriteString(*params.Region)
 			out.WriteString(".")
 			out.WriteString(c.PartitionResult.DnsSuffix)
 			return out.String()
 		}()
 		uri, err := url.Parse(uriString)
 		if err != nil {
 			return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
 		}
 		return smithyendpoints.Endpoint{
 			URI:     *uri,
 			Headers: http.Header{},
 			Properties: func() smithy.Properties {
 				var out smithy.Properties
 				smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
 					{
 						SchemeID: "sigv4",
 						SignerProperties: func() smithy.Properties {
 							var sp smithy.Properties
 							smithyhttp.SetSigV4SigningName(&sp, "sts")
 							smithyhttp.SetSigV4ASigningName(&sp, "sts")
 
 							smithyhttp.SetSigV4SigningRegion(&sp, *params.Region)
 							return sp
 						}(),
 					},
 				})
 				return out
 			}(),
 		}, nil
 	case 3:
 		return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: FIPS and custom endpoint are not supported")
 	case 4:
 		return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: Dualstack and custom endpoint are not supported")
 	case 5:
 		uriString := *params.Endpoint
 		uri, err := url.Parse(uriString)
 		if err != nil {
 			return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
 		}
 		return smithyendpoints.Endpoint{
 			URI:     *uri,
 			Headers: http.Header{},
 		}, nil
 	case 6:
 		uriString := func() string {
 			var out strings.Builder
 			out.WriteString("https://sts-fips.")
 			out.WriteString(*params.Region)
 			out.WriteString(".")
 			out.WriteString(c.PartitionResult.DualStackDnsSuffix)
 			return out.String()
 		}()
 		uri, err := url.Parse(uriString)
 		if err != nil {
 			return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
 		}
 		return smithyendpoints.Endpoint{
 			URI:     *uri,
 			Headers: http.Header{},
 		}, nil
 	case 7:
 		return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "FIPS and DualStack are enabled, but this partition does not support one or both")
 	case 8:
 		uriString := func() string {
 			var out strings.Builder
 			out.WriteString("https://sts.")
 			out.WriteString(*params.Region)
 			out.WriteString(".amazonaws.com")
 			return out.String()
 		}()
 		uri, err := url.Parse(uriString)
 		if err != nil {
 			return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
 		}
 		return smithyendpoints.Endpoint{
 			URI:     *uri,
 			Headers: http.Header{},
 		}, nil
 	case 9:
 		uriString := func() string {
 			var out strings.Builder
 			out.WriteString("https://sts-fips.")
 			out.WriteString(*params.Region)
 			out.WriteString(".")
 			out.WriteString(c.PartitionResult.DnsSuffix)
 			return out.String()
 		}()
 		uri, err := url.Parse(uriString)
 		if err != nil {
 			return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
 		}
 		return smithyendpoints.Endpoint{
 			URI:     *uri,
 			Headers: http.Header{},
 		}, nil
 	case 10:
 		return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "FIPS is enabled but this partition does not support FIPS")
 	case 11:
 		uriString := func() string {
 			var out strings.Builder
 			out.WriteString("https://sts.")
 			out.WriteString(*params.Region)
 			out.WriteString(".")
 			out.WriteString(c.PartitionResult.DualStackDnsSuffix)
 			return out.String()
 		}()
 		uri, err := url.Parse(uriString)
 		if err != nil {
 			return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
 		}
 		return smithyendpoints.Endpoint{
 			URI:     *uri,
 			Headers: http.Header{},
 		}, nil
 	case 12:
 		return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "DualStack is enabled but this partition does not support DualStack")
 	case 13:
 		uriString := func() string {
 			var out strings.Builder
 			out.WriteString("https://sts.")
 			out.WriteString(*params.Region)
 			out.WriteString(".")
 			out.WriteString(c.PartitionResult.DnsSuffix)
 			return out.String()
 		}()
 		uri, err := url.Parse(uriString)
 		if err != nil {
 			return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
 		}
 		return smithyendpoints.Endpoint{
 			URI:     *uri,
 			Headers: http.Header{},
 		}, nil
 	case 14:
 		return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: Missing Region")
 	}
 	return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, invalid result index: %d", idx)
 }
 
 // EndpointResolverV2 provides the interface for resolving service endpoints.
 type EndpointResolverV2 interface {
 	ResolveEndpoint(ctx context.Context, params EndpointParameters) (
 		smithyendpoints.Endpoint, error,
 	)
 }
 
 // resolver provides the implementation for resolving endpoints.
 type resolver struct{}
 
 func NewDefaultEndpointResolverV2() EndpointResolverV2 {
 	return &resolver{}
 }
 
 // ResolveEndpoint attempts to resolve the endpoint with the provided options,
 // returning the endpoint if found. Otherwise an error is returned.
 func (r *resolver) ResolveEndpoint(
 	ctx context.Context, params EndpointParameters,
 ) (
 	endpoint smithyendpoints.Endpoint, err error,
 ) {
 	params = params.WithDefaults()
 	if err = params.ValidateRequired(); err != nil {
 		return endpoint, fmt.Errorf("endpoint parameters are not valid, %w", err)
 	}
 
 	c := &conditionContext{}
 	ref := bdd.Evaluate(bddNodes[:], bddRoot, func(idx int) bool {
 		return evalCondition(idx, &params, c)
 	})
 	return resolveResult(ref, &params, c)
 }
 
 type endpointParamsBinder interface {
 	bindEndpointParams(*EndpointParameters)
 }
 
 func bindEndpointParams(ctx context.Context, input interface{}, options Options) (*EndpointParameters, error) {
 	params := &EndpointParameters{}
 
 	region, err := bindRegion(options.Region)
 	if err != nil {
 		return nil, err
 	}
 	params.Region = region
 
 	params.UseDualStack = aws.Bool(options.EndpointOptions.UseDualStackEndpoint == aws.DualStackEndpointStateEnabled)
 	params.UseFIPS = aws.Bool(options.EndpointOptions.UseFIPSEndpoint == aws.FIPSEndpointStateEnabled)
 	params.Endpoint = options.BaseEndpoint
 
 	if b, ok := input.(endpointParamsBinder); ok {
 		b.bindEndpointParams(params)
 	}
 
 	return params, nil
 }
 
 type resolveEndpointV2Middleware struct {
 	options Options
 }
 
 func (*resolveEndpointV2Middleware) ID() string {
 	return "ResolveEndpointV2"
 }
 
 func (m *resolveEndpointV2Middleware) HandleFinalize(ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler) (
 	out middleware.FinalizeOutput, metadata middleware.Metadata, err error,
 ) {
 	_, span := tracing.StartSpan(ctx, "ResolveEndpoint")
 	defer span.End()
 
 	if awsmiddleware.GetRequiresLegacyEndpoints(ctx) {
 		return next.HandleFinalize(ctx, in)
 	}
 
 	req, ok := in.Request.(*smithyhttp.Request)
 	if !ok {
 		return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
 	}
 
 	if m.options.EndpointResolverV2 == nil {
 		return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil")
 	}
 
 	params, err := bindEndpointParams(ctx, getOperationInput(ctx), m.options)
 	if err != nil {
 		return out, metadata, fmt.Errorf("failed to bind endpoint params, %w", err)
 	}
 	endpt, err := timeOperationMetric(ctx, "client.call.resolve_endpoint_duration",
 		func() (smithyendpoints.Endpoint, error) {
 			return m.options.EndpointResolverV2.ResolveEndpoint(ctx, *params)
 		})
 	if err != nil {
 		return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err)
 	}
 
 	span.SetProperty("client.call.resolved_endpoint", endpt.URI.String())
 
 	if endpt.URI.RawPath == "" && req.URL.RawPath != "" {
 		endpt.URI.RawPath = endpt.URI.Path
 	}
 	req.URL.Scheme = endpt.URI.Scheme
 	req.URL.Host = endpt.URI.Host
 	req.URL.Path = smithyhttp.JoinPath(endpt.URI.Path, req.URL.Path)
 	req.URL.RawPath = smithyhttp.JoinPath(endpt.URI.RawPath, req.URL.RawPath)
 	for k := range endpt.Headers {
 		req.Header.Set(k, endpt.Headers.Get(k))
 	}
 
 	rscheme := getResolvedAuthScheme(ctx)
 	if rscheme == nil {
 		return out, metadata, fmt.Errorf("no resolved auth scheme")
 	}
 
 	opts, _ := smithyauth.GetAuthOptions(&endpt.Properties)
 	for _, o := range opts {
 		rscheme.SignerProperties.SetAll(&o.SignerProperties)
 	}
 
 	span.End()
 	return next.HandleFinalize(ctx, in)
 }