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

package dynamodb

import (
	"context"
	"errors"
	"fmt"
	"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/dynamodb/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"
	"net/http"
	"net/url"
	"os"
	"strings"
)

// 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 = "dynamodb"
		}
		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_DYNAMODB")

	if g && !s {
		return
	}

	value, found, err := internalConfig.ResolveServiceBaseEndpoint(context.Background(), "DynamoDB", 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

	// The AWS AccountId used for the request.
	//
	// Parameter is
	// required.
	//
	// AWS::Auth::AccountId
	AccountId *string

	// The AccountId Endpoint Mode.
	//
	// Parameter is
	// required.
	//
	// AWS::Auth::AccountIdEndpointMode
	AccountIdEndpointMode *string

	// ResourceArn containing arn of resource
	//
	// Parameter is required.
	ResourceArn *string

	// ResourceArnList containing list of resource arns
	//
	// Parameter is required.
	ResourceArnList []string
}

// 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")
	}

	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)
	}
	return p
}

const bddRoot int32 = 2

var bddNodes = [201]int32{
	-1, 1, -1, 0, 5, 3, 1, 4, 100000025, 2, 100000001, 65, 1, 63, 6, 2, 52, 7, 3, 8, 100000025, 4, 51, 9, 6, 30, 10, 9, 11, 100000011, 10, 13, 12, 26, 100000019, 100000011, 11, 29, 14, 12, 15, 20, 13, 16, 20, 14, 17, 20, 15, 18, 20, 16, 19, 20, 17, 100000022, 20, 18, 21, 27, 19, 22, 27, 20, 23, 27, 21, 24, 27, 22, 25, 27, 23, 26, 27, 24, 100000023, 27, 25, 28, 29, 27, 100000024, 100000017, 26, 100000018, 100000011, 7, 31, 100000021, 9, 32, 100000020, 10, 34, 33, 26, 100000019, 100000020, 11, 50, 35, 12, 36, 41, 13, 37, 41, 14, 38, 41, 15, 39, 41, 16, 40, 41, 17, 100000014, 41, 18, 42, 48, 19, 43, 48, 20, 44, 48, 21, 45, 48, 22, 46, 48, 23, 47, 48, 24, 100000015, 48, 25, 49, 50, 27, 100000016, 100000017, 26, 100000018, 100000020, 6, 100000006, 100000007, 3, 53, 100000025, 4, 100000005, 54, 5, 56, 55, 6, 100000010, 100000013, 6, 60, 57, 9, 58, 59, 26, 100000008, 59, 28, 100000011, 100000012, 7, 61, 100000010, 9, 62, 100000009, 26, 100000008, 100000009, 2, 100000001, 64, 3, 66, 65, 6, 100000002, 100000004, 6, 100000002, 67, 8, 100000003, 100000004}

type conditionContext struct {
	PartitionResult *awsrulesfn.PartitionConfig
	ParsedArn_ssa_2 *awsrulesfn.ARN
	FirstArn        *string
	ParsedArn_ssa_1 *awsrulesfn.ARN
}

