package resolver

Import Path
	google.golang.org/grpc/resolver (on go.dev)

Dependency Relation
	imports 13 packages, and imported by 18 packages

Involved Source Files

	    map.go
	  d resolver.go
		Package resolver defines APIs for name resolution in gRPC.
		All APIs in this package are experimental.
Package-Level Type Names (total 17, in which 13 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Address (struct)
		Address represents a server the client connects to.
		
		# Experimental
		
		Notice: This type is EXPERIMENTAL and may be changed or removed in a
		later release.

		Fields (total 5, all are exported)
			Addr string
				Addr is the server address on which a connection will be established.

			Attributes *attributes.Attributes
				Attributes contains arbitrary data about this address intended for
				consumption by the SubConn.

			BalancerAttributes *attributes.Attributes
				BalancerAttributes contains arbitrary data about this address intended
				for consumption by the LB policy.  These attributes do not affect SubConn
				creation, connection establishment, handshaking, etc.
				
				Deprecated: when an Address is inside an Endpoint, this field should not
				be used, and it will eventually be removed entirely.

			Metadata any
				Metadata is the information associated with Addr, which may be used
				to make load balancing decision.
				
				Deprecated: use Attributes instead.

			ServerName string
				ServerName is the name of this address.
				If non-empty, the ServerName is used as the transport certification authority for
				the address, instead of the hostname from the Dial target string. In most cases,
				this should not be set.
				
				WARNING: ServerName must only be populated with trusted values. It
				is insecure to populate it with data from untrusted inputs since untrusted
				values could be used to bypass the authority checks performed by TLS.

		Methods (total 2, both are exported)
			( Address) Equal(o Address) bool
				Equal returns whether a and o are identical.  Metadata is compared directly,
				not with any recursive introspection.
				
				This method compares all fields of the address. When used to tell apart
				addresses during subchannel creation or connection establishment, it might be
				more appropriate for the caller to implement custom equality logic.

			( Address) String() string
				String returns JSON formatted string representation of the address.

		Implements (at least 4, in which 2 are exported)
			 Address : expvar.Var
			 Address : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 Address : context.stringer
			 Address : runtime.stringer
		As Outputs Of (at least 9, in which 4 are exported)
			func (*AddressMapV2)[T].Keys() []Address
			func google.golang.org/grpc/internal/metadata.Set(addr Address, md metadata.MD) Address
			func google.golang.org/grpc/internal/proxyattributes.Set(addr Address, opts proxyattributes.Options) Address
			func google.golang.org/grpc/internal/transport/networktype.Set(address Address, networkType string) Address
			/* 5+ unexporteds ... *//* 5+ unexporteds: */
			func toMapKey(addr *Address) Address
			func google.golang.org/grpc.copyAddresses(in []Address) []Address
			func google.golang.org/grpc/balancer.connectedAddress(scs balancer.SubConnState) Address
			func google.golang.org/grpc/balancer/pickfirst/pickfirstleaf.deDupAddresses(addrs []Address) []Address
			func google.golang.org/grpc/balancer/pickfirst/pickfirstleaf.interleaveAddresses(addrs []Address) []Address
		As Inputs Of (at least 29, in which 15 are exported)
			func Address.Equal(o Address) bool
			func (*AddressMapV2)[T].Delete(addr Address)
			func (*AddressMapV2)[T].Get(addr Address) (value T, ok bool)
			func (*AddressMapV2)[T].Set(addr Address, value T)
			func ClientConn.NewAddress(addresses []Address)
			func google.golang.org/grpc/balancer.ClientConn.NewSubConn([]Address, balancer.NewSubConnOptions) (balancer.SubConn, error)
			func google.golang.org/grpc/balancer.ClientConn.UpdateAddresses(balancer.SubConn, []Address)
			func google.golang.org/grpc/balancer.SubConn.UpdateAddresses([]Address)
			func google.golang.org/grpc/internal/metadata.Get(addr Address) metadata.MD
			func google.golang.org/grpc/internal/metadata.Set(addr Address, md metadata.MD) Address
			func google.golang.org/grpc/internal/proxyattributes.Get(addr Address) (proxyattributes.Options, bool)
			func google.golang.org/grpc/internal/proxyattributes.Set(addr Address, opts proxyattributes.Options) Address
			func google.golang.org/grpc/internal/transport.NewHTTP2Client(connectCtx, ctx context.Context, addr Address, opts transport.ConnectOptions, onClose func(transport.GoAwayReason)) (_ transport.ClientTransport, err error)
			func google.golang.org/grpc/internal/transport/networktype.Get(address Address) (string, bool)
			func google.golang.org/grpc/internal/transport/networktype.Set(address Address, networkType string) Address
			/* 14+ unexporteds ... *//* 14+ unexporteds: */
			func toMapKey(addr *Address) Address
			func google.golang.org/grpc.addressesToEndpoints(addrs []Address) []Endpoint
			func google.golang.org/grpc.copyAddresses(in []Address) []Address
			func google.golang.org/grpc.equalAddressesIgnoringBalAttributes(a, b []Address) bool
			func google.golang.org/grpc.equalAddressIgnoringBalAttributes(a, b *Address) bool
			func google.golang.org/grpc.(*ClientConn).getServerName(addr Address) string
			func google.golang.org/grpc.(*ClientConn).newAddrConnLocked(addrs []Address, opts balancer.NewSubConnOptions) (*grpc.addrConn, error)
			func google.golang.org/grpc/balancer.setConnectedAddress(scs *balancer.SubConnState, addr Address)
			func google.golang.org/grpc/balancer/pickfirst/pickfirstleaf.deDupAddresses(addrs []Address) []Address
			func google.golang.org/grpc/balancer/pickfirst/pickfirstleaf.equalAddressIgnoringBalAttributes(a, b *Address) bool
			func google.golang.org/grpc/balancer/pickfirst/pickfirstleaf.interleaveAddresses(addrs []Address) []Address
			func google.golang.org/grpc/internal/resolver/delegatingresolver.skipProxy(address Address) bool
			func google.golang.org/grpc/internal/transport.dial(ctx context.Context, fn func(context.Context, string) (net.Conn, error), addr Address, grpcUA string) (net.Conn, error)
			func google.golang.org/grpc/internal/transport.proxyDial(ctx context.Context, addr Address, grpcUA string, opts proxyattributes.Options) (net.Conn, error)

	 type AddressMap = (struct)
		AddressMap is an AddressMapV2[any].  It will be deleted in an upcoming
		release of grpc-go.
		
		Deprecated: use the generic AddressMapV2 type instead.

	 type AddressMapV2[T] (struct)

		Type Parameters:
			T: any

		AddressMapV2 is a map of addresses to arbitrary values taking into account
		Attributes.  BalancerAttributes are ignored, as are Metadata and Type.
		Multiple accesses may not be performed concurrently.  Must be created via
		NewAddressMap; do not construct directly.

		Fields (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			m map[Address]addressMapEntryList[T]
				The underlying map is keyed by an Address with fields that we don't care
				about being set to their zero values. The only fields that we care about
				are `Addr`, `ServerName` and `Attributes`. Since we need to be able to
				distinguish between addresses with same `Addr` and `ServerName`, but
				different `Attributes`, we cannot store the `Attributes` in the map key.
				
				The comparison operation for structs work as follows:
				 Struct values are comparable if all their fields are comparable. Two
				 struct values are equal if their corresponding non-blank fields are equal.
				
				The value type of the map contains a slice of addresses which match the key
				in their `Addr` and `ServerName` fields and contain the corresponding value
				associated with them.

		Methods (total 6, all are exported)
			(*AddressMapV2[T]) Delete(addr Address)
				Delete removes addr from the map.

			(*AddressMapV2[T]) Get(addr Address) (value T, ok bool)
				Get returns the value for the address in the map, if present.

			(*AddressMapV2[T]) Keys() []Address
				Keys returns a slice of all current map keys.

			(*AddressMapV2[T]) Len() int
				Len returns the number of entries in the map.

			(*AddressMapV2[T]) Set(addr Address, value T)
				Set updates or adds the value to the address in the map.

			(*AddressMapV2[T]) Values() []T
				Values returns a slice of all current map values.

		As Outputs Of (at least 2, both are exported)
			func NewAddressMap() *AddressMap
			func NewAddressMapV2[T]() *AddressMapV2[T]

	 type AuthorityOverrider (interface)
		AuthorityOverrider is implemented by Builders that wish to override the
		default authority for the ClientConn.
		By default, the authority used is target.Endpoint().

		Methods (only one, which is exported)
			( AuthorityOverrider) OverrideAuthority(Target) string
				OverrideAuthority returns the authority to use for a ClientConn with the
				given target. The implementation must generate it without blocking,
				typically in line, and must keep it unchanged.
				
				The returned string must be a valid ":authority" header value, i.e. be
				encoded according to
				[RFC3986](https://datatracker.ietf.org/doc/html/rfc3986#section-3.2) as
				necessary.

		Implemented By (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			*google.golang.org/grpc/internal/resolver/unix.builder

	 type Builder (interface)
		Builder creates a resolver that will be used to watch name resolution updates.

		Methods (total 2, both are exported)
			( Builder) Build(target Target, cc ClientConn, opts BuildOptions) (Resolver, error)
				Build creates a new resolver for the given target.
				
				gRPC dial calls Build synchronously, and fails if the returned error is
				not nil.

			( Builder) Scheme() string
				Scheme returns the scheme supported by this resolver.  Scheme is defined
				at https://github.com/grpc/grpc/blob/master/doc/naming.md.  The returned
				string should not contain uppercase characters, as they will not match
				the parsed target's scheme as defined in RFC 3986.

		Implemented By (at least 3, none are exported)
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			*google.golang.org/grpc/internal/resolver/dns.dnsBuilder
			*google.golang.org/grpc/internal/resolver/passthrough.passthroughBuilder
			*google.golang.org/grpc/internal/resolver/unix.builder
		As Outputs Of (at least 4, in which 3 are exported)
			func Get(scheme string) Builder
			func google.golang.org/grpc/resolver/dns.NewBuilder() Builder
			func google.golang.org/grpc/internal/resolver/dns.NewBuilder() Builder
			/* at least one unexported ... *//* at least one unexported: */
			func google.golang.org/grpc.(*ClientConn).getResolver(scheme string) Builder
		As Inputs Of (at least 3, all are exported)
			func Register(b Builder)
			func google.golang.org/grpc.WithResolvers(rs ...Builder) grpc.DialOption
			func google.golang.org/grpc/internal/resolver/delegatingresolver.New(target Target, cc ClientConn, opts BuildOptions, targetResolverBuilder Builder, targetResolutionEnabled bool) (Resolver, error)

	 type BuildOptions (struct)
		BuildOptions includes additional information for the builder to create
		the resolver.

		Fields (total 6, all are exported)
			Authority string
				Authority is the effective authority of the clientconn for which the
				resolver is built.

			CredsBundle credentials.Bundle
				CredsBundle is the credentials bundle used by the ClientConn for
				communicating with the target gRPC service (set via
				WithCredentialsBundle). In cases where a name resolution service
				requires the same credentials, the resolver may use this field. In most
				cases though, it is not appropriate, and this field may be ignored.

			DialCreds credentials.TransportCredentials
				DialCreds is the transport credentials used by the ClientConn for
				communicating with the target gRPC service (set via
				WithTransportCredentials). In cases where a name resolution service
				requires the same credentials, the resolver may use this field. In most
				cases though, it is not appropriate, and this field may be ignored.

			Dialer func(context.Context, string) (net.Conn, error)
				Dialer is the custom dialer used by the ClientConn for dialling the
				target gRPC service (set via WithDialer). In cases where a name
				resolution service requires the same dialer, the resolver may use this
				field. In most cases though, it is not appropriate, and this field may
				be ignored.

			DisableServiceConfig bool
				DisableServiceConfig indicates whether a resolver implementation should
				fetch service config data.

			MetricsRecorder stats.MetricsRecorder
				MetricsRecorder is the metrics recorder to do recording.

		As Inputs Of (at least 2, both are exported)
			func Builder.Build(target Target, cc ClientConn, opts BuildOptions) (Resolver, error)
			func google.golang.org/grpc/internal/resolver/delegatingresolver.New(target Target, cc ClientConn, opts BuildOptions, targetResolverBuilder Builder, targetResolutionEnabled bool) (Resolver, error)

	 type ClientConn (interface)
		ClientConn contains the callbacks for resolver to notify any updates
		to the gRPC ClientConn.
		
		This interface is to be implemented by gRPC. Users should not need a
		brand new implementation of this interface. For the situations like
		testing, the new implementation should embed this interface. This allows
		gRPC to add new methods to this interface.

		Methods (total 4, all are exported)
			( ClientConn) NewAddress(addresses []Address)
				NewAddress is called by resolver to notify ClientConn a new list
				of resolved addresses.
				The address list should be the complete list of resolved addresses.
				
				Deprecated: Use UpdateState instead.

			( ClientConn) ParseServiceConfig(serviceConfigJSON string) *serviceconfig.ParseResult
				ParseServiceConfig parses the provided service config and returns an
				object that provides the parsed config.

			( ClientConn) ReportError(error)
				ReportError notifies the ClientConn that the Resolver encountered an
				error. The ClientConn then forwards this error to the load balancing
				policy.

			( ClientConn) UpdateState(State) error
				UpdateState updates the state of the ClientConn appropriately.
				
				If an error is returned, the resolver should try to resolve the
				target again. The resolver should use a backoff timer to prevent
				overloading the server with requests. If a resolver is certain that
				reresolving will not change the result, e.g. because it is
				a watch-based resolver, returned errors can be ignored.
				
				If the resolved State is the same as the last reported one, calling
				UpdateState can be omitted.

		Implemented By (at least 2, neither is exported)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			*google.golang.org/grpc.ccResolverWrapper
			*google.golang.org/grpc/internal/resolver/delegatingresolver.wrappingClientConn
		As Inputs Of (at least 2, both are exported)
			func Builder.Build(target Target, cc ClientConn, opts BuildOptions) (Resolver, error)
			func google.golang.org/grpc/internal/resolver/delegatingresolver.New(target Target, cc ClientConn, opts BuildOptions, targetResolverBuilder Builder, targetResolutionEnabled bool) (Resolver, error)

	 type Endpoint (struct)
		An Endpoint is one network endpoint, or server, which may have multiple
		addresses with which it can be accessed.

		Fields (total 2, both are exported)
			Addresses []Address
				Addresses contains a list of addresses used to access this endpoint.

			Attributes *attributes.Attributes
				Attributes contains arbitrary data about this endpoint intended for
				consumption by the LB policy.

		As Outputs Of (at least 3, in which 1 is exported)
			func (*EndpointMap)[T].Keys() []Endpoint
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func google.golang.org/grpc.addressesToEndpoints(addrs []Address) []Endpoint
			func google.golang.org/grpc/balancer/endpointsharding.rotateEndpoints(es []Endpoint) []Endpoint
		As Inputs Of (at least 6, in which 4 are exported)
			func ValidateEndpoints(endpoints []Endpoint) error
			func (*EndpointMap)[T].Delete(e Endpoint)
			func (*EndpointMap)[T].Get(e Endpoint) (value T, ok bool)
			func (*EndpointMap)[T].Set(e Endpoint, value T)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func encodeEndpoint(e Endpoint) endpointMapKey
			func google.golang.org/grpc/balancer/endpointsharding.rotateEndpoints(es []Endpoint) []Endpoint

	 type EndpointMap[T] (struct)

		Type Parameters:
			T: any

		EndpointMap is a map of endpoints to arbitrary values keyed on only the
		unordered set of address strings within an endpoint. This map is not thread
		safe, thus it is unsafe to access concurrently. Must be created via
		NewEndpointMap; do not construct directly.

		Fields (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			endpoints map[endpointMapKey]endpointData[T]
		Methods (total 6, all are exported)
			(*EndpointMap[T]) Delete(e Endpoint)
				Delete removes the specified endpoint from the map.

			(*EndpointMap[T]) Get(e Endpoint) (value T, ok bool)
				Get returns the value for the address in the map, if present.

			(*EndpointMap[T]) Keys() []Endpoint
				Keys returns a slice of all current map keys, as endpoints specifying the
				addresses present in the endpoint keys, in which uniqueness is determined by
				the unordered set of addresses. Thus, endpoint information returned is not
				the full endpoint data (drops duplicated addresses and attributes) but can be
				used for EndpointMap accesses.

			(*EndpointMap[T]) Len() int
				Len returns the number of entries in the map.

			(*EndpointMap[T]) Set(e Endpoint, value T)
				Set updates or adds the value to the address in the map.

			(*EndpointMap[T]) Values() []T
				Values returns a slice of all current map values.

		As Outputs Of (at least one exported)
			func NewEndpointMap[T]() *EndpointMap[T]

	 type ResolveNowOptions (struct)
		ResolveNowOptions includes additional information for ResolveNow.

		As Inputs Of (at least 4, in which 2 are exported)
			func Resolver.ResolveNow(ResolveNowOptions)
			func google.golang.org/grpc/balancer.ClientConn.ResolveNow(ResolveNowOptions)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func google.golang.org/grpc.(*ClientConn).resolveNow(o ResolveNowOptions)
			func google.golang.org/grpc.(*ClientConn).resolveNowLocked(o ResolveNowOptions)

	 type Resolver (interface)
		Resolver watches for the updates on the specified target.
		Updates include address updates and service config updates.

		Methods (total 2, both are exported)
			( Resolver) Close()
				Close closes the resolver.

			( Resolver) ResolveNow(ResolveNowOptions)
				ResolveNow will be called by gRPC to try to resolve the target name
				again. It's just a hint, resolver can ignore this if it's not necessary.
				
				It could be called multiple times concurrently.

		Implemented By (at least 7, none are exported)
			/* 7+ unexporteds ... *//* 7+ unexporteds: */
			*google.golang.org/grpc/internal/balancer/gracefulswitch.balancerWrapper
			*google.golang.org/grpc/internal/resolver/delegatingresolver.delegatingResolver
			 google.golang.org/grpc/internal/resolver/delegatingresolver.nopResolver
			 google.golang.org/grpc/internal/resolver/dns.deadResolver
			*google.golang.org/grpc/internal/resolver/dns.dnsResolver
			*google.golang.org/grpc/internal/resolver/passthrough.passthroughResolver
			*google.golang.org/grpc/internal/resolver/unix.nopResolver
		As Outputs Of (at least 2, both are exported)
			func Builder.Build(target Target, cc ClientConn, opts BuildOptions) (Resolver, error)
			func google.golang.org/grpc/internal/resolver/delegatingresolver.New(target Target, cc ClientConn, opts BuildOptions, targetResolverBuilder Builder, targetResolutionEnabled bool) (Resolver, error)

	 type State (struct)
		State contains the current Resolver state relevant to the ClientConn.

		Fields (total 4, all are exported)
			Addresses []Address
				Addresses is the latest set of resolved addresses for the target.
				
				If a resolver sets Addresses but does not set Endpoints, one Endpoint
				will be created for each Address before the State is passed to the LB
				policy.  The BalancerAttributes of each entry in Addresses will be set
				in Endpoints.Attributes, and be cleared in the Endpoint's Address's
				BalancerAttributes.
				
				Soon, Addresses will be deprecated and replaced fully by Endpoints.

			Attributes *attributes.Attributes
				Attributes contains arbitrary data about the resolver intended for
				consumption by the load balancing policy.

			Endpoints []Endpoint
				Endpoints is the latest set of resolved endpoints for the target.
				
				If a resolver produces a State containing Endpoints but not Addresses,
				it must take care to ensure the LB policies it selects will support
				Endpoints.

			ServiceConfig *serviceconfig.ParseResult
				ServiceConfig contains the result from parsing the latest service
				config.  If it is nil, it indicates no service config is present or the
				resolver does not provide service configs.

		As Outputs Of (at least 3, all are exported)
			func google.golang.org/grpc/balancer/grpclb/state.Set(state State, s *state.State) State
			func google.golang.org/grpc/balancer/pickfirst/pickfirstleaf.EnableHealthListener(state State) State
			func google.golang.org/grpc/internal/resolver.SetConfigSelector(state State, cs resolver.ConfigSelector) State
		As Inputs Of (at least 8, in which 6 are exported)
			func ClientConn.UpdateState(State) error
			func google.golang.org/grpc/balancer/grpclb/state.Get(state State) *state.State
			func google.golang.org/grpc/balancer/grpclb/state.Set(state State, s *state.State) State
			func google.golang.org/grpc/balancer/pickfirst/pickfirstleaf.EnableHealthListener(state State) State
			func google.golang.org/grpc/internal/resolver.GetConfigSelector(state State) resolver.ConfigSelector
			func google.golang.org/grpc/internal/resolver.SetConfigSelector(state State, cs resolver.ConfigSelector) State
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func google.golang.org/grpc.(*ClientConn).updateResolverStateAndUnlock(s State, err error) error
			func google.golang.org/grpc/internal/resolver/delegatingresolver.needsProxyResolver(state *State) bool

	 type Target (struct)
		Target represents a target for gRPC, as specified in:
		https://github.com/grpc/grpc/blob/master/doc/naming.md.
		It is parsed from the target string that gets passed into Dial or DialContext
		by the user. And gRPC passes it to the resolver and the balancer.
		
		If the target follows the naming spec, and the parsed scheme is registered
		with gRPC, we will parse the target string according to the spec. If the
		target does not contain a scheme or if the parsed scheme is not registered
		(i.e. no corresponding resolver available to resolve the endpoint), we will
		apply the default scheme, and will attempt to reparse it.

		Fields (only one, which is exported)
			URL url.URL
				URL contains the parsed dial target with an optional default scheme added
				to it if the original dial target contained no scheme or contained an
				unregistered scheme. Any query params specified in the original dial
				target can be accessed from here.

		Methods (total 2, both are exported)
			( Target) Endpoint() string
				Endpoint retrieves endpoint without leading "/" from either `URL.Path`
				or `URL.Opaque`. The latter is used when the former is empty.

			( Target) String() string
				String returns the canonical string representation of Target.

		Implements (at least 4, in which 2 are exported)
			 Target : expvar.Var
			 Target : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 Target : context.stringer
			 Target : runtime.stringer
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func google.golang.org/grpc.parseTarget(target string) (Target, error)
		As Inputs Of (at least 3, all are exported)
			func AuthorityOverrider.OverrideAuthority(Target) string
			func Builder.Build(target Target, cc ClientConn, opts BuildOptions) (Resolver, error)
			func google.golang.org/grpc/internal/resolver/delegatingresolver.New(target Target, cc ClientConn, opts BuildOptions, targetResolverBuilder Builder, targetResolutionEnabled bool) (Resolver, error)

	/* 4 unexporteds ... *//* 4 unexporteds: */
	 type addressMapEntry[T] (struct)

		Type Parameters:
			T: any

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			addr Address
			value T

	 type addressMapEntryList[T] ([])

		Type Parameters:
			T: any

		Methods (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			( addressMapEntryList[T]) find(addr Address) int
				find returns the index of addr in the addressMapEntry slice, or -1 if not
				present.


	 type endpointData[T] (struct)

		Type Parameters:
			T: any

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			decodedKey Endpoint
				decodedKey stores the original key to avoid decoding when iterating on
				EndpointMap keys.

			value T

	 type endpointMapKey string (basic type)

		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func encodeEndpoint(e Endpoint) endpointMapKey


Package-Level Functions (total 10, in which 8 are exported)

	 func Get(scheme string) Builder
		Get returns the resolver builder registered with the given scheme.
		
		If no builder is register with the scheme, nil will be returned.

	 func GetDefaultScheme() string
		GetDefaultScheme gets the default scheme that will be used by grpc.Dial.  If
		SetDefaultScheme is never called, the default scheme used by grpc.NewClient is "dns" instead.

	 func NewAddressMap() *AddressMap
		NewAddressMap creates a new AddressMapV2[any].
		
		Deprecated: use the generic NewAddressMapV2 constructor instead.

	 func NewAddressMapV2[T]() *AddressMapV2[T]

		Type Parameters:
			T: any

		NewAddressMapV2 creates a new AddressMapV2.

	 func NewEndpointMap[T]() *EndpointMap[T]

		Type Parameters:
			T: any

		NewEndpointMap creates a new EndpointMap.

	 func Register(b Builder)
		Register registers the resolver builder to the resolver map. b.Scheme will
		be used as the scheme registered with this builder. The registry is case
		sensitive, and schemes should not contain any uppercase characters.
		
		NOTE: this function must only be called during initialization time (i.e. in
		an init() function), and is not thread-safe. If multiple Resolvers are
		registered with the same name, the one registered last will take effect.

	 func SetDefaultScheme(scheme string)
		SetDefaultScheme sets the default scheme that will be used. The default
		scheme is initially set to "passthrough".
		
		NOTE: this function must only be called during initialization time (i.e. in
		an init() function), and is not thread-safe. The scheme set last overrides
		previously set values.

	 func ValidateEndpoints(endpoints []Endpoint) error
		ValidateEndpoints validates endpoints from a petiole policy's perspective.
		Petiole policies should call this before calling into their children. See
		[gRPC A61](https://github.com/grpc/proposal/blob/master/A61-IPv4-IPv6-dualstack-backends.md)
		for details.

	/* 2 unexporteds ... *//* 2 unexporteds: */
	 func encodeEndpoint(e Endpoint) endpointMapKey
		encodeEndpoint returns a string that uniquely identifies the unordered set of
		addresses within an endpoint.

	 func toMapKey(addr *Address) Address
Package-Level Variables (total 2, neither is exported)

	/* 2 unexporteds ... *//* 2 unexporteds: */
	  var defaultScheme string
		defaultScheme is the default scheme to use.

	  var m map[string]Builder
		m is a map from scheme to resolver builder.

The pages are generated with Golds v0.7.6. (GOOS=linux GOARCH=amd64)