Deprecated API

Contents

• Interfaces
• Classes
• Exceptions
• Fields
• Methods
• Constructors

Deprecated Interfaces

Interface	Description
io.servicetalk.buffer.api.BufferHolder	This API is going to be removed in future releases with no planned replacement. If it cannot be removed from your application, consider copying it into your codebase.
io.servicetalk.client.api.internal.DefaultPartitionedClientGroup.PartitionedClientFactory	We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
io.servicetalk.client.api.internal.RequestConcurrencyController	This interface is not used by ServiceTalk internal code anymore and will be removed in the future releases. If you depend on it, consider replicating this implementation in your codebase or reach out to us explaining the use-case.
io.servicetalk.client.api.internal.ReservableRequestConcurrencyController	This interface is not used by ServiceTalk internal code anymore and will be removed in the future releases. If you depend on it, consider replicating this implementation in your codebase or reach out to us explaining the use-case.
io.servicetalk.client.api.partition.PartitionAttributes	We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
io.servicetalk.client.api.partition.PartitionAttributesBuilder	We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
io.servicetalk.client.api.partition.PartitionedServiceDiscovererEvent	We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
io.servicetalk.client.api.partition.PartitionMap	We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
io.servicetalk.client.api.partition.PartitionMapFactory	We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
io.servicetalk.concurrent.api.GroupedPublisher.QueueSizeProvider	Use Publisher.groupBy(Function, int) instead.
io.servicetalk.concurrent.api.ScanWithLifetimeMapper	Use ScanLifetimeMapper.
io.servicetalk.concurrent.api.ScanWithMapper	Use ScanMapper.
io.servicetalk.encoding.api.ContentCodec	Use BufferEncoder and BufferDecoder.
io.servicetalk.grpc.api.GrpcRoutes.AllGrpcRoutes	This class is not used starting from version 0.42.0 (see PR#1893), we plan to remove it in future releases. In case you have a use-case, let us know.
io.servicetalk.grpc.api.GrpcSerializationProvider	Serialization is now specified via MethodDescriptor. Compression is configured per route. gRPC framing is internalized in the gRPC implementation.
io.servicetalk.grpc.api.GrpcServiceFilterFactory	gRPC Service Filters will be removed in future release of ServiceTalk. We encourage the use of StreamingHttpServiceFilterFactory and if the access to the decoded payload is necessary, then performing that logic can be done in the particular service implementation. Please use HttpServerBuilder.appendServiceFilter(StreamingHttpServiceFilterFactory) upon the builder obtained using GrpcServerBuilder.initializeHttp(GrpcServerBuilder.HttpInitializer) if HTTP filters are acceptable in your use case.
io.servicetalk.http.api.ClientInvoker	There is no use of this interface in our codebase, it will be removed in the future releases. If you depend on it, consider replicating a similar interface in your codebase.
io.servicetalk.http.api.HttpApiConversions.ServiceAdapterHolder	this interface is not needed anymore and will be removed in a future version with no replacement.
io.servicetalk.http.api.HttpDeserializer	Use HttpDeserializer2 or HttpStreamingDeserializer.
io.servicetalk.http.api.HttpSerializationProvider	Use HttpSerializers, HttpSerializer2, HttpDeserializer2, HttpStreamingSerializer, and HttpStreamingDeserializer.
io.servicetalk.http.api.HttpSerializer	Use HttpSerializer2 or HttpStreamingSerializer.
io.servicetalk.http.api.PartitionedHttpClientBuilder	We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
io.servicetalk.http.api.PartitionHttpClientBuilderConfigurator	Use PartitionedHttpClientBuilder.SingleAddressInitializer.
io.servicetalk.http.netty.RetryingHttpRequesterFilter.DelayedRetry	Use DelayedRetryException instead.
io.servicetalk.http.utils.TimeoutFromRequest	In areas which require TimeoutFromRequest use variants that accept BiFunction<HttpRequestMetaData, TimeSource, Duration>. E.g.: TimeoutHttpRequesterFilter(BiFunction, boolean), TimeoutHttpServiceFilter(BiFunction, boolean) for filters.
io.servicetalk.loadbalancer.RoundRobinLoadBalancerBuilder	use LoadBalancerBuilder interfaces instead.
io.servicetalk.loadbalancer.RoundRobinLoadBalancerBuilderProvider	use the LoadBalancerBuilder implementations along with LoadBalancerBuilderProvider
io.servicetalk.serialization.api.SerializationProvider	General Type serialization is not supported by all serializers. Defer to your specific Serializer implementation.
io.servicetalk.serialization.api.Serializer	Use the following types: Serializer StreamingSerializer Deserializer StreamingDeserializer
io.servicetalk.serialization.api.StreamingDeserializer	Use StreamingDeserializer.
io.servicetalk.serialization.api.StreamingSerializer	Use StreamingSerializer.
io.servicetalk.transport.api.ConnectionAcceptor	use LateConnectionAcceptor instead.
io.servicetalk.transport.api.ConnectionAcceptorFactory	use LateConnectionAcceptor instead.
io.servicetalk.transport.netty.internal.SplittingFlushStrategy.FlushBoundaryProvider	This interface will be removed in the future releases.

Deprecated Classes

Class	Description
io.servicetalk.client.api.internal.DefaultPartitionedClientGroup	We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
io.servicetalk.client.api.internal.IgnoreConsumedEvent	This class is not used by ServiceTalk internal code anymore and will be removed in the future releases. If you depend on it, consider replica ting this implementation in your codebase.
io.servicetalk.client.api.internal.partition.DefaultPartitionAttributesBuilder	We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
io.servicetalk.client.api.internal.partition.PowerSetPartitionMap	We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
io.servicetalk.client.api.internal.partition.PowerSetPartitionMapFactory	We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
io.servicetalk.client.api.internal.RequestConcurrencyControllers	This class is not used by ServiceTalk internal code anymore and will be removed in the future releases. If you depend on it, consider replicating this implementation in your codebase.
io.servicetalk.client.api.internal.ReservableRequestConcurrencyControllers	This class is not used by ServiceTalk internal code anymore and will be removed in the future releases. If you depend on it, consider replicating this implementation in your codebase.
io.servicetalk.concurrent.internal.ArrayUtils	This internal class will be removed in the future releases without a replacement. If you depend on it, consider copying into your codebase.
io.servicetalk.concurrent.internal.ConcurrentTerminalSubscriber	This internal class will be removed in the future releases without a replacement. If you depend on it, consider copying into your codebase.
io.servicetalk.concurrent.internal.LatestValueSubscriber	This class is no longer used by ServiceTalk and will be removed in the future releases. If you depend on it, consider copying into your codebase.
io.servicetalk.data.jackson.JacksonSerializationProvider	Use JacksonSerializerFactory.
io.servicetalk.data.protobuf.ProtobufSerializationProvider	Use ProtobufSerializerFactory.
io.servicetalk.dns.discovery.netty.DefaultDnsServiceDiscovererBuilder	this class will be made package-private in the future, rely on the DnsServiceDiscovererBuilder instead.
io.servicetalk.encoding.api.internal.ContentCodecToBufferDecoder	Use BufferDecoder. This type will be removed along with ContentCodec.
io.servicetalk.encoding.api.internal.ContentCodecToBufferEncoder	Use BufferEncoder. This type will be removed along with ContentCodec.
io.servicetalk.encoding.netty.ContentCodings	Use NettyCompression and NettyBufferEncoders.
io.servicetalk.encoding.netty.ZipContentCodecBuilder	Use ZipCompressionBuilder.
io.servicetalk.grpc.protobuf.ProtoBufSerializationProviderBuilder	The gRPC framing is now built into grpc-netty. This class is no longer necessary and will be removed in a future release. ProtoBufSerializationProviderBuilder.registerMessageType(Class, Parser) is used to add one or more MessageLite message types. Resulting GrpcSerializationProvider from ProtoBufSerializationProviderBuilder.build() will only serialize and deserialize those message types.
io.servicetalk.health.v1.Health.CheckMetadata	This class will be removed in the future in favor of direct usage of GrpcClientMetadata. Deprecation of GrpcMetadata.path() renders this type unnecessary.
io.servicetalk.health.v1.Health.WatchMetadata	This class will be removed in the future in favor of direct usage of GrpcClientMetadata. Deprecation of GrpcMetadata.path() renders this type unnecessary.
io.servicetalk.http.api.ContentCodingHttpRequesterFilter	Use ContentEncodingHttpRequesterFilter.
io.servicetalk.http.api.ContentCodingHttpServiceFilter	Use ContentEncodingHttpServiceFilter.
io.servicetalk.http.api.HttpSerializationProviders	Use HttpSerializers.
io.servicetalk.http.api.StrategyInfluencerChainBuilder	Merge ExecutionStrategy directly instead.
io.servicetalk.http.netty.DefaultHttpLoadBalancerFactory	use DefaultHttpLoadBalancerFactory instead.
io.servicetalk.loadbalancer.DelegatingRoundRobinLoadBalancerBuilder	use DelegatingLoadBalancerBuilder instead.
io.servicetalk.loadbalancer.RoundRobinLoadBalancerFactory	use LoadBalancers to create LoadBalancerFactory instances. RoundRobinLoadBalancerBuilder.
io.servicetalk.loadbalancer.RoundRobinLoadBalancerFactory.Builder	rely on the LoadBalancers.builder(String) instead.
io.servicetalk.loadbalancer.RoundRobinLoadBalancers	use LoadBalancers instead.
io.servicetalk.opentelemetry.http.OpenTelemetryHttpRequestFilter	use OpenTelemetryHttpRequesterFilter instead.
io.servicetalk.opentelemetry.http.OpenTelemetryHttpServerFilter	use OpenTelemetryHttpServiceFilter instead.
io.servicetalk.serialization.api.DefaultSerializer	Use implementations of following types: Serializer StreamingSerializer Deserializer StreamingDeserializer
io.servicetalk.serialization.api.TypeHolder	General Type serialization is not supported by all serializers. Defer to your specific Serializer implementation. For example jackson offers TypeReference which can be used directly.
io.servicetalk.transport.netty.internal.BufferHandler	This API is going to be removed in future releases with no planned replacement. If it cannot be removed from your application, consider copying it into your codebase.
io.servicetalk.transport.netty.internal.DelegatingFlushStrategy	this class will be made package-private in the future releases. If you depend on this code, consider copying it into your codebase.
io.servicetalk.transport.netty.internal.SplittingFlushStrategy	This class will be removed in the future releases.

Deprecated Exceptions

Exceptions	Description
io.servicetalk.client.api.partition.ClosedPartitionException	We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
io.servicetalk.client.api.partition.DuplicateAttributeException	We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
io.servicetalk.client.api.partition.UnknownPartitionException	We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
io.servicetalk.concurrent.internal.QueueFullAndRejectedSubscribeException	This class is no longer used by ServiceTalk and will be removed in the future releases. If you depend on it, consider copying into your codebase.
io.servicetalk.encoding.api.CodecDecodingException	Use BufferEncodingException.
io.servicetalk.encoding.api.CodecEncodingException	Use BufferEncodingException.
io.servicetalk.grpc.api.MessageEncodingException	This exception type was thrown only by ProtoBufSerializationProviderBuilder that was deprecated and will be removed in future releases. Use SerializationException instead that can be thrown by a new implementation.
io.servicetalk.http.netty.ProxyResponseException	Use ProxyConnectResponseException instead
io.servicetalk.serialization.api.SerializationException	Use SerializationException.

Deprecated Fields

Field	Description
io.servicetalk.grpc.api.DefaultGrpcClientMetadata.INSTANCE	Use DefaultGrpcClientMetadata() to create a new instance instead. GrpcClientMetadata contains modifiable GrpcMetadata.requestContext() and GrpcMetadata.responseContext() now. Using this constant there will be no access to the actual context and both mentioned methods will throw UnsupportedOperationException.
io.servicetalk.health.v1.Health.BlockingCheckRpc.PATH	Use Health.BlockingCheckRpc.methodDescriptor().
io.servicetalk.health.v1.Health.BlockingWatchRpc.PATH	Use Health.BlockingWatchRpc.methodDescriptor().
io.servicetalk.health.v1.Health.CheckMetadata.INSTANCE	Use DefaultGrpcClientMetadata.
io.servicetalk.health.v1.Health.CheckRpc.PATH	Use Health.CheckRpc.methodDescriptor().
io.servicetalk.health.v1.Health.WatchMetadata.INSTANCE	Use DefaultGrpcClientMetadata.
io.servicetalk.health.v1.Health.WatchRpc.PATH	Use Health.WatchRpc.methodDescriptor().
io.servicetalk.http.api.HttpContextKeys.HTTP_TARGET_ADDRESS_BEHIND_PROXY	Use TransportObserverConnectionFactoryFilter to configure TransportObserver and then listen ConnectionObserver.onProxyConnect(Object) callback to distinguish between a regular connection and a connection to the secure HTTP proxy tunnel. For clear text HTTP proxies, consider installing a custom client filter that will populate HttpMetaData.context() with a similar key or reach out to the ServiceTalk developers to discuss ideas.
io.servicetalk.http.netty.RetryingHttpRequesterFilter.BackOffPolicy.NO_RETRIES	This will be removed in a future release of ST. Alternative offering here RetryingHttpRequesterFilter.BackOffPolicy.ofNoRetries().
io.servicetalk.http.netty.RetryingHttpRequesterFilter.HttpResponseException.message	Use Throwable.getMessage().
io.servicetalk.http.netty.RetryingHttpRequesterFilter.HttpResponseException.metaData	Use RetryingHttpRequesterFilter.HttpResponseException.metaData().

Deprecated Methods

Method	Description
io.servicetalk.buffer.api.CharSequences.asciiStringIndexOf(CharSequence, char, int)	Use CharSequences.indexOf(CharSequence, char, int).
io.servicetalk.client.api.ConnectionFactory.newConnection(ResolvedAddress, TransportObserver)	Use ConnectionFactory.newConnection(Object, ContextMap, TransportObserver).
io.servicetalk.client.api.ConnectionFactoryFilter.append(ConnectionFactoryFilter<ResolvedAddress, C>)	consider using higher level client builders to append filters.
io.servicetalk.client.api.DelegatingConnectionFactory.newConnection(ResolvedAddress, TransportObserver)
io.servicetalk.client.api.LoadBalancedAddress.newConnection()	Implement and use LoadBalancedAddress.newConnection(ContextMap).
io.servicetalk.client.api.LoadBalancer.selectConnection(Predicate<C>)	Use LoadBalancer.selectConnection(Predicate, ContextMap).
io.servicetalk.client.api.LoadBalancerFactory.newLoadBalancer(Publisher<? extends ServiceDiscovererEvent<ResolvedAddress>>, ConnectionFactory<ResolvedAddress, T>)	Use LoadBalancerFactory.newLoadBalancer(Publisher, ConnectionFactory, String).
io.servicetalk.client.api.LoadBalancerFactory.newLoadBalancer(String, Publisher<? extends Collection<? extends ServiceDiscovererEvent<ResolvedAddress>>>, ConnectionFactory<ResolvedAddress, T>)	Use LoadBalancerFactory.newLoadBalancer(Publisher, ConnectionFactory, String).
io.servicetalk.concurrent.api.AsyncContext.forEachEntry(BiPredicate<ContextMap.Key<?>, Object>)	Use AsyncContext.forEach(BiPredicate)
io.servicetalk.concurrent.api.AsyncContext.putAllFromMap(Map<ContextMap.Key<?>, Object>)	Use AsyncContext.putAll(Map)
io.servicetalk.concurrent.api.AsyncContext.removeAllEntries(Iterable<ContextMap.Key<?>>)	Use AsyncContext.removeAll(Iterable)
io.servicetalk.concurrent.api.Publisher.fromInputStream(InputStream)	Use Publisher.fromInputStream(InputStream, ByteArrayMapper) with ByteArrayMapper.toByteArray().
io.servicetalk.concurrent.api.Publisher.fromInputStream(InputStream, int)	Use Publisher.fromInputStream(InputStream, ByteArrayMapper) with ByteArrayMapper.toByteArray(int).
io.servicetalk.concurrent.api.Publisher.multicastToExactly(int)	Use Publisher.multicast(int).
io.servicetalk.concurrent.api.Publisher.multicastToExactly(int, int)	Use Publisher.multicast(int, int).
io.servicetalk.concurrent.api.Publisher.scanWith(Supplier<? extends ScanWithMapper<? super T, ? extends R>>)	Use Publisher.scanWithMapper(Supplier).
io.servicetalk.concurrent.api.Publisher.scanWithLifetime(Supplier<? extends ScanWithLifetimeMapper<? super T, ? extends R>>)	Use Publisher.scanWithLifetimeMapper(Supplier).
io.servicetalk.concurrent.api.Single.concat(Publisher<? extends T>, boolean)	Use Single.concat(Publisher) or Single.concatDeferSubscribe(Publisher) instead.
io.servicetalk.concurrent.internal.AutoClosableUtils.closeAndReThrowUnchecked(AutoCloseable)	Use AutoClosableUtils.closeAndReThrow(AutoCloseable).
io.servicetalk.data.jackson.jersey.ServiceTalkJacksonSerializerFeature.contextResolverFor(ObjectMapper)	Use ServiceTalkJacksonSerializerFeature.newContextResolver(ObjectMapper).
io.servicetalk.data.jackson.jersey.ServiceTalkJacksonSerializerFeature.contextResolverFor(JacksonSerializationProvider)	Use ServiceTalkJacksonSerializerFeature.newContextResolver(JacksonSerializerFactory).
io.servicetalk.dns.discovery.netty.DefaultDnsServiceDiscovererBuilder.minTTL(int)	Use DefaultDnsServiceDiscovererBuilder.ttl(int, int).
io.servicetalk.dns.discovery.netty.DnsServiceDiscovererObserver.onNewDiscovery(String)	use DnsServiceDiscovererObserver.onNewDiscovery(String, String) instead. To avoid breaking changes, all current implementations must implement both methods. In the next version the default implementation will swap. Then users will be able to keep implementation only for the new method. In the release after, the deprecated method will be removed.
io.servicetalk.encoding.api.Identity.identity()	Use Identity.identityEncoder().
io.servicetalk.encoding.api.internal.HeaderUtils.encodingFor(Collection<ContentCodec>, CharSequence)	Use HeaderUtils.encodingForRaw(List, Function, CharSequence).
io.servicetalk.encoding.api.internal.HeaderUtils.negotiateAcceptedEncoding(CharSequence, List<ContentCodec>)	Use HeaderUtils.negotiateAcceptedEncodingRaw(CharSequence, List, Function).
io.servicetalk.encoding.api.internal.HeaderUtils.negotiateAcceptedEncoding(List<ContentCodec>, List<ContentCodec>)	Use HeaderUtils.negotiateAcceptedEncodingRaw(CharSequence, List, Function).
io.servicetalk.grpc.api.DefaultGrpcClientMetadata.requestEncoding()
io.servicetalk.grpc.api.GrpcClientCallFactory.newBlockingCall(GrpcSerializationProvider, Class<Req>, Class<Resp>)	use GrpcClientCallFactory.newBlockingCall(MethodDescriptor, BufferDecoderGroup).
io.servicetalk.grpc.api.GrpcClientCallFactory.newBlockingRequestStreamingCall(GrpcSerializationProvider, Class<Req>, Class<Resp>)	Use GrpcClientCallFactory.newBlockingRequestStreamingCall(MethodDescriptor, BufferDecoderGroup).
io.servicetalk.grpc.api.GrpcClientCallFactory.newBlockingResponseStreamingCall(GrpcSerializationProvider, Class<Req>, Class<Resp>)	Use GrpcClientCallFactory.newBlockingResponseStreamingCall(MethodDescriptor, BufferDecoderGroup).
io.servicetalk.grpc.api.GrpcClientCallFactory.newBlockingStreamingCall(GrpcSerializationProvider, Class<Req>, Class<Resp>)	Use GrpcClientCallFactory.newBlockingStreamingCall(MethodDescriptor, BufferDecoderGroup).
io.servicetalk.grpc.api.GrpcClientCallFactory.newCall(GrpcSerializationProvider, Class<Req>, Class<Resp>)	Use GrpcClientCallFactory.newCall(MethodDescriptor, BufferDecoderGroup).
io.servicetalk.grpc.api.GrpcClientCallFactory.newRequestStreamingCall(GrpcSerializationProvider, Class<Req>, Class<Resp>)	Use GrpcClientCallFactory.newRequestStreamingCall(MethodDescriptor, BufferDecoderGroup).
io.servicetalk.grpc.api.GrpcClientCallFactory.newResponseStreamingCall(GrpcSerializationProvider, Class<Req>, Class<Resp>)	Use GrpcClientCallFactory.newResponseStreamingCall(MethodDescriptor, BufferDecoderGroup).
io.servicetalk.grpc.api.GrpcClientCallFactory.newStreamingCall(GrpcSerializationProvider, Class<Req>, Class<Resp>)	Use GrpcClientCallFactory.newStreamingCall(MethodDescriptor, BufferDecoderGroup).
io.servicetalk.grpc.api.GrpcClientFactory.supportedMessageCodings()	Use generated code methods targeting List of BufferEncoders and BufferDecoderGroup.
io.servicetalk.grpc.api.GrpcClientFactory.supportedMessageCodings(List<ContentCodec>)	Use generated code methods targeting List of BufferEncoders and BufferDecoderGroup.
io.servicetalk.grpc.api.GrpcClientMetadata.requestEncoding()	Use GrpcClientMetadata.requestCompressor().
io.servicetalk.grpc.api.GrpcExecutionStrategies.offloadNever()	Use GrpcExecutionStrategies.offloadNone() instead.
io.servicetalk.grpc.api.GrpcMetadata.path()	Use MethodDescriptor.httpPath().
io.servicetalk.grpc.api.GrpcRoutes.addBlockingRequestStreamingRoute(String, GrpcExecutionStrategy, GrpcRoutes.BlockingRequestStreamingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)	Use GrpcRoutes.addBlockingRequestStreamingRoute(GrpcExecutionStrategy, MethodDescriptor, BufferDecoderGroup, List, BlockingRequestStreamingRoute).
io.servicetalk.grpc.api.GrpcRoutes.addBlockingRequestStreamingRoute(String, Class<?>, String, GrpcRoutes.BlockingRequestStreamingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)	Use GrpcRoutes.addBlockingStreamingRoute(Class, MethodDescriptor, BufferDecoderGroup, List, BlockingStreamingRoute).
io.servicetalk.grpc.api.GrpcRoutes.addBlockingResponseStreamingRoute(String, GrpcExecutionStrategy, GrpcRoutes.BlockingResponseStreamingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)	Use GrpcRoutes.addBlockingResponseStreamingRoute(GrpcExecutionStrategy, MethodDescriptor, BufferDecoderGroup, List, BlockingResponseStreamingRoute).
io.servicetalk.grpc.api.GrpcRoutes.addBlockingResponseStreamingRoute(String, Class<?>, String, GrpcRoutes.BlockingResponseStreamingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)	Use GrpcRoutes.addBlockingResponseStreamingRoute(Class, MethodDescriptor, BufferDecoderGroup, List, BlockingResponseStreamingRoute).
io.servicetalk.grpc.api.GrpcRoutes.addBlockingRoute(String, GrpcExecutionStrategy, GrpcRoutes.BlockingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)	Use GrpcRoutes.addBlockingRoute(GrpcExecutionStrategy, MethodDescriptor, BufferDecoderGroup, List, BlockingRoute).
io.servicetalk.grpc.api.GrpcRoutes.addBlockingRoute(String, Class<?>, String, GrpcRoutes.BlockingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)	Use GrpcRoutes.addBlockingRoute(Class, MethodDescriptor, BufferDecoderGroup, List, BlockingRoute).
io.servicetalk.grpc.api.GrpcRoutes.addBlockingStreamingRoute(String, GrpcExecutionStrategy, GrpcRoutes.BlockingStreamingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)	Use GrpcRoutes.addBlockingStreamingRoute(GrpcExecutionStrategy, MethodDescriptor, BufferDecoderGroup, List, BlockingStreamingRoute).
io.servicetalk.grpc.api.GrpcRoutes.addBlockingStreamingRoute(String, Class<?>, String, GrpcRoutes.BlockingStreamingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)	Use GrpcRoutes.addBlockingStreamingRoute(Class, MethodDescriptor, BufferDecoderGroup, List, BlockingStreamingRoute).
io.servicetalk.grpc.api.GrpcRoutes.addRequestStreamingRoute(String, GrpcExecutionStrategy, GrpcRoutes.RequestStreamingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)	Use GrpcRoutes.addRequestStreamingRoute(GrpcExecutionStrategy, MethodDescriptor, BufferDecoderGroup, List, RequestStreamingRoute).
io.servicetalk.grpc.api.GrpcRoutes.addRequestStreamingRoute(String, Class<?>, String, GrpcRoutes.RequestStreamingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)	Use GrpcRoutes.addRequestStreamingRoute(Class, MethodDescriptor, BufferDecoderGroup, List, RequestStreamingRoute).
io.servicetalk.grpc.api.GrpcRoutes.addResponseStreamingRoute(String, GrpcExecutionStrategy, GrpcRoutes.ResponseStreamingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)	Use GrpcRoutes.addResponseStreamingRoute(GrpcExecutionStrategy, MethodDescriptor, BufferDecoderGroup, List, ResponseStreamingRoute).
io.servicetalk.grpc.api.GrpcRoutes.addResponseStreamingRoute(String, Class<?>, String, GrpcRoutes.ResponseStreamingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)	Use GrpcRoutes.addResponseStreamingRoute(Class, MethodDescriptor, BufferDecoderGroup, List, ResponseStreamingRoute).
io.servicetalk.grpc.api.GrpcRoutes.addRoute(String, GrpcExecutionStrategy, GrpcRoutes.Route<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)	Use GrpcRoutes.addRoute(GrpcExecutionStrategy, MethodDescriptor, BufferDecoderGroup, List, Route).
io.servicetalk.grpc.api.GrpcRoutes.addRoute(String, Class<?>, String, GrpcRoutes.Route<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)	Use GrpcRoutes.addRoute(Class, MethodDescriptor, BufferDecoderGroup, List, Route).
io.servicetalk.grpc.api.GrpcRoutes.addStreamingRoute(String, GrpcExecutionStrategy, GrpcRoutes.StreamingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)	Use GrpcRoutes.addStreamingRoute(GrpcExecutionStrategy, MethodDescriptor, BufferDecoderGroup, List, StreamingRoute)
io.servicetalk.grpc.api.GrpcRoutes.addStreamingRoute(String, Class<?>, String, GrpcRoutes.StreamingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)	Use GrpcRoutes.addStreamingRoute(Class, MethodDescriptor, BufferDecoderGroup, List, StreamingRoute).
io.servicetalk.grpc.api.GrpcRoutes.BlockingResponseStreamingRoute.handle(GrpcServiceContext, Req, GrpcPayloadWriter<Resp>)	Use GrpcRoutes.BlockingResponseStreamingRoute.handle(GrpcServiceContext, Object, BlockingStreamingGrpcServerResponse). In the next release, this method will have a default implementation but the new overload won't. To avoid breaking API changes, make sure to implement both methods. The release after next will remove this method. This intermediate step is necessary to maintain FunctionalInterface contract that requires to have a single non-default method. Note: if you also use GrpcRoutes.BlockingResponseStreamingRoute.wrap(GrpcRoutes.BlockingResponseStreamingRoute, GracefulAutoCloseable) method, make sure to pass there an implementation of GrpcRoutes.BlockingResponseStreamingRoute that implements both overloads instead of a lambda. Otherwise, the default GrpcRoutes.BlockingResponseStreamingRoute.handle(GrpcServiceContext, Object, BlockingStreamingGrpcServerResponse) implementation will be used.
io.servicetalk.grpc.api.GrpcRoutes.BlockingStreamingRoute.handle(GrpcServiceContext, BlockingIterable<Req>, GrpcPayloadWriter<Resp>)	Use GrpcRoutes.BlockingStreamingRoute.handle(GrpcServiceContext, BlockingIterable, BlockingStreamingGrpcServerResponse). In the next release, this method will have a default implementation but the new overload won't. To avoid breaking API changes, make sure to implement both methods. The release after next will remove this method. This intermediate step is necessary to maintain FunctionalInterface contract that requires to have a single non-default method. Note: if you also use GrpcRoutes.BlockingStreamingRoute.wrap(GrpcRoutes.BlockingStreamingRoute, GracefulAutoCloseable) method, make sure to pass there an implementation of GrpcRoutes.BlockingStreamingRoute that implements both overloads instead of a lambda. Otherwise, the default GrpcRoutes.BlockingStreamingRoute.handle(GrpcServiceContext, BlockingIterable, BlockingStreamingGrpcServerResponse) implementation will be used.
io.servicetalk.grpc.api.GrpcRoutes.newServiceFromRoutes(GrpcRoutes.AllGrpcRoutes)	This method is not used starting from version 0.42.0 (see PR#1893), we plan to remove it in future releases. In case you have a use-case, let us know.
io.servicetalk.grpc.api.GrpcRoutes.registerRoutes(Service)	This method is not used starting from version 0.42.0 (see PR#1893), we plan to remove it in future releases. In case you have a use-case, let us know.
io.servicetalk.grpc.api.GrpcServiceContext.supportedMessageCodings()	Will be removed along with ContentCodec.
io.servicetalk.grpc.api.GrpcStatus.asException()	Use GrpcStatusException(GrpcStatus).
io.servicetalk.grpc.api.GrpcStatus.asException(Supplier<Status>)	Use GrpcStatusException.of(Status).
io.servicetalk.grpc.api.GrpcStatus.cause()	Use GrpcStatusException.fromThrowable(Throwable) to create a GrpcStatusException then Throwable.getCause().
io.servicetalk.grpc.api.GrpcStatus.fromThrowable(Throwable)	Use GrpcStatusException.fromThrowable(Throwable).
io.servicetalk.grpc.api.GrpcStatus.fromThrowableNullable(Throwable)	Use GrpcStatusException.fromThrowable(Throwable).
io.servicetalk.health.v1.Health.BlockingHealthClient.check(Health.CheckMetadata, HealthCheckRequest)	Use Health.BlockingHealthClient.check(GrpcClientMetadata,HealthCheckRequest).
io.servicetalk.health.v1.Health.BlockingHealthClient.watch(Health.WatchMetadata, HealthCheckRequest)	Use Health.BlockingHealthClient.watch(GrpcClientMetadata,HealthCheckRequest).
io.servicetalk.health.v1.Health.BlockingWatchRpc.watch(GrpcServiceContext, HealthCheckRequest, GrpcPayloadWriter<HealthCheckResponse>)	Use Health.BlockingWatchRpc.watch(GrpcServiceContext, HealthCheckRequest, BlockingStreamingGrpcServerResponse). In the next release, this method will have a default implementation but the new overload won't. To avoid breaking API changes, make sure to implement both methods. The release after next will remove this method. This intermediate step is necessary to maintain FunctionalInterface contract that requires to have a single non-default method.
io.servicetalk.health.v1.Health.HealthClient.check(Health.CheckMetadata, HealthCheckRequest)	Use Health.HealthClient.check(GrpcClientMetadata,HealthCheckRequest).
io.servicetalk.health.v1.Health.HealthClient.watch(Health.WatchMetadata, HealthCheckRequest)	Use Health.HealthClient.watch(GrpcClientMetadata,HealthCheckRequest).
io.servicetalk.health.v1.Health.ServiceFactory.Builder.addService(Health.BlockingHealthService)	Use Health.ServiceFactory.Builder.addBlockingService(io.servicetalk.health.v1.Health.BlockingHealthService).
io.servicetalk.health.v1.Health.ServiceFactory.Builder.newServiceFromRoutes(GrpcRoutes.AllGrpcRoutes)
io.servicetalk.health.v1.Health.ServiceFactory.Builder.registerRoutes(Health.HealthService)
io.servicetalk.health.v1.HealthCheckResponse.ServingStatus.valueOf(int)
io.servicetalk.http.api.BlockingStreamingHttpRequest.encoding(ContentCodec)
io.servicetalk.http.api.BlockingStreamingHttpRequest.payloadBody(HttpDeserializer<T>)	Use BlockingStreamingHttpRequest.payloadBody(HttpStreamingDeserializer).
io.servicetalk.http.api.BlockingStreamingHttpRequest.payloadBody(Iterable<T>, HttpSerializer<T>)	Use BlockingStreamingHttpRequest.payloadBody(Iterable, HttpStreamingSerializer).
io.servicetalk.http.api.BlockingStreamingHttpRequest.transform(TrailersTransformer<T, Buffer>)	Use BlockingStreamingHttpRequest.messageBody() and BlockingStreamingHttpRequest.messageBody(HttpMessageBodyIterable).
io.servicetalk.http.api.BlockingStreamingHttpRequest.transformPayloadBody(Function<BlockingIterable<Buffer>, BlockingIterable<T>>, HttpSerializer<T>)	Use BlockingStreamingHttpRequest.payloadBody(HttpStreamingDeserializer) and BlockingStreamingHttpRequest.payloadBody(Iterable, HttpStreamingSerializer).
io.servicetalk.http.api.BlockingStreamingHttpRequest.transformPayloadBody(Function<BlockingIterable<T>, BlockingIterable<R>>, HttpDeserializer<T>, HttpSerializer<R>)	Use BlockingStreamingHttpRequest.payloadBody(HttpStreamingDeserializer) and BlockingStreamingHttpRequest.payloadBody(Iterable, HttpStreamingSerializer).
io.servicetalk.http.api.BlockingStreamingHttpRequest.transformPayloadBody(UnaryOperator<BlockingIterable<Buffer>>)	Use BlockingStreamingHttpRequest.payloadBody() and BlockingStreamingHttpRequest.payloadBody(Iterable).
io.servicetalk.http.api.BlockingStreamingHttpResponse.encoding(ContentCodec)
io.servicetalk.http.api.BlockingStreamingHttpResponse.payloadBody(HttpDeserializer<T>)	Use BlockingStreamingHttpResponse.payloadBody(HttpStreamingDeserializer).
io.servicetalk.http.api.BlockingStreamingHttpResponse.payloadBody(Iterable<T>, HttpSerializer<T>)	Use BlockingStreamingHttpResponse.payloadBody(Iterable, HttpStreamingSerializer).
io.servicetalk.http.api.BlockingStreamingHttpResponse.transform(TrailersTransformer<T, Buffer>)	Use BlockingStreamingHttpResponse.messageBody() and BlockingStreamingHttpResponse.messageBody(HttpMessageBodyIterable).
io.servicetalk.http.api.BlockingStreamingHttpResponse.transformPayloadBody(Function<BlockingIterable<Buffer>, BlockingIterable<T>>, HttpSerializer<T>)	Use BlockingStreamingHttpResponse.payloadBody(HttpStreamingDeserializer) and BlockingStreamingHttpResponse.payloadBody(Iterable, HttpStreamingSerializer).
io.servicetalk.http.api.BlockingStreamingHttpResponse.transformPayloadBody(Function<BlockingIterable<T>, BlockingIterable<R>>, HttpDeserializer<T>, HttpSerializer<R>)	Use BlockingStreamingHttpResponse.payloadBody(HttpStreamingDeserializer) and BlockingStreamingHttpResponse.payloadBody(Iterable, HttpStreamingSerializer).
io.servicetalk.http.api.BlockingStreamingHttpResponse.transformPayloadBody(UnaryOperator<BlockingIterable<Buffer>>)	Use BlockingStreamingHttpResponse.payloadBody() and BlockingStreamingHttpResponse.payloadBody(Iterable).
io.servicetalk.http.api.BlockingStreamingHttpServerResponse.sendMetaData(HttpSerializer<T>)	Use BlockingStreamingHttpServerResponse.sendMetaData(HttpStreamingSerializer).
io.servicetalk.http.api.Http2SettingsBuilder.initialWindowSize(long)	Use Http2SettingsBuilder.initialWindowSize(int).
io.servicetalk.http.api.HttpApiConversions.toBlockingClient(StreamingHttpClient, HttpExecutionStrategyInfluencer)	Use overload with HttpExecutionStrategy rather than HttpExecutionStrategyInfluencer
io.servicetalk.http.api.HttpApiConversions.toBlockingConnection(StreamingHttpConnection, HttpExecutionStrategyInfluencer)	Use overload with HttpExecutionStrategy rather than HttpExecutionStrategyInfluencer
io.servicetalk.http.api.HttpApiConversions.toBlockingStreamingClient(StreamingHttpClient, HttpExecutionStrategyInfluencer)	Use overload with HttpExecutionStrategy rather than HttpExecutionStrategyInfluencer
io.servicetalk.http.api.HttpApiConversions.toBlockingStreamingConnection(StreamingHttpConnection, HttpExecutionStrategyInfluencer)	Use overload with HttpExecutionStrategy rather than HttpExecutionStrategyInfluencer
io.servicetalk.http.api.HttpApiConversions.toClient(StreamingHttpClient, HttpExecutionStrategyInfluencer)	Use overload with HttpExecutionStrategy rather than HttpExecutionStrategyInfluencer
io.servicetalk.http.api.HttpApiConversions.toConnection(StreamingHttpConnection, HttpExecutionStrategyInfluencer)	Use overload with HttpExecutionStrategy rather than HttpExecutionStrategyInfluencer
io.servicetalk.http.api.HttpApiConversions.toReservedBlockingConnection(ReservedStreamingHttpConnection, HttpExecutionStrategyInfluencer)	Use overload with HttpExecutionStrategy rather than HttpExecutionStrategyInfluencer
io.servicetalk.http.api.HttpApiConversions.toReservedBlockingStreamingConnection(ReservedStreamingHttpConnection, HttpExecutionStrategyInfluencer)	Use overload with HttpExecutionStrategy rather than HttpExecutionStrategyInfluencer
io.servicetalk.http.api.HttpApiConversions.toReservedConnection(ReservedStreamingHttpConnection, HttpExecutionStrategyInfluencer)	Use overload with HttpExecutionStrategy rather than HttpExecutionStrategyInfluencer
io.servicetalk.http.api.HttpApiConversions.toStreamingHttpService(BlockingHttpService, HttpExecutionStrategy)	Use HttpApiConversions.toStreamingHttpService(HttpExecutionStrategy, BlockingHttpService) instead.
io.servicetalk.http.api.HttpApiConversions.toStreamingHttpService(BlockingHttpService, HttpExecutionStrategyInfluencer)	Use HttpApiConversions.toStreamingHttpService(HttpExecutionStrategy, BlockingHttpService) instead.
io.servicetalk.http.api.HttpApiConversions.toStreamingHttpService(BlockingStreamingHttpService, HttpExecutionStrategy)	use HttpApiConversions.toStreamingHttpService(HttpExecutionStrategy, BlockingStreamingHttpService) instead.
io.servicetalk.http.api.HttpApiConversions.toStreamingHttpService(BlockingStreamingHttpService, HttpExecutionStrategyInfluencer)	Use HttpApiConversions.toStreamingHttpService(HttpExecutionStrategy, BlockingStreamingHttpService) instead.
io.servicetalk.http.api.HttpApiConversions.toStreamingHttpService(HttpService, HttpExecutionStrategy)	use HttpApiConversions.toStreamingHttpService(HttpExecutionStrategy, HttpService) instead.
io.servicetalk.http.api.HttpApiConversions.toStreamingHttpService(HttpService, HttpExecutionStrategyInfluencer)	Use HttpApiConversions.toStreamingHttpService(HttpExecutionStrategy, HttpService) instead.
io.servicetalk.http.api.HttpExecutionStrategies.offloadNever()	Use HttpExecutionStrategies.offloadNone() instead.
io.servicetalk.http.api.HttpExecutionStrategyInfluencer.defaultStreamingInfluencer()	This method is not useful anymore and will be removed in future releases.
io.servicetalk.http.api.HttpExecutionStrategyInfluencer.influenceStrategy(HttpExecutionStrategy)	Implement HttpExecutionStrategyInfluencer.requiredOffloads() instead.
io.servicetalk.http.api.HttpLoadBalancerFactory.toLoadBalancedConnection(FilterableStreamingHttpConnection)	Implement and use HttpLoadBalancerFactory.toLoadBalancedConnection(FilterableStreamingHttpConnection, ReservableRequestConcurrencyController, ContextMap)
io.servicetalk.http.api.HttpMetaData.encoding()	Use HttpRequestMetaData.contentEncoding() for requests and ContentEncodingHttpServiceFilter for responses. An example can be found here.
io.servicetalk.http.api.HttpMetaData.encoding(ContentCodec)	Use HttpRequestMetaData.contentEncoding(BufferEncoder) for requests and ContentEncodingHttpServiceFilter for responses. An example can be found here.
io.servicetalk.http.api.HttpProviders.MultiAddressHttpClientBuilderProvider.newBuilder(MultiAddressHttpClientBuilder<U, R>)	Use HttpProviders.MultiAddressHttpClientBuilderProvider.newBuilder(String, MultiAddressHttpClientBuilder). To avoid breaking changes, all current implementations must implement both methods. In the next version the default implementation will swap. Then users will be able to keep implementation only for the new method. In the release after, the deprecated method will be removed.
io.servicetalk.http.api.HttpRequest.encoding(ContentCodec)
io.servicetalk.http.api.HttpRequest.payloadBody(HttpDeserializer<T>)	Use HttpRequest.payloadBody(HttpDeserializer2).
io.servicetalk.http.api.HttpRequest.payloadBody(T, HttpSerializer<T>)	Use HttpRequest.payloadBody(Object, HttpSerializer2).
io.servicetalk.http.api.HttpResponse.payloadBody(HttpDeserializer<T>)	Use HttpResponse.payloadBody(HttpDeserializer2).
io.servicetalk.http.api.HttpResponse.payloadBody(T, HttpSerializer<T>)	Use HttpResponse.payloadBody(Object, HttpSerializer2).
io.servicetalk.http.api.HttpSerializationProviders.formUrlEncodedDeserializer()	Use HttpSerializers.formUrlEncodedSerializer().
io.servicetalk.http.api.HttpSerializationProviders.formUrlEncodedDeserializer(Charset)	Use HttpSerializers.formUrlEncodedSerializer(Charset).
io.servicetalk.http.api.HttpSerializationProviders.formUrlEncodedDeserializer(Charset, Predicate<HttpHeaders>)	Use HttpSerializers.formUrlEncodedSerializer(Charset).
io.servicetalk.http.api.HttpSerializationProviders.formUrlEncodedSerializer()	Use HttpSerializers.formUrlEncodedSerializer().
io.servicetalk.http.api.HttpSerializationProviders.formUrlEncodedSerializer(Charset)	Use HttpSerializers.formUrlEncodedSerializer(Charset).
io.servicetalk.http.api.HttpSerializationProviders.formUrlEncodedSerializer(Charset, Consumer<HttpHeaders>)	Use HttpSerializers.formUrlEncodedSerializer(Charset).
io.servicetalk.http.api.HttpSerializationProviders.jsonSerializer(SerializationProvider)	Use HttpSerializers.jsonSerializer(SerializerDeserializer) or HttpSerializers.jsonStreamingSerializer(StreamingSerializerDeserializer).
io.servicetalk.http.api.HttpSerializationProviders.jsonSerializer(Serializer)	Use HttpSerializers.jsonSerializer(SerializerDeserializer) or HttpSerializers.jsonStreamingSerializer(StreamingSerializerDeserializer).
io.servicetalk.http.api.HttpSerializationProviders.serializationProvider(SerializationProvider, Consumer<HttpHeaders>, Predicate<HttpHeaders>)	Use HttpSerializers, HttpSerializer2, HttpDeserializer2, HttpStreamingSerializer, and HttpStreamingDeserializer.
io.servicetalk.http.api.HttpSerializationProviders.serializationProvider(Serializer, Consumer<HttpHeaders>, Predicate<HttpHeaders>)	Use HttpSerializers, HttpSerializer2, HttpDeserializer2, HttpStreamingSerializer, and HttpStreamingDeserializer.
io.servicetalk.http.api.HttpSerializationProviders.textDeserializer()	Use HttpSerializers.textSerializerUtf8() for aggregated. For streaming, use one of the following: HttpSerializers.appSerializerUtf8FixLen() HttpSerializers.appSerializerAsciiVarLen() Aggregate the payload (e.g. StreamingHttpRequest.toRequest()) and use HttpSerializers.textSerializer(Charset) if your payload is text HttpSerializers.streamingSerializer(StreamingSerializerDeserializer, Consumer, Predicate) targeted at your HttpHeaderNames.CONTENT_TYPE
io.servicetalk.http.api.HttpSerializationProviders.textDeserializer(Charset)	Use HttpSerializers.textSerializer(Charset) for aggregated. For streaming, use one of the following: HttpSerializers.appSerializerUtf8FixLen() HttpSerializers.appSerializerAsciiVarLen() Aggregate the payload (e.g. StreamingHttpRequest.toRequest()) and use HttpSerializers.textSerializer(Charset) if your payload is text HttpSerializers.streamingSerializer(StreamingSerializerDeserializer, Consumer, Predicate) targeted at your HttpHeaderNames.CONTENT_TYPE
io.servicetalk.http.api.HttpSerializationProviders.textDeserializer(Charset, Predicate<HttpHeaders>)	Use HttpSerializers.textSerializer(Charset) for aggregated. For streaming, use one of the following: HttpSerializers.appSerializerUtf8FixLen() HttpSerializers.appSerializerAsciiVarLen() Aggregate the payload (e.g. StreamingHttpRequest.toRequest()) and use HttpSerializers.textSerializer(Charset) if your payload is text HttpSerializers.streamingSerializer(StreamingSerializerDeserializer, Consumer, Predicate) targeted at your HttpHeaderNames.CONTENT_TYPE
io.servicetalk.http.api.HttpSerializationProviders.textSerializer()	Use HttpSerializers.textSerializerUtf8() for aggregated. For streaming, use one of the following: HttpSerializers.appSerializerUtf8FixLen() HttpSerializers.appSerializerAsciiVarLen() HttpSerializers.stringStreamingSerializer(Charset, Consumer)
io.servicetalk.http.api.HttpSerializationProviders.textSerializer(Charset)	Use HttpSerializers.textSerializer(Charset) for aggregated. For streaming, use one of the following: HttpSerializers.appSerializerUtf8FixLen() HttpSerializers.appSerializerAsciiVarLen() HttpSerializers.stringStreamingSerializer(Charset, Consumer)
io.servicetalk.http.api.HttpSerializationProviders.textSerializer(Charset, Consumer<HttpHeaders>)	Use HttpSerializers.textSerializer(Charset) for aggregated. For streaming, use one of the following: HttpSerializers.appSerializerUtf8FixLen() HttpSerializers.appSerializerAsciiVarLen() HttpSerializers.stringStreamingSerializer(Charset, Consumer)
io.servicetalk.http.api.HttpServerBuilder.appendConnectionAcceptorFilter(ConnectionAcceptorFactory)	use HttpServerBuilder.appendLateConnectionAcceptor(LateConnectionAcceptor) instead.
io.servicetalk.http.api.SingleAddressHttpClientBuilder.proxyAddress(U)	Use SingleAddressHttpClientBuilder.proxyConfig(ProxyConfig) with ProxyConfig.forAddress(Object).
io.servicetalk.http.api.StreamingHttpRequest.encoding(ContentCodec)
io.servicetalk.http.api.StreamingHttpRequest.payloadBody(Publisher<T>, HttpSerializer<T>)	Use StreamingHttpRequest.payloadBody(Publisher, HttpStreamingSerializer).
io.servicetalk.http.api.StreamingHttpRequest.payloadBody(HttpDeserializer<T>)	Use StreamingHttpRequest.payloadBody(HttpStreamingDeserializer).
io.servicetalk.http.api.StreamingHttpRequest.transformPayloadBody(Function<Publisher<Buffer>, Publisher<T>>, HttpSerializer<T>)	Use StreamingHttpRequest.transformPayloadBody(Function, HttpStreamingSerializer).
io.servicetalk.http.api.StreamingHttpRequest.transformPayloadBody(Function<Publisher<T>, Publisher<R>>, HttpDeserializer<T>, HttpSerializer<R>)	Use StreamingHttpRequest.transformPayloadBody(Function, HttpStreamingDeserializer, HttpStreamingSerializer).
io.servicetalk.http.api.StreamingHttpResponse.encoding(ContentCodec)
io.servicetalk.http.api.StreamingHttpResponse.payloadBody(Publisher<T>, HttpSerializer<T>)	Use StreamingHttpResponse.payloadBody(Publisher, HttpStreamingSerializer).
io.servicetalk.http.api.StreamingHttpResponse.payloadBody(HttpDeserializer<T>)	Use StreamingHttpResponse.payloadBody(HttpStreamingDeserializer).
io.servicetalk.http.api.StreamingHttpResponse.transformPayloadBody(Function<Publisher<Buffer>, Publisher<T>>, HttpSerializer<T>)	Use StreamingHttpResponse.transformPayloadBody(Function, HttpStreamingSerializer).
io.servicetalk.http.api.StreamingHttpResponse.transformPayloadBody(Function<Publisher<T>, Publisher<R>>, HttpDeserializer<T>, HttpSerializer<R>)	Use StreamingHttpResponse.transformPayloadBody(Function, HttpStreamingDeserializer, HttpStreamingSerializer).
io.servicetalk.http.netty.DefaultHttpLoadBalancerFactory.Builder.fromDefaults()	use DefaultHttpLoadBalancerFactory and wrap the raw load balancer factory you're interested in using.
io.servicetalk.http.netty.HttpClients.forMultiAddressUrl(ServiceDiscoverer<HostAndPort, InetSocketAddress, ServiceDiscovererEvent<InetSocketAddress>>)	Use HttpClients.forMultiAddressUrl() to create MultiAddressHttpClientBuilder, then use MultiAddressHttpClientBuilder.initializer(SingleAddressInitializer) to override ServiceDiscoverer using SingleAddressHttpClientBuilder.serviceDiscoverer(ServiceDiscoverer) for all or some of the internal clients.
io.servicetalk.http.netty.HttpClients.forPartitionedAddress(ServiceDiscoverer<U, R, PartitionedServiceDiscovererEvent<R>>, U, Function<HttpRequestMetaData, PartitionAttributesBuilder>)	We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
io.servicetalk.http.netty.RetryingHttpRequesterFilter.BackOffPolicy.ofImmediate()	Use RetryingHttpRequesterFilter.BackOffPolicy.ofImmediateBounded().
io.servicetalk.http.netty.RetryingHttpRequesterFilter.Builder.retryDelayedRetries(BiFunction<HttpRequestMetaData, RetryingHttpRequesterFilter.DelayedRetry, RetryingHttpRequesterFilter.BackOffPolicy>)	Use RetryingHttpRequesterFilter.Builder.retryDelayedRetryExceptions(BiFunction) instead.
io.servicetalk.http.utils.TimeoutFromRequest.toTimeoutFromRequest(Function<HttpRequestMetaData, Duration>, HttpExecutionStrategy)	In areas which require TimeoutFromRequest use variants that accept BiFunction<HttpRequestMetaData, TimeSource, Duration>. E.g.: TimeoutHttpRequesterFilter(BiFunction, boolean), TimeoutHttpServiceFilter(BiFunction, boolean) for filters. Note that passed BiFunction should never block.
io.servicetalk.loadbalancer.RoundRobinLoadBalancerFactory.Builder.healthCheckInterval(Duration)	Use RoundRobinLoadBalancerFactory.Builder.healthCheckInterval(Duration, Duration).
io.servicetalk.loadbalancer.RoundRobinLoadBalancerFactory.newLoadBalancer(String, Publisher<? extends Collection<? extends ServiceDiscovererEvent<ResolvedAddress>>>, ConnectionFactory<ResolvedAddress, T>)
io.servicetalk.loadbalancer.RoundRobinLoadBalancers.builder(String)	use {#LoadBalancers} constructors instead.
io.servicetalk.serialization.api.Serializer.deserialize(Publisher<Buffer>, TypeHolder<T>)	Use StreamingDeserializer.deserialize(Publisher, BufferAllocator).
io.servicetalk.serialization.api.Serializer.deserialize(Publisher<Buffer>, Class<T>)	Use StreamingDeserializer.deserialize(Publisher, BufferAllocator).
io.servicetalk.serialization.api.Serializer.deserialize(BlockingIterable<Buffer>, TypeHolder<T>)	Use StreamingDeserializer.deserialize(Iterable, BufferAllocator).
io.servicetalk.serialization.api.Serializer.deserialize(BlockingIterable<Buffer>, Class<T>)	Use StreamingDeserializer.deserialize(Iterable, BufferAllocator).
io.servicetalk.serialization.api.Serializer.deserialize(Iterable<Buffer>, TypeHolder<T>)	Use StreamingDeserializer.deserialize(Iterable, BufferAllocator).
io.servicetalk.serialization.api.Serializer.deserialize(Iterable<Buffer>, Class<T>)	Use StreamingDeserializer.deserialize(Iterable, BufferAllocator).
io.servicetalk.serialization.api.Serializer.deserializeAggregated(Buffer, TypeHolder<T>)	Use StreamingDeserializer that understands your protocol's framing.
io.servicetalk.serialization.api.Serializer.deserializeAggregated(Buffer, Class<T>)	Use StreamingDeserializer that understands your protocol's framing.
io.servicetalk.serialization.api.Serializer.deserializeAggregatedSingle(Buffer, TypeHolder<T>)	Use Deserializer.
io.servicetalk.serialization.api.Serializer.deserializeAggregatedSingle(Buffer, Class<T>)	Use Deserializer.
io.servicetalk.serialization.api.Serializer.serialize(Publisher<T>, BufferAllocator, TypeHolder<T>)	Use StreamingSerializer.serialize(Publisher, BufferAllocator).
io.servicetalk.serialization.api.Serializer.serialize(Publisher<T>, BufferAllocator, TypeHolder<T>, IntUnaryOperator)	Use StreamingSerializer.serialize(Publisher, BufferAllocator).
io.servicetalk.serialization.api.Serializer.serialize(Publisher<T>, BufferAllocator, Class<T>)	Use StreamingSerializer.serialize(Publisher, BufferAllocator).
io.servicetalk.serialization.api.Serializer.serialize(Publisher<T>, BufferAllocator, Class<T>, IntUnaryOperator)	Use StreamingSerializer.serialize(Publisher, BufferAllocator).
io.servicetalk.serialization.api.Serializer.serialize(BlockingIterable<T>, BufferAllocator, TypeHolder<T>)	Use StreamingSerializer.serialize(Iterable, BufferAllocator).
io.servicetalk.serialization.api.Serializer.serialize(BlockingIterable<T>, BufferAllocator, TypeHolder<T>, IntUnaryOperator)	Use StreamingSerializer.serialize(Iterable, BufferAllocator).
io.servicetalk.serialization.api.Serializer.serialize(BlockingIterable<T>, BufferAllocator, Class<T>)	Use StreamingSerializer.serialize(Iterable, BufferAllocator).
io.servicetalk.serialization.api.Serializer.serialize(BlockingIterable<T>, BufferAllocator, Class<T>, IntUnaryOperator)	Use StreamingSerializer.serialize(Iterable, BufferAllocator).
io.servicetalk.serialization.api.Serializer.serialize(Iterable<T>, BufferAllocator, TypeHolder<T>)	Use StreamingSerializer.serialize(Iterable, BufferAllocator).
io.servicetalk.serialization.api.Serializer.serialize(Iterable<T>, BufferAllocator, TypeHolder<T>, IntUnaryOperator)	Use StreamingSerializer.serialize(Iterable, BufferAllocator).
io.servicetalk.serialization.api.Serializer.serialize(Iterable<T>, BufferAllocator, Class<T>)	Use StreamingSerializer.serialize(Iterable, BufferAllocator).
io.servicetalk.serialization.api.Serializer.serialize(Iterable<T>, BufferAllocator, Class<T>, IntUnaryOperator)	Use StreamingSerializer.serialize(Iterable, BufferAllocator).
io.servicetalk.serialization.api.Serializer.serialize(T, Buffer)	Use Serializer
io.servicetalk.serialization.api.Serializer.serialize(T, BufferAllocator)	Use Serializer.serialize(Object, BufferAllocator).
io.servicetalk.serialization.api.Serializer.serialize(T, BufferAllocator, int)	Use Serializer.serialize(Object, BufferAllocator).
io.servicetalk.serialization.api.StreamingDeserializer.deserialize(Buffer)	Use StreamingDeserializer that understands your protocol's framing.
io.servicetalk.serialization.api.StreamingDeserializer.deserialize(BlockingIterable<Buffer>)	Use StreamingDeserializer.deserialize(Iterable, BufferAllocator).
io.servicetalk.serialization.api.StreamingDeserializer.deserialize(Iterable<Buffer>)	Use StreamingDeserializer.deserialize(Iterable, BufferAllocator).
io.servicetalk.serialization.api.StreamingSerializer.serialize(Object, Buffer)	Use StreamingSerializer.
io.servicetalk.tcp.netty.internal.TcpServerBinder.bind(SocketAddress, ReadOnlyTcpServerConfig, boolean, ExecutionContext<?>, InfluencerConnectionAcceptor, BiFunction<Channel, ConnectionObserver, Single<CC>>, Consumer<CC>)	use the bind method with early and late acceptors instead.
io.servicetalk.transport.api.ConnectionObserver.onSecurityHandshake()	use ConnectionObserver.onSecurityHandshake(SslConfig)
io.servicetalk.transport.api.ConnectionObserver.onTransportHandshakeComplete()	Use ConnectionObserver.onTransportHandshakeComplete(ConnectionInfo)
io.servicetalk.transport.api.ConnectionObserver.ReadObserver.itemRead()	Use ConnectionObserver.ReadObserver.itemRead(Object)
io.servicetalk.transport.api.ConnectionObserver.WriteObserver.itemReceived()	Use {ConnectionObserver.WriteObserver.itemReceived(Object)}
io.servicetalk.transport.api.ConnectionObserver.WriteObserver.itemWritten()	Use ConnectionObserver.WriteObserver.itemWritten(Object)
io.servicetalk.transport.api.EarlyConnectionAcceptor.accept(ConnectionInfo)	Implement EarlyConnectionAcceptor.accept(ConnectionContext) instead
io.servicetalk.transport.api.LateConnectionAcceptor.accept(ConnectionInfo)	Implement LateConnectionAcceptor.accept(ConnectionContext) instead
io.servicetalk.transport.api.TransportObserver.onNewConnection()	Use TransportObserver.onNewConnection(Object, Object)
io.servicetalk.transport.netty.internal.DefaultNettyConnection.initChannel(Channel, BufferAllocator, Executor, IoExecutor, CloseHandler, FlushStrategy, long, SslConfig, ChannelInitializer, ExecutionStrategy, ConnectionInfo.Protocol, ConnectionObserver, boolean, Predicate<Object>)	Use #initChannel(Channel, ExecutionContext, CloseHandler, FlushStrategy, long, SslConfig, ChannelInitializer, Protocol, ConnectionObserver, boolean, Predicate).
io.servicetalk.transport.netty.internal.DefaultNettyConnection.initChannel(Channel, BufferAllocator, Executor, IoExecutor, CloseHandler, FlushStrategy, Long, ChannelInitializer, ExecutionStrategy, ConnectionInfo.Protocol, ConnectionObserver, boolean)	Use #initChannel(Channel, ExecutionContext, CloseHandler, FlushStrategy, long, SslConfig, ChannelInitializer, Protocol, ConnectionObserver, boolean, Predicate).
io.servicetalk.transport.netty.internal.DefaultNettyConnection.initChannel(Channel, BufferAllocator, Executor, IoExecutor, CloseHandler, FlushStrategy, Long, ChannelInitializer, ExecutionStrategy, ConnectionInfo.Protocol, ConnectionObserver, boolean, Predicate<Object>)	Use #initChannel(Channel, ExecutionContext, CloseHandler, FlushStrategy, long, SslConfig, ChannelInitializer, Protocol, ConnectionObserver, boolean, Predicate).
io.servicetalk.transport.netty.internal.DefaultNettyConnection.initChildChannel(Channel, ExecutionContext<?>, CloseHandler, FlushStrategy, long, ConnectionInfo.Protocol, SslConfig, SSLSession, ChannelConfig, ConnectionObserver.StreamObserver, boolean, Predicate<Object>, UnaryOperator<Throwable>)	Use #initChildChannel(Channel, ConnectionContext, CloseHandler, FlushStrategy, long, Protocol, ChannelConfig, StreamObserver, boolean, Predicate, UnaryOperator).
io.servicetalk.transport.netty.internal.DefaultNettyConnection.initChildChannel(Channel, ExecutionContext<?>, CloseHandler, FlushStrategy, Long, ConnectionInfo.Protocol, SSLSession, ChannelConfig, ConnectionObserver.StreamObserver, boolean, Predicate<Object>, UnaryOperator<Throwable>)	Use #initChildChannel(Channel, ConnectionContext, CloseHandler, FlushStrategy, long, Protocol, ChannelConfig, StreamObserver, boolean, Predicate, UnaryOperator).
io.servicetalk.transport.netty.internal.DefaultNettyConnection.initChildChannel(Channel, ExecutionContext<?>, CloseHandler, FlushStrategy, Long, ConnectionInfo.Protocol, SSLSession, ChannelConfig, ConnectionObserver.StreamObserver, boolean, UnaryOperator<Throwable>)	Use #initChildChannel(Channel, ConnectionContext, CloseHandler, FlushStrategy, long, Protocol, ChannelConfig, StreamObserver, boolean, Predicate, UnaryOperator).
io.servicetalk.transport.netty.internal.NettyIoExecutor.asExecutor()	IoExecutor now implements Executor so this method is redundant.
io.servicetalk.transport.netty.internal.NettyIoExecutors.fromNettyEventLoop(EventLoop)	Use NettyIoExecutors.fromNettyEventLoop(EventLoop, boolean).
io.servicetalk.transport.netty.internal.NettyIoExecutors.fromNettyEventLoopGroup(EventLoopGroup)	Use NettyIoExecutors.fromNettyEventLoopGroup(EventLoopGroup, boolean).
io.servicetalk.transport.netty.internal.NettyIoExecutors.toNettyIoExecutor(IoExecutor)	Use EventLoopAwareNettyIoExecutors.toEventLoopAwareNettyIoExecutor(IoExecutor).
io.servicetalk.transport.netty.internal.NettyPipelineSslUtils.extractSslSessionAndReport(ChannelPipeline, SslHandshakeCompletionEvent, Consumer<Throwable>, boolean)	Use NettyPipelineSslUtils.extractSslSession(ChannelPipeline, SslHandshakeCompletionEvent, Consumer) instead, reporting to ConnectionObserver.SecurityHandshakeObserver is handled automatically for all SslHandlers initialized by SslClientChannelInitializer or SslServerChannelInitializer.
io.servicetalk.transport.netty.internal.NettyPipelineSslUtils.extractSslSessionAndReport(SslConfig, ChannelPipeline, ConnectionObserver)	Use NettyPipelineSslUtils.extractSslSession(SslConfig, ChannelPipeline) instead, reporting to ConnectionObserver.SecurityHandshakeObserver is handled automatically for all SslHandlers initialized by SslClientChannelInitializer or SslServerChannelInitializer
io.servicetalk.transport.netty.internal.NettyPipelineSslUtils.isSslEnabled(ChannelPipeline)	not required anymore, will be removed in the future releases, see NettyPipelineSslUtils.extractSslSessionAndReport(SslConfig, ChannelPipeline, ConnectionObserver) for an alternative approach
io.servicetalk.utils.internal.PlatformDependent.hasUnsafe()	This method is not used by internal ServiceTalk code anymore and will be removed in future releases.
io.servicetalk.utils.internal.PlatformDependent.throwException(Throwable)	Use ThrowableUtils.throwException(Throwable).

Deprecated Constructors

Constructor	Description
io.servicetalk.dns.discovery.netty.DefaultDnsServiceDiscovererBuilder()	use DnsServiceDiscoverers.builder(String) instead.
io.servicetalk.grpc.api.DefaultGrpcClientMetadata(String)	Use DefaultGrpcClientMetadata().
io.servicetalk.grpc.api.DefaultGrpcClientMetadata(String, ContentCodec)	Use DefaultGrpcClientMetadata(BufferEncoder)
io.servicetalk.grpc.api.DefaultGrpcClientMetadata(String, ContentCodec, Duration)	Use DefaultGrpcClientMetadata(BufferEncoder, Duration).
io.servicetalk.grpc.api.DefaultGrpcClientMetadata(String, GrpcClientMetadata)	Use DefaultGrpcClientMetadata(DefaultGrpcClientMetadata).
io.servicetalk.grpc.api.DefaultGrpcClientMetadata(String, GrpcExecutionStrategy)	Use DefaultGrpcClientMetadata(GrpcExecutionStrategy, BufferEncoder).
io.servicetalk.grpc.api.DefaultGrpcClientMetadata(String, GrpcExecutionStrategy, ContentCodec)	Use DefaultGrpcClientMetadata(GrpcExecutionStrategy, BufferEncoder).
io.servicetalk.grpc.api.DefaultGrpcClientMetadata(String, GrpcExecutionStrategy, ContentCodec, Duration)	Use DefaultGrpcClientMetadata(GrpcExecutionStrategy, BufferEncoder, Duration).
io.servicetalk.grpc.api.DefaultGrpcClientMetadata(String, GrpcExecutionStrategy, Duration)	Use DefaultGrpcClientMetadata(GrpcExecutionStrategy, BufferEncoder, Duration).
io.servicetalk.grpc.api.DefaultGrpcClientMetadata(String, Duration)	Use DefaultGrpcClientMetadata(BufferEncoder, Duration).
io.servicetalk.grpc.api.DefaultGrpcClientMetadata(String, Supplier<ContextMap>, Supplier<ContextMap>, GrpcExecutionStrategy, ContentCodec, Duration)
io.servicetalk.grpc.api.GrpcRoutes(RouteExecutionStrategyFactory<GrpcExecutionStrategy>)	this constructor is not needed anymore, use GrpcRoutes() instead.
io.servicetalk.grpc.api.GrpcStatus(GrpcStatusCode, Throwable)	Use GrpcStatusException if there is a Throwable cause.
io.servicetalk.grpc.api.GrpcStatus(GrpcStatusCode, Throwable, CharSequence)	Use GrpcStatusException if there is a cause or GrpcStatus(GrpcStatusCode, String).
io.servicetalk.health.v1.Health.ServiceFactory(Health.BlockingHealthService, RouteExecutionStrategyFactory<GrpcExecutionStrategy>)	Use Builder() and set the custom strategy on Health.ServiceFactory.Builder.routeExecutionStrategyFactory(RouteExecutionStrategyFactory) instead.
io.servicetalk.health.v1.Health.ServiceFactory(Health.BlockingHealthService, RouteExecutionStrategyFactory<GrpcExecutionStrategy>, List<ContentCodec>)	Use Builder(RouteExecutionStrategyFactory), Health.ServiceFactory.Builder.bufferDecoderGroup(BufferDecoderGroup), and Health.ServiceFactory.Builder.bufferEncoders(List).
io.servicetalk.health.v1.Health.ServiceFactory(Health.BlockingHealthService, List<ContentCodec>)	Use Builder(), Health.ServiceFactory.Builder.bufferDecoderGroup(BufferDecoderGroup), and Health.ServiceFactory.Builder.bufferEncoders(List).
io.servicetalk.health.v1.Health.ServiceFactory(Health.HealthService, RouteExecutionStrategyFactory<GrpcExecutionStrategy>)	Use Builder() and set the custom strategy on Health.ServiceFactory.Builder.routeExecutionStrategyFactory(RouteExecutionStrategyFactory) instead.
io.servicetalk.health.v1.Health.ServiceFactory(Health.HealthService, RouteExecutionStrategyFactory<GrpcExecutionStrategy>, List<ContentCodec>)	Use Builder(RouteExecutionStrategyFactory), Health.ServiceFactory.Builder.bufferDecoderGroup(BufferDecoderGroup), and Health.ServiceFactory.Builder.bufferEncoders(List).
io.servicetalk.health.v1.Health.ServiceFactory(Health.HealthService, List<ContentCodec>)	Use Builder(), Health.ServiceFactory.Builder.bufferDecoderGroup(BufferDecoderGroup), and Health.ServiceFactory.Builder.bufferEncoders(List).
io.servicetalk.health.v1.Health.ServiceFactory.Builder(RouteExecutionStrategyFactory<GrpcExecutionStrategy>)	use Health.ServiceFactory.Builder.routeExecutionStrategyFactory(RouteExecutionStrategyFactory) on the Builder instead.
io.servicetalk.health.v1.Health.ServiceFactory.Builder(RouteExecutionStrategyFactory<GrpcExecutionStrategy>, List<ContentCodec>)	Use Builder(RouteExecutionStrategyFactory), Health.ServiceFactory.Builder.bufferDecoderGroup(BufferDecoderGroup), and Health.ServiceFactory.Builder.bufferEncoders(List).
io.servicetalk.health.v1.Health.ServiceFactory.Builder(List<ContentCodec>)	Use Health.ServiceFactory.Builder.bufferDecoderGroup(BufferDecoderGroup) and Health.ServiceFactory.Builder.bufferEncoders(List).
io.servicetalk.http.utils.TimeoutHttpRequesterFilter(TimeoutFromRequest, boolean)	Use TimeoutHttpRequesterFilter(BiFunction, boolean).
io.servicetalk.http.utils.TimeoutHttpRequesterFilter(TimeoutFromRequest, boolean, Executor)	Use TimeoutHttpRequesterFilter(BiFunction, boolean, Executor).
io.servicetalk.http.utils.TimeoutHttpServiceFilter(TimeoutFromRequest, boolean)	Use TimeoutHttpServiceFilter(BiFunction, boolean).
io.servicetalk.http.utils.TimeoutHttpServiceFilter(TimeoutFromRequest, boolean, Executor)	Use TimeoutHttpServiceFilter(BiFunction, boolean, Executor).
io.servicetalk.loadbalancer.RoundRobinLoadBalancerFactory.Builder()	use LoadBalancers.builder(String) instead.
io.servicetalk.opentelemetry.http.OpenTelemetryHttpRequestFilter(OpenTelemetry, String)	this method is internal, no user should be setting the OpenTelemetry as it is obtained by using GlobalOpenTelemetry.get() and there should be no other implementations but the one available in the classpath, this constructor will be removed in the future releases. Use OpenTelemetryHttpRequestFilter(String, OpenTelemetryOptions) or OpenTelemetryHttpRequestFilter() instead.
io.servicetalk.opentelemetry.http.OpenTelemetryHttpServerFilter(OpenTelemetry)	this method is internal, no user should be setting the OpenTelemetry as it is obtained by using GlobalOpenTelemetry.get() and there should be no other implementations but the one available in the classpath, this constructor will be removed in the future releases. Use OpenTelemetryHttpServerFilter(OpenTelemetryOptions) or OpenTelemetryHttpServerFilter() instead.
io.servicetalk.tcp.netty.internal.TcpClientChannelInitializer(ReadOnlyTcpClientConfig, ConnectionObserver)	Use TcpClientChannelInitializer(ReadOnlyTcpClientConfig, ConnectionObserver, ExecutionContext, boolean)
io.servicetalk.tcp.netty.internal.TcpClientChannelInitializer(ReadOnlyTcpClientConfig, ConnectionObserver, boolean)	Use TcpClientChannelInitializer(ReadOnlyTcpClientConfig, ConnectionObserver, ExecutionContext, boolean)
io.servicetalk.tcp.netty.internal.TcpServerChannelInitializer(ReadOnlyTcpServerConfig, ConnectionObserver)	Use TcpServerChannelInitializer(ReadOnlyTcpServerConfig, ConnectionObserver, ExecutionContext)
io.servicetalk.transport.netty.internal.ConnectionObserverInitializer(ConnectionObserver, boolean, boolean)	Use ConnectionObserverInitializer(ConnectionObserver, Function, boolean, SslConfig) instead
io.servicetalk.transport.netty.internal.ConnectionObserverInitializer(ConnectionObserver, Function<Channel, ConnectionInfo>, boolean, boolean)	Use ConnectionObserverInitializer(ConnectionObserver, Function, boolean, SslConfig) instead
io.servicetalk.transport.netty.internal.IdleTimeoutInitializer(Duration)	Use IdleTimeoutInitializer(long)
io.servicetalk.transport.netty.internal.SniServerChannelInitializer(Mapping<String, SslContext>)	Use SniServerChannelInitializer(Mapping, int, long).