func evalCondition(idx int, params *EndpointParameters, c *conditionContext) bool {
	switch idx {
	case 0:
		return params.Region != nil
	case 1:
		return params.Endpoint != nil
	case 2:
		return *params.UseFIPS == true
	case 3:
		if v := awsrulesfn.GetPartition(*params.Region); v != nil {
			c.PartitionResult = v
			return true
		}
		return false
	case 4:
		return *params.Region == "local"
	case 5:
		return c.PartitionResult.SupportsFIPS == true
	case 6:
		return *params.UseDualStack == true
	case 7:
		return c.PartitionResult.SupportsDualStack == true
	case 8:
		return func() string {
			var out strings.Builder
			out.WriteString("https://dynamodb.")
			out.WriteString(*params.Region)
			out.WriteString(".")
			out.WriteString(c.PartitionResult.DualStackDnsSuffix)
			return out.String()
		}() == *params.Endpoint
	case 9:
		return params.AccountIdEndpointMode != nil
	case 10:
		return c.PartitionResult.Name == "aws"
	case 11:
		return *params.AccountIdEndpointMode == "disabled"
	case 12:
		return params.ResourceArn != nil
	case 13:
		if v := awsrulesfn.ParseARN(*params.ResourceArn); v != nil {
			c.ParsedArn_ssa_2 = v
			return true
		}
		return false
	case 14:
		return c.ParsedArn_ssa_2.Region == *params.Region
	case 15:
		return c.ParsedArn_ssa_2.Service == "dynamodb"
	case 16:
		return rulesfn.IsValidHostLabel(c.ParsedArn_ssa_2.AccountId, false)
	case 17:
		return rulesfn.IsValidHostLabel(c.ParsedArn_ssa_2.Region, false)
	case 18:
		return params.ResourceArnList != nil
	case 19:
		if v := rulesfn.StringSlice(params.ResourceArnList).Get(0); v != nil {
			c.FirstArn = v
			return true
		}
		return false
	case 20:
		if v := awsrulesfn.ParseARN(*c.FirstArn); v != nil {
			c.ParsedArn_ssa_1 = v
			return true
		}
		return false
	case 21:
		return c.ParsedArn_ssa_1.Region == *params.Region
	case 22:
		return c.ParsedArn_ssa_1.Service == "dynamodb"
	case 23:
		return rulesfn.IsValidHostLabel(c.ParsedArn_ssa_1.AccountId, false)
	case 24:
		return rulesfn.IsValidHostLabel(c.ParsedArn_ssa_1.Region, false)
	case 25:
		return params.AccountId != nil
	case 26:
		return *params.AccountIdEndpointMode == "required"
	case 27:
		return rulesfn.IsValidHostLabel(*params.AccountId, false)
	case 28:
		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:
		return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: FIPS and custom endpoint are not supported")
	case 2:
		return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: Dualstack and custom endpoint are not supported")
	case 3:
		return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "Endpoint override is not supported for dual-stack endpoints. Please enable dual-stack functionality by enabling the configuration. For more details, see: https://docs.aws.amazon.com/sdkref/latest/guide/feature-endpoints.html")
	case 4:
		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 5:
		return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: FIPS and local endpoint are not supported")
	case 6:
		return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: Dualstack and local endpoint are not supported")
	case 7:
		uriString := "http://localhost:8000"
		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, "dynamodb")
							smithyhttp.SetSigV4ASigningName(&sp, "dynamodb")

							smithyhttp.SetSigV4SigningRegion(&sp, "us-east-1")
							return sp
						}(),
					},
				})
				return out
			}(),
		}, nil
	case 8:
		return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported")
	case 9:
		uriString := func() string {
			var out strings.Builder
			out.WriteString("https://dynamodb-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 10:
		return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "FIPS and DualStack are enabled, but this partition does not support one or both")
	case 11:
		uriString := func() string {
			var out strings.Builder
			out.WriteString("https://dynamodb.")
			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 12:
		uriString := func() string {
			var out strings.Builder
			out.WriteString("https://dynamodb-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 13:
		return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "FIPS is enabled but this partition does not support FIPS")
	case 14:
		uriString := func() string {
			var out strings.Builder
			out.WriteString("https://")
			out.WriteString(c.ParsedArn_ssa_2.AccountId)
			out.WriteString(".ddb.")
			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{},
			Properties: func() smithy.Properties {
				var out smithy.Properties
				out.Set("metricValues", []interface{}{
					"O",
				})
				return out
			}(),
		}, nil
	case 15:
		uriString := func() string {
			var out strings.Builder
			out.WriteString("https://")
			out.WriteString(c.ParsedArn_ssa_1.AccountId)
			out.WriteString(".ddb.")
			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{},
			Properties: func() smithy.Properties {
				var out smithy.Properties
				out.Set("metricValues", []interface{}{
					"O",
				})
				return out
			}(),
		}, nil
	case 16:
		uriString := func() string {
			var out strings.Builder
			out.WriteString("https://")
			out.WriteString(*params.AccountId)
			out.WriteString(".ddb.")
			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{},
			Properties: func() smithy.Properties {
				var out smithy.Properties
				out.Set("metricValues", []interface{}{
					"O",
				})
				return out
			}(),
		}, nil
	case 17:
		return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "Credentials-sourced account ID parameter is invalid")
	case 18:
		return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "AccountIdEndpointMode is required but no AccountID was provided or able to be loaded")
	case 19:
		return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition")
	case 20:
		uriString := func() string {
			var out strings.Builder
			out.WriteString("https://dynamodb.")
			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 21:
		return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "DualStack is enabled but this partition does not support DualStack")
	case 22:
		uriString := func() string {
			var out strings.Builder
			out.WriteString("https://")
			out.WriteString(c.ParsedArn_ssa_2.AccountId)
			out.WriteString(".ddb.")
			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
				out.Set("metricValues", []interface{}{
					"O",
				})
				return out
			}(),
		}, nil
	case 23:
		uriString := func() string {
			var out strings.Builder
			out.WriteString("https://")
			out.WriteString(c.ParsedArn_ssa_1.AccountId)
			out.WriteString(".ddb.")
			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
				out.Set("metricValues", []interface{}{
					"O",
				})
				return out
			}(),
		}, nil
	case 24:
		uriString := func() string {
			var out strings.Builder
			out.WriteString("https://")
			out.WriteString(*params.AccountId)
			out.WriteString(".ddb.")
			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
				out.Set("metricValues", []interface{}{
					"O",
				})
				return out
			}(),
		}, nil
	case 25:
		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
	params.AccountId = resolveAccountID(getIdentity(ctx), options.AccountIDEndpointMode)
	params.AccountIdEndpointMode = aws.String(string(options.AccountIDEndpointMode))

	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)
	}

	if err := checkAccountID(getIdentity(ctx), m.options.AccountIDEndpointMode); err != nil {
		return out, metadata, fmt.Errorf("invalid accountID set: %w", err)
	}

	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)
}