func()

in service/s3control/endpoints.go [378:2450]

• 1,920 lines of code
• 195 McCabe index (conditional complexity)

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)
	}
	_UseFIPS := *params.UseFIPS
	_UseDualStack := *params.UseDualStack

	if exprVal := params.Region; exprVal != nil {
		_Region := *exprVal
		_ = _Region
		if _UseFIPS == true {
			if exprVal := awsrulesfn.GetPartition(_Region); exprVal != nil {
				_partitionResult := *exprVal
				_ = _partitionResult
				if _partitionResult.Name == "aws-cn" {
					return endpoint, fmt.Errorf("endpoint rule error, %s", "Partition does not support FIPS")
				}
			}
		}
		if exprVal := params.OutpostId; exprVal != nil {
			_OutpostId := *exprVal
			_ = _OutpostId
			if exprVal := awsrulesfn.GetPartition(_Region); exprVal != nil {
				_partitionResult := *exprVal
				_ = _partitionResult
				if exprVal := params.RequiresAccountId; exprVal != nil {
					_RequiresAccountId := *exprVal
					_ = _RequiresAccountId
					if _RequiresAccountId == true {
						if !(params.AccountId != nil) {
							return endpoint, fmt.Errorf("endpoint rule error, %s", "AccountId is required but not set")
						}
					}
				}
				if exprVal := params.AccountId; exprVal != nil {
					_AccountId := *exprVal
					_ = _AccountId
					if !(rulesfn.IsValidHostLabel(_AccountId, false)) {
						return endpoint, fmt.Errorf("endpoint rule error, %s", "AccountId must only contain a-z, A-Z, 0-9 and `-`.")
					}
				}
				if !(rulesfn.IsValidHostLabel(_OutpostId, false)) {
					return endpoint, fmt.Errorf("endpoint rule error, %s", "OutpostId must only contain a-z, A-Z, 0-9 and `-`.")
				}
				if exprVal := params.Endpoint; exprVal != nil {
					_Endpoint := *exprVal
					_ = _Endpoint
					if _UseDualStack == true {
						return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: DualStack and custom endpoint are not supported")
					}
				}
				if rulesfn.IsValidHostLabel(_Region, true) {
					if exprVal := params.Endpoint; exprVal != nil {
						_Endpoint := *exprVal
						_ = _Endpoint
						if exprVal := rulesfn.ParseURL(_Endpoint); exprVal != nil {
							_url := *exprVal
							_ = _url
							uriString := func() string {
								var out strings.Builder
								out.WriteString(_url.Scheme)
								out.WriteString("://")
								out.WriteString(_url.Authority)
								out.WriteString(_url.Path)
								return out.String()
							}()

							uri, err := url.Parse(uriString)
							if err != nil {
								return 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: "aws.auth#sigv4",
											SignerProperties: func() smithy.Properties {
												var sp smithy.Properties
												smithyhttp.SetDisableDoubleEncoding(&sp, true)

												smithyhttp.SetSigV4SigningName(&sp, "s3-outposts")
												smithyhttp.SetSigV4ASigningName(&sp, "s3-outposts")

												smithyhttp.SetSigV4SigningRegion(&sp, _Region)
												return sp
											}(),
										},
									})
									return out
								}(),
							}, nil
						}
					}
					if _UseFIPS == true {
						if _UseDualStack == true {
							uriString := func() string {
								var out strings.Builder
								out.WriteString("https://s3-outposts-fips.")
								out.WriteString(_Region)
								out.WriteString(".")
								out.WriteString(_partitionResult.DualStackDnsSuffix)
								return out.String()
							}()

							uri, err := url.Parse(uriString)
							if err != nil {
								return 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: "aws.auth#sigv4",
											SignerProperties: func() smithy.Properties {
												var sp smithy.Properties
												smithyhttp.SetDisableDoubleEncoding(&sp, true)

												smithyhttp.SetSigV4SigningName(&sp, "s3-outposts")
												smithyhttp.SetSigV4ASigningName(&sp, "s3-outposts")

												smithyhttp.SetSigV4SigningRegion(&sp, _Region)
												return sp
											}(),
										},
									})
									return out
								}(),
							}, nil
						}
					}
					if _UseFIPS == true {
						uriString := func() string {
							var out strings.Builder
							out.WriteString("https://s3-outposts-fips.")
							out.WriteString(_Region)
							out.WriteString(".")
							out.WriteString(_partitionResult.DnsSuffix)
							return out.String()
						}()

						uri, err := url.Parse(uriString)
						if err != nil {
							return 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: "aws.auth#sigv4",
										SignerProperties: func() smithy.Properties {
											var sp smithy.Properties
											smithyhttp.SetDisableDoubleEncoding(&sp, true)

											smithyhttp.SetSigV4SigningName(&sp, "s3-outposts")
											smithyhttp.SetSigV4ASigningName(&sp, "s3-outposts")

											smithyhttp.SetSigV4SigningRegion(&sp, _Region)
											return sp
										}(),
									},
								})
								return out
							}(),
						}, nil
					}
					if _UseDualStack == true {
						uriString := func() string {
							var out strings.Builder
							out.WriteString("https://s3-outposts.")
							out.WriteString(_Region)
							out.WriteString(".")
							out.WriteString(_partitionResult.DualStackDnsSuffix)
							return out.String()
						}()

						uri, err := url.Parse(uriString)
						if err != nil {
							return 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: "aws.auth#sigv4",
										SignerProperties: func() smithy.Properties {
											var sp smithy.Properties
											smithyhttp.SetDisableDoubleEncoding(&sp, true)

											smithyhttp.SetSigV4SigningName(&sp, "s3-outposts")
											smithyhttp.SetSigV4ASigningName(&sp, "s3-outposts")

											smithyhttp.SetSigV4SigningRegion(&sp, _Region)
											return sp
										}(),
									},
								})
								return out
							}(),
						}, nil
					}
					uriString := func() string {
						var out strings.Builder
						out.WriteString("https://s3-outposts.")
						out.WriteString(_Region)
						out.WriteString(".")
						out.WriteString(_partitionResult.DnsSuffix)
						return out.String()
					}()

					uri, err := url.Parse(uriString)
					if err != nil {
						return 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: "aws.auth#sigv4",
									SignerProperties: func() smithy.Properties {
										var sp smithy.Properties
										smithyhttp.SetDisableDoubleEncoding(&sp, true)

										smithyhttp.SetSigV4SigningName(&sp, "s3-outposts")
										smithyhttp.SetSigV4ASigningName(&sp, "s3-outposts")

										smithyhttp.SetSigV4SigningRegion(&sp, _Region)
										return sp
									}(),
								},
							})
							return out
						}(),
					}, nil
				}
				return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid region: region was not a valid DNS name.")
			}
			return endpoint, fmt.Errorf("Endpoint resolution failed. Invalid operation or environment input.")
		}
		if exprVal := params.AccessPointName; exprVal != nil {
			_AccessPointName := *exprVal
			_ = _AccessPointName
			if exprVal := rulesfn.SubString(_AccessPointName, 0, 7, true); exprVal != nil {
				_accessPointSuffix := *exprVal
				_ = _accessPointSuffix
				if _accessPointSuffix == "--xa-s3" {
					if exprVal := awsrulesfn.GetPartition(_Region); exprVal != nil {
						_partitionResult := *exprVal
						_ = _partitionResult
						if _UseDualStack == true {
							return endpoint, fmt.Errorf("endpoint rule error, %s", "S3Express does not support Dual-stack.")
						}
						if exprVal := rulesfn.SubString(_AccessPointName, 7, 15, true); exprVal != nil {
							_s3expressAvailabilityZoneId := *exprVal
							_ = _s3expressAvailabilityZoneId
							if exprVal := rulesfn.SubString(_AccessPointName, 15, 17, true); exprVal != nil {
								_s3expressAvailabilityZoneDelim := *exprVal
								_ = _s3expressAvailabilityZoneDelim
								if _s3expressAvailabilityZoneDelim == "--" {
									if _UseFIPS == true {
										uriString := func() string {
											var out strings.Builder
											out.WriteString("https://s3express-control-fips.")
											out.WriteString(_Region)
											out.WriteString(".")
											out.WriteString(_partitionResult.DnsSuffix)
											return out.String()
										}()

										uri, err := url.Parse(uriString)
										if err != nil {
											return 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: "aws.auth#sigv4",
														SignerProperties: func() smithy.Properties {
															var sp smithy.Properties
															smithyhttp.SetDisableDoubleEncoding(&sp, true)

															smithyhttp.SetSigV4SigningName(&sp, "s3express")
															smithyhttp.SetSigV4ASigningName(&sp, "s3express")

															smithyhttp.SetSigV4SigningRegion(&sp, _Region)
															return sp
														}(),
													},
												})
												return out
											}(),
										}, nil
									}
									uriString := func() string {
										var out strings.Builder
										out.WriteString("https://s3express-control.")
										out.WriteString(_Region)
										out.WriteString(".")
										out.WriteString(_partitionResult.DnsSuffix)
										return out.String()
									}()

									uri, err := url.Parse(uriString)
									if err != nil {
										return 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: "aws.auth#sigv4",
													SignerProperties: func() smithy.Properties {
														var sp smithy.Properties
														smithyhttp.SetDisableDoubleEncoding(&sp, true)

														smithyhttp.SetSigV4SigningName(&sp, "s3express")
														smithyhttp.SetSigV4ASigningName(&sp, "s3express")

														smithyhttp.SetSigV4SigningRegion(&sp, _Region)
														return sp
													}(),
												},
											})
											return out
										}(),
									}, nil
								}
							}
						}
						if exprVal := rulesfn.SubString(_AccessPointName, 7, 16, true); exprVal != nil {
							_s3expressAvailabilityZoneId := *exprVal
							_ = _s3expressAvailabilityZoneId
							if exprVal := rulesfn.SubString(_AccessPointName, 16, 18, true); exprVal != nil {
								_s3expressAvailabilityZoneDelim := *exprVal
								_ = _s3expressAvailabilityZoneDelim
								if _s3expressAvailabilityZoneDelim == "--" {
									if _UseFIPS == true {
										uriString := func() string {
											var out strings.Builder
											out.WriteString("https://s3express-control-fips.")
											out.WriteString(_Region)
											out.WriteString(".")
											out.WriteString(_partitionResult.DnsSuffix)
											return out.String()
										}()

										uri, err := url.Parse(uriString)
										if err != nil {
											return 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: "aws.auth#sigv4",
														SignerProperties: func() smithy.Properties {
															var sp smithy.Properties
															smithyhttp.SetDisableDoubleEncoding(&sp, true)

															smithyhttp.SetSigV4SigningName(&sp, "s3express")
															smithyhttp.SetSigV4ASigningName(&sp, "s3express")

															smithyhttp.SetSigV4SigningRegion(&sp, _Region)
															return sp
														}(),
													},
												})
												return out
											}(),
										}, nil
									}
									uriString := func() string {
										var out strings.Builder
										out.WriteString("https://s3express-control.")
										out.WriteString(_Region)
										out.WriteString(".")
										out.WriteString(_partitionResult.DnsSuffix)
										return out.String()
									}()

									uri, err := url.Parse(uriString)
									if err != nil {
										return 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: "aws.auth#sigv4",
													SignerProperties: func() smithy.Properties {
														var sp smithy.Properties
														smithyhttp.SetDisableDoubleEncoding(&sp, true)

														smithyhttp.SetSigV4SigningName(&sp, "s3express")
														smithyhttp.SetSigV4ASigningName(&sp, "s3express")

														smithyhttp.SetSigV4SigningRegion(&sp, _Region)
														return sp
													}(),
												},
											})
											return out
										}(),
									}, nil
								}
							}
						}
						if exprVal := rulesfn.SubString(_AccessPointName, 7, 20, true); exprVal != nil {
							_s3expressAvailabilityZoneId := *exprVal
							_ = _s3expressAvailabilityZoneId
							if exprVal := rulesfn.SubString(_AccessPointName, 20, 22, true); exprVal != nil {
								_s3expressAvailabilityZoneDelim := *exprVal
								_ = _s3expressAvailabilityZoneDelim
								if _s3expressAvailabilityZoneDelim == "--" {
									if _UseFIPS == true {
										uriString := func() string {
											var out strings.Builder
											out.WriteString("https://s3express-control-fips.")
											out.WriteString(_Region)
											out.WriteString(".")
											out.WriteString(_partitionResult.DnsSuffix)
											return out.String()
										}()

										uri, err := url.Parse(uriString)
										if err != nil {
											return 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: "aws.auth#sigv4",
														SignerProperties: func() smithy.Properties {
															var sp smithy.Properties
															smithyhttp.SetDisableDoubleEncoding(&sp, true)

															smithyhttp.SetSigV4SigningName(&sp, "s3express")
															smithyhttp.SetSigV4ASigningName(&sp, "s3express")

															smithyhttp.SetSigV4SigningRegion(&sp, _Region)
															return sp
														}(),
													},
												})
												return out
											}(),
										}, nil
									}
									uriString := func() string {
										var out strings.Builder
										out.WriteString("https://s3express-control.")
										out.WriteString(_Region)
										out.WriteString(".")
										out.WriteString(_partitionResult.DnsSuffix)
										return out.String()
									}()

									uri, err := url.Parse(uriString)
									if err != nil {
										return 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: "aws.auth#sigv4",
													SignerProperties: func() smithy.Properties {
														var sp smithy.Properties
														smithyhttp.SetDisableDoubleEncoding(&sp, true)

														smithyhttp.SetSigV4SigningName(&sp, "s3express")
														smithyhttp.SetSigV4ASigningName(&sp, "s3express")

														smithyhttp.SetSigV4SigningRegion(&sp, _Region)
														return sp
													}(),
												},
											})
											return out
										}(),
									}, nil
								}
							}
						}
						if exprVal := rulesfn.SubString(_AccessPointName, 7, 21, true); exprVal != nil {
							_s3expressAvailabilityZoneId := *exprVal
							_ = _s3expressAvailabilityZoneId
							if exprVal := rulesfn.SubString(_AccessPointName, 21, 23, true); exprVal != nil {
								_s3expressAvailabilityZoneDelim := *exprVal
								_ = _s3expressAvailabilityZoneDelim
								if _s3expressAvailabilityZoneDelim == "--" {
									if _UseFIPS == true {
										uriString := func() string {
											var out strings.Builder
											out.WriteString("https://s3express-control-fips.")
											out.WriteString(_Region)
											out.WriteString(".")
											out.WriteString(_partitionResult.DnsSuffix)
											return out.String()
										}()

										uri, err := url.Parse(uriString)
										if err != nil {
											return 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: "aws.auth#sigv4",
														SignerProperties: func() smithy.Properties {
															var sp smithy.Properties
															smithyhttp.SetDisableDoubleEncoding(&sp, true)

															smithyhttp.SetSigV4SigningName(&sp, "s3express")
															smithyhttp.SetSigV4ASigningName(&sp, "s3express")

															smithyhttp.SetSigV4SigningRegion(&sp, _Region)
															return sp
														}(),
													},
												})
												return out
											}(),
										}, nil
									}
									uriString := func() string {
										var out strings.Builder
										out.WriteString("https://s3express-control.")
										out.WriteString(_Region)
										out.WriteString(".")
										out.WriteString(_partitionResult.DnsSuffix)
										return out.String()
									}()

									uri, err := url.Parse(uriString)
									if err != nil {
										return 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: "aws.auth#sigv4",
													SignerProperties: func() smithy.Properties {
														var sp smithy.Properties
														smithyhttp.SetDisableDoubleEncoding(&sp, true)

														smithyhttp.SetSigV4SigningName(&sp, "s3express")
														smithyhttp.SetSigV4ASigningName(&sp, "s3express")

														smithyhttp.SetSigV4SigningRegion(&sp, _Region)
														return sp
													}(),
												},
											})
											return out
										}(),
									}, nil
								}
							}
						}
						if exprVal := rulesfn.SubString(_AccessPointName, 7, 27, true); exprVal != nil {
							_s3expressAvailabilityZoneId := *exprVal
							_ = _s3expressAvailabilityZoneId
							if exprVal := rulesfn.SubString(_AccessPointName, 27, 29, true); exprVal != nil {
								_s3expressAvailabilityZoneDelim := *exprVal
								_ = _s3expressAvailabilityZoneDelim
								if _s3expressAvailabilityZoneDelim == "--" {
									if _UseFIPS == true {
										uriString := func() string {
											var out strings.Builder
											out.WriteString("https://s3express-control-fips.")
											out.WriteString(_Region)
											out.WriteString(".")
											out.WriteString(_partitionResult.DnsSuffix)
											return out.String()
										}()

										uri, err := url.Parse(uriString)
										if err != nil {
											return 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: "aws.auth#sigv4",
														SignerProperties: func() smithy.Properties {
															var sp smithy.Properties
															smithyhttp.SetDisableDoubleEncoding(&sp, true)

															smithyhttp.SetSigV4SigningName(&sp, "s3express")
															smithyhttp.SetSigV4ASigningName(&sp, "s3express")

															smithyhttp.SetSigV4SigningRegion(&sp, _Region)
															return sp
														}(),
													},
												})
												return out
											}(),
										}, nil
									}
									uriString := func() string {
										var out strings.Builder
										out.WriteString("https://s3express-control.")
										out.WriteString(_Region)
										out.WriteString(".")
										out.WriteString(_partitionResult.DnsSuffix)
										return out.String()
									}()

									uri, err := url.Parse(uriString)
									if err != nil {
										return 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: "aws.auth#sigv4",
													SignerProperties: func() smithy.Properties {
														var sp smithy.Properties
														smithyhttp.SetDisableDoubleEncoding(&sp, true)

														smithyhttp.SetSigV4SigningName(&sp, "s3express")
														smithyhttp.SetSigV4ASigningName(&sp, "s3express")

														smithyhttp.SetSigV4SigningRegion(&sp, _Region)
														return sp
													}(),
												},
											})
											return out
										}(),
									}, nil
								}
							}
						}
						return endpoint, fmt.Errorf("endpoint rule error, %s", "Unrecognized S3Express Access Point name format.")
					}
					return endpoint, fmt.Errorf("Endpoint resolution failed. Invalid operation or environment input.")
				}
			}
		}
		if exprVal := params.UseS3ExpressControlEndpoint; exprVal != nil {
			_UseS3ExpressControlEndpoint := *exprVal
			_ = _UseS3ExpressControlEndpoint
			if _UseS3ExpressControlEndpoint == true {
				if exprVal := awsrulesfn.GetPartition(_Region); exprVal != nil {
					_partitionResult := *exprVal
					_ = _partitionResult
					if _UseFIPS == true {
						uriString := func() string {
							var out strings.Builder
							out.WriteString("https://s3express-control-fips.")
							out.WriteString(_Region)
							out.WriteString(".")
							out.WriteString(_partitionResult.DnsSuffix)
							return out.String()
						}()

						uri, err := url.Parse(uriString)
						if err != nil {
							return 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: "aws.auth#sigv4",
										SignerProperties: func() smithy.Properties {
											var sp smithy.Properties
											smithyhttp.SetDisableDoubleEncoding(&sp, true)

											smithyhttp.SetSigV4SigningName(&sp, "s3express")
											smithyhttp.SetSigV4ASigningName(&sp, "s3express")

											smithyhttp.SetSigV4SigningRegion(&sp, _Region)
											return sp
										}(),
									},
								})
								return out
							}(),
						}, nil
					}
					uriString := func() string {
						var out strings.Builder
						out.WriteString("https://s3express-control.")
						out.WriteString(_Region)
						out.WriteString(".")
						out.WriteString(_partitionResult.DnsSuffix)
						return out.String()
					}()

					uri, err := url.Parse(uriString)
					if err != nil {
						return 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: "aws.auth#sigv4",
									SignerProperties: func() smithy.Properties {
										var sp smithy.Properties
										smithyhttp.SetDisableDoubleEncoding(&sp, true)

										smithyhttp.SetSigV4SigningName(&sp, "s3express")
										smithyhttp.SetSigV4ASigningName(&sp, "s3express")

										smithyhttp.SetSigV4SigningRegion(&sp, _Region)
										return sp
									}(),
								},
							})
							return out
						}(),
					}, nil
				}
				return endpoint, fmt.Errorf("Endpoint resolution failed. Invalid operation or environment input.")
			}
		}
		if _Region == "snow" {
			if exprVal := params.Endpoint; exprVal != nil {
				_Endpoint := *exprVal
				_ = _Endpoint
				if exprVal := rulesfn.ParseURL(_Endpoint); exprVal != nil {
					_url := *exprVal
					_ = _url
					if exprVal := awsrulesfn.GetPartition(_Region); exprVal != nil {
						_partitionResult := *exprVal
						_ = _partitionResult
						if _UseDualStack == true {
							return endpoint, fmt.Errorf("endpoint rule error, %s", "S3 Snow does not support DualStack")
						}
						if _UseFIPS == true {
							return endpoint, fmt.Errorf("endpoint rule error, %s", "S3 Snow does not support FIPS")
						}
						uriString := func() string {
							var out strings.Builder
							out.WriteString(_url.Scheme)
							out.WriteString("://")
							out.WriteString(_url.Authority)
							return out.String()
						}()

						uri, err := url.Parse(uriString)
						if err != nil {
							return 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: "aws.auth#sigv4",
										SignerProperties: func() smithy.Properties {
											var sp smithy.Properties
											smithyhttp.SetDisableDoubleEncoding(&sp, true)

											smithyhttp.SetSigV4SigningName(&sp, "s3")
											smithyhttp.SetSigV4ASigningName(&sp, "s3")

											smithyhttp.SetSigV4SigningRegion(&sp, _Region)
											return sp
										}(),
									},
								})
								return out
							}(),
						}, nil
					}
					return endpoint, fmt.Errorf("Endpoint resolution failed. Invalid operation or environment input.")
				}
			}
		}
		if exprVal := params.AccessPointName; exprVal != nil {
			_AccessPointName := *exprVal
			_ = _AccessPointName
			if exprVal := awsrulesfn.ParseARN(_AccessPointName); exprVal != nil {
				_accessPointArn := *exprVal
				_ = _accessPointArn
				if exprVal := _accessPointArn.ResourceId.Get(0); exprVal != nil {
					_arnType := *exprVal
					_ = _arnType
					if !(_arnType == "") {
						if _accessPointArn.Service == "s3-outposts" {
							if exprVal := _accessPointArn.ResourceId.Get(1); exprVal != nil {
								_outpostId := *exprVal
								_ = _outpostId
								if rulesfn.IsValidHostLabel(_outpostId, false) {
									if exprVal := params.Endpoint; exprVal != nil {
										_Endpoint := *exprVal
										_ = _Endpoint
										if _UseDualStack == true {
											return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: DualStack and custom endpoint are not supported")
										}
									}
									if exprVal := params.UseArnRegion; exprVal != nil {
										_UseArnRegion := *exprVal
										_ = _UseArnRegion
										if _UseArnRegion == false {
											if !(_accessPointArn.Region == _Region) {
												return endpoint, fmt.Errorf("endpoint rule error, %s", func() string {
													var out strings.Builder
													out.WriteString("Invalid configuration: region from ARN `")
													out.WriteString(_accessPointArn.Region)
													out.WriteString("` does not match client region `")
													out.WriteString(_Region)
													out.WriteString("` and UseArnRegion is `false`")
													return out.String()
												}())
											}
										}
									}
									if exprVal := awsrulesfn.GetPartition(_Region); exprVal != nil {
										_partitionResult := *exprVal
										_ = _partitionResult
										if exprVal := awsrulesfn.GetPartition(_accessPointArn.Region); exprVal != nil {
											_arnPartition := *exprVal
											_ = _arnPartition
											if _arnPartition.Name == _partitionResult.Name {
												if rulesfn.IsValidHostLabel(_accessPointArn.Region, true) {
													if !(_accessPointArn.AccountId == "") {
														if rulesfn.IsValidHostLabel(_accessPointArn.AccountId, false) {
															if exprVal := params.AccountId; exprVal != nil {
																_AccountId := *exprVal
																_ = _AccountId
																if !(_AccountId == _accessPointArn.AccountId) {
																	return endpoint, fmt.Errorf("endpoint rule error, %s", func() string {
																		var out strings.Builder
																		out.WriteString("Invalid ARN: the accountId specified in the ARN (`")
																		out.WriteString(_accessPointArn.AccountId)
																		out.WriteString("`) does not match the parameter (`")
																		out.WriteString(_AccountId)
																		out.WriteString("`)")
																		return out.String()
																	}())
																}
															}
															if exprVal := _accessPointArn.ResourceId.Get(2); exprVal != nil {
																_outpostType := *exprVal
																_ = _outpostType
																if exprVal := _accessPointArn.ResourceId.Get(3); exprVal != nil {
																	_accessPointName := *exprVal
																	_ = _accessPointName
																	if _outpostType == "accesspoint" {
																		if _UseFIPS == true {
																			if _UseDualStack == true {
																				uriString := func() string {
																					var out strings.Builder
																					out.WriteString("https://s3-outposts-fips.")
																					out.WriteString(_accessPointArn.Region)
																					out.WriteString(".")
																					out.WriteString(_arnPartition.DualStackDnsSuffix)
																					return out.String()
																				}()

																				uri, err := url.Parse(uriString)
																				if err != nil {
																					return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
																				}

																				return smithyendpoints.Endpoint{
																					URI: *uri,
																					Headers: func() http.Header {
																						headers := http.Header{}
																						headers.Set("x-amz-account-id", _accessPointArn.AccountId)
																						headers.Set("x-amz-outpost-id", _outpostId)
																						return headers
																					}(),
																					Properties: func() smithy.Properties {
																						var out smithy.Properties
																						smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
																							{
																								SchemeID: "aws.auth#sigv4",
																								SignerProperties: func() smithy.Properties {
																									var sp smithy.Properties
																									smithyhttp.SetDisableDoubleEncoding(&sp, true)

																									smithyhttp.SetSigV4SigningName(&sp, "s3-outposts")
																									smithyhttp.SetSigV4ASigningName(&sp, "s3-outposts")

																									smithyhttp.SetSigV4SigningRegion(&sp, _accessPointArn.Region)
																									return sp
																								}(),
																							},
																						})
																						return out
																					}(),
																				}, nil
																			}
																		}
																		if _UseFIPS == true {
																			uriString := func() string {
																				var out strings.Builder
																				out.WriteString("https://s3-outposts-fips.")
																				out.WriteString(_accessPointArn.Region)
																				out.WriteString(".")
																				out.WriteString(_arnPartition.DnsSuffix)
																				return out.String()
																			}()

																			uri, err := url.Parse(uriString)
																			if err != nil {
																				return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
																			}

																			return smithyendpoints.Endpoint{
																				URI: *uri,
																				Headers: func() http.Header {
																					headers := http.Header{}
																					headers.Set("x-amz-account-id", _accessPointArn.AccountId)
																					headers.Set("x-amz-outpost-id", _outpostId)
																					return headers
																				}(),
																				Properties: func() smithy.Properties {
																					var out smithy.Properties
																					smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
																						{
																							SchemeID: "aws.auth#sigv4",
																							SignerProperties: func() smithy.Properties {
																								var sp smithy.Properties
																								smithyhttp.SetDisableDoubleEncoding(&sp, true)

																								smithyhttp.SetSigV4SigningName(&sp, "s3-outposts")
																								smithyhttp.SetSigV4ASigningName(&sp, "s3-outposts")

																								smithyhttp.SetSigV4SigningRegion(&sp, _accessPointArn.Region)
																								return sp
																							}(),
																						},
																					})
																					return out
																				}(),
																			}, nil
																		}
																		if _UseDualStack == true {
																			uriString := func() string {
																				var out strings.Builder
																				out.WriteString("https://s3-outposts.")
																				out.WriteString(_accessPointArn.Region)
																				out.WriteString(".")
																				out.WriteString(_arnPartition.DualStackDnsSuffix)
																				return out.String()
																			}()

																			uri, err := url.Parse(uriString)
																			if err != nil {
																				return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
																			}

																			return smithyendpoints.Endpoint{
																				URI: *uri,
																				Headers: func() http.Header {
																					headers := http.Header{}
																					headers.Set("x-amz-account-id", _accessPointArn.AccountId)
																					headers.Set("x-amz-outpost-id", _outpostId)
																					return headers
																				}(),
																				Properties: func() smithy.Properties {
																					var out smithy.Properties
																					smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
																						{
																							SchemeID: "aws.auth#sigv4",
																							SignerProperties: func() smithy.Properties {
																								var sp smithy.Properties
																								smithyhttp.SetDisableDoubleEncoding(&sp, true)

																								smithyhttp.SetSigV4SigningName(&sp, "s3-outposts")
																								smithyhttp.SetSigV4ASigningName(&sp, "s3-outposts")

																								smithyhttp.SetSigV4SigningRegion(&sp, _accessPointArn.Region)
																								return sp
																							}(),
																						},
																					})
																					return out
																				}(),
																			}, nil
																		}
																		if exprVal := params.Endpoint; exprVal != nil {
																			_Endpoint := *exprVal
																			_ = _Endpoint
																			if exprVal := rulesfn.ParseURL(_Endpoint); exprVal != nil {
																				_url := *exprVal
																				_ = _url
																				uriString := func() string {
																					var out strings.Builder
																					out.WriteString(_url.Scheme)
																					out.WriteString("://")
																					out.WriteString(_url.Authority)
																					out.WriteString(_url.Path)
																					return out.String()
																				}()

																				uri, err := url.Parse(uriString)
																				if err != nil {
																					return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
																				}

																				return smithyendpoints.Endpoint{
																					URI: *uri,
																					Headers: func() http.Header {
																						headers := http.Header{}
																						headers.Set("x-amz-account-id", _accessPointArn.AccountId)
																						headers.Set("x-amz-outpost-id", _outpostId)
																						return headers
																					}(),
																					Properties: func() smithy.Properties {
																						var out smithy.Properties
																						smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
																							{
																								SchemeID: "aws.auth#sigv4",
																								SignerProperties: func() smithy.Properties {
																									var sp smithy.Properties
																									smithyhttp.SetDisableDoubleEncoding(&sp, true)

																									smithyhttp.SetSigV4SigningName(&sp, "s3-outposts")
																									smithyhttp.SetSigV4ASigningName(&sp, "s3-outposts")

																									smithyhttp.SetSigV4SigningRegion(&sp, _accessPointArn.Region)
																									return sp
																								}(),
																							},
																						})
																						return out
																					}(),
																				}, nil
																			}
																		}
																		uriString := func() string {
																			var out strings.Builder
																			out.WriteString("https://s3-outposts.")
																			out.WriteString(_accessPointArn.Region)
																			out.WriteString(".")
																			out.WriteString(_arnPartition.DnsSuffix)
																			return out.String()
																		}()

																		uri, err := url.Parse(uriString)
																		if err != nil {
																			return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
																		}

																		return smithyendpoints.Endpoint{
																			URI: *uri,
																			Headers: func() http.Header {
																				headers := http.Header{}
																				headers.Set("x-amz-account-id", _accessPointArn.AccountId)
																				headers.Set("x-amz-outpost-id", _outpostId)
																				return headers
																			}(),
																			Properties: func() smithy.Properties {
																				var out smithy.Properties
																				smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
																					{
																						SchemeID: "aws.auth#sigv4",
																						SignerProperties: func() smithy.Properties {
																							var sp smithy.Properties
																							smithyhttp.SetDisableDoubleEncoding(&sp, true)

																							smithyhttp.SetSigV4SigningName(&sp, "s3-outposts")
																							smithyhttp.SetSigV4ASigningName(&sp, "s3-outposts")

																							smithyhttp.SetSigV4SigningRegion(&sp, _accessPointArn.Region)
																							return sp
																						}(),
																					},
																				})
																				return out
																			}(),
																		}, nil
																	}
																	return endpoint, fmt.Errorf("endpoint rule error, %s", func() string {
																		var out strings.Builder
																		out.WriteString("Expected an outpost type `accesspoint`, found `")
																		out.WriteString(_outpostType)
																		out.WriteString("`")
																		return out.String()
																	}())
																}
																return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid ARN: expected an access point name")
															}
															return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid ARN: Expected a 4-component resource")
														}
														return endpoint, fmt.Errorf("endpoint rule error, %s", func() string {
															var out strings.Builder
															out.WriteString("Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `")
															out.WriteString(_accessPointArn.AccountId)
															out.WriteString("`")
															return out.String()
														}())
													}
													return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid ARN: missing account ID")
												}
												return endpoint, fmt.Errorf("endpoint rule error, %s", func() string {
													var out strings.Builder
													out.WriteString("Invalid region in ARN: `")
													out.WriteString(_accessPointArn.Region)
													out.WriteString("` (invalid DNS name)")
													return out.String()
												}())
											}
											return endpoint, fmt.Errorf("endpoint rule error, %s", func() string {
												var out strings.Builder
												out.WriteString("Client was configured for partition `")
												out.WriteString(_partitionResult.Name)
												out.WriteString("` but ARN has `")
												out.WriteString(_arnPartition.Name)
												out.WriteString("`")
												return out.String()
											}())
										}
										return endpoint, fmt.Errorf("Endpoint resolution failed. Invalid operation or environment input.")
									}
									return endpoint, fmt.Errorf("Endpoint resolution failed. Invalid operation or environment input.")
								}
								return endpoint, fmt.Errorf("endpoint rule error, %s", func() string {
									var out strings.Builder
									out.WriteString("Invalid ARN: The outpost Id must only contain a-z, A-Z, 0-9 and `-`., found: `")
									out.WriteString(_outpostId)
									out.WriteString("`")
									return out.String()
								}())
							}
							return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid ARN: The Outpost Id was not set")
						}
						return endpoint, fmt.Errorf("Endpoint resolution failed. Invalid operation or environment input.")
					}
				}
				return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid ARN: No ARN type specified")
			}
		}
		if exprVal := params.Bucket; exprVal != nil {
			_Bucket := *exprVal
			_ = _Bucket
			if exprVal := awsrulesfn.ParseARN(_Bucket); exprVal != nil {
				_bucketArn := *exprVal
				_ = _bucketArn
				if exprVal := _bucketArn.ResourceId.Get(0); exprVal != nil {
					_arnType := *exprVal
					_ = _arnType
					if !(_arnType == "") {
						if _bucketArn.Service == "s3-outposts" {
							if exprVal := _bucketArn.ResourceId.Get(1); exprVal != nil {
								_outpostId := *exprVal
								_ = _outpostId
								if rulesfn.IsValidHostLabel(_outpostId, false) {
									if exprVal := params.Endpoint; exprVal != nil {
										_Endpoint := *exprVal
										_ = _Endpoint
										if _UseDualStack == true {
											return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: DualStack and custom endpoint are not supported")
										}
									}
									if exprVal := params.UseArnRegion; exprVal != nil {
										_UseArnRegion := *exprVal
										_ = _UseArnRegion
										if _UseArnRegion == false {
											if !(_bucketArn.Region == _Region) {
												return endpoint, fmt.Errorf("endpoint rule error, %s", func() string {
													var out strings.Builder
													out.WriteString("Invalid configuration: region from ARN `")
													out.WriteString(_bucketArn.Region)
													out.WriteString("` does not match client region `")
													out.WriteString(_Region)
													out.WriteString("` and UseArnRegion is `false`")
													return out.String()
												}())
											}
										}
									}
									if exprVal := awsrulesfn.GetPartition(_bucketArn.Region); exprVal != nil {
										_arnPartition := *exprVal
										_ = _arnPartition
										if exprVal := awsrulesfn.GetPartition(_Region); exprVal != nil {
											_partitionResult := *exprVal
											_ = _partitionResult
											if _arnPartition.Name == _partitionResult.Name {
												if rulesfn.IsValidHostLabel(_bucketArn.Region, true) {
													if !(_bucketArn.AccountId == "") {
														if rulesfn.IsValidHostLabel(_bucketArn.AccountId, false) {
															if exprVal := params.AccountId; exprVal != nil {
																_AccountId := *exprVal
																_ = _AccountId
																if !(_AccountId == _bucketArn.AccountId) {
																	return endpoint, fmt.Errorf("endpoint rule error, %s", func() string {
																		var out strings.Builder
																		out.WriteString("Invalid ARN: the accountId specified in the ARN (`")
																		out.WriteString(_bucketArn.AccountId)
																		out.WriteString("`) does not match the parameter (`")
																		out.WriteString(_AccountId)
																		out.WriteString("`)")
																		return out.String()
																	}())
																}
															}
															if exprVal := _bucketArn.ResourceId.Get(2); exprVal != nil {
																_outpostType := *exprVal
																_ = _outpostType
																if exprVal := _bucketArn.ResourceId.Get(3); exprVal != nil {
																	_bucketName := *exprVal
																	_ = _bucketName
																	if _outpostType == "bucket" {
																		if _UseFIPS == true {
																			if _UseDualStack == true {
																				uriString := func() string {
																					var out strings.Builder
																					out.WriteString("https://s3-outposts-fips.")
																					out.WriteString(_bucketArn.Region)
																					out.WriteString(".")
																					out.WriteString(_arnPartition.DualStackDnsSuffix)
																					return out.String()
																				}()

																				uri, err := url.Parse(uriString)
																				if err != nil {
																					return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
																				}

																				return smithyendpoints.Endpoint{
																					URI: *uri,
																					Headers: func() http.Header {
																						headers := http.Header{}
																						headers.Set("x-amz-account-id", _bucketArn.AccountId)
																						headers.Set("x-amz-outpost-id", _outpostId)
																						return headers
																					}(),
																					Properties: func() smithy.Properties {
																						var out smithy.Properties
																						smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
																							{
																								SchemeID: "aws.auth#sigv4",
																								SignerProperties: func() smithy.Properties {
																									var sp smithy.Properties
																									smithyhttp.SetDisableDoubleEncoding(&sp, true)

																									smithyhttp.SetSigV4SigningName(&sp, "s3-outposts")
																									smithyhttp.SetSigV4ASigningName(&sp, "s3-outposts")

																									smithyhttp.SetSigV4SigningRegion(&sp, _bucketArn.Region)
																									return sp
																								}(),
																							},
																						})
																						return out
																					}(),
																				}, nil
																			}
																		}
																		if _UseFIPS == true {
																			uriString := func() string {
																				var out strings.Builder
																				out.WriteString("https://s3-outposts-fips.")
																				out.WriteString(_bucketArn.Region)
																				out.WriteString(".")
																				out.WriteString(_arnPartition.DnsSuffix)
																				return out.String()
																			}()

																			uri, err := url.Parse(uriString)
																			if err != nil {
																				return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
																			}

																			return smithyendpoints.Endpoint{
																				URI: *uri,
																				Headers: func() http.Header {
																					headers := http.Header{}
																					headers.Set("x-amz-account-id", _bucketArn.AccountId)
																					headers.Set("x-amz-outpost-id", _outpostId)
																					return headers
																				}(),
																				Properties: func() smithy.Properties {
																					var out smithy.Properties
																					smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
																						{
																							SchemeID: "aws.auth#sigv4",
																							SignerProperties: func() smithy.Properties {
																								var sp smithy.Properties
																								smithyhttp.SetDisableDoubleEncoding(&sp, true)

																								smithyhttp.SetSigV4SigningName(&sp, "s3-outposts")
																								smithyhttp.SetSigV4ASigningName(&sp, "s3-outposts")

																								smithyhttp.SetSigV4SigningRegion(&sp, _bucketArn.Region)
																								return sp
																							}(),
																						},
																					})
																					return out
																				}(),
																			}, nil
																		}
																		if _UseDualStack == true {
																			uriString := func() string {
																				var out strings.Builder
																				out.WriteString("https://s3-outposts.")
																				out.WriteString(_bucketArn.Region)
																				out.WriteString(".")
																				out.WriteString(_arnPartition.DualStackDnsSuffix)
																				return out.String()
																			}()

																			uri, err := url.Parse(uriString)
																			if err != nil {
																				return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
																			}

																			return smithyendpoints.Endpoint{
																				URI: *uri,
																				Headers: func() http.Header {
																					headers := http.Header{}
																					headers.Set("x-amz-account-id", _bucketArn.AccountId)
																					headers.Set("x-amz-outpost-id", _outpostId)
																					return headers
																				}(),
																				Properties: func() smithy.Properties {
																					var out smithy.Properties
																					smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
																						{
																							SchemeID: "aws.auth#sigv4",
																							SignerProperties: func() smithy.Properties {
																								var sp smithy.Properties
																								smithyhttp.SetDisableDoubleEncoding(&sp, true)

																								smithyhttp.SetSigV4SigningName(&sp, "s3-outposts")
																								smithyhttp.SetSigV4ASigningName(&sp, "s3-outposts")

																								smithyhttp.SetSigV4SigningRegion(&sp, _bucketArn.Region)
																								return sp
																							}(),
																						},
																					})
																					return out
																				}(),
																			}, nil
																		}
																		if exprVal := params.Endpoint; exprVal != nil {
																			_Endpoint := *exprVal
																			_ = _Endpoint
																			if exprVal := rulesfn.ParseURL(_Endpoint); exprVal != nil {
																				_url := *exprVal
																				_ = _url
																				uriString := func() string {
																					var out strings.Builder
																					out.WriteString(_url.Scheme)
																					out.WriteString("://")
																					out.WriteString(_url.Authority)
																					out.WriteString(_url.Path)
																					return out.String()
																				}()

																				uri, err := url.Parse(uriString)
																				if err != nil {
																					return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
																				}

																				return smithyendpoints.Endpoint{
																					URI: *uri,
																					Headers: func() http.Header {
																						headers := http.Header{}
																						headers.Set("x-amz-account-id", _bucketArn.AccountId)
																						headers.Set("x-amz-outpost-id", _outpostId)
																						return headers
																					}(),
																					Properties: func() smithy.Properties {
																						var out smithy.Properties
																						smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
																							{
																								SchemeID: "aws.auth#sigv4",
																								SignerProperties: func() smithy.Properties {
																									var sp smithy.Properties
																									smithyhttp.SetDisableDoubleEncoding(&sp, true)

																									smithyhttp.SetSigV4SigningName(&sp, "s3-outposts")
																									smithyhttp.SetSigV4ASigningName(&sp, "s3-outposts")

																									smithyhttp.SetSigV4SigningRegion(&sp, _bucketArn.Region)
																									return sp
																								}(),
																							},
																						})
																						return out
																					}(),
																				}, nil
																			}
																		}
																		uriString := func() string {
																			var out strings.Builder
																			out.WriteString("https://s3-outposts.")
																			out.WriteString(_bucketArn.Region)
																			out.WriteString(".")
																			out.WriteString(_arnPartition.DnsSuffix)
																			return out.String()
																		}()

																		uri, err := url.Parse(uriString)
																		if err != nil {
																			return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
																		}

																		return smithyendpoints.Endpoint{
																			URI: *uri,
																			Headers: func() http.Header {
																				headers := http.Header{}
																				headers.Set("x-amz-account-id", _bucketArn.AccountId)
																				headers.Set("x-amz-outpost-id", _outpostId)
																				return headers
																			}(),
																			Properties: func() smithy.Properties {
																				var out smithy.Properties
																				smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
																					{
																						SchemeID: "aws.auth#sigv4",
																						SignerProperties: func() smithy.Properties {
																							var sp smithy.Properties
																							smithyhttp.SetDisableDoubleEncoding(&sp, true)

																							smithyhttp.SetSigV4SigningName(&sp, "s3-outposts")
																							smithyhttp.SetSigV4ASigningName(&sp, "s3-outposts")

																							smithyhttp.SetSigV4SigningRegion(&sp, _bucketArn.Region)
																							return sp
																						}(),
																					},
																				})
																				return out
																			}(),
																		}, nil
																	}
																	return endpoint, fmt.Errorf("endpoint rule error, %s", func() string {
																		var out strings.Builder
																		out.WriteString("Invalid ARN: Expected an outpost type `bucket`, found `")
																		out.WriteString(_outpostType)
																		out.WriteString("`")
																		return out.String()
																	}())
																}
																return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid ARN: expected a bucket name")
															}
															return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid ARN: Expected a 4-component resource")
														}
														return endpoint, fmt.Errorf("endpoint rule error, %s", func() string {
															var out strings.Builder
															out.WriteString("Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `")
															out.WriteString(_bucketArn.AccountId)
															out.WriteString("`")
															return out.String()
														}())
													}
													return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid ARN: missing account ID")
												}
												return endpoint, fmt.Errorf("endpoint rule error, %s", func() string {
													var out strings.Builder
													out.WriteString("Invalid region in ARN: `")
													out.WriteString(_bucketArn.Region)
													out.WriteString("` (invalid DNS name)")
													return out.String()
												}())
											}
											return endpoint, fmt.Errorf("endpoint rule error, %s", func() string {
												var out strings.Builder
												out.WriteString("Client was configured for partition `")
												out.WriteString(_partitionResult.Name)
												out.WriteString("` but ARN has `")
												out.WriteString(_arnPartition.Name)
												out.WriteString("`")
												return out.String()
											}())
										}
										return endpoint, fmt.Errorf("Endpoint resolution failed. Invalid operation or environment input.")
									}
									return endpoint, fmt.Errorf("Endpoint resolution failed. Invalid operation or environment input.")
								}
								return endpoint, fmt.Errorf("endpoint rule error, %s", func() string {
									var out strings.Builder
									out.WriteString("Invalid ARN: The outpost Id must only contain a-z, A-Z, 0-9 and `-`., found: `")
									out.WriteString(_outpostId)
									out.WriteString("`")
									return out.String()
								}())
							}
							return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid ARN: The Outpost Id was not set")
						}
						return endpoint, fmt.Errorf("Endpoint resolution failed. Invalid operation or environment input.")
					}
				}
				return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid ARN: No ARN type specified")
			}
		}
		if exprVal := awsrulesfn.GetPartition(_Region); exprVal != nil {
			_partitionResult := *exprVal
			_ = _partitionResult
			if rulesfn.IsValidHostLabel(_Region, true) {
				if exprVal := params.RequiresAccountId; exprVal != nil {
					_RequiresAccountId := *exprVal
					_ = _RequiresAccountId
					if _RequiresAccountId == true {
						if !(params.AccountId != nil) {
							return endpoint, fmt.Errorf("endpoint rule error, %s", "AccountId is required but not set")
						}
					}
				}
				if exprVal := params.AccountId; exprVal != nil {
					_AccountId := *exprVal
					_ = _AccountId
					if !(rulesfn.IsValidHostLabel(_AccountId, false)) {
						return endpoint, fmt.Errorf("endpoint rule error, %s", "AccountId must only contain a-z, A-Z, 0-9 and `-`.")
					}
				}
				if exprVal := params.Endpoint; exprVal != nil {
					_Endpoint := *exprVal
					_ = _Endpoint
					if exprVal := rulesfn.ParseURL(_Endpoint); exprVal != nil {
						_url := *exprVal
						_ = _url
						if _UseDualStack == true {
							return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: DualStack and custom endpoint are not supported")
						}
						if exprVal := params.RequiresAccountId; exprVal != nil {
							_RequiresAccountId := *exprVal
							_ = _RequiresAccountId
							if _RequiresAccountId == true {
								if exprVal := params.AccountId; exprVal != nil {
									_AccountId := *exprVal
									_ = _AccountId
									uriString := func() string {
										var out strings.Builder
										out.WriteString(_url.Scheme)
										out.WriteString("://")
										out.WriteString(_AccountId)
										out.WriteString(".")
										out.WriteString(_url.Authority)
										out.WriteString(_url.Path)
										return out.String()
									}()

									uri, err := url.Parse(uriString)
									if err != nil {
										return 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: "aws.auth#sigv4",
													SignerProperties: func() smithy.Properties {
														var sp smithy.Properties
														smithyhttp.SetDisableDoubleEncoding(&sp, true)

														smithyhttp.SetSigV4SigningName(&sp, "s3")
														smithyhttp.SetSigV4ASigningName(&sp, "s3")

														smithyhttp.SetSigV4SigningRegion(&sp, _Region)
														return sp
													}(),
												},
											})
											return out
										}(),
									}, nil
								}
							}
						}
						uriString := func() string {
							var out strings.Builder
							out.WriteString(_url.Scheme)
							out.WriteString("://")
							out.WriteString(_url.Authority)
							out.WriteString(_url.Path)
							return out.String()
						}()

						uri, err := url.Parse(uriString)
						if err != nil {
							return 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: "aws.auth#sigv4",
										SignerProperties: func() smithy.Properties {
											var sp smithy.Properties
											smithyhttp.SetDisableDoubleEncoding(&sp, true)

											smithyhttp.SetSigV4SigningName(&sp, "s3")
											smithyhttp.SetSigV4ASigningName(&sp, "s3")

											smithyhttp.SetSigV4SigningRegion(&sp, _Region)
											return sp
										}(),
									},
								})
								return out
							}(),
						}, nil
					}
				}
				if _UseFIPS == true {
					if _UseDualStack == true {
						if exprVal := params.RequiresAccountId; exprVal != nil {
							_RequiresAccountId := *exprVal
							_ = _RequiresAccountId
							if _RequiresAccountId == true {
								if exprVal := params.AccountId; exprVal != nil {
									_AccountId := *exprVal
									_ = _AccountId
									uriString := func() string {
										var out strings.Builder
										out.WriteString("https://")
										out.WriteString(_AccountId)
										out.WriteString(".s3-control-fips.dualstack.")
										out.WriteString(_Region)
										out.WriteString(".")
										out.WriteString(_partitionResult.DnsSuffix)
										return out.String()
									}()

									uri, err := url.Parse(uriString)
									if err != nil {
										return 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: "aws.auth#sigv4",
													SignerProperties: func() smithy.Properties {
														var sp smithy.Properties
														smithyhttp.SetDisableDoubleEncoding(&sp, true)

														smithyhttp.SetSigV4SigningName(&sp, "s3")
														smithyhttp.SetSigV4ASigningName(&sp, "s3")

														smithyhttp.SetSigV4SigningRegion(&sp, _Region)
														return sp
													}(),
												},
											})
											return out
										}(),
									}, nil
								}
							}
						}
					}
				}
				if _UseFIPS == true {
					if _UseDualStack == true {
						uriString := func() string {
							var out strings.Builder
							out.WriteString("https://s3-control-fips.dualstack.")
							out.WriteString(_Region)
							out.WriteString(".")
							out.WriteString(_partitionResult.DnsSuffix)
							return out.String()
						}()

						uri, err := url.Parse(uriString)
						if err != nil {
							return 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: "aws.auth#sigv4",
										SignerProperties: func() smithy.Properties {
											var sp smithy.Properties
											smithyhttp.SetDisableDoubleEncoding(&sp, true)

											smithyhttp.SetSigV4SigningName(&sp, "s3")
											smithyhttp.SetSigV4ASigningName(&sp, "s3")

											smithyhttp.SetSigV4SigningRegion(&sp, _Region)
											return sp
										}(),
									},
								})
								return out
							}(),
						}, nil
					}
				}
				if _UseFIPS == true {
					if _UseDualStack == false {
						if exprVal := params.RequiresAccountId; exprVal != nil {
							_RequiresAccountId := *exprVal
							_ = _RequiresAccountId
							if _RequiresAccountId == true {
								if exprVal := params.AccountId; exprVal != nil {
									_AccountId := *exprVal
									_ = _AccountId
									uriString := func() string {
										var out strings.Builder
										out.WriteString("https://")
										out.WriteString(_AccountId)
										out.WriteString(".s3-control-fips.")
										out.WriteString(_Region)
										out.WriteString(".")
										out.WriteString(_partitionResult.DnsSuffix)
										return out.String()
									}()

									uri, err := url.Parse(uriString)
									if err != nil {
										return 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: "aws.auth#sigv4",
													SignerProperties: func() smithy.Properties {
														var sp smithy.Properties
														smithyhttp.SetDisableDoubleEncoding(&sp, true)

														smithyhttp.SetSigV4SigningName(&sp, "s3")
														smithyhttp.SetSigV4ASigningName(&sp, "s3")

														smithyhttp.SetSigV4SigningRegion(&sp, _Region)
														return sp
													}(),
												},
											})
											return out
										}(),
									}, nil
								}
							}
						}
					}
				}
				if _UseFIPS == true {
					if _UseDualStack == false {
						uriString := func() string {
							var out strings.Builder
							out.WriteString("https://s3-control-fips.")
							out.WriteString(_Region)
							out.WriteString(".")
							out.WriteString(_partitionResult.DnsSuffix)
							return out.String()
						}()

						uri, err := url.Parse(uriString)
						if err != nil {
							return 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: "aws.auth#sigv4",
										SignerProperties: func() smithy.Properties {
											var sp smithy.Properties
											smithyhttp.SetDisableDoubleEncoding(&sp, true)

											smithyhttp.SetSigV4SigningName(&sp, "s3")
											smithyhttp.SetSigV4ASigningName(&sp, "s3")

											smithyhttp.SetSigV4SigningRegion(&sp, _Region)
											return sp
										}(),
									},
								})
								return out
							}(),
						}, nil
					}
				}
				if _UseFIPS == false {
					if _UseDualStack == true {
						if exprVal := params.RequiresAccountId; exprVal != nil {
							_RequiresAccountId := *exprVal
							_ = _RequiresAccountId
							if _RequiresAccountId == true {
								if exprVal := params.AccountId; exprVal != nil {
									_AccountId := *exprVal
									_ = _AccountId
									uriString := func() string {
										var out strings.Builder
										out.WriteString("https://")
										out.WriteString(_AccountId)
										out.WriteString(".s3-control.dualstack.")
										out.WriteString(_Region)
										out.WriteString(".")
										out.WriteString(_partitionResult.DnsSuffix)
										return out.String()
									}()

									uri, err := url.Parse(uriString)
									if err != nil {
										return 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: "aws.auth#sigv4",
													SignerProperties: func() smithy.Properties {
														var sp smithy.Properties
														smithyhttp.SetDisableDoubleEncoding(&sp, true)

														smithyhttp.SetSigV4SigningName(&sp, "s3")
														smithyhttp.SetSigV4ASigningName(&sp, "s3")

														smithyhttp.SetSigV4SigningRegion(&sp, _Region)
														return sp
													}(),
												},
											})
											return out
										}(),
									}, nil
								}
							}
						}
					}
				}
				if _UseFIPS == false {
					if _UseDualStack == true {
						uriString := func() string {
							var out strings.Builder
							out.WriteString("https://s3-control.dualstack.")
							out.WriteString(_Region)
							out.WriteString(".")
							out.WriteString(_partitionResult.DnsSuffix)
							return out.String()
						}()

						uri, err := url.Parse(uriString)
						if err != nil {
							return 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: "aws.auth#sigv4",
										SignerProperties: func() smithy.Properties {
											var sp smithy.Properties
											smithyhttp.SetDisableDoubleEncoding(&sp, true)

											smithyhttp.SetSigV4SigningName(&sp, "s3")
											smithyhttp.SetSigV4ASigningName(&sp, "s3")

											smithyhttp.SetSigV4SigningRegion(&sp, _Region)
											return sp
										}(),
									},
								})
								return out
							}(),
						}, nil
					}
				}
				if _UseFIPS == false {
					if _UseDualStack == false {
						if exprVal := params.RequiresAccountId; exprVal != nil {
							_RequiresAccountId := *exprVal
							_ = _RequiresAccountId
							if _RequiresAccountId == true {
								if exprVal := params.AccountId; exprVal != nil {
									_AccountId := *exprVal
									_ = _AccountId
									uriString := func() string {
										var out strings.Builder
										out.WriteString("https://")
										out.WriteString(_AccountId)
										out.WriteString(".s3-control.")
										out.WriteString(_Region)
										out.WriteString(".")
										out.WriteString(_partitionResult.DnsSuffix)
										return out.String()
									}()

									uri, err := url.Parse(uriString)
									if err != nil {
										return 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: "aws.auth#sigv4",
													SignerProperties: func() smithy.Properties {
														var sp smithy.Properties
														smithyhttp.SetDisableDoubleEncoding(&sp, true)

														smithyhttp.SetSigV4SigningName(&sp, "s3")
														smithyhttp.SetSigV4ASigningName(&sp, "s3")

														smithyhttp.SetSigV4SigningRegion(&sp, _Region)
														return sp
													}(),
												},
											})
											return out
										}(),
									}, nil
								}
							}
						}
					}
				}
				if _UseFIPS == false {
					if _UseDualStack == false {
						uriString := func() string {
							var out strings.Builder
							out.WriteString("https://s3-control.")
							out.WriteString(_Region)
							out.WriteString(".")
							out.WriteString(_partitionResult.DnsSuffix)
							return out.String()
						}()

						uri, err := url.Parse(uriString)
						if err != nil {
							return 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: "aws.auth#sigv4",
										SignerProperties: func() smithy.Properties {
											var sp smithy.Properties
											smithyhttp.SetDisableDoubleEncoding(&sp, true)

											smithyhttp.SetSigV4SigningName(&sp, "s3")
											smithyhttp.SetSigV4ASigningName(&sp, "s3")

											smithyhttp.SetSigV4SigningRegion(&sp, _Region)
											return sp
										}(),
									},
								})
								return out
							}(),
						}, nil
					}
				}
				return endpoint, fmt.Errorf("Endpoint resolution failed. Invalid operation or environment input.")
			}
			return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid region: region was not a valid DNS name.")
		}
		return endpoint, fmt.Errorf("Endpoint resolution failed. Invalid operation or environment input.")
	}
	return endpoint, fmt.Errorf("endpoint rule error, %s", "Region must be set")
